VOID Klog(PCHAR pFormat, ...) { NTSTATUS status; CHAR buf[MAX_MESSAGE_SIZE]; va_list argptr; KeWaitForSingleObject( &WriteEvent, Executive, KernelMode, FALSE, NULL); va_start(argptr, pFormat); vsprintf(buf, pFormat, argptr); va_end(argptr); DbgPrint("Buf length = %d\n", strlen(buf)); WriteToBuffer(pRb, "some", 4); }
TPZContBufferedStream &TPZContBufferedStream:: operator<<(const TPZContBufferedStream &other) { const unsigned int nBytesOther = other.fSize; char *temp = new char[nBytesOther]; other.ConstRead(temp, nBytesOther); WriteToBuffer(temp, nBytesOther); delete[] temp; return *this; }
TPZContBufferedStream &TPZContBufferedStream:: operator<<(TPZContBufferedStream &other) { if (&other != this) { const unsigned int nBytesOther = other.fSize; char *temp = new char[nBytesOther]; other.ReadFromBuffer(temp, nBytesOther); WriteToBuffer(temp, nBytesOther); delete[] temp; } return *this; }
int CSerial_Base::Serialize(char *pBuffer) { if (pBuffer == 0) return 0 ; //写入类名 const char* lpszPacketName = GetPacketClassInfo()->m_lpszPacketName ; int len = strlen(lpszPacketName)+ 1; memcpy(pBuffer,lpszPacketName,len); WriteToBuffer(pBuffer+len); return GetSize(); }
bool ReadRegistryForLocalRegid(char *szRegPath,char *szRegId,char *&szError) { CRegKey regObj; try{ DWORD dwCount = 0; LONG lError = 0; lError = regObj.Open(HKEY_LOCAL_MACHINE, szRegPath, KEY_READ); if(ERROR_SUCCESS != lError) { WriteToBuffer(szError,"Opening Registry Failed\0"); WriteToBuffer(szError,szRegPath); regObj.Close(); return false; } dwCount = 100; lError = regObj.QueryValue(szRegId,"regid\0",&dwCount); if(ERROR_SUCCESS != lError) { WriteToBuffer(szError,"Reading Registry Key For regid Failed.\0"); regObj.Close(); return false; } return true; } catch(...) { WriteToBuffer(szError,"Exception occurred. while reading registry\0"); return false; } }
void cTexturedQuadFactory::PrepareLayers(std::vector<cSubmittedLayer>& layers) { if(!mVisibleState.mHasChanges) { std::copy( mVisibleState.mLayers.begin() ,mVisibleState.mLayers.end() ,std::back_inserter(layers) ); return; } mVisibleState.Reset(mVertexBuffers.Back(), &mShader, this); auto last = mZSortedInfo.begin(); mVisibleState.StartLayer((*last)->mDrawOrder); mVisibleState.NewTexture((*last)->mTexture, 0); uint32_t num_quads = 0; for(auto it = mZSortedInfo.begin(); it != mZSortedInfo.end(); ++it) { if((*it)->mTexture != (*last)->mTexture) { mVisibleState.NewTexture((*it)->mTexture, num_quads); num_quads = 0; } if((*it)->mDrawOrder != (*last)->mDrawOrder) { mVisibleState.NewLayer((*it)->mDrawOrder, num_quads); num_quads = 0; } last = it; ++num_quads; } const uint32_t total_quads = mVisibleState.FinishLayers(num_quads); const uint32_t total_bytes = sizeof(cPosTexCoord)*4*total_quads; //map vertices into buffer { auto mapped = mVertexBuffers.Back().Buffer(0).MapBytes(total_bytes); for(auto it = mZSortedInfo.begin(); it != mZSortedInfo.end(); ++it) { mapped.WriteToBuffer((*it)->mVerts); } } std::copy( mVisibleState.mLayers.begin() ,mVisibleState.mLayers.end() ,std::back_inserter(layers) ); }
int main( void ) { DWORD dwWaitResult; // TODO: Create the shared buffer // Create events and THREADCOUNT threads to read from the buffer CreateEventsAndThreads(); // At this point, the reader threads have started and are most // likely waiting for the global event to be signaled. However, // it is safe to write to the buffer because the event is a // manual-reset event. WriteToBuffer(); printf("Main thread waiting for threads to exit...\n"); // The handle for each thread is signaled when the thread is // terminated. dwWaitResult = WaitForMultipleObjects( THREADCOUNT, // number of handles in array ghThreads, // array of thread handles TRUE, // wait until all are signaled INFINITE); switch (dwWaitResult) { // All thread objects were signaled case WAIT_OBJECT_0: printf("All threads ended, cleaning up for application exit...\n"); break; // An error occurred default: printf("WaitForMultipleObjects failed (%d)\n", GetLastError()); return 1; } // Close the events to clean up CloseEvents(); return 0; }
// destructor BNode::~BNode() { // if dirty, rewrite to disk if (dirty_) { int block_length = btree_->file()->block_length(); char* buf = new char[block_length]; WriteToBuffer(buf); btree_->file()->WriteBlock(buf, block_); delete[] buf; } // release delete[] key_; key_ = NULL; delete[] son_; son_ = NULL; }
int Bitfield::WriteToFile(const char *fname) { int result = -1; FILE *fp = (FILE *)0; char *bitbuf = (char *)0; fp = fopen(fname, "w"); if( !fp ) goto done; bitbuf = new char[nbytes]; #ifndef WINDOWS if( !bitbuf ) goto done; #endif WriteToBuffer(bitbuf); if( fwrite(bitbuf, nbytes, 1, fp) != 1 ) goto done; result = 0; done: if( bitbuf ) delete []bitbuf; if( fp ) fclose(fp); DiskAccess(); return result; }
void BinarySerializeNode::setAttr ( const char* _key, const void* _value, uint _bytes ) { WriteToBuffer ( _value, _bytes ); }
void PRNG::Update(size_t /* index */) { WriteToBuffer(params.queue, this->buffer, CL_TRUE, 0, sizeof(uint64_t), &this->seed); this->seed++; }
void BinarySerializeNode::setAttr ( const char* _key, double _value ) { WriteToBuffer ( &_value, sizeof(double) ); }
void BinarySerializeNode::setAttr ( const char* _key, uint64 _value ) { WriteToBuffer ( &_value, sizeof(uint64) ); }
bool CVolumeDirectory::Read(u64 _Offset, u64 _Length, u8* _pBuffer, bool decrypt) const { if (!decrypt && (_Offset + _Length >= 0x400) && m_is_wii) { // Fully supporting this would require re-encrypting every file that's read. // Only supporting the areas that IOS allows software to read could be more feasible. // Currently, only the header (up to 0x400) is supported, though we're cheating a bit // with it by reading the header inside the current partition instead. Supporting the // header is enough for booting games, but not for running things like the Disc Channel. return false; } if (decrypt && !m_is_wii) PanicAlertT("Tried to decrypt data from a non-Wii volume"); // header if (_Offset < DISKHEADERINFO_ADDRESS) { WriteToBuffer(DISKHEADER_ADDRESS, DISKHEADERINFO_ADDRESS, m_diskHeader.data(), _Offset, _Length, _pBuffer); } // header info if (_Offset >= DISKHEADERINFO_ADDRESS && _Offset < APPLOADER_ADDRESS) { WriteToBuffer(DISKHEADERINFO_ADDRESS, sizeof(m_diskHeaderInfo), (u8*)m_diskHeaderInfo.get(), _Offset, _Length, _pBuffer); } // apploader if (_Offset >= APPLOADER_ADDRESS && _Offset < APPLOADER_ADDRESS + m_apploader.size()) { WriteToBuffer(APPLOADER_ADDRESS, m_apploader.size(), m_apploader.data(), _Offset, _Length, _pBuffer); } // dol if (_Offset >= m_dol_address && _Offset < m_dol_address + m_DOL.size()) { WriteToBuffer(m_dol_address, m_DOL.size(), m_DOL.data(), _Offset, _Length, _pBuffer); } // fst if (_Offset >= m_fst_address && _Offset < m_dataStartAddress) { WriteToBuffer(m_fst_address, m_FSTData.size(), m_FSTData.data(), _Offset, _Length, _pBuffer); } if (m_virtualDisk.empty()) return true; // Determine which file the offset refers to std::map<u64, std::string>::const_iterator fileIter = m_virtualDisk.lower_bound(_Offset); if (fileIter->first > _Offset && fileIter != m_virtualDisk.begin()) --fileIter; // zero fill to start of file data PadToAddress(fileIter->first, _Offset, _Length, _pBuffer); while (fileIter != m_virtualDisk.end() && _Length > 0) { _dbg_assert_(DVDINTERFACE, fileIter->first <= _Offset); u64 fileOffset = _Offset - fileIter->first; const std::string fileName = fileIter->second; std::unique_ptr<PlainFileReader> reader(PlainFileReader::Create(fileName)); if (reader == nullptr) return false; u64 fileSize = reader->GetDataSize(); FileMon::CheckFile(fileName, fileSize); if (fileOffset < fileSize) { u64 fileBytes = fileSize - fileOffset; if (_Length < fileBytes) fileBytes = _Length; if (!reader->Read(fileOffset, fileBytes, _pBuffer)) return false; _Length -= fileBytes; _pBuffer += fileBytes; _Offset += fileBytes; } ++fileIter; if (fileIter != m_virtualDisk.end()) { _dbg_assert_(DVDINTERFACE, fileIter->first >= _Offset); PadToAddress(fileIter->first, _Offset, _Length, _pBuffer); } } return true; }
Camera::Camera(EngineParams& params) : KernelObject(params) { fprintf(stderr, "Initializing <Camera>.\n"); fprintf(stderr, "Loading '*/camera.xml'.\n"); std::fstream stream; pugi::xml_document doc; GetData("camera.xml", stream); fprintf(stderr, "Parsing camera parameters..."); ParseXML(doc, stream); fprintf(stderr, " done.\n"); pugi::xml_node node = doc.child("camera"); Vector cameraPos = parseVector(node.child("position")); Vector cameraTarget = parseVector(node.child("target")); Vector dir = normalize(cameraTarget - cameraPos); node = node.child("misc"); float FOV = (PI / 180.0f) * node.attribute("fov").as_float(); node = node.parent(); node = node.child("focal"); /* Depth-of-field params. */ float focalSpread = node.attribute("spread").as_float(); float focalLength = node.attribute("length").as_float(); fprintf(stderr, "Camera position = (%.2f, %.2f, %.2f).\n", cameraPos.x, cameraPos.y, cameraPos.z); fprintf(stderr, "Camera target = (%.2f, %.2f, %.2f).\n", cameraTarget.x, cameraTarget.y, cameraTarget.z); fprintf(stderr, "Field of view = %.2f radians.\n", FOV); fprintf(stderr, "Focal length = %.2f.\n", focalLength); fprintf(stderr, "Focal spread = %.2f.\n", focalSpread); Vector normal, tangent; Basis(dir, &normal, &tangent); Vector focalPlane[4]; float z = 1.0f / tan(FOV * 0.5f); focalPlane[0] = normalize(Vector(-1.0f, +1.0f, z)); focalPlane[1] = normalize(Vector(+1.0f, +1.0f, z)); focalPlane[2] = normalize(Vector(+1.0f, -1.0f, z)); focalPlane[3] = normalize(Vector(-1.0f, -1.0f, z)); for (size_t t = 0; t < 4; ++t) { /* Transform the focal plane to camera space (= "rotate" it) */ focalPlane[t] = Transform(focalPlane[t], tangent, normal, dir); focalPlane[t] = focalPlane[t] * focalLength + cameraPos; } this->buffer = CreateBuffer(params.context, CL_MEM_READ_ONLY, sizeof(cl_data), nullptr); cl_data data; for (size_t t = 0; t < 4; ++t) focalPlane[t].CL(&data.p[t]); cameraPos.CL(&data.pos); normal.CL(&data.up); tangent.CL(&data.left); data.spread = focalSpread; WriteToBuffer(params.queue, this->buffer, CL_TRUE, 0, sizeof(cl_data), &data); fprintf(stderr, "Initialization complete.\n\n"); stream.close(); }
void BinarySerializeNode::setAttr ( const char* _key, char _value ) { WriteToBuffer ( &_value, sizeof(char) ); }
bool EQEmu::PFS::Archive::Save(std::string filename) { std::vector<char> buffer; //Write Header WriteToBuffer(uint32_t, 0, buffer, 0); WriteToBuffer(uint8_t, 'P', buffer, 4); WriteToBuffer(uint8_t, 'F', buffer, 5); WriteToBuffer(uint8_t, 'S', buffer, 6); WriteToBuffer(uint8_t, ' ', buffer, 7); WriteToBuffer(uint32_t, 131072, buffer, 8); std::vector<std::tuple<int32_t, uint32_t, uint32_t>> dir_entries; std::vector<char> files_list; uint32_t file_offset = 0; uint32_t file_size = 0; uint32_t dir_offset = 0; uint32_t file_count = (uint32_t)files.size(); uint32_t file_pos = 0; WriteToBuffer(uint32_t, file_count, files_list, file_pos); file_pos += 4; auto iter = files.begin(); while(iter != files.end()) { int32_t crc = EQEmu::PFS::CRC::Instance().Get(iter->first); uint32_t offset = (uint32_t)buffer.size(); uint32_t sz = files_uncompressed_size[iter->first]; buffer.insert(buffer.end(), iter->second.begin(), iter->second.end()); dir_entries.push_back(std::make_tuple(crc, offset, sz)); uint32_t filename_len = (uint32_t)iter->first.length() + 1; WriteToBuffer(uint32_t, filename_len, files_list, file_pos); file_pos += 4; WriteToBufferLength(&(iter->first[0]), filename_len - 1, files_list, file_pos); file_pos += filename_len; WriteToBuffer(uint8_t, 0, files_list, file_pos - 1); ++iter; } file_offset = (uint32_t)buffer.size(); if (!WriteDeflatedFileBlock(files_list, buffer)) { return false; } file_size = (uint32_t)files_list.size(); dir_offset = (uint32_t)buffer.size(); WriteToBuffer(uint32_t, dir_offset, buffer, 0); uint32_t cur_dir_entry_offset = dir_offset; uint32_t dir_count = (uint32_t)dir_entries.size() + 1; WriteToBuffer(uint32_t, dir_count, buffer, cur_dir_entry_offset); cur_dir_entry_offset += 4; auto dir_iter = dir_entries.begin(); while(dir_iter != dir_entries.end()) { int32_t crc = std::get<0>(*dir_iter); uint32_t offset = std::get<1>(*dir_iter); uint32_t size = std::get<2>(*dir_iter); WriteToBuffer(int32_t, crc, buffer, cur_dir_entry_offset); WriteToBuffer(uint32_t, offset, buffer, cur_dir_entry_offset + 4); WriteToBuffer(uint32_t, size, buffer, cur_dir_entry_offset + 8); cur_dir_entry_offset += 12; ++dir_iter; } WriteToBuffer(int32_t, 0x61580AC9, buffer, cur_dir_entry_offset); WriteToBuffer(uint32_t, file_offset, buffer, cur_dir_entry_offset + 4); WriteToBuffer(uint32_t, file_size, buffer, cur_dir_entry_offset + 8); cur_dir_entry_offset += 12; if(footer) { WriteToBuffer(int8_t, 'S', buffer, cur_dir_entry_offset); WriteToBuffer(int8_t, 'T', buffer, cur_dir_entry_offset + 1); WriteToBuffer(int8_t, 'E', buffer, cur_dir_entry_offset + 2); WriteToBuffer(int8_t, 'V', buffer, cur_dir_entry_offset + 3); WriteToBuffer(int8_t, 'E', buffer, cur_dir_entry_offset + 4); WriteToBuffer(uint32_t, footer_date, buffer, cur_dir_entry_offset + 5); } FILE *f = fopen(filename.c_str(), "wb"); if(f) { size_t sz = fwrite(&buffer[0], buffer.size(), 1, f); if(sz != 1) { fclose(f); return false; } fclose(f); } else { return false; } return true; }
void BinarySerializeNode::setAttr ( const char* _key, const wchar* _value ) { uint strlen = str::len(_value); WriteToBuffer ( &strlen, sizeof(uint) ); WriteToBuffer ( _value, strlen * sizeof(wchar) ); }
bool CVolumeDirectory::Read(u64 _Offset, u64 _Length, u8* _pBuffer) const { // header if (_Offset < DISKHEADERINFO_ADDRESS) { WriteToBuffer(DISKHEADER_ADDRESS, DISKHEADERINFO_ADDRESS, m_diskHeader.data(), _Offset, _Length, _pBuffer); } // header info if (_Offset >= DISKHEADERINFO_ADDRESS && _Offset < APPLOADER_ADDRESS) { WriteToBuffer(DISKHEADERINFO_ADDRESS, sizeof(m_diskHeaderInfo), (u8*)m_diskHeaderInfo.get(), _Offset, _Length, _pBuffer); } // apploader if (_Offset >= APPLOADER_ADDRESS && _Offset < APPLOADER_ADDRESS + m_apploader.size()) { WriteToBuffer(APPLOADER_ADDRESS, m_apploader.size(), m_apploader.data(), _Offset, _Length, _pBuffer); } // dol if (_Offset >= m_dol_address && _Offset < m_dol_address + m_DOL.size()) { WriteToBuffer(m_dol_address, m_DOL.size(), m_DOL.data(), _Offset, _Length, _pBuffer); } // fst if (_Offset >= m_fst_address && _Offset < m_dataStartAddress) { WriteToBuffer(m_fst_address, m_FSTData.size(), m_FSTData.data(), _Offset, _Length, _pBuffer); } if (m_virtualDisk.empty()) return true; // Determine which file the offset refers to std::map<u64, std::string>::const_iterator fileIter = m_virtualDisk.lower_bound(_Offset); if (fileIter->first > _Offset && fileIter != m_virtualDisk.begin()) --fileIter; // zero fill to start of file data PadToAddress(fileIter->first, _Offset, _Length, _pBuffer); while (fileIter != m_virtualDisk.end() && _Length > 0) { _dbg_assert_(DVDINTERFACE, fileIter->first <= _Offset); u64 fileOffset = _Offset - fileIter->first; PlainFileReader* reader = PlainFileReader::Create(fileIter->second); if (reader == nullptr) return false; u64 fileSize = reader->GetDataSize(); if (fileOffset < fileSize) { u64 fileBytes = fileSize - fileOffset; if (_Length < fileBytes) fileBytes = _Length; if (!reader->Read(fileOffset, fileBytes, _pBuffer)) return false; _Length -= fileBytes; _pBuffer += fileBytes; _Offset += fileBytes; } ++fileIter; if (fileIter != m_virtualDisk.end()) { _dbg_assert_(DVDINTERFACE, fileIter->first >= _Offset); PadToAddress(fileIter->first, _Offset, _Length, _pBuffer); } delete reader; } return true; }
void SocketConnection::WriteToBuffer(MapNode *mapnode, bool write, int id, int& totalLen, int &totalSize) { /// loop through mapnode /// don't do anything for pure mapnode structures.. if(mapnode->Type() != 0) { if(write) (totalLen < 256)? WriteUnsignedChar((unsigned char)id) : WriteInt(id); else ++totalLen; if(mapnode->Type() == MapNode::BOOL_TYPE) { if(write) WriteChar( mapnode->AsBool()? 1 : 0); else totalSize += srcFormat.CharSize(); } else if(mapnode->Type() == MapNode::CHAR_TYPE) { if(write) WriteChar( mapnode->AsChar() ); else totalSize += srcFormat.CharSize(); } else if(mapnode->Type() == MapNode::UNSIGNED_CHAR_TYPE) { if(write) WriteUnsignedChar( mapnode->AsUnsignedChar() ); else totalSize += srcFormat.CharSize(); } else if(mapnode->Type() == MapNode::INT_TYPE) { if(write) WriteInt( mapnode->AsInt() ); else totalSize += srcFormat.IntSize(); } else if(mapnode->Type() == MapNode::FLOAT_TYPE) { if(write) WriteFloat( mapnode->AsFloat() ); else totalSize += srcFormat.FloatSize(); } else if(mapnode->Type() == MapNode::DOUBLE_TYPE) { if(write) WriteDouble( mapnode->AsDouble() ); else totalSize += srcFormat.DoubleSize(); } else if(mapnode->Type() == MapNode::LONG_TYPE) { if(write) WriteLong( mapnode->AsLong() ); else totalSize += srcFormat.LongSize(); } else if(mapnode->Type() == MapNode::STRING_TYPE) { if(write) WriteString( mapnode->AsString() ); else totalSize += srcFormat.CharSize()*(mapnode->AsString().size() + 1); } else if(mapnode->Type() == MapNode::BOOL_VECTOR_TYPE) { const boolVector& vec = mapnode->AsBoolVector(); // if(vec.size() > 0) { if(write) { WriteInt(vec.size()); for(int i = 0; i < vec.size(); ++i) WriteChar( vec[i]? 1 : 0); } else { //std::cout << mapnode->TypeName() << " " << str << std::endl; totalSize += srcFormat.IntSize(); totalSize += (vec.size()*srcFormat.CharSize()); } } } else if(mapnode->Type() == MapNode::CHAR_VECTOR_TYPE) { const charVector& vec = mapnode->AsCharVector(); // if(vec.size() > 0) { if(write) { WriteInt(vec.size()); for(int i = 0; i < vec.size(); ++i) WriteChar( vec[i] ); } else { //std::cout << mapnode->TypeName() << " " << str << std::endl; totalSize += srcFormat.IntSize(); totalSize += (vec.size()*srcFormat.CharSize()); } } } else if(mapnode->Type() == MapNode::UNSIGNED_CHAR_VECTOR_TYPE) { const unsignedCharVector& vec = mapnode->AsUnsignedCharVector(); // if(vec.size() > 0) { if(write) { WriteInt(vec.size()); for(int i = 0; i < vec.size(); ++i) WriteUnsignedChar( vec[i] ); } else { //std::cout << mapnode->TypeName() << " " << str << std::endl; totalSize += srcFormat.IntSize(); totalSize += (vec.size()*srcFormat.CharSize()); } } } else if(mapnode->Type() == MapNode::INT_VECTOR_TYPE) { const intVector& vec = mapnode->AsIntVector(); // if(vec.size() > 0) { if(write) { WriteInt(vec.size()); for(int i = 0; i < vec.size(); ++i) WriteInt( vec[i] ); } else { //std::cout << mapnode->TypeName() << " " << str << std::endl; totalSize += srcFormat.IntSize(); totalSize += (vec.size()*srcFormat.IntSize()); } } } else if(mapnode->Type() == MapNode::FLOAT_VECTOR_TYPE) { const floatVector& vec = mapnode->AsFloatVector(); // if(vec.size() > 0) { if(write) { WriteInt(vec.size()); for(int i = 0; i < vec.size(); ++i) WriteFloat( vec[i] ); } else { //std::cout << mapnode->TypeName() << " " << str << std::endl; totalSize += srcFormat.IntSize(); totalSize += (vec.size()*srcFormat.FloatSize()); } } } else if(mapnode->Type() == MapNode::DOUBLE_VECTOR_TYPE) { const doubleVector& vec = mapnode->AsDoubleVector(); // if(vec.size() > 0) { if(write) { WriteInt(vec.size()); for(int i = 0; i < vec.size(); ++i) WriteDouble( vec[i] ); } else { //std::cout << mapnode->TypeName() << " " << str << std::endl; totalSize += srcFormat.IntSize(); totalSize += (vec.size()*srcFormat.DoubleSize()); } } } else if(mapnode->Type() == MapNode::LONG_VECTOR_TYPE) { const longVector& vec = mapnode->AsLongVector(); // if(vec.size() > 0) { if(write) { WriteInt(vec.size()); for(int i = 0; i < vec.size(); ++i) WriteLong( vec[i] ); } else { //std::cout << mapnode->TypeName() << " " << str << std::endl; totalSize += srcFormat.IntSize(); totalSize += (vec.size()*srcFormat.LongSize()); } } } else if(mapnode->Type() == MapNode::STRING_VECTOR_TYPE) { const stringVector& vec = mapnode->AsStringVector(); //std::cout << "String vector type : " << vec.size() << std::endl; //if(vec.size() > 0) { if(write) { WriteInt(vec.size()); for(int i = 0; i < vec.size(); ++i) WriteString( vec[i] ); } else { //std::cout << mapnode->TypeName() << " " << str << std::endl; totalSize += srcFormat.IntSize(); for(int i = 0; i < vec.size(); ++i) totalSize += (vec[i].size() + 1)*srcFormat.CharSize(); } } } else { std::cout << "not handled: " << mapnode->TypeName() << std::endl; } } stringVector names; mapnode->GetEntryNames(names); for(int i = 0; i < names.size(); ++i) { //std::cout << "** " << names[i] << std::endl; std::string& name = names[i]; MapNode* mc = mapnode->GetEntry(names[i]); if(mc->Type() == 0) { //JSONNode& child = data->operator [](name); //WriteToBuffer(mc,&child,write,0,totalLen,totalSize); WriteToBuffer(mc,write,0,totalLen,totalSize); } else { int id = atoi(name.c_str());//data->operator [](name).GetInt(); //std::cout << name << " " << id << " " << names[i] << std::endl; WriteToBuffer(mc,write,id,totalLen,totalSize); } } }