//----------------------------
        static bool WriteValueByType(MySqlStreamWriter writer,
            ref MyStructData dataTemp,
            ref TempSingleValueHolder singleValueHolder)
        {
            int availableContentSpace = Packet.MAX_PACKET_LENGTH - (int)writer.OnlyPacketContentLength;
            if (singleValueHolder.round == 0)
            {
                //---------------------------
                //this is first round *** 
                //---------------------------
                switch (dataTemp.type)
                {
                    case MySqlDataType.NULL:
                        //we not write null data
                        return true;
                    case MySqlDataType.BIT:
                    case MySqlDataType.BLOB:
                    case MySqlDataType.MEDIUM_BLOB:
                    case MySqlDataType.LONG_BLOB:

                        //writer.WriteLengthCodedBuffer(dataTemp.myBuffer);
                        //this is first round
                        singleValueHolder.isBufferOrString = true;
                        singleValueHolder.bufferContent = dataTemp.myBuffer;
                        singleValueHolder.contentLen = singleValueHolder.bufferContent.Length;
                        //generate output
                        singleValueHolder.encodedLengthLen = writer.GenerateEncodeLengthNumber(singleValueHolder.contentLen, singleValueHolder.headerLenBuffer);
                        if (availableContentSpace > singleValueHolder.TotalLength)
                        {
                            //write in first round
                            writer.WriteLengthCodedBuffer(singleValueHolder.bufferContent);
                            return true;
                        }
                        //go below

                        break;
                    case MySqlDataType.VARCHAR:
                    case MySqlDataType.VAR_STRING:
                    case MySqlDataType.STRING:
                        {
                            //this is first round
                            singleValueHolder.isBufferOrString = true;
                            singleValueHolder.bufferContent = Encoding.UTF8.GetBytes(dataTemp.myString);
                            singleValueHolder.contentLen = singleValueHolder.bufferContent.Length;
                            //generate output
                            singleValueHolder.encodedLengthLen = writer.GenerateEncodeLengthNumber(singleValueHolder.contentLen, singleValueHolder.headerLenBuffer);
                            if (availableContentSpace > singleValueHolder.TotalLength)
                            {
                                //write in first round
                                writer.WriteLengthCodedBuffer(singleValueHolder.bufferContent);
                                return true;
                            }
                            //go below 
                        }
                        break;
                    case MySqlDataType.TINY:
                        //if we can write in 1st round 
                        if (availableContentSpace > 1)
                        {
                            writer.WriteUnsignedNumber(1, dataTemp.myUInt32);
                            return true;
                        }
                        else
                        {
                            //go below 
                            MySqlStreamWriter.WriteUnsignedNumber(1, dataTemp.myUInt32, singleValueHolder.generalContent);
                        }
                        break;
                    case MySqlDataType.SHORT:
                        if (availableContentSpace > 2)
                        {
                            writer.WriteUnsignedNumber(2, dataTemp.myUInt32);
                            return true;
                        }
                        else
                        {
                            MySqlStreamWriter.WriteUnsignedNumber(2, dataTemp.myUInt32, singleValueHolder.generalContent);
                        }
                        break;
                    case MySqlDataType.LONG:
                        if (availableContentSpace > 4)
                        {
                            writer.WriteUnsignedNumber(4, dataTemp.myUInt32);
                            return true;
                        }
                        else
                        {
                            MySqlStreamWriter.WriteUnsignedNumber(4, dataTemp.myUInt32, singleValueHolder.generalContent);
                            //go below 
                        }
                        break;
                    case MySqlDataType.LONGLONG:
                        if (availableContentSpace > 8)
                        {
                            writer.WriteInt64(dataTemp.myInt64);
                            return true;
                        }
                        else
                        {
                            //go below 
                            MySqlStreamWriter.Write(dataTemp.myInt64, singleValueHolder.generalContent);
                        }

                        break;
                    case MySqlDataType.FLOAT:
                        if (availableContentSpace > 4)
                        {
                            writer.WriteFloat((float)dataTemp.myDouble);
                            return true;
                        }
                        else
                        {
                            //go below 
                            MySqlStreamWriter.Write((float)dataTemp.myDouble, singleValueHolder.generalContent);
                        }
                        break;
                    case MySqlDataType.DOUBLE:
                        if (availableContentSpace > 8)
                        {
                            writer.WriteDouble(dataTemp.myDouble);
                            return true;
                        }
                        else
                        {
                            //go below 
                            MySqlStreamWriter.Write(dataTemp.myDouble, singleValueHolder.generalContent);
                        }
                        break;
                    default:
                        //TODO: review here
                        throw new NotSupportedException();
                        //writer.WriteLengthCodedNull();
                }
            }
            //----------------------------------------------------------------------------------------------------------
            if (singleValueHolder.isBufferOrString)
            {
                //write encoded len & data
                //check if we write complete header or not   
                if (singleValueHolder.encodedLengthBufferWriteIndex < singleValueHolder.encodedLengthLen)
                {
                    //can we write complete encoded length header here?
                    int remaining = singleValueHolder.encodedLengthLen - singleValueHolder.encodedLengthBufferWriteIndex;
                    if (availableContentSpace > remaining)
                    {
                        for (int i = 0; i < remaining; ++i)
                        {
                            writer.WriteByte(singleValueHolder.headerLenBuffer[singleValueHolder.encodedLengthBufferWriteIndex]);
                            singleValueHolder.encodedLengthBufferWriteIndex++;
                        }
                        availableContentSpace -= remaining;
                    }
                    else if (availableContentSpace == remaining)
                    {
                        //TODO: review here
                        throw new NotSupportedException();
                        //we can write only header ***
                        for (int i = 0; i < remaining; ++i)
                        {
                            writer.WriteByte(singleValueHolder.headerLenBuffer[singleValueHolder.encodedLengthBufferWriteIndex]);
                            singleValueHolder.encodedLengthBufferWriteIndex++;
                        }
                        availableContentSpace -= remaining;
                    }
                    else
                    {
                        //can't complete encoded length here in this step
                        for (int i = 0; i < availableContentSpace; ++i)
                        {
                            writer.WriteByte(singleValueHolder.headerLenBuffer[singleValueHolder.encodedLengthBufferWriteIndex]);
                            singleValueHolder.encodedLengthBufferWriteIndex++;
                        }
                        return false;
                    }
                }
                //---------------
                //write the body
                int remainBodyLen = singleValueHolder.contentLen - singleValueHolder.contentStart;
                if (availableContentSpace > remainBodyLen)
                {
                    //write buffer 
                    //we use bufferContent ****
                    writer.WriteBuffer(singleValueHolder.bufferContent, singleValueHolder.contentStart, remainBodyLen);
                    singleValueHolder.contentStart += remainBodyLen;
                    return true;

                }
                else if (availableContentSpace == remainBodyLen)
                { 
                    //TODO: review here
                    throw new NotSupportedException();
                    //this needs last packet with 0 byte content size ***
                    writer.WriteBuffer(singleValueHolder.generalContent, singleValueHolder.contentStart, remainBodyLen);
                    singleValueHolder.contentStart += remainBodyLen;
                    return false;
                }
                else
                {
                    //write buffer 
                    //we use bufferContent ****
                    writer.WriteBuffer(singleValueHolder.bufferContent, singleValueHolder.contentStart, availableContentSpace);
                    singleValueHolder.contentStart += availableContentSpace;
                    return false;
                }
            }
            else
            {
                //---------------
                //write the body
                int remainBodyLen = singleValueHolder.contentLen - singleValueHolder.contentStart;
                if (availableContentSpace > remainBodyLen)
                {
                    //write buffer 
                    //we use generalContent ****
                    writer.WriteBuffer(singleValueHolder.generalContent, singleValueHolder.contentStart, remainBodyLen);
                    singleValueHolder.contentStart += remainBodyLen;
                    return true;
                }
                else if (availableContentSpace == remainBodyLen)
                {   
                    
                    //TODO: review here
                    throw new NotSupportedException();
                    //this needs last packet with 0 byte content size ***
                    writer.WriteBuffer(singleValueHolder.generalContent, singleValueHolder.contentStart, remainBodyLen);
                    singleValueHolder.contentStart += remainBodyLen;
                    return false;
                }
                else
                {
                    //write buffer 
                    //we use generalContent ****
                    writer.WriteBuffer(singleValueHolder.generalContent, singleValueHolder.contentStart, availableContentSpace);
                    singleValueHolder.contentStart += availableContentSpace;
                    return false;
                }
            }
        }