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);
}
}
}
