C++ fstream::write方法代码示例

void WriteSector(char* buffer, size_t sec) {
    sec += partitionOffset;
    if (sec > partitionLength)
        return;

    if ((sec * 512) > fsize) {
        std::cout << "WOAH BRO THIS SECTOR IS WRONG: " << sec << std::endl;
        return;
    }

    f.seekp(sec * 512, std::ios::beg);
    f.write(buffer, 512);
}

void PEObject::WriteHeader(std::fstream &stream)
{
    unsigned zero = 0;
    for (int i =0; i < name.size() && i < 8; i++)
        stream.write(&name[i], 1);
    for (int i = name.size(); i < 8; i++)
        stream.write((char *)&zero, 1);
    unsigned msize = ObjectAlign(objectAlign, size);
    stream.write((char *)&msize, 4);
    stream.write((char *)&virtual_addr, 4);
    msize = ObjectAlign(fileAlign, initSize);
    stream.write((char *)&msize, 4);
    stream.write((char *)&raw_addr, 4);
    stream.write((char *)&zero, 4);
    stream.write((char *)&zero, 4);
    stream.write((char *)&zero, 4);
    int flg = (flags ^ WINF_NEG_FLAGS) & WINF_IMAGE_FLAGS; /* get characteristice for section */
    stream.write((char *)&flg, 4);
}

void LuaHistoryFile::SaveLuaTable(lua_State* luaState, int nIndex, size_t nBufferLen, std::fstream& fileStream)
{
	vector<string> vecStrings;
	if(lua_istable(luaState,nIndex))
	{
		int nStrCnt = lua_objlen(luaState,nIndex);
		const char* cszWrite = NULL;
		for(int ix = 1; ix <= nStrCnt; ++ix)
		{
			lua_rawgeti(luaState, nIndex , ix);
			if(lua_isstring(luaState, -1))
			{
				cszWrite = luaL_checkstring(luaState, -1);
				wstring wstrWrite;
				UTF8_to_Unicode(cszWrite, strlen(cszWrite), wstrWrite);
				string astrWrite;
				wstrWrite += WCHAR('\n');
				Unicode_to_ANSI(wstrWrite.c_str(), wstrWrite.size(),astrWrite);
				vecStrings.push_back(astrWrite);
				
			}
			lua_pop(luaState,1);
		}
	}
	char szStrCnt[100];
	itoa(vecStrings.size(), szStrCnt, 100);
	int nStrCntLen = strlen(szStrCnt);
	szStrCnt[nStrCntLen] = '\n';
	fileStream.write(szStrCnt, nStrCntLen + 1);
	for(size_t ix = 0; ix < vecStrings.size(); ++ix)
	{
		const char* buf = vecStrings[ix].c_str();
		size_t buflen = vecStrings[ix].size();
		fileStream.write(buf, buflen);
		
	}
	
}

/// Writes to file stream.
void Tile::WriteTo(std::fstream & file)
{
	// Write version
	file.write((char*)&tileVersion, sizeof(int));
	// Fetch type index.
	this->typeIndex = -1;
	if (type)
		typeIndex = type->type;
	// Write type index
	file.write((char*)&typeIndex, sizeof(int));
	// Write position.
	position.WriteTo(file);
	// Write stuff bound to the tile.
	int stuff = 0;
	if (event)
		stuff |= 0x001;
	file.write((char*)&stuff, sizeof(int));
	// Write the path to the source of the event.
	if (event)
		event->source.WriteTo(file);
	// Write description of additional details to file.
	description.WriteTo(file);
}

int User::writeUNPW(std::fstream &fout){
	if (!fout.is_open()){
		fout.open("UNPW.bin", std::ios::out, std::ios::binary);
	}
	auto fpos = fout.cur;
	fout.seekp(0, fout.beg);
	encode(username);
	encode(password);
	fout.write((char*)&username, sizeof(str));
	fout.write((char*)&password, sizeof(str));
	decode(username);
	decode(password);
	fout.seekp(0, fpos);
	return 0;
}

void Transaction::Store(std::fstream &stream)
{
	m_Date.Store(stream);
	StoreString(m_Description, stream);
	StoreString(m_Payee, stream);
	StoreString(m_Category, stream);
	m_Amount.Store(stream);
	
	stream.write((char *) &m_Type, sizeof(unsigned char));
	
	std::bitset<8> localset;	
	localset[0] = m_Cleared;
	localset[1] = m_Split;
	localset[2] = m_Reconciled;
	localset[3] = m_Flagged;
	localset[4] = m_HasFITID;
	
	unsigned char cBitset = static_cast<unsigned char>(localset.to_ulong());
	stream.write((char *) &cBitset, sizeof(unsigned char));
	
	if (m_HasFITID)
	{
		StoreString(m_FITID, stream);
	}
	
	unsigned char numSplits = static_cast<unsigned char>(m_aSplits.size());
	stream.write((char *) &numSplits, sizeof(unsigned char));
	
	std::vector<SplitTransaction>::iterator it = m_aSplits.begin();
	std::vector<SplitTransaction>::iterator itEnd = m_aSplits.end();
	
	for (; it != itEnd; ++it)
	{
		(*it).Store(stream);
	}
}

	Database::Database(char* file) {
		backing.open(file, std::ios::in|std::ios::out|std::ios::binary);
		if (backing.eof()) {
			char ver = FIDBVER;
			backing.write(&ver, 1);
		} else {
			char usedver = '\0';
			backing.read(&usedver, 1);
			if (usedver != FIDBVER) {
				std::cerr << "Version " << usedver << " in file differs from " << FIDBVER << " in library!" << std::endl;
				return;
			}
		}
		indexstore = _ReadIndex(1); //Index is always on second byte
	}

	void Database::_GetLock(uint64_t blockpos, bool readonly) {
		char blocklock = 1;
		backing.seekg(blockpos);
		backing.read(&blocklock, 1);
		while (blocklock == 1)
		{
			std::this_thread::sleep_for(std::chrono::milliseconds(50)); //Thanks StackOverflow!
			backing.seekg(blockpos);
			backing.read(&blocklock, 1);
		}
		if (readonly) {
			blocklock = 1;
			backing.seekp(blockpos);
			backing.write(&blocklock, 1);
		}
	}

exp bool RawWrite(const char* fname, size_t offsetIn, size_t offset, size_t len) {
    std::ifstream in(fname, std::ios::in | std::ios::binary);
    if (!in.is_open())
        return false;

    // Seek to proper offsets
    in.seekg(offsetIn, std::ios::beg);
    f.seekp(offset + partitionOffset * 512, std::ios::beg);

    // Read data
    char* buffer = new char[len];
    in.read(buffer, len);
    f.write(buffer, len);

    delete[] buffer;
    in.close();

    return true;
}

bool patch(std::fstream &file, char* buffer, size_t size)
{
	std::vector<size_t> advapi;
	find_all(buffer, "ADVAPI32", size, 8, advapi);

	std::vector<int> functionlist;

	bool fullcheck = false;
	bool supported = true;

	if (!advapi.empty())
	{
		if (fullcheck) for (int i = 0; i < 806; i++)
		{
			size_t func_len = strlen(Advapi_Function[i]);

			if (find_single(buffer, Advapi_Function[i], size, func_len))
			{
				functionlist.push_back(i);
				supported = supported && Advapi_Support[i];
			}
		};

		if (supported)
		{
			for (size_t pos : advapi)
			{
				file.seekg(pos, std::ios::beg);
				file.write("REGEMU32", 8);
			}
		}

		wprintf(L"ADVAPI32 found (%d) and patched. ", advapi.size());
	}
	else
	{
		wprintf(L"ADVAPI32 not found. ");
	}

	return !advapi.empty();
}

//******************************************************************************************************************************************************
//******************************************************************************************************************************************************
int WriteFile(std::fstream& fileHandle, BOOL* fieldSelections, int extractionMode, double* modeParameters, int numModeParameters, int numRecs, const mxArray *prhs[], int prhsIndex)
{
    EventRec buf;
    memset(&buf, 0, mRecordSize );
    int index = 0;

    for( int i = 0; i < numRecs; i++ ) {

        index = 0;
        if( fieldSelections[IndexTimestamp] ) {
            buf.qwTimeStamp = (unsigned __int64)(mInputFields[index][i]);
            index++;
        }

        if( !mGeneralOps.ValidRecToExtract(i, buf.qwTimeStamp, extractionMode, modeParameters, numModeParameters) ) {
            continue;
        }

        if( fieldSelections[IndexEventId] ) {
            buf.nevent_id = (short)(mInputFields[index][i]);
            index++;
        }
        if( fieldSelections[IndexTtl] ) {
            buf.nttl = (short)(mInputFields[index][i]);
            index++;
        }
        if( fieldSelections[IndexExtras] ) {
            for( int j = 0; j < EVENT_NUM_EXTRAS; j++) {
                buf.dnExtra[j] = (__int32)(mInputFields[index][(i*EVENT_NUM_EXTRAS)+j]);
            }
            index++;
        }
        if( fieldSelections[IndexEventString] ) {
            memset( buf.EventString, 0, sizeof(char)*NLX_EventRecStringSize);
            mxGetString( mxGetCell( prhs[prhsIndex], i ), buf.EventString, NLX_EventRecStringSize );
        }

        fileHandle.write( (const char*)&buf, mRecordSize );
    }
    return(Nlx2MatOK);
}

	void push_back(uint8_t x)
    {
        m_write_buf[m_widx] = x;
        if (m_sync) {
            m_read_buf[m_widx] = x;
        }
        ++m_widx;
        if (m_widx == m_buffer_size) {
            if (!m_sync) { // if not sync, write block to disk
                if (!m_stream.is_open()) {
                    m_stream.open(m_file_name,
                                  std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc);
                }
                m_stream.seekp(m_buffer_size * (m_wb++), std::ios::beg);
                m_stream.write((char*)m_write_buf, m_buffer_size);
                ++m_disk_buffered_blocks;
            }
            m_sync = 0;
            m_widx = 0;
        }
    }

void ssolver::Statedef::checkpoint(std::fstream & cp_file)
{
    cp_file.write((char*)&pTime, sizeof(double));
    cp_file.write((char*)&pNSteps, sizeof(uint));

	SpecdefPVecCI s_end = pSpecdefs.end();
	for (SpecdefPVecCI s = pSpecdefs.begin(); s != s_end; ++s) {
        (*s)->checkpoint(cp_file);
    }

	CompdefPVecCI c_end = pCompdefs.end();
	for (CompdefPVecCI c = pCompdefs.begin(); c != c_end; ++c) {
        (*c)->checkpoint(cp_file);
    }

	PatchdefPVecCI p_end = pPatchdefs.end();
	for (PatchdefPVecCI p = pPatchdefs.begin(); p != p_end; ++p) {
        (*p)->checkpoint(cp_file);
    }

	DiffBoundarydefPVecCI db_end = pDiffBoundarydefs.end();
	for (DiffBoundarydefPVecCI db = pDiffBoundarydefs.begin(); db != db_end; ++db) {
        (*db)->checkpoint(cp_file);
    }

	ReacdefPVecCI r_end = pReacdefs.end();
	for (ReacdefPVecCI r = pReacdefs.begin(); r != r_end; ++r) {
        (*r)->checkpoint(cp_file);
    }

	SReacdefPVecCI sr_end = pSReacdefs.end();
	for (SReacdefPVecCI sr = pSReacdefs.begin(); sr != sr_end; ++sr) {
        (*sr)->checkpoint(cp_file);
    }

	DiffdefPVecCI d_end = pDiffdefs.end();
	for (DiffdefPVecCI d = pDiffdefs.begin(); d != d_end; ++d) {
        (*d)->checkpoint(cp_file);
    }
}

void
CBOLoader::_writeOctreeByMat(OctreeByMatScene *aScene, std::fstream &f) {

	/* Write the bounding box */
	BoundingBox& aBoundingVolume = (BoundingBox &)aScene->getBoundingVolume();
	std::vector<vec3> &points = aBoundingVolume.getNonTransformedPoints();
	float flo[6];
	flo[0] = points[0].x;
	flo[1] = points[0].y;
	flo[2] = points[0].z;
	flo[3] = points[1].x;
	flo[4] = points[1].y;
	flo[5] = points[1].z;
	f.write(reinterpret_cast<char*> (flo), 6 * sizeof(float));

	OctreeByMat *o = aScene->m_pGeometry;
	_writeString(o->getName(),f);

	std::shared_ptr<OctreeByMatNode> &n = o->m_pOctreeRootNode;

	_writeOctreeByMatNode(n,f);
}

// WriteLn
// Writes the formatted output to the file stream, returning the number of
// bytes written.
int WriteLn(std::fstream& stream, const char* fmt, ...)
{
   char buf[MAX_BUFFER_LEN];
   int nLength;
   t_Str szMsg;

   memset(buf, 0, MAX_BUFFER_LEN);
   va_list args;

   va_start (args, fmt);
   nLength = vsnprintf(buf, MAX_BUFFER_LEN, fmt, args);
   va_end (args);


   if ( buf[nLength] != '\n' && buf[nLength] != '\r' )
      buf[nLength++] = '\n';


   stream.write(buf, nLength);

   return nLength;
}