C++ wxFile::Tell方法代码示例

/* MemChunk::importFileStream
 * Loads a file (or part of it) from a currently open file stream
 * into the MemChunk
 * Returns false if file couldn't be opened, true otherwise
 *******************************************************************/
bool MemChunk::importFileStream(wxFile& file, uint32_t len)
{
	// Check file
	if (!file.IsOpened())
		return false;

	// Clear current data if it exists
	clear();

	// Get current file position
	uint32_t offset = file.Tell();

	// If length isn't specified or exceeds the file length,
	// only read to the end of the file
	if (offset + len > file.Length() || len == 0)
		len = file.Length() - offset;

	// Setup variables
	size = len;

	// Read the file
	if (size > 0)
	{
		//data = new uint8_t[size];
		if (allocData(size))
			file.Read(data, size);
		else
			return false;
	}

	return true;
}

static uint GetFileSizeImpl(wxFile& file, const wxString& name)
{
    if (file.IsOpened())
    {
        wxFileOffset pos = file.Tell();
        file.SeekEnd();
        wxFileOffset size = file.Tell();
        file.Seek(pos);
        return size;
    }
    else
    {
        wxFile file2(name, wxFile::read);
        if (!file2.IsOpened())
            return 0;
        file2.SeekEnd();
        return file2.Tell();
    }
}

// -------------------------------------------------------------------------------- //
wxString guGetNextXMLChunk( wxFile &xmlfile, wxFileOffset &CurPos, const char * startstr, const char * endstr, const wxMBConv &conv )
{
    #define XMLREAD_BUFFER_SIZE         10240
    wxString RetVal;
    //wxFileOffset CurPos = xmlfile.Tell();
    CurPos = xmlfile.Tell();
    wxFileOffset StartPos = wxNOT_FOUND;
    wxFileOffset EndPos = wxNOT_FOUND;
    int endstrlen = strlen( endstr );
    char * Buffer = ( char * ) malloc( XMLREAD_BUFFER_SIZE + 1 );
    if( Buffer )
    {
        while( StartPos == wxNOT_FOUND )
        {
            int ReadCount = xmlfile.Read( Buffer, XMLREAD_BUFFER_SIZE );
            if( ReadCount != wxInvalidOffset && ReadCount > 0 )
            {
                Buffer[ ReadCount ] = 0;
            }
            else
            {
                break;
            }
            char * StartString = strstr( Buffer, startstr );
            if( StartString )
            {
                StartPos = CurPos + ( StartString - Buffer );
                break;
            }
            else
            {
                CurPos += ReadCount;
            }
        }

        if( StartPos != wxNOT_FOUND )
        {
            xmlfile.Seek( StartPos );
            CurPos = StartPos;
            while( EndPos == wxNOT_FOUND )
            {
                int ReadCount = xmlfile.Read( Buffer, XMLREAD_BUFFER_SIZE );
                if( ReadCount != wxInvalidOffset && ReadCount > 0 )
                {
                    Buffer[ ReadCount ] = 0;
                }
                else
                {
                    break;
                }
                char * EndString = strstr( Buffer, endstr );
                if( EndString )
                {
                    EndPos = CurPos + ( EndString - Buffer ) + endstrlen;
                    break;
                }
                else
                {
                    // Prevent that </artist was partially included
                    CurPos += ReadCount - endstrlen;
                    xmlfile.Seek( -endstrlen, wxFromCurrent );
                }
            }

            if( EndPos != wxNOT_FOUND )
            {
                //guLogMessage( wxT( "Found From %lli => %lli  (%lli)" ), StartPos, EndPos, EndPos - StartPos );
                int BufferSize = EndPos - StartPos;
                if( BufferSize )
                {
                    char * BufferString = ( char * ) malloc( BufferSize + 1 );
                    if( BufferString )
                    {
                        xmlfile.Seek( StartPos );
                        int ReadCount = xmlfile.Read( BufferString, BufferSize );
                        if( ReadCount != wxInvalidOffset )
                        {
                            BufferString[ ReadCount ] = 0;
                            RetVal = wxString( BufferString, conv );
                            //guLogMessage( wxT( "%i %i" ), BufferSize, ReadCount );
                        }

                        free( BufferString );
                    }
                }
            }
        }

        free( Buffer );
    }


    return RetVal;
}

bool ButcherMetadataFile::WriteMetadata(wxFile &file, ButcherMetadataStorage *storage)
{
    butchermetadata_dataheader_t dataheader;
    butchermetadata_dataitemheader_t dataitemheader;

    ButcherMetadataDataList *curlist;
    ButcherMetadataData *curdata;
    ButcherMetadataData::data_t::const_iterator dataiterator;
    auto_ptr<ButcherMetadataBinary> itembin;

    char buf[BMD_BUF_TEMP_SIZE];
    size_t nRead, nTotal;

    unsigned int listi;
    for (listorder_t::const_iterator i=storage->GetListOrder().begin(); i!=storage->GetListOrder().end(); i++)
    {
        curlist=&storage->Get(*i);

        // items
        for (listi=0; listi<curlist->Count(); listi++)
        {
            // data header begin
            memset(&dataheader, 0, sizeof(dataheader));
            dataheader.kind=BUTCHERMETADATA_KIND_METADATABEGIN;
            strncpy(dataheader.sig, BUTCHERMETADATA_SIG_METADATA, BUTCHERMETADATA_SIG_SIZE);
            dataheader.id=curlist->GetMetadataID();

            file.Write(&dataheader, sizeof(dataheader));

            curdata=&curlist->Get(listi);

            for (dataiterator=curdata->GetData().begin(); dataiterator!=curdata->GetData().end(); dataiterator++)
            {

                // data item header begin
                memset(&dataheader, 0, sizeof(dataheader));
                dataheader.kind=BUTCHERMETADATA_KIND_ITEMBEGIN;
                strncpy(dataheader.sig, BUTCHERMETADATA_SIG_METADATA, BUTCHERMETADATA_SIG_SIZE);
                dataheader.id=dataiterator->first;

                file.Write(&dataheader, sizeof(dataheader));


                // item
                itembin.reset(dataiterator->second->GetData());

                // item header
                memset(&dataitemheader, 0, sizeof(dataitemheader));
                strncpy(dataitemheader.sig, BUTCHERMETADATA_SIG_METADATAITEM, BUTCHERMETADATA_SIG_SIZE);
                dataitemheader.datatype=dataiterator->second->GetDataType();
                if (itembin.get())
                {
                    itembin->SeekI(0, wxFromStart);
                    dataitemheader.datasize=itembin->GetLength();
                }

                file.Write(&dataitemheader, sizeof(dataitemheader));

                // store item position in file
                dataiterator->second->SetPosition(file.Tell(), dataitemheader.datasize);

                // item data
                nTotal=0;
                if (itembin.get())
                {
                    // write item data
                    do
                    {
                        nRead = itembin->Read(buf, WXSIZEOF(buf)).LastRead();
                        if ( nRead )
                        {
                            nTotal+=nRead;
                            file.Write(buf, nRead);
                        }
                    }
                    while ( nRead );
                }
                if (nTotal!=dataitemheader.datasize)
                    throw ButcherException(
                        wxString::Format(_("Data written different than expected (expect: %d - read: %d)."),
                            dataitemheader.datasize, nTotal));

                // free itembin
                itembin.reset(NULL);

                // BINARY item
                if (dataiterator->second->GetDataType()==ButcherMetadataDataItem::DT_BINARY)
                {
/*
                    // set new binary pointing to current file
                    dynamic_cast<ButcherMetadataDataItem_Binary*>(&*(dataiterator->second))->SetBinary(
                        new wxVirtualInputStream(file, dataiterator->second->GetPosition(),
                            dataiterator->second->GetSize())
                    );
*/

                    dynamic_cast<ButcherMetadataDataItem_Binary*>(&*(dataiterator->second))->SetBinary(NULL);
                }

                // METADATA item
//.........这里部分代码省略.........

bool ButcherMetadataFile::ReadMetadata(wxFile &file, ButcherMetadataStorage *storage)
{
    butchermetadata_dataheader_t dataheader, dataitemendheader;
    butchermetadata_dataitemheader_t dataitemheader;
    ButcherMetadataDataItem *newitem;
    ButcherMetadataData *curmd=NULL;
    //auto_ptr<char> itemdata;
    size_t n;
    bool started=false, readitemend;

    while (true)
    {
        // data header
        n=file.Read(&dataheader, sizeof(dataheader));

        if (n==0) return false; // no more data
        if (n!=sizeof(dataheader)) do_invalidfile(_("Could not read data header"));

        if (strncmp(dataheader.sig, BUTCHERMETADATA_SIG_METADATA, BUTCHERMETADATA_SIG_SIZE)!=0)
            do_invalidfile(_("Invalid data header signature"));

        switch (dataheader.kind)
        {
        case BUTCHERMETADATA_KIND_METADATABEGIN:
            if (started) // cannot start before ending
                do_invalidfile(_("Metadata error: cannot start before ending"));

            started=true;

            // add metadata to list
            curmd=storage->Get(dataheader.id, true).Add();
            break;
        case BUTCHERMETADATA_KIND_METADATAEND:
            if (!started)
                do_invalidfile(_("Metadata error: cannot end before starting"));
            // metadata was read
            started=false;
            curmd=NULL;
            break;
        case BUTCHERMETADATA_KIND_ITEMBEGIN:
            if (!started)
                do_invalidfile(_("Metadata error: cannot have item outside metadata"));

            // read item
            n=file.Read(&dataitemheader, sizeof(dataitemheader));

            if (n==0) do_invalidfile(_("End of data without metadata end")); // no more data, but not metadataend found
            if (n!=sizeof(dataitemheader)) do_invalidfile(_("Could not read item header"));

            // item header
            if (strncmp(dataitemheader.sig, BUTCHERMETADATA_SIG_METADATAITEM, BUTCHERMETADATA_SIG_SIZE)!=0)
                do_invalidfile(_("Invalid item header"));

            newitem=NULL;
            switch (dataitemheader.datatype)
            {
            case ButcherMetadataDataItem::DT_METADATA:
                newitem=new ButcherMetadataDataItem_Metadata(curmd, dataheader.id, file.Tell(), 0);
                break;
            case ButcherMetadataDataItem::DT_STRING:
                newitem=new ButcherMetadataDataItem_String(curmd, dataheader.id, wxEmptyString, file.Tell(), dataitemheader.datasize);
                break;
            case ButcherMetadataDataItem::DT_INTEGER:
                newitem=new ButcherMetadataDataItem_Integer(curmd, dataheader.id, 0, file.Tell(), dataitemheader.datasize);
                break;
            case ButcherMetadataDataItem::DT_BINARY:
                newitem=new ButcherMetadataDataItem_Binary(curmd, dataheader.id, NULL, file.Tell(), dataitemheader.datasize);
                break;
            default:
                do_invalidfile(_("Invalid item data type"));
                break;
            }
            // read item data
            readitemend=true;
            curmd->Add(newitem);
            if (dataitemheader.datasize>0)
            {
                if (newitem->ReadData())
                {
                    //itemdata=auto_ptr<char>(new char[dataitemheader.datasize]);
#ifndef _MSC_VER
					char itemdata[dataitemheader.datasize];
#else
					auto_ptr<char> itemdata_auto(new char[dataitemheader.datasize]);
					char *itemdata=itemdata_auto.get();
#endif
                    n=file.Read(&*itemdata, dataitemheader.datasize);

                    if (n==0) do_invalidfile(_("End of data while reading item data"));
                    if (n!=dataitemheader.datasize) do_invalidfile(_("Could not read item data"));

                    //newitem->SetData(&*itemdata, dataitemheader.datasize);
                    newitem->SetData(itemdata, dataitemheader.datasize);

                }
                else
                {
                    // skip data
                    file.Seek((wxFileOffset)dataitemheader.datasize, wxFromCurrent);
                }
//.........这里部分代码省略.........

DWORD CNWCFile::Load(wxFile& in, FILE* out, FILELOAD fl)
{
	char buf[64];
	if ( sizeof(szNWCHeader) != in.Read(buf, sizeof(szNWCHeader)) ||
		 memcmp(szNWCHeader, buf, sizeof(szNWCHeader)) != 0 )
	{
		if ( memcmp(szCompressHeader1, buf, sizeof(szCompressHeader1)) == 0 )
		{
			return LoadCompressed(in, out, fl);
		}

		wxFprintf(stderr, _T("invalid szNWCHeader\n"));
		return ERROR_INVALID_DATA;
	}

	if ( !ReadLEShort(in, nVersion) )
	{
		wxFprintf(stderr, _T("unexpected EOF while reading version\n"));
		wxASSERT(false);
		return ERROR_INVALID_DATA;
	}

	if ( IsValidVersion(nVersion) )
	{
		wxFprintf(out, _T("version:%d.%d\n"), nVerMajor, nVerMinor);
	}
	else
	{
		wxFprintf(stderr, _T("unknown version number\n"));
		return ERROR_INVALID_VERSION;
	}

	long nPos = in.Tell();
	char _szHeader2[4] = "\x02\x00\x00";							// implies NUL at last
	if ( !ReadBytes(in, btUnknown2) ||
		 btUnknown2[0] != _szHeader2[0] || btUnknown2[1] != _szHeader2[1] || btUnknown2[3] != _szHeader2[3] )
	{
		//wxFprintf(stderr, "invalid btUnknown2 at 0x%08x\n", nPos);
		//wxASSERT(false);
	}

	if ( btUnknown2[2] == 5 )
	{
		wxFprintf(out, _T("saved by unregistered version\n"));
	}
	else if ( btUnknown2[2] != 0 )
	{
		//wxFprintf(stderr, "invalid btUnknown2 at 0x%08x\n", nPos);
	}

	strUser = LoadStringNULTerminated(in);
	strUnknown1 = LoadStringNULTerminated(in);
	wxFprintf(out, _T("user:'%s', '%s'\n"), strUser.c_str(), strUnknown1.c_str());

	nPos = in.Tell();
	char szHeader3[8] = "\x00\x00\x00\x00\x00\x00\x00";					// implies NUL at last
	if ( sizeof(szHeader3) != in.Read(buf, sizeof(szHeader3)) ||
		 memcmp(szHeader3, buf, sizeof(szHeader3)) != 0 )
	{
		wxFprintf(stderr, _T("invalid btUnknown2 at 0x%08x\n"), nPos);
		//wxASSERT(false);
	}

	short nUnknown4;
	if ( !ReadBytes(in, nUnknown4) )
	{
		wxFprintf(stderr, _T("unexpected EOF while reading\n"));
		wxASSERT(false);
		return ERROR_INVALID_DATA;
	}

	strTitle = LoadStringNULTerminated(in);
	strAuthor = LoadStringNULTerminated(in);
	if ( nVersion >= NWC_Version200 )
		strLyricist = LoadStringNULTerminated(in);
	strCopyright1 = LoadStringNULTerminated(in);
	strCopyright2 = LoadStringNULTerminated(in);
	strComment = LoadStringNULTerminated(in);
	wxFprintf(out, _T("title:'%s'\n"), strTitle.c_str());
	wxFprintf(out, _T("author:'%s'\n"), strAuthor.c_str());
	if ( nVersion >= NWC_Version200 )
		wxFprintf(out, _T("lyricist:'%s'\n"), strLyricist.c_str());
	wxFprintf(out, _T("copyright1:'%s'\n"), strCopyright1.c_str());
	wxFprintf(out, _T("copyright2:'%s'\n"), strCopyright2.c_str());
	wxFprintf(out, _T("comment:'%s'\n"), strComment.c_str());

	nPos = in.Tell();
	char _szReserved5[] = "\x5F\x00\x46\x32\x00";
	bool bResult = ReadBytes(in, chExtendLastSystem) &&
				   ReadBytes(in, chIncreaseNoteSpacing) &&
				   ReadBytes(in, btUnknown3) &&
				   ReadBytes(in, btMeasureNumbers) &&
				   ReadBytes(in, btUnknown4) &&
				   ReadLEShort(in, nMeasureStart);
	if ( !bResult || memcmp(_szReserved5, btUnknown3, sizeof(btUnknown3)) != 0 )
	{
//		wxFprintf(stderr, "invalid szReserved5 at 0x%08x\n", nPos);
//		wxASSERT(false);
//		return ERROR_INVALID_DATA;
	}
//.........这里部分代码省略.........