NvParameterizedTraits.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_PARAMETERIZED_TRAITS_H
#define NV_PARAMETERIZED_TRAITS_H

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

namespace NvParameterized
{

PX_PUSH_PACK_DEFAULT

class Traits;
class Interface;

class Factory
{
public:

    virtual ::NvParameterized::Interface *create( Traits *paramTraits ) = 0;

    virtual ::NvParameterized::Interface *finish( Traits *paramTraits, void *obj, void *buf, int32_t *refCount ) = 0;

    virtual const char * getClassName() = 0;

    virtual uint32_t getVersion() = 0;

    virtual uint32_t getAlignment() = 0;

    virtual const uint32_t * getChecksum( uint32_t &bits ) = 0;

    virtual ~Factory() {}

    virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits) = 0;
};

class Conversion
{
public:
    virtual ~Conversion() {}

    virtual bool operator()(::NvParameterized::Interface &legacyObj, ::NvParameterized::Interface &obj) = 0;

    virtual void release() = 0;
};

class Traits
{
public:
    virtual ~Traits() {}

    virtual void registerFactory( ::NvParameterized::Factory & factory ) = 0;

    virtual ::NvParameterized::Factory *removeFactory( const char * className ) = 0;

    virtual ::NvParameterized::Factory *removeFactory( const char * className, uint32_t version ) = 0;

    virtual bool doesFactoryExist(const char* className) = 0;

    virtual bool doesFactoryExist(const char* className, uint32_t version) = 0;

    virtual ::NvParameterized::Interface * createNvParameterized( const char * name ) = 0;

    virtual ::NvParameterized::Interface * createNvParameterized( const char * name, uint32_t ver ) = 0;

    virtual ::NvParameterized::Interface * finishNvParameterized( const char * name, void *obj, void *buf, int32_t *refCount ) = 0;

    virtual ::NvParameterized::Interface * finishNvParameterized( const char * name, uint32_t ver, void *obj, void *buf, int32_t *refCount ) = 0;

    virtual uint32_t getCurrentVersion(const char *className) const = 0;

    virtual uint32_t getAlignment(const char *className, uint32_t classVersion) const = 0;

    virtual void registerConversion(const char * /*className*/, uint32_t /*from*/, uint32_t /*to*/, Conversion & /*conv*/) {}

    virtual ::NvParameterized::Conversion *removeConversion(const char * /*className*/, uint32_t /*from*/, uint32_t /*to*/) { return 0; }

    virtual bool updateLegacyNvParameterized(::NvParameterized::Interface &legacyObj, ::NvParameterized::Interface &obj)
    {
        PX_UNUSED(&legacyObj);
        PX_UNUSED(&obj);

        return false;
    }

    virtual bool getNvParameterizedNames( const char ** names, uint32_t &outCount, uint32_t inCount) const = 0;

    virtual bool getNvParameterizedVersions(const char* className, uint32_t* versions, uint32_t &outCount, uint32_t inCount) const = 0;

    virtual int32_t incRefCount(int32_t *refCount) = 0;

    virtual int32_t decRefCount(int32_t *refCount) = 0;

    virtual void onInplaceObjectDestroyed(void * /*buf*/, ::NvParameterized::Interface * /*obj*/) {}

    virtual void onAllInplaceObjectsDestroyed(void *buf) { free(buf); }

    virtual void *alloc(uint32_t nbytes) = 0;

    virtual void *alloc(uint32_t nbytes, uint32_t align) = 0;

    virtual void free(void *buf) = 0;

    virtual char *strdup(const char *str)
    {
        if( !str )
            return NULL;

        uint32_t strLen = (uint32_t)strlen(str) + 1;
        char *retStr = (char *)this->alloc(strLen, 1);
        
        PX_ASSERT( retStr );
        
        if( NULL != retStr )
#if PX_WINDOWS_FAMILY || PX_XBOXONE
            strcpy_s( retStr, strLen, str );
#else
            strncpy(retStr, str, strLen);
#endif
        return retStr;
    }

    virtual void strfree(char *str)
    {
        if( NULL != str )
            this->free( str );
    }

    virtual void traitsWarn(const char * /*msg*/) const {}

    virtual void release(void) = 0;

    class Allocator
    {
		::NvParameterized::Traits *mTraits;

    public:

        Allocator(Traits *traits): mTraits(traits) {}

        void *allocate(size_t size)
        {
            return allocate(size, __FILE__, __LINE__);
        }

        void *allocate(size_t size, const char * /*filename*/, int /*line*/)
        {
            PX_ASSERT( static_cast<uint32_t>(size) == size );
            return mTraits->alloc(static_cast<uint32_t>(size));
        }

        void deallocate(void *ptr)
        {
            return mTraits->free(ptr);
        }
    };
};


PX_POP_PACK

} // namespace NvParameterized

#endif // NV_PARAMETERIZED_TRAITS_H