PRTUtils.h

/*
  COPYRIGHT (c) 2012-2024 Esri R&D Center Zurich
  TRADE SECRETS: ESRI PROPRIETARY AND CONFIDENTIAL
  Unpublished material - all rights reserved under the
  Copyright Laws of the United States and applicable international
  laws, treaties, and conventions.

  For additional information, contact:
  Environmental Systems Research Institute, Inc.
  Attn: Contracts and Legal Services Department
  380 New York Street
  Redlands, California, 92373
  USA

  email: contracts@esri.com
*/

#ifndef PRTX_CLASSUTILS_H_
#define PRTX_CLASSUTILS_H_

#include "prt/Object.h"

#include "prtx/prtx.h"

#include <memory>
#include <string>


namespace prt {

class AttributeMap;
class AttributeMapBuilder;
class ResolveMap;
class ResolveMapBuilder;
class InitialShape;
class InitialShapeBuilder;
class RuleFileInfo;
class EncoderInfo;
class EncoderInfoBuilder;
class DecoderInfo;
class Annotation;
class CacheObject;
class OcclusionSet;
class FileOutputCallbacks;
class MemoryOutputCallbacks;

} // namespace prt


namespace prtx {


namespace PRTUtils {


struct ObjectDestroyer {
    void operator()(prt::Object const* p) { if(p != nullptr) p->destroy(); }
};


template<typename P> class ObjectPtr {
public:
    typedef P   type;
    typedef P*  ptrType;

    ObjectPtr() { }
    explicit ObjectPtr(P* p) : mPRT(p, ObjectDestroyer()) { }
    virtual ~ObjectPtr() { }

    P* get() const { return mPRT.get(); }
    P* operator->() const { return mPRT.get(); }
    P& operator*() const { return *mPRT; }
    bool operator<(const ObjectPtr<P>& rhs) const { return (mPRT.get() < rhs.mPRT.get()); }
    bool operator==(const ObjectPtr<P>& rhs) const { return (mPRT.get() == rhs.mPRT.get()); }
    bool operator()() const { return (bool)mPRT; }
    explicit operator bool() const { return mPRT.operator bool(); }

    void reset(P* p) { mPRT.reset(p, ObjectDestroyer()); }

protected:
    std::shared_ptr<P> mPRT;
};


typedef ObjectPtr<const	prt::AttributeMap>          AttributeMapPtr;
typedef ObjectPtr<		prt::AttributeMapBuilder>   AttributeMapBuilderPtr;

typedef ObjectPtr<const	prt::ResolveMap>            ResolveMapPtr;
typedef ObjectPtr<		prt::ResolveMapBuilder>     ResolveMapBuilderPtr;

typedef ObjectPtr<const	prt::InitialShape>          InitialShapePtr;
typedef ObjectPtr<		prt::InitialShapeBuilder>   InitialShapeBuilderPtr;

typedef ObjectPtr<		prt::OcclusionSet>          OcclusionSetPtr;

typedef ObjectPtr<const	prt::RuleFileInfo>          RuleFileInfoPtr;
typedef ObjectPtr<const	prt::EncoderInfo>           EncoderInfoPtr;
typedef ObjectPtr<const	prt::DecoderInfo>           DecoderInfoPtr;
typedef ObjectPtr<const	prt::Annotation>            AnnotationPtr;
typedef ObjectPtr<		prt::CacheObject>           CacheObjectPtr;


using AttributeMapUPtr          = std::unique_ptr<prt::AttributeMap const,  prtx::PRTUtils::ObjectDestroyer>;
using AttributeMapBuilderUPtr   = std::unique_ptr<prt::AttributeMapBuilder, prtx::PRTUtils::ObjectDestroyer>;
using ResolveMapUPtr            = std::unique_ptr<prt::ResolveMap const,    prtx::PRTUtils::ObjectDestroyer>;
using ResolveMapBuilderUPtr     = std::unique_ptr<prt::ResolveMapBuilder,   prtx::PRTUtils::ObjectDestroyer>;
using EncoderInfoUPtr           = std::unique_ptr<prt::EncoderInfo const,   prtx::PRTUtils::ObjectDestroyer>;
using EncoderInfoBuilderUPtr    = std::unique_ptr<prt::EncoderInfoBuilder,  prtx::PRTUtils::ObjectDestroyer>;

using FileOutputCallbacksPtr    = ObjectPtr<prt::FileOutputCallbacks>;
using FileOutputCallbacksUPtr   = std::unique_ptr<prt::FileOutputCallbacks, prtx::PRTUtils::ObjectDestroyer>;
using MemoryOutputCallbacksPtr  = ObjectPtr<prt::MemoryOutputCallbacks>;
using MemoryOutputCallbacksUPtr = std::unique_ptr<prt::MemoryOutputCallbacks, prtx::PRTUtils::ObjectDestroyer>;


PRTX_EXPORTS_API std::string objectToXML(prt::Object const* const p);


} // namespace PRTUtils


} // namespace prtx


#endif /* PRTX_CLASSUTILS_H_ */