NvSerializer.h

Go to the documentation of this file.

//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.

#ifndef NV_SERIALIZER_H
#define NV_SERIALIZER_H

#include <filebuf/PxFileBuf.h>


namespace NvParameterized
{

PX_PUSH_PACK_DEFAULT

struct SerializePlatform
{
    typedef enum
    {
        ARCH_GEN = 0,
        ARCH_X86 = 1,
        ARCH_X86_64 = 2,
        ARCH_PPC = 3,
        ARCH_CELL = 4,
        ARCH_ARM = 5,
        ARCH_ARM_64 = 6,
        ARCH_LAST
    } ArchType;

    ArchType archType;

    typedef enum
    {
        COMP_GEN = 0,
        COMP_GCC = 1,
        COMP_VC = 2,
        COMP_MW = 3,
        COMP_LAST
    } CompilerType;

    CompilerType compilerType;

    uint32_t compilerVer;

    typedef enum
    {
        OS_WINDOWS = 0,
        OS_LINUX = 1,
        OS_LV2 = 2, // PS3
        OS_MACOSX = 3,
        OS_XBOX = 4,
        OS_GEN = 5,
        OS_ANDROID = 6,
        OS_XBOXONE = 7,
        OS_PS4 = 8,
        OS_HOS = 9,
        OS_LAST
    } OsType;

    OsType osType;

    uint32_t osVer;

    static const uint32_t ANY_VERSION = (uint32_t)-1;

    PX_INLINE SerializePlatform();
    
    PX_INLINE SerializePlatform(ArchType archType, CompilerType compType, uint32_t compVer, OsType osType, uint32_t osVer);

    PX_INLINE bool operator ==(const SerializePlatform &p) const;

    PX_INLINE bool operator !=(const SerializePlatform &p) const;
};

class Interface;
class Definition;
class Traits;
struct SerializePlatform;

class Serializer
{
public:

    enum ErrorType
    {
        ERROR_NONE = 0,

        ERROR_UNKNOWN,
        ERROR_NOT_IMPLEMENTED,

        // File format related errors
        ERROR_INVALID_PLATFORM,
        ERROR_INVALID_PLATFORM_NAME,
        ERROR_INVALID_FILE_VERSION,
        ERROR_INVALID_FILE_FORMAT,
        ERROR_INVALID_MAGIC,
        ERROR_INVALID_CHAR,

        // External errors
        ERROR_STREAM_ERROR,
        ERROR_MEMORY_ALLOCATION_FAILURE,
        ERROR_UNALIGNED_MEMORY,
        ERROR_PRESERIALIZE_FAILED,
        ERROR_INTERNAL_BUFFER_OVERFLOW,
        ERROR_OBJECT_CREATION_FAILED,
        ERROR_CONVERSION_FAILED,

        // Xml-specific errors
        ERROR_VAL2STRING_FAILED,
        ERROR_STRING2VAL_FAILED,
        ERROR_INVALID_TYPE_ATTRIBUTE,
        ERROR_UNKNOWN_XML_TAG,
        ERROR_MISSING_DOCTYPE,
        ERROR_MISSING_ROOT_ELEMENT,
        ERROR_INVALID_NESTING,
        ERROR_INVALID_ATTR,

        // Other stuff
        ERROR_INVALID_ARRAY,
        ERROR_ARRAY_INDEX_OUT_OF_RANGE,
        ERROR_INVALID_VALUE,
        ERROR_INVALID_INTERNAL_PTR,
        ERROR_INVALID_PARAM_HANDLE,
        ERROR_INVALID_RELOC_TYPE,
        ERROR_INVALID_DATA_TYPE,
        ERROR_INVALID_REFERENCE
    };

    enum SerializeType
    {
        NST_XML = 0,

        NST_BINARY,

        NST_LAST
    };

    static SerializeType peekSerializeType(physx::general_PxIOStream2::PxFileBuf &stream);

    static ErrorType peekPlatform(physx::general_PxIOStream2::PxFileBuf &stream, SerializePlatform &platform);

    virtual ~Serializer() {}

    virtual ErrorType setTargetPlatform(const SerializePlatform &platform) = 0;

    virtual void setAutoUpdate(bool doUpdate) = 0;

    virtual ErrorType serialize(
        physx::general_PxIOStream2::PxFileBuf &stream,
        const ::NvParameterized::Interface **objs,
        uint32_t nobjs,
        bool doSerializeMetadata = false) = 0;

    virtual ErrorType peekNumObjects(physx::general_PxIOStream2::PxFileBuf &stream, uint32_t &numObjects) = 0;

    virtual ErrorType peekClassNames(physx::general_PxIOStream2::PxFileBuf &stream, char **classNames, uint32_t &numClassNames) = 0;

    virtual ErrorType peekNumObjectsInplace(const void *data, uint32_t dataLen, uint32_t &numObjects) = 0;

    template < typename T, int bufSize = 8 > class DeserializedResults
    {
        T buf[bufSize]; //For small number of objects

        T *objs;

        uint32_t nobjs;

        Traits *traits;

        void clear();

    public:

        PX_INLINE DeserializedResults();

        PX_INLINE ~DeserializedResults();

        PX_INLINE DeserializedResults(const DeserializedResults &data);

        PX_INLINE DeserializedResults &operator =(const DeserializedResults &rhs);

        PX_INLINE void init(Traits *traits_, uint32_t nobjs_);

        PX_INLINE void init(Traits *traits_, T *objs_, uint32_t nobjs_);

        PX_INLINE uint32_t size() const;

        PX_INLINE T &operator[](uint32_t i);

        PX_INLINE const T &operator[](uint32_t i) const;

        PX_INLINE void getObjects(T *outObjs);

        PX_INLINE void releaseAll();
    };

    typedef DeserializedResults< ::NvParameterized::Interface *> DeserializedData;

    struct MetadataEntry
    {
        const char *className;

        uint32_t version;

        Definition *def;
    };

    typedef DeserializedResults<MetadataEntry> DeserializedMetadata;

    virtual ErrorType deserializeMetadata(physx::general_PxIOStream2::PxFileBuf &stream, DeserializedMetadata &desData);

    virtual ErrorType deserialize(physx::general_PxIOStream2::PxFileBuf &stream, DeserializedData &desData);

    virtual ErrorType deserialize(physx::general_PxIOStream2::PxFileBuf &stream, DeserializedData &desData, bool &isUpdated) = 0;

    virtual ErrorType deserializeInplace(void *data, uint32_t dataLen, DeserializedData &desData);

    virtual ErrorType deserializeInplace(void *data, uint32_t dataLen, DeserializedData &desData, bool &isUpdated) = 0;

    virtual ErrorType peekInplaceAlignment(physx::general_PxIOStream2::PxFileBuf& stream, uint32_t& align) = 0;

    virtual void release() = 0;
};

PX_POP_PACK

} // namespace NvParameterized

#include "NvSerializer.inl"

#endif // NV_SERIALIZER_H