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