EVEUnmarshal.h

Go to the documentation of this file.

/*
    ------------------------------------------------------------------------------------
    LICENSE:
    ------------------------------------------------------------------------------------
    This file is part of EVEmu: EVE Online Server Emulator
    Copyright 2006 - 2021 The EVEmu Team
    For the latest information visit https://evemu.dev
    ------------------------------------------------------------------------------------
    This program is free software; you can redistribute it and/or modify it under
    the terms of the GNU Lesser General Public License as published by the Free Software
    Foundation; either version 2 of the License, or (at your option) any later
    version.

    This program is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License along with
    this program; if not, write to the Free Software Foundation, Inc., 59 Temple
    Place - Suite 330, Boston, MA 02111-1307, USA, or go to
    http://www.gnu.org/copyleft/lesser.txt.
    ------------------------------------------------------------------------------------
    Author:        Zhur
*/

#ifndef EVE_UNMARSHAL_H
#define EVE_UNMARSHAL_H

#include "python/PyRep.h"


extern PyRep* Unmarshal( const Buffer& data );
extern PyRep* InflateUnmarshal( const Buffer& data );

class UnmarshalStream
{
public:
    UnmarshalStream()
    : mStoredObjects( nullptr )
    {
    }

    ~UnmarshalStream();

    PyRep* Load( const Buffer& data );

protected:
    template<typename T>
    const T& Peek() const { return *Peek<T>( 1 ); }
    template<typename T>
    Buffer::const_iterator<T> Peek( size_t count ) const { return mInItr.As<T>(); }

    template<typename T>
    const T& Read() { return *Read<T>( 1 ); }
    template<typename T>
    Buffer::const_iterator<T> Read( size_t count )
    {
        Buffer::const_iterator<T> res = Peek<T>( count );
        mInItr = ( res + count ).template As<uint8>();
        return res;
    }

    uint32 ReadSizeEx()
    {
        uint32 size = Read<uint8>();
        if( 0xFF == size )
            size = Read<uint32>();

        return size;
    }

    PyRep* LoadStream( size_t streamLength );

    PyRep* LoadRep();

    void CreateObjectStore( size_t streamLength, uint32 saveCount );
    void DestroyObjectStore();

    uint32 GetStorageIndex() { return *mStoreIndexItr++; }
    PyRep* GetStoredObject( uint32 index );
    void StoreObject( uint32 index, PyRep* object );

private:
    PyRep* LoadNone() { return PyStatic.NewNone(); }

    PyRep* LoadBoolTrue() { return PyStatic.NewTrue(); }
    PyRep* LoadBoolFalse() { return PyStatic.NewFalse(); }

    PyRep* LoadIntegerLongLong() { return new PyLong( Read<int64>() ); }
    PyRep* LoadIntegerLong() { return new PyInt( Read<int32>() ); }
    PyRep* LoadIntegerSignedShort() { return new PyInt( Read<int16>() ); }
    PyRep* LoadIntegerByte() { return new PyInt( Read<int8>() ); }
    PyRep* LoadIntegerVar();
    PyRep* LoadIntegerMinusOne() { return new PyInt( -1 ); }
    PyRep* LoadIntegerZero() { return new PyInt( 0 ); }
    PyRep* LoadIntegerOne() { return new PyInt( 1 ); }

    PyRep* LoadReal() { return new PyFloat( Read<double>() ); }
    PyRep* LoadRealZero() { return new PyFloat( 0.0 ); }

    PyRep* LoadStringEmpty() { return new PyString( "" ); }
    PyRep* LoadStringChar();
    PyRep* LoadStringShort();
    PyRep* LoadStringLong();
    PyRep* LoadStringTable();

    PyRep* LoadWStringEmpty() { return new PyWString( "", 0 ); }
    PyRep* LoadWStringUCS2Char();
    PyRep* LoadWStringUCS2();
    PyRep* LoadWStringUTF8();

    PyRep* LoadToken();

    PyRep* LoadBuffer();

    PyRep* LoadTupleEmpty() { return new PyTuple( 0 ); }
    PyRep* LoadTuple();
    PyRep* LoadTupleOne();
    PyRep* LoadTupleTwo();

    PyRep* LoadListEmpty() { return new PyList( 0 ); }
    PyRep* LoadList();
    PyRep* LoadListOne();

    PyRep* LoadDict();

    PyRep* LoadObject();
    PyRep* LoadObjectEx1();
    PyRep* LoadObjectEx2();

    PyRep* LoadSubStream();
    PyRep* LoadSubStruct();
    PyRep* LoadChecksumedStream();

    PyRep* LoadPackedRow();

    PyRep* LoadError();
    PyRep* LoadSavedStreamElement();

    PyObjectEx* LoadObjectEx( bool is_type_2 );
    bool LoadRLE(Buffer& out );

    Buffer::const_iterator<uint8> mInItr;

    Buffer::const_iterator<uint32> mStoreIndexItr;
    PyList* mStoredObjects;

    static PyRep* ( UnmarshalStream::* const s_mLoadMap[] )();
};

#endif