clicache/src/impl/PdxLocalWriter.cpp - geode-native - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */


 #include "PdxLocalWriter.hpp"
 #include "PdxHelper.hpp"
 #include "PdxTypeRegistry.hpp"
 #include "../DataOutput.hpp"
 #include "DotNetTypes.hpp"
 #include "../Cache.hpp"

 using namespace System;

 namespace Apache
 {
   namespace Geode
   {
     namespace Client
     {

       namespace Internal
       {

           PdxLocalWriter::PdxLocalWriter(DataOutput^ dataOutput, PdxType^ pdxType)
           {
             m_dataOutput = dataOutput;
             m_pdxType = pdxType;
             m_currentOffsetIndex = 0;
             m_preserveData = nullptr;
             if (pdxType != nullptr)
               m_pdxClassName = pdxType->PdxClassName;
             //m_pdxDomainType = nullptr;
             initialize();
           }

           PdxLocalWriter::PdxLocalWriter(DataOutput^ dataOutput, PdxType^ pdxType, String^ pdxClassName)
           {
             m_dataOutput = dataOutput;
             m_pdxType = pdxType;
             m_currentOffsetIndex = 0;
             m_preserveData = nullptr;
             // m_pdxDomainType = pdxDomainType;
             m_pdxClassName = pdxClassName;
             initialize();
           }

           void PdxLocalWriter::initialize()
           {
             if(m_pdxType != nullptr)
             {
               m_currentOffsetIndex = 0;
               //TODO:: 1 offset below if you can avoid
               m_offsets = gcnew array<int>(m_pdxType->NumberOfVarLenFields);
             }

             //start position, this should start of c++ dataoutput buffer and then use bufferlen
             m_startPosition = m_dataOutput->GetStartBufferPosition();
             //TODO: need to use this carefully
             m_startPositionOffset = static_cast<int>(m_dataOutput->BufferLength);//data has been write
             m_dataOutput->AdvanceCursor(PdxHelper::PdxHeader);//to write pdx header
           }

           void PdxLocalWriter::AddOffset()
           {
             //bufferlength gives lenght which has been writeen to unmanged Dataoutput
             //m_startPositionOffset: from where pdx header length starts
             int bufferLen = static_cast<int>(m_dataOutput->BufferLength - m_startPositionOffset);
             int offset = bufferLen - PdxHelper::PdxHeader/* this needs to subtract*/;

             m_offsets[m_currentOffsetIndex++] = offset;
           }

           void PdxLocalWriter::EndObjectWriting()
           {
             //write header
             WritePdxHeader();
           }

           System::Byte* PdxLocalWriter::GetPdxStream(int& pdxLen)
           {
             System::Byte* stPos = m_dataOutput->GetStartBufferPosition() + m_startPositionOffset;
             int len = PdxHelper::ReadInt32(stPos);
             pdxLen = len;
             //ignore len and typeid
             return m_dataOutput->GetBytes(stPos + 8, len );
           }


           void PdxLocalWriter::WritePdxHeader()
           {
             Int32 len = calculateLenWithOffsets();
             Int32 typeId = m_pdxType->TypeId;

             //GetStartBufferPosition ; if unmanaged dataoutput get change
             System::Byte* starpos = m_dataOutput->GetStartBufferPosition() + m_startPositionOffset;
             PdxHelper::WriteInt32(starpos , len);
             PdxHelper::WriteInt32(starpos + 4, typeId);

             WriteOffsets(len);
           }

           Int32 PdxLocalWriter::calculateLenWithOffsets()
           {
             //int bufferLen = m_dataOutput->GetCursorPdx();
             int bufferLen = static_cast<int>(m_dataOutput->BufferLength - m_startPositionOffset);
             Int32 totalOffsets = 0;
             if(m_offsets->Length > 0)
               totalOffsets = m_offsets->Length -1;//for first var len no need to append offset
             Int32 totalLen = bufferLen - PdxHelper::PdxHeader + totalOffsets;


             if(totalLen <= 0xff)//1 byte
               return totalLen;
             else if (totalLen + totalOffsets <= 0xffff)//2 byte
               return totalLen + totalOffsets ;
             else//4 byte
               return totalLen + totalOffsets*3 ;
           }

           void PdxLocalWriter::WriteOffsets(Int32 len)
           {
             if(len <= 0xff)
             {
               for(int i = m_offsets->Length-1; i >0 ; i--)
                 m_dataOutput->WriteByte((Byte)m_offsets[i]);

             }
             else if(len <= 0xffff)
             {
               for(int i = m_offsets->Length-1; i >0 ; i--)
 								m_dataOutput->WriteUInt16((UInt16)m_offsets[i]);
             }
             else
             {
               for(int i = m_offsets->Length-1; i >0 ; i--)
                 m_dataOutput->WriteUInt32((UInt32)m_offsets[i]);
             }
           }

           bool PdxLocalWriter::isFieldWritingStarted()
           {
             return true;
           }

           IPdxWriter^ PdxLocalWriter::WriteUnreadFields(IPdxUnreadFields^ unread)
           {
             if(isFieldWritingStarted())
             {
               throw gcnew IllegalStateException("WriteUnreadFields must be called before "
 																									+ "any other fields are written.");
             }

             if(unread != nullptr)
             {
               m_preserveData = (PdxRemotePreservedData^)unread;

               m_pdxType = m_dataOutput->Cache->GetPdxTypeRegistry()->GetPdxType(m_preserveData->MergedTypeId);
               if(m_pdxType == nullptr)
               {//its local type
                 //this needs to fix for IPdxTypemapper
                 m_pdxType = GetLocalPdxType(m_pdxClassName);
               }
               m_offsets = gcnew array<int>(m_pdxType->NumberOfVarLenFields);
             }
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteByte( String^ fieldName, SByte value )
           {
 						m_dataOutput->WriteSByte(value);
             return this;
           }

           void PdxLocalWriter::WriteByte(Byte byte)
           {
             m_dataOutput->WriteByte(byte);
           }

           IPdxWriter^ PdxLocalWriter::WriteSByte( String^ fieldName, SByte value )
           {
             m_dataOutput->WriteSByte(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteBoolean( String^ fieldName, bool value )
           {
             m_dataOutput->WriteBoolean(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteChar( String^ fieldName, Char value )
           {
             m_dataOutput->WriteChar(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteUInt16( String^ fieldName, System::UInt16 value )
           {
             m_dataOutput->WriteUInt16(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteUInt32( String^ fieldName, System::UInt32 value )
           {
             m_dataOutput->WriteUInt32(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteUInt64( String^ fieldName, System::UInt64 value )
           {
             m_dataOutput->WriteUInt64(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteShort( String^ fieldName, System::Int16 value )
           {
             m_dataOutput->WriteInt16(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteInt( String^ fieldName, System::Int32 value )
           {
             m_dataOutput->WriteInt32(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteLong( String^ fieldName, Int64 value )
           {
 						m_dataOutput->WriteInt64(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteFloat( String^ fieldName, float value )
           {
             m_dataOutput->WriteFloat(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteDouble( String^ fieldName, double value )
           {
             m_dataOutput->WriteDouble(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteString( String^ fieldName, String^ value )
           {
             AddOffset();
             m_dataOutput->WriteString(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteUTFHuge( String^ fieldName, String^ value )
           {
             AddOffset();
             m_dataOutput->WriteUTFHuge(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteASCIIHuge( String^ fieldName, String^ value )
           {
             AddOffset();
             m_dataOutput->WriteASCIIHuge(value);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteObject( String^ fieldName, Object^ obj )
           {
             AddOffset();
             m_dataOutput->WriteObject(obj);
             return this;
           }

           //TODO:
           //IPdxWriter^ PdxLocalWriter::WriteMap( String^ fieldName, System::Collections::IDictionary^ map );

           IPdxWriter^ PdxLocalWriter::WriteCollection( String^ fieldName, System::Collections::IList^ obj)
           {
             AddOffset();
             m_dataOutput->WriteCollection(obj);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteDate( String^ fieldName, System::DateTime date)
           {
             m_dataOutput->WriteDate(date);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteBooleanArray( String^ fieldName, array<bool>^ boolArray)
           {
             AddOffset();
             m_dataOutput->WriteBooleanArray(boolArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteCharArray(String^ fieldName, array<Char>^ charArray)
           {
             AddOffset();
             m_dataOutput->WriteCharArray(charArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteByteArray(String^ fieldName, array<Byte>^ byteArray)
           {
             AddOffset();
 						m_dataOutput->WriteBytes(byteArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteSByteArray(String^ fieldName, array<SByte>^ sbyteArray)
           {
             AddOffset();
             m_dataOutput->WriteSBytes(sbyteArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteShortArray(String^ fieldName, array<System::Int16>^ shortArray)
           {
             AddOffset();
             m_dataOutput->WriteShortArray(shortArray);//TODO::this don't write typeid looks confusing
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteUnsignedShortArray(String^ fieldName, array<System::UInt16>^ ushortArray)
           {
             AddOffset();
            // m_dataOutput->WriteObject(ushortArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteIntArray(String^ fieldName, array<System::Int32>^ intArray)
           {
             AddOffset();
             m_dataOutput->WriteIntArray(intArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteUnsignedIntArray(String^ fieldName, array<System::UInt32>^ uintArray)
           {
             AddOffset();
            // m_dataOutput->WriteObject(uintArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteLongArray(String^ fieldName, array<Int64>^ longArray)
           {
             AddOffset();
             m_dataOutput->WriteLongArray(longArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteUnsignedLongArray(String^ fieldName, array<System::UInt64>^ ulongArray)
           {
             AddOffset();
             //m_dataOutput->WriteObject(ulongArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteFloatArray(String^ fieldName, array<float>^ floatArray)
           {
             AddOffset();
             m_dataOutput->WriteFloatArray(floatArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteDoubleArray(String^ fieldName, array<double>^ doubleArray)
           {
             AddOffset();
             m_dataOutput->WriteDoubleArray(doubleArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteStringArray(String^ fieldName, array<String^>^ stringArray)
           {
             AddOffset();
             m_dataOutput->WriteStringArray(stringArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteObjectArray(String^ fieldName, List<Object^>^ objectArray)
           {
             AddOffset();
             m_dataOutput->WriteObjectArray(objectArray);
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteArrayOfByteArrays(String^ fieldName, array<array<Byte>^>^ byteArrays)
           {
             AddOffset();
             m_dataOutput->WriteArrayOfByteArrays(byteArrays);
             return this;
           }

           //TODO:
           //IPdxWriter^ PdxLocalWriter::WriteEnum(String^ fieldName, Enum e) ;
           //IPdxWriter^ PdxLocalWriter::WriteInetAddress(String^ fieldName, InetAddress address);


           IPdxWriter^ PdxLocalWriter::MarkIdentityField(String^ fieldName)
           {
             return this;
           }

           IPdxWriter^ PdxLocalWriter::WriteField(String^ fieldName, Object^ fieldValue, Type^ type)
           {
             if(type->Equals(DotNetTypes::IntType))
             {
               return this->WriteInt(fieldName, (int)fieldValue);
             }
             else if(type->Equals(DotNetTypes::StringType))
             {
               return this->WriteString(fieldName, (String^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::BooleanType))
             {
               return this->WriteBoolean(fieldName, (bool)fieldValue);
             }
             else if(type->Equals(DotNetTypes::FloatType))
             {
               return this->WriteFloat(fieldName, (float)fieldValue);
             }
             else if(type->Equals(DotNetTypes::DoubleType))
             {
               return this->WriteDouble(fieldName, (double)fieldValue);
             }
             else if(type->Equals(DotNetTypes::CharType))
             {
               return this->WriteChar(fieldName, (Char)fieldValue);
             }
             else if(type->Equals(DotNetTypes::SByteType))
             {
               return this->WriteByte(fieldName, (SByte)fieldValue);
             }
             else if(type->Equals(DotNetTypes::ShortType))
             {
               return this->WriteShort(fieldName, (short)fieldValue);
             }
             else if(type->Equals(DotNetTypes::LongType))
             {
               return this->WriteLong(fieldName, (Int64)fieldValue);
             }
             else if(type->Equals(DotNetTypes::ByteArrayType))
             {
               return this->WriteByteArray(fieldName, (array<Byte>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::DoubleArrayType))
             {
               return this->WriteDoubleArray(fieldName, (array<double>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::FloatArrayType))
             {
               return this->WriteFloatArray(fieldName, (array<float>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::ShortArrayType))
             {
               return this->WriteShortArray(fieldName, (array<Int16>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::IntArrayType))
             {
               return this->WriteIntArray(fieldName, (array<System::Int32>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::LongArrayType))
             {
               return this->WriteLongArray(fieldName, (array<Int64>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::BoolArrayType))
             {
               return this->WriteBooleanArray(fieldName, (array<bool>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::CharArrayType))
             {
               return this->WriteCharArray(fieldName, (array<Char>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::StringArrayType))
             {
               return this->WriteStringArray(fieldName, (array<String^>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::DateType))
             {
               return this->WriteDate(fieldName, (DateTime)fieldValue);
             }
             else if(type->Equals(DotNetTypes::ByteArrayOfArrayType))
             {
               return this->WriteArrayOfByteArrays(fieldName, (array<array<Byte>^>^)fieldValue);
             }
             else if(type->Equals(DotNetTypes::ObjectArrayType))
             {
               return this->WriteObjectArray(fieldName, safe_cast<System::Collections::Generic::List<Object^>^>(fieldValue));
             }
             else
             {
               return this->WriteObject(fieldName, fieldValue);
             }
           }

           PdxType^ PdxLocalWriter::GetLocalPdxType(String^ pdxClassName)
           {
             return m_dataOutput->Cache->GetPdxTypeRegistry()->GetLocalPdxType(pdxClassName);
           }

           Apache::Geode::Client::Cache^ PdxLocalWriter::Cache::get() { return m_dataOutput->Cache; }

       }  // namespace Internal
     }  // namespace Client
   }  // namespace Geode
 }  // namespace Apache
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/


	#include "PdxLocalWriter.hpp"
	#include "PdxHelper.hpp"
	#include "PdxTypeRegistry.hpp"
	#include "../DataOutput.hpp"
	#include "DotNetTypes.hpp"
	#include "../Cache.hpp"

	using namespace System;

	namespace Apache
	{
	namespace Geode
	{
	namespace Client
	{

	namespace Internal
	{

	PdxLocalWriter::PdxLocalWriter(DataOutput^ dataOutput, PdxType^ pdxType)
	{
	m_dataOutput = dataOutput;
	m_pdxType = pdxType;
	m_currentOffsetIndex = 0;
	m_preserveData = nullptr;
	if (pdxType != nullptr)
	m_pdxClassName = pdxType->PdxClassName;
	//m_pdxDomainType = nullptr;
	initialize();
	}

	PdxLocalWriter::PdxLocalWriter(DataOutput^ dataOutput, PdxType^ pdxType, String^ pdxClassName)
	{
	m_dataOutput = dataOutput;
	m_pdxType = pdxType;
	m_currentOffsetIndex = 0;
	m_preserveData = nullptr;
	// m_pdxDomainType = pdxDomainType;
	m_pdxClassName = pdxClassName;
	initialize();
	}

	void PdxLocalWriter::initialize()
	{
	if(m_pdxType != nullptr)
	{
	m_currentOffsetIndex = 0;
	//TODO:: 1 offset below if you can avoid
	m_offsets = gcnew array<int>(m_pdxType->NumberOfVarLenFields);
	}

	//start position, this should start of c++ dataoutput buffer and then use bufferlen
	m_startPosition = m_dataOutput->GetStartBufferPosition();
	//TODO: need to use this carefully
	m_startPositionOffset = static_cast<int>(m_dataOutput->BufferLength);//data has been write
	m_dataOutput->AdvanceCursor(PdxHelper::PdxHeader);//to write pdx header
	}

	void PdxLocalWriter::AddOffset()
	{
	//bufferlength gives lenght which has been writeen to unmanged Dataoutput
	//m_startPositionOffset: from where pdx header length starts
	int bufferLen = static_cast<int>(m_dataOutput->BufferLength - m_startPositionOffset);
	int offset = bufferLen - PdxHelper::PdxHeader/* this needs to subtract*/;

	m_offsets[m_currentOffsetIndex++] = offset;
	}

	void PdxLocalWriter::EndObjectWriting()
	{
	//write header
	WritePdxHeader();
	}

	System::Byte* PdxLocalWriter::GetPdxStream(int& pdxLen)
	{
	System::Byte* stPos = m_dataOutput->GetStartBufferPosition() + m_startPositionOffset;
	int len = PdxHelper::ReadInt32(stPos);
	pdxLen = len;
	//ignore len and typeid
	return m_dataOutput->GetBytes(stPos + 8, len );
	}


	void PdxLocalWriter::WritePdxHeader()
	{
	Int32 len = calculateLenWithOffsets();
	Int32 typeId = m_pdxType->TypeId;

	//GetStartBufferPosition ; if unmanaged dataoutput get change
	System::Byte* starpos = m_dataOutput->GetStartBufferPosition() + m_startPositionOffset;
	PdxHelper::WriteInt32(starpos , len);
	PdxHelper::WriteInt32(starpos + 4, typeId);

	WriteOffsets(len);
	}

	Int32 PdxLocalWriter::calculateLenWithOffsets()
	{
	//int bufferLen = m_dataOutput->GetCursorPdx();
	int bufferLen = static_cast<int>(m_dataOutput->BufferLength - m_startPositionOffset);
	Int32 totalOffsets = 0;
	if(m_offsets->Length > 0)
	totalOffsets = m_offsets->Length -1;//for first var len no need to append offset
	Int32 totalLen = bufferLen - PdxHelper::PdxHeader + totalOffsets;


	if(totalLen <= 0xff)//1 byte
	return totalLen;
	else if (totalLen + totalOffsets <= 0xffff)//2 byte
	return totalLen + totalOffsets ;
	else//4 byte
	return totalLen + totalOffsets*3 ;
	}

	void PdxLocalWriter::WriteOffsets(Int32 len)
	{
	if(len <= 0xff)
	{
	for(int i = m_offsets->Length-1; i >0 ; i--)
	m_dataOutput->WriteByte((Byte)m_offsets[i]);

	}
	else if(len <= 0xffff)
	{
	for(int i = m_offsets->Length-1; i >0 ; i--)
	m_dataOutput->WriteUInt16((UInt16)m_offsets[i]);
	}
	else
	{
	for(int i = m_offsets->Length-1; i >0 ; i--)
	m_dataOutput->WriteUInt32((UInt32)m_offsets[i]);
	}
	}

	bool PdxLocalWriter::isFieldWritingStarted()
	{
	return true;
	}

	IPdxWriter^ PdxLocalWriter::WriteUnreadFields(IPdxUnreadFields^ unread)
	{
	if(isFieldWritingStarted())
	{
	throw gcnew IllegalStateException("WriteUnreadFields must be called before "
	+ "any other fields are written.");
	}

	if(unread != nullptr)
	{
	m_preserveData = (PdxRemotePreservedData^)unread;

	m_pdxType = m_dataOutput->Cache->GetPdxTypeRegistry()->GetPdxType(m_preserveData->MergedTypeId);
	if(m_pdxType == nullptr)
	{//its local type
	//this needs to fix for IPdxTypemapper
	m_pdxType = GetLocalPdxType(m_pdxClassName);
	}
	m_offsets = gcnew array<int>(m_pdxType->NumberOfVarLenFields);
	}
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteByte( String^ fieldName, SByte value )
	{
	m_dataOutput->WriteSByte(value);
	return this;
	}

	void PdxLocalWriter::WriteByte(Byte byte)
	{
	m_dataOutput->WriteByte(byte);
	}

	IPdxWriter^ PdxLocalWriter::WriteSByte( String^ fieldName, SByte value )
	{
	m_dataOutput->WriteSByte(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteBoolean( String^ fieldName, bool value )
	{
	m_dataOutput->WriteBoolean(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteChar( String^ fieldName, Char value )
	{
	m_dataOutput->WriteChar(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteUInt16( String^ fieldName, System::UInt16 value )
	{
	m_dataOutput->WriteUInt16(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteUInt32( String^ fieldName, System::UInt32 value )
	{
	m_dataOutput->WriteUInt32(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteUInt64( String^ fieldName, System::UInt64 value )
	{
	m_dataOutput->WriteUInt64(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteShort( String^ fieldName, System::Int16 value )
	{
	m_dataOutput->WriteInt16(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteInt( String^ fieldName, System::Int32 value )
	{
	m_dataOutput->WriteInt32(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteLong( String^ fieldName, Int64 value )
	{
	m_dataOutput->WriteInt64(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteFloat( String^ fieldName, float value )
	{
	m_dataOutput->WriteFloat(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteDouble( String^ fieldName, double value )
	{
	m_dataOutput->WriteDouble(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteString( String^ fieldName, String^ value )
	{
	AddOffset();
	m_dataOutput->WriteString(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteUTFHuge( String^ fieldName, String^ value )
	{
	AddOffset();
	m_dataOutput->WriteUTFHuge(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteASCIIHuge( String^ fieldName, String^ value )
	{
	AddOffset();
	m_dataOutput->WriteASCIIHuge(value);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteObject( String^ fieldName, Object^ obj )
	{
	AddOffset();
	m_dataOutput->WriteObject(obj);
	return this;
	}

	//TODO:
	//IPdxWriter^ PdxLocalWriter::WriteMap( String^ fieldName, System::Collections::IDictionary^ map );

	IPdxWriter^ PdxLocalWriter::WriteCollection( String^ fieldName, System::Collections::IList^ obj)
	{
	AddOffset();
	m_dataOutput->WriteCollection(obj);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteDate( String^ fieldName, System::DateTime date)
	{
	m_dataOutput->WriteDate(date);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteBooleanArray( String^ fieldName, array<bool>^ boolArray)
	{
	AddOffset();
	m_dataOutput->WriteBooleanArray(boolArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteCharArray(String^ fieldName, array<Char>^ charArray)
	{
	AddOffset();
	m_dataOutput->WriteCharArray(charArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteByteArray(String^ fieldName, array<Byte>^ byteArray)
	{
	AddOffset();
	m_dataOutput->WriteBytes(byteArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteSByteArray(String^ fieldName, array<SByte>^ sbyteArray)
	{
	AddOffset();
	m_dataOutput->WriteSBytes(sbyteArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteShortArray(String^ fieldName, array<System::Int16>^ shortArray)
	{
	AddOffset();
	m_dataOutput->WriteShortArray(shortArray);//TODO::this don't write typeid looks confusing
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteUnsignedShortArray(String^ fieldName, array<System::UInt16>^ ushortArray)
	{
	AddOffset();
	// m_dataOutput->WriteObject(ushortArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteIntArray(String^ fieldName, array<System::Int32>^ intArray)
	{
	AddOffset();
	m_dataOutput->WriteIntArray(intArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteUnsignedIntArray(String^ fieldName, array<System::UInt32>^ uintArray)
	{
	AddOffset();
	// m_dataOutput->WriteObject(uintArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteLongArray(String^ fieldName, array<Int64>^ longArray)
	{
	AddOffset();
	m_dataOutput->WriteLongArray(longArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteUnsignedLongArray(String^ fieldName, array<System::UInt64>^ ulongArray)
	{
	AddOffset();
	//m_dataOutput->WriteObject(ulongArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteFloatArray(String^ fieldName, array<float>^ floatArray)
	{
	AddOffset();
	m_dataOutput->WriteFloatArray(floatArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteDoubleArray(String^ fieldName, array<double>^ doubleArray)
	{
	AddOffset();
	m_dataOutput->WriteDoubleArray(doubleArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteStringArray(String^ fieldName, array<String^>^ stringArray)
	{
	AddOffset();
	m_dataOutput->WriteStringArray(stringArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteObjectArray(String^ fieldName, List<Object^>^ objectArray)
	{
	AddOffset();
	m_dataOutput->WriteObjectArray(objectArray);
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteArrayOfByteArrays(String^ fieldName, array<array<Byte>^>^ byteArrays)
	{
	AddOffset();
	m_dataOutput->WriteArrayOfByteArrays(byteArrays);
	return this;
	}

	//TODO:
	//IPdxWriter^ PdxLocalWriter::WriteEnum(String^ fieldName, Enum e) ;
	//IPdxWriter^ PdxLocalWriter::WriteInetAddress(String^ fieldName, InetAddress address);


	IPdxWriter^ PdxLocalWriter::MarkIdentityField(String^ fieldName)
	{
	return this;
	}

	IPdxWriter^ PdxLocalWriter::WriteField(String^ fieldName, Object^ fieldValue, Type^ type)
	{
	if(type->Equals(DotNetTypes::IntType))
	{
	return this->WriteInt(fieldName, (int)fieldValue);
	}
	else if(type->Equals(DotNetTypes::StringType))
	{
	return this->WriteString(fieldName, (String^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::BooleanType))
	{
	return this->WriteBoolean(fieldName, (bool)fieldValue);
	}
	else if(type->Equals(DotNetTypes::FloatType))
	{
	return this->WriteFloat(fieldName, (float)fieldValue);
	}
	else if(type->Equals(DotNetTypes::DoubleType))
	{
	return this->WriteDouble(fieldName, (double)fieldValue);
	}
	else if(type->Equals(DotNetTypes::CharType))
	{
	return this->WriteChar(fieldName, (Char)fieldValue);
	}
	else if(type->Equals(DotNetTypes::SByteType))
	{
	return this->WriteByte(fieldName, (SByte)fieldValue);
	}
	else if(type->Equals(DotNetTypes::ShortType))
	{
	return this->WriteShort(fieldName, (short)fieldValue);
	}
	else if(type->Equals(DotNetTypes::LongType))
	{
	return this->WriteLong(fieldName, (Int64)fieldValue);
	}
	else if(type->Equals(DotNetTypes::ByteArrayType))
	{
	return this->WriteByteArray(fieldName, (array<Byte>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::DoubleArrayType))
	{
	return this->WriteDoubleArray(fieldName, (array<double>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::FloatArrayType))
	{
	return this->WriteFloatArray(fieldName, (array<float>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::ShortArrayType))
	{
	return this->WriteShortArray(fieldName, (array<Int16>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::IntArrayType))
	{
	return this->WriteIntArray(fieldName, (array<System::Int32>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::LongArrayType))
	{
	return this->WriteLongArray(fieldName, (array<Int64>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::BoolArrayType))
	{
	return this->WriteBooleanArray(fieldName, (array<bool>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::CharArrayType))
	{
	return this->WriteCharArray(fieldName, (array<Char>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::StringArrayType))
	{
	return this->WriteStringArray(fieldName, (array<String^>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::DateType))
	{
	return this->WriteDate(fieldName, (DateTime)fieldValue);
	}
	else if(type->Equals(DotNetTypes::ByteArrayOfArrayType))
	{
	return this->WriteArrayOfByteArrays(fieldName, (array<array<Byte>^>^)fieldValue);
	}
	else if(type->Equals(DotNetTypes::ObjectArrayType))
	{
	return this->WriteObjectArray(fieldName, safe_cast<System::Collections::Generic::List<Object^>^>(fieldValue));
	}
	else
	{
	return this->WriteObject(fieldName, fieldValue);
	}
	}

	PdxType^ PdxLocalWriter::GetLocalPdxType(String^ pdxClassName)
	{
	return m_dataOutput->Cache->GetPdxTypeRegistry()->GetLocalPdxType(pdxClassName);
	}

	Apache::Geode::Client::Cache^ PdxLocalWriter::Cache::get() { return m_dataOutput->Cache; }

	} // namespace Internal
	} // namespace Client
	} // namespace Geode
	} // namespace Apache