void ser(struct node* root,int search)
{
	if(root->data==search)
	{
		if(root->right!=NULL)
		{
			root=root->right;
			while(root->left!=NULL)
			{
				root=root->left;
			}
			printf("%d ",root->data);
		}
		else
		{
			while(root->par->left!=root)
			{
				root=root->par;
			}
			printf("%d ",root->par->data);
		}
	}
	else if(root->data>search)
	{
		ser(root->left,search);
	}
	else
	{
		ser(root->right,search);
	}
}

// static
void Serdes::SerializeMapObjects(MapObjects const & mapObjects, std::vector<int8_t> & result)
{
  result.clear();
  using Sink = MemWriter<std::vector<int8_t>>;

  Sink writer(result);
  std::string const nextLine = "\n";
  MapObjectEvent event;

  mapObjects.ForEach([&writer, &event, &nextLine](MapObject const & item)
  {
    for (auto const & poiEvent : item.GetEvents())
    {
      // Additional scope is added because of the coding::SerializerJson dumps result at destruction.
      {
        coding::SerializerJson<Sink> ser(writer);
        event.m_bestPoiType = item.GetBestType();
        event.m_poiPos = item.GetPos();
        event.m_defaultName = item.GetDefaultName();
        event.m_readableName = item.GetReadableName();
        event.m_event = poiEvent;
        ser(event);
      }
      writer.Write(nextLine.data(), nextLine.size());
    }
  });
}

///////////////////////////////////////////////////////////////////////////////
// WriteObjectToArchive -- called from WriteObject, does most of the work
///////////////////////////////////////////////////////////////////////////////
static void WriteObjectToArchive(cArchive&                 arch,
                                 const TCHAR*              filename, // filename is used only for issuing error messages
                                 const iTypedSerializable* pObjHeader,
                                 const iTypedSerializable& obj,
                                 cFileHeader&              fileHeader,
                                 bool                      bEncrypt,
                                 const cElGamalSigPrivateKey* pPrivateKey)
{
    try
    {
        // Set file version.
        // If we in the future we wish to support reading databases of different versions,
        // we will have to move this set to outside WriteObject().
        fileHeader.SetVersion(CURRENT_FIXED_VERSION);

        fileHeader.SetEncoding(bEncrypt ? cFileHeader::ASYM_ENCRYPTION : cFileHeader::COMPRESSED);

        {
            cSerializerImpl fhSer(arch, cSerializerImpl::S_WRITE, filename);
            fileHeader.Write(&fhSer);
        }

        if (bEncrypt)
        {
            cElGamalSigArchive cryptoArchive;
            cryptoArchive.SetWrite(&arch, pPrivateKey);
            cSerializerImpl ser(cryptoArchive, cSerializerImpl::S_WRITE, filename);
            ser.Init();
            if (pObjHeader)
                ser.WriteObject(pObjHeader);
            ser.WriteObject(&obj);
            ser.Finit();
            cryptoArchive.FlushWrite();
        }
        else
        {
            // not encrypted
            cNullCryptoArchive cryptoArchive;
            cryptoArchive.Start(&arch);
            cSerializerImpl ser(cryptoArchive, cSerializerImpl::S_WRITE, filename);
            ser.Init();
            if (pObjHeader)
                ser.WriteObject(pObjHeader);
            ser.WriteObject(&obj);
            ser.Finit();
            cryptoArchive.Finish();
        }
    }
    catch (eError& e)
    {
        throw ePoly(e.GetID(), cErrorUtil::MakeFileError(e.GetMsg(), filename), e.GetFlags());
    }
}

HalfFloatGridSource::HalfFloatGridSource(const String &serializedVolumeFile, const bool trilinearValue, const bool trilinearGradient, const bool sobelGradient) :
    GridSource(trilinearValue, trilinearGradient, sobelGradient)
{

    Timer t;
    DataStreamPtr streamRead = Root::getSingleton().openFileStream(serializedVolumeFile);
#if OGRE_NO_ZIP_ARCHIVE == 0
    DataStreamPtr uncompressStream(OGRE_NEW DeflateStream(serializedVolumeFile, streamRead));
    StreamSerialiser ser(uncompressStream);
#else
    StreamSerialiser ser(streamRead);
#endif
    if (!ser.readChunkBegin(VOLUME_CHUNK_ID, VOLUME_CHUNK_VERSION))
    {
        OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
                    "Invalid volume file given!",
                    __FUNCTION__);
    }

    // Read header
    Vector3 readFrom, readTo;
    ser.read(&readFrom);
    ser.read(&readTo);
    float voxelWidth;
    ser.read<float>(&voxelWidth);
    size_t width, height, depth;
    ser.read<size_t>(&width);
    ser.read<size_t>(&height);
    ser.read<size_t>(&depth);
    mWidth = static_cast<int>(width);
    mHeight = static_cast<int>(height);
    mDepth = static_cast<int>(depth);
    mDepthTimesHeight = static_cast<int>(mDepth * mHeight);

    Vector3 worldDimension = readTo - readFrom;
    mPosXScale = (Real)1.0 / (Real)worldDimension.x * (Real)mWidth;
    mPosYScale = (Real)1.0 / (Real)worldDimension.y * (Real)mHeight;
    mPosZScale = (Real)1.0 / (Real)worldDimension.z * (Real)mDepth;

    mVolumeSpaceToWorldSpaceFactor = (Real)worldDimension.x * (Real)mWidth;
    mMaxClampedAbsoluteDensity = 0;

    // Read data
    size_t elementCount = mWidth * mHeight * mDepth;
    mData = OGRE_ALLOC_T(uint16, elementCount, MEMCATEGORY_GENERAL);
    ser.read(mData, elementCount);

    ser.readChunkEnd(VOLUME_CHUNK_ID);

    LogManager::getSingleton().stream() << "Processed serialization in " << t.getMilliseconds() << "ms.";
}

void controlc()					// say ^C
{ cstring *sptr;				// string ptr
  u_char junk[10];
  short s;					// for returns
  sptr = (cstring *) junk;			// where to put it
  s = SQ_WriteFormat(SQ_LF);			// new line
  if (s < 0) ser(s);				// check for error
  bcopy("^C", sptr->buf, 2);			// copy in the prompt
  sptr->buf[3] = '\0';				// null terminate
  sptr->len = 2;				// and the length
  s = SQ_Write(sptr);				// write the prompt
  if (s < 0) ser(s);				// check for error
  return;					// exit
}

	//---------------------------------------------------------------------
	void Page::save(const String& filename)
	{
		DataStreamPtr stream = Root::getSingleton().createFileStream(filename, 
			getManager()->getPageResourceGroup(), true);
		StreamSerialiser ser(stream);
		save(ser);
	}

netBool UnreliableListener::Push(SerializerLess &_ser, const Peer& _peer)
{
	assert(m_stream != nullptr);

	Channel& channel = GetChannel(m_sendChannels, _peer);

	SerializerLess *back = channel.Back();

	// bundling
	if(channel.IsEmpty() || back->GetSize() + _ser.GetSize() > back->GetBufferSize())
	{
		SerializerLess ser(m_pool.GetSerializer());
		// prepare serializer
		ser.Write(m_stream->GetType());

		SerializerLess stream_ser(ser, m_stream->GetHeaderSize(), ser.GetBufferSize());
		stream_ser.Write(GetType());
		stream_ser.Close();

		ser.SetCursor(ser.GetCursor() + stream_ser.GetSize());
		ser.Close();
		channel.Push(ser);
	}

	return Pack(_ser, _peer);
}

///////////////////////////////////////////////////////////////////////////////
// SetFCOData
///////////////////////////////////////////////////////////////////////////////
void cDbDataSourceIter::SetFCOData( const iFCO* pFCO ) //throw (eError)
{
	ASSERT( ! Done() );
	if( Done() )
	{
		throw eHierDatabase( _T("Attempt to set FCO data when the iterator is done.") );
	}
	// TODO -- assert and throw if the fco's type is not the same as our creation function
	//		There is no way to do this through the serializable interface, but when there is,
	//		we should do the above assertion.
	//
	// if data already exists here, we first remove it; 
	//
	if( mDbIter.HasData() )
	{
		mDbIter.RemoveData();
	}
	//
	// write the fco's property set to a memory archive...
	//
	// TODO -- does this need to be static?
	static cMemoryArchive arch;
	arch.Seek			( 0, cBidirArchive::BEGINNING );
	cSerializerImpl ser	(arch, cSerializerImpl::S_WRITE);
	ser.Init();
	ser.WriteObject		( pFCO->GetPropSet() );
	ser.Finit();
	//
	// write this to the archive...
	//
	mDbIter.SetData( arch.GetMemory(), arch.CurrentPos() );
}

/*
===============
idCommonLocal::SendUsercmd
===============
*/
void idCommonLocal::SendUsercmds( int localClientNum ) {
    if ( !mapSpawned ) {
        return;
    }
    int currentTime = Sys_Milliseconds();
    if ( currentTime < nextUsercmdSendTime ) {
        return;
    }
    idLobbyBase & lobby = session->GetActingGameStateLobbyBase();
    if ( lobby.IsHost() ) {
        return;
    }
    // We always send the last NUM_USERCMD_SEND usercmds
    // Which may result in duplicate usercmds being sent in the case of a low net_ucmdRate
    // But the LZW compressor means the extra usercmds are not large and the redundancy can smooth packet loss
    byte buffer[idPacketProcessor::MAX_FINAL_PACKET_SIZE];
    idBitMsg msg( buffer, sizeof( buffer ) );
    idSerializer ser( msg, true );
    usercmd_t empty;
    usercmd_t * last = &empty;

    usercmd_t * cmdBuffer[NUM_USERCMD_SEND];
    const int numCmds = userCmdMgr.GetPlayerCmds( localClientNum, cmdBuffer, NUM_USERCMD_SEND );
    msg.WriteByte( numCmds );
    for ( int i = 0; i < numCmds; i++ ) {
        cmdBuffer[i]->Serialize( ser, *last );

        last = cmdBuffer[i];
    }
    session->SendUsercmds( msg );

    nextUsercmdSendTime = MSEC_ALIGN_TO_FRAME( currentTime + net_ucmdRate.GetInteger() );
}

bool MetaTestTypesPubSubType::getKey(void *data, InstanceHandle_t* handle)
{
    if(!m_isGetKeyDefined)
        return false;

    MetaTestType* p_type = (MetaTestType*) data;

    // Object that manages the raw buffer.
    eprosima::fastcdr::FastBuffer fastbuffer((char*)m_keyBuffer,MetaTestType::getKeyMaxCdrSerializedSize());
    // Object that serializes the data.
    eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS);

    p_type->serializeKey(ser);
    if(MetaTestType::getKeyMaxCdrSerializedSize()>16)
    {
        m_md5.init();
        m_md5.update(m_keyBuffer,(unsigned int)ser.getSerializedDataLength());
        m_md5.finalize();
        for(uint8_t i = 0; i<16; ++i)
        {
            handle->value[i] = m_md5.digest[i];
        }
    }
    else
    {
        for(uint8_t i = 0; i<16; ++i)
        {
            handle->value[i] = m_keyBuffer[i];
        }
    }

    return true;
}

void MeshSaverImplv1_0::WriteVersion(OutputStreamPtr& out) {
	OutputSerializer ser(out);
	uint32 meshMagic = FILE_MAGIC_MESH;
	VersionID ver = NEX_MAKE_VERSION(1, 0, 0);
	String versionInfo = Convert::ToVersionString(ver);
	ser << meshMagic << versionInfo;
}

void serialize_gc(int fd, const vector<GarbledGate>& gc) {
    struct serializer : public boost::static_visitor<> {
        int fd;
        serializer(int fd_) : fd(fd_) {}
        void operator()(const InputWire& w) {
            char who = tag_to_bool(w.who) ? 'S' : 'R';
            dbgprintf(stderr, "Serializing InputWire(%c, %lu)\n", who, w.index);
            write_aon(fd, "0", sizeof(char));
            write_aon(fd, &who, sizeof(char));
            write_aon(fd, (char*)&w.index, sizeof(size_t));
        }
        void operator()(const GarbledWire& w) {
            dbgprintf(stderr, "Serializing GarbledWire(%lu, %lu)\n", w.l, w.r);
            write_aon(fd, "1", sizeof(char));
            write_aon(fd, (char*)&w.values[0][0][0], 2 * 2 * (SEC_PARAM+1)*sizeof(uint8_t));
            write_aon(fd, (char*)&w.l, sizeof(size_t));
            write_aon(fd, (char*)&w.r, sizeof(size_t));
        }
        void operator()(const OutputWire& w) {
            dbgprintf(stderr, "Serializing OutputWire(%lu)\n", w.index);
            write_aon(fd, "2", sizeof(char));
            write_aon(fd, (char*)&w.index, sizeof(w.index));
        }
    };
    size_t i, n = gc.size();
    serializer ser(fd);
    write_aon(fd, (char*)&n, sizeof(size_t));
    for(i=0; i<n; i++) {
        boost::apply_visitor(ser, gc[i]);
    }
}

common::Error makeDiscoveryClusterInfo(const common::net::HostAndPort& parentHost,
                                       const std::string& text,
                                       std::vector<ServerDiscoveryClusterInfoSPtr>* infos) {
  if (text.empty() || !infos) {
    return common::make_error_value("Invalid input argument(s)", common::ErrorValue::E_ERROR);
    ;
  }

  size_t pos = 0;
  size_t start = 0;

  while ((pos = text.find(MARKER, start)) != std::string::npos) {
    std::string line = text.substr(start, pos - start);

    ServerCommonInfo inf;
    bool self = false;
    common::Error lerr = MakeServerCommonInfoFromLine(line, &inf, &self);
    if (lerr && lerr->isError()) {
      continue;
    }
    if (common::net::isLocalHost(inf.host.host)) {  // for direct connection
      inf.host.host = parentHost.host;
    }

    ServerDiscoveryClusterInfoSPtr ser(new DiscoveryClusterInfo(inf, self));
    infos->push_back(ser);
    start = pos + 1;
  }

  return common::Error();
}

    void Source::serialize(const Vector3 &from, const Vector3 &to, float voxelWidth, Real maxClampedAbsoluteDensity, const String &file)
    {
     
        Timer t;

        // Compress
        DataStreamPtr stream = Root::getSingleton().createFileStream(file);
        DataStreamPtr compressStream(OGRE_NEW DeflateStream(file, stream));
        StreamSerialiser ser(compressStream);
        ser.writeChunkBegin(VOLUME_CHUNK_ID, VOLUME_CHUNK_VERSION);

        // Write Metadata
        ser.write(&from);
        ser.write(&to);
        ser.write<float>(&voxelWidth);
        Vector3 diagonal = to - from;
        size_t gridWidth = (size_t)(diagonal.x / voxelWidth);
        size_t gridHeight = (size_t)(diagonal.y / voxelWidth);
        size_t gridDepth = (size_t)(diagonal.z / voxelWidth);
        ser.write<size_t>(&gridWidth);
        ser.write<size_t>(&gridHeight);
        ser.write<size_t>(&gridDepth);

        // Go over the volume and write the density data.
        Vector3 pos;
        Real realVal;
        size_t x;
        size_t y;
        uint16 buffer[SERIALIZATION_CHUNK_SIZE];
        size_t bufferI = 0;
        for (size_t z = 0; z < gridDepth; ++z)
        {
            for (x = 0; x < gridWidth; ++x)
            {
                for (y = 0; y < gridHeight; ++y)
                {
                    pos.x = x * voxelWidth + from.x;
                    pos.y = y * voxelWidth + from.y;
                    pos.z = z * voxelWidth + from.z;
                    realVal = Math::Clamp<Real>(getValue(pos), -maxClampedAbsoluteDensity, maxClampedAbsoluteDensity);
                    buffer[bufferI] = Bitwise::floatToHalf(realVal);
                    bufferI++;
                    if (bufferI == SERIALIZATION_CHUNK_SIZE)
                    {
                        ser.write<uint16>(buffer, SERIALIZATION_CHUNK_SIZE);
                        bufferI = 0;
                    }
                }
            }
        }
        if (bufferI > 0)
        {
            ser.write<uint16>(buffer, bufferI);
        }
        LogManager::getSingleton().stream() << "Time for serialization: " << t.getMilliseconds() << "ms";

        ser.writeChunkEnd(VOLUME_CHUNK_ID);
        
    }

void ext_list::ext::serialise(xml::serializer &serialiser, const std::string& ns)
{
    std::istringstream ser(serialised_value_);
    xml::parser p(ser, "", xml::parser::receive_default);
    p.next_expect(xml::parser::event_type::start_element, xml::qname(ns, "wrap"));
    roundtrip(p, serialiser);
    p.next_expect(xml::parser::event_type::end_element, xml::qname(ns, "wrap"));
}

bool Data64kbType::serialize(void *data, SerializedPayload_t *payload) {
	Data64kb *p_type = (Data64kb*) data;
	eprosima::fastcdr::FastBuffer fastbuffer((char*) payload->data, payload->max_size); // Object that manages the raw buffer.
	eprosima::fastcdr::Cdr ser(fastbuffer,eprosima::fastcdr::Cdr::LITTLE_ENDIANNESS); 	// Object that serializes the data.
	payload->encapsulation = CDR_LE;  	//Select the correct endianess
	p_type->serialize(ser); 	// Serialize the object:
    payload->length = (uint16_t)ser.getSerializedDataLength(); 	//Get the serialized length
	return true;
}

/*
========================
idCommonLocal::NetReadUsercmds
========================
*/
void idCommonLocal::NetReadUsercmds( int clientNum, idBitMsg& msg )
{
	if( clientNum == -1 )
	{
		idLib::Warning( "NetReadUsercmds: Trying to read commands from invalid clientNum %d", clientNum );
		return;
	}
	
	// TODO: This shouldn't actually happen. Figure out why it does.
	// Seen on clients when another client leaves a match.
	if( msg.GetReadData() == NULL )
	{
		return;
	}
	
	idSerializer ser( msg, false );
	
	usercmd_t fakeCmd;
	usercmd_t* base = &fakeCmd;
	
	usercmd_t lastCmd;
	
	bool										gotNewCmd = false;
	idStaticList< usercmd_t, NUM_USERCMD_RELAY >	newCmdBuffer;
	
	usercmd_t baseCmd = userCmdMgr.NewestUserCmdForPlayer( clientNum );
	int curMilliseconds = baseCmd.clientGameMilliseconds;
	
	const int numCmds = msg.ReadByte();
	
	for( int i = 0; i < numCmds; i++ )
	{
		usercmd_t newCmd;
		newCmd.Serialize( ser, *base );
		
		lastCmd = newCmd;
		base = &lastCmd;
		
		int newMilliseconds = newCmd.clientGameMilliseconds;
		
		if( newMilliseconds > curMilliseconds )
		{
			if( verify( i < NUM_USERCMD_RELAY ) )
			{
				newCmdBuffer.Append( newCmd );
				gotNewCmd = true;
				curMilliseconds = newMilliseconds;
			}
		}
	}
	
	// Push the commands into the buffer.
	for( int i = 0; i < newCmdBuffer.Num(); ++i )
	{
		userCmdMgr.PutUserCmdForPlayer( clientNum, newCmdBuffer[i] );
	}
}

//////////////////////////////////////////////////////////////////////////
// Init
//////////////////////////////////////////////////////////////////////////
void SaveLoad::create(GameId id) {
	initStream();

	Common::Serializer ser(NULL, _savegame);
	SavegameMainHeader header;
	header.saveLoadWithSerializer(ser);

	flushStream(id);
}

node *ser(node*head,int key)
{
    if(head->next->roll==key)
	    return head;
    else
    {
	    head = ser(head->next,key);
	    return head;
    }
}

/**
 *  liest die GlobalGameSettings aus der Datei.
 *
 *  @author OLiver
 */
void SavedFile::ReadGGS(BinaryFile& file)
{
    unsigned length = file.ReadUnsignedInt();
    boost::interprocess::unique_ptr<unsigned char, Deleter<unsigned char[]> > buffer(new unsigned char[length]);

    file.ReadRawData(buffer.get(), length);
    Serializer ser(buffer.get(), length);

    ggs.Deserialize(ser);
}