NxSerializer.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2008-2014 NVIDIA Corporation. All rights reserved.

#ifndef NX_SERIALIZER_H
#define NX_SERIALIZER_H

#include "foundation/PxAssert.h"
#include <PxFileBuf.h>

#include "NxApexUsingNamespace.h"

namespace NxParameterized
{

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_LAST
    } ArchType;

    ArchType archType;

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

    CompilerType compilerType;

    physx::PxU32 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_LAST
    } OsType;

    OsType osType;

    physx::PxU32 osVer;

    static const physx::PxU32 ANY_VERSION = (physx::PxU32)-1;

    PX_INLINE SerializePlatform();

    PX_INLINE SerializePlatform(ArchType archType, CompilerType compType, physx::PxU32 compVer, OsType osType, physx::PxU32 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 ::NxParameterized::Interface **objs,
        physx::PxU32 nobjs,
        bool doSerializeMetadata = false) = 0;

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

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

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

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

        T *objs;

        physx::PxU32 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_, physx::PxU32 nobjs_);

        PX_INLINE void init(Traits *traits_, T *objs_, physx::PxU32 nobjs_);

        PX_INLINE physx::PxU32 size() const;

        PX_INLINE T &operator[](physx::PxU32 i);

        PX_INLINE const T &operator[](physx::PxU32 i) const;

        PX_INLINE void getObjects(T *outObjs);

        PX_INLINE void releaseAll();
    };

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

    struct MetadataEntry
    {
        const char *className;

        physx::PxU32 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, physx::PxU32 dataLen, DeserializedData &desData);

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

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

    virtual void release() = 0;
};

PX_POP_PACK

} // namespace NxParameterized

#include "NxSerializer.inl"

#endif // NX_SERIALIZER_H