diff options
Diffstat (limited to 'public/include/XMPCore/source')
17 files changed, 2251 insertions, 0 deletions
diff --git a/public/include/XMPCore/source/IArrayNode.cpp b/public/include/XMPCore/source/IArrayNode.cpp new file mode 100644 index 0000000..12fd0da --- /dev/null +++ b/public/include/XMPCore/source/IArrayNode.cpp @@ -0,0 +1,163 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class IArrayNodeProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IArrayNodeProxy; + +#include "XMPCore/Interfaces/IArrayNode.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCore/Interfaces/ICoreObjectFactory.h" + +#include <assert.h> + +namespace AdobeXMPCore { + +#if XMP_WinBuild + #pragma warning( push ) + #pragma warning( disable : 4250 ) +#endif + + class IArrayNodeProxy + : public virtual IArrayNode + , public virtual ICompositeNodeProxy + { + private: + pIArrayNode mRawPtr; + + public: + IArrayNodeProxy( pIArrayNode ptr ) + : mRawPtr( ptr ) + , ICompositeNodeProxy( ptr ) + , INodeProxy( ptr ) {} + + ~IArrayNodeProxy() __NOTHROW__ {} + + pIArrayNode APICALL GetActualIArrayNode() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pIArrayNode_I APICALL GetIArrayNode_I() __NOTHROW__ { + return mRawPtr->GetIArrayNode_I(); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + virtual eArrayForm APICALL GetArrayForm() const { + return CallConstSafeFunction< IArrayNode_v1, eArrayForm, uint32 >( + mRawPtr, &IArrayNode_v1::getArrayForm ); + } + + virtual eNodeType APICALL GetChildNodeType() const { + return CallConstSafeFunction< IArrayNode_v1, eNodeType, uint32 >( + mRawPtr, &IArrayNode_v1::getChildNodeType ); + } + + virtual spINode APICALL GetNodeAtIndex( sizet index ) { + return CallSafeFunctionReturningPointer< IArrayNode_v1, pINode_base, INode, sizet >( + mRawPtr, &IArrayNode_v1::getNodeAtIndex, index ); + } + + virtual void APICALL InsertNodeAtIndex( const spINode & node, sizet index ) { + return CallSafeFunctionReturningVoid< IArrayNode_v1, pINode_base, sizet >( + mRawPtr, &IArrayNode_v1::insertNodeAtIndex, node ? node->GetActualINode() : NULL, index ); + } + + virtual spINode APICALL RemoveNodeAtIndex( sizet index ) { + return CallSafeFunctionReturningPointer< IArrayNode_v1, pINode_base, INode, sizet >( + mRawPtr, &IArrayNode_v1::removeNodeAtIndex, index ); + } + + virtual spINode APICALL ReplaceNodeAtIndex( const spINode & node, sizet index ) { + return CallSafeFunctionReturningPointer< IArrayNode_v1, pINode_base, INode, pINode_base, sizet >( + mRawPtr, &IArrayNode_v1::replaceNodeAtIndex, node ? node->GetActualINode() :NULL, index ); + } + + virtual uint32 APICALL getArrayForm( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getArrayForm( error ); + } + + virtual pINode_base APICALL getNodeAtIndex( sizet index, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getNodeAtIndex( index, error ); + } + + virtual void APICALL insertNodeAtIndex( pINode_base node, sizet index, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->insertNodeAtIndex( node, index, error ); + } + + virtual pINode_base APICALL removeNodeAtIndex( sizet index, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->removeNodeAtIndex( index, error ); + } + + virtual pINode_base APICALL replaceNodeAtIndex( pINode_base node, sizet index, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->replaceNodeAtIndex( node, index, error ); + } + + virtual uint32 APICALL getChildNodeType( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getChildNodeType( error ); + } + + }; + +#if XMP_WinBuild + #pragma warning( pop ) +#endif + + spIArrayNode IArrayNode_v1::MakeShared( pIArrayNode_base ptr ) { + if ( !ptr ) return spIArrayNode(); + pIArrayNode p = IArrayNode::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< IArrayNode >() : ptr; + return shared_ptr< IArrayNode >( new IArrayNodeProxy( p ) ); + } + + spIArrayNode IArrayNode_v1::CreateUnorderedArrayNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIArrayNode_base, IArrayNode, uint32, const char *, sizet, const char *, sizet >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateArrayNode, static_cast< uint32 >( IArrayNode::kAFUnordered ), + nameSpace, nameSpaceLength, name, nameLength ); + } + + spIArrayNode IArrayNode_v1::CreateOrderedArrayNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIArrayNode_base, IArrayNode, uint32, const char *, sizet, const char *, sizet >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateArrayNode, static_cast< uint32 >( IArrayNode::kAFOrdered ), + nameSpace, nameSpaceLength, name, nameLength ); + } + + spIArrayNode IArrayNode_v1::CreateAlternativeArrayNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIArrayNode_base, IArrayNode, uint32, const char *, sizet, const char *, sizet >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateArrayNode, static_cast< uint32 >( IArrayNode::kAFAlternative ), + nameSpace, nameSpaceLength, name, nameLength ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/IClientDOMParser.cpp b/public/include/XMPCore/source/IClientDOMParser.cpp new file mode 100644 index 0000000..c476782 --- /dev/null +++ b/public/include/XMPCore/source/IClientDOMParser.cpp @@ -0,0 +1,76 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +#include "XMPCore/Interfaces/IClientDOMParser.h" +#include "XMPCore/Interfaces/INode.h" + +#if 1//!BUILDING_XMPCORE_LIB +namespace AdobeXMPCore { + + pINode_base APICALL IClientDOMParser_v1::parse( const char * buffer, sizet bufferLength, pcIConfigurable configurationParameters, ReportErrorAndContinueABISafeProc proc, pcIError_base & error, uint32 & unknownExceptionCaught ) __NOTHROW__ { + unknownExceptionCaught = 0; + error = NULL; + try { + auto node = Parse( buffer, bufferLength, configurationParameters, proc ); + if ( node ) { + node->Acquire(); + return node->GetActualINode(); + } + return NULL; + } catch ( spcIError err ) { + error = err->GetActualIError(); + error->Acquire(); + } catch ( ... ) { + unknownExceptionCaught = 1; + } + return NULL; + } + + uint32 APICALL IClientDOMParser_v1::areKeysCaseSensitive( pcIError_base & error, uint32 & unknownExceptionCaught ) const __NOTHROW__ { + unknownExceptionCaught = 0; + error = NULL; + try { + return AreKeysCaseSensitive() ? 1 : 0; + } catch ( spcIError err ) { + error = err->GetActualIError(); + error->Acquire(); + } catch ( ... ) { + unknownExceptionCaught = 1; + } + return 0; + } + + void APICALL IClientDOMParser_v1::initialize( pIConfigurable configurationParameters, pcIError_base & error, uint32 & unknownExceptionCaught ) __NOTHROW__ { + unknownExceptionCaught = 0; + error = NULL; + try { + Initialize( configurationParameters ); + } catch ( spcIError err ) { + error = err->GetActualIError(); + error->Acquire(); + } catch ( ... ) { + unknownExceptionCaught = 1; + } + } + + uint32 APICALL IClientDOMParser_v1::validate( const uint64 & key, uint32 dataType, const IConfigurable::CombinedDataValue & dataValue, pcIError_base & error, uint32 & unknownExceptionCaught ) __NOTHROW__ { + unknownExceptionCaught = 0; + error = NULL; + try { + return static_cast< uint32 >( Validate( key, static_cast< IConfigurable::eDataType >( dataType ), dataValue ) ); + } catch ( spcIError err ) { + error = err->GetActualIError(); + error->Acquire(); + } catch ( ... ) { + unknownExceptionCaught = 1; + } + return 0; + } +} +#endif // !BUILDING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/IClientDOMSerializer.cpp b/public/include/XMPCore/source/IClientDOMSerializer.cpp new file mode 100644 index 0000000..f1f9f52 --- /dev/null +++ b/public/include/XMPCore/source/IClientDOMSerializer.cpp @@ -0,0 +1,73 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +#include "XMPCore/Interfaces/IClientDOMSerializer.h" +#include "XMPCore/Interfaces/INode.h" +#include "XMPCommon/Interfaces/IUTF8String.h" +#include "XMPCore/Interfaces/INameSpacePrefixMap.h" + +#if !BUILDING_XMPCORE_LIB +namespace AdobeXMPCore { + + void APICALL IClientDOMSerializer_v1::serialize( pINode_base node, pcINameSpacePrefixMap_base map, pcIConfigurable configurationParameters, ReportErrorAndContinueABISafeProc proc, pIUTF8String_base string, pcIError_base & error, uint32 & unknownErrorThrown ) __NOTHROW__ { + unknownErrorThrown = 0; + error = NULL; + try { + Serialize( INode::MakeShared( node ), INameSpacePrefixMap::MakeShared( map ), configurationParameters, proc, IUTF8String::MakeShared( string ) ); + } catch ( spcIError err ) { + error = err->GetActualIError(); + error->Acquire(); + } catch ( ... ) { + unknownErrorThrown = 1; + } + } + + uint32 APICALL IClientDOMSerializer_v1::areKeysCaseSensitive( pcIError_base & error, uint32 & unknownExceptionCaught ) const __NOTHROW__ { + unknownExceptionCaught = 0; + error = NULL; + try { + return AreKeysCaseSensitive() ? 1 : 0; + } catch ( spcIError err ) { + error = err->GetActualIError(); + error->Acquire(); + } catch ( ... ) { + unknownExceptionCaught = 1; + } + return 0; + } + + void APICALL IClientDOMSerializer_v1::initialize( pIConfigurable configurationParameters, pcIError_base & error, uint32 & unknownExceptionCaught ) __NOTHROW__ { + unknownExceptionCaught = 0; + error = NULL; + try { + Initialize( configurationParameters ); + } catch ( spcIError err ) { + error = err->GetActualIError(); + error->Acquire(); + } catch ( ... ) { + unknownExceptionCaught = 1; + } + } + + uint32 APICALL IClientDOMSerializer_v1::validate( const uint64 & key, uint32 dataType, const IConfigurable::CombinedDataValue & dataValue, pcIError_base & error, uint32 & unknownExceptionCaught ) __NOTHROW__ { + unknownExceptionCaught = 0; + error = NULL; + try { + return static_cast< uint32 >( Validate( key, static_cast< IConfigurable::eDataType >( dataType ), dataValue ) ); + } catch ( spcIError err ) { + error = err->GetActualIError(); + error->Acquire(); + } catch ( ... ) { + unknownExceptionCaught = 1; + } + return 0; + } + +} +#endif // !BUILDING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/ICompositeNode.cpp b/public/include/XMPCore/source/ICompositeNode.cpp new file mode 100644 index 0000000..603501b --- /dev/null +++ b/public/include/XMPCore/source/ICompositeNode.cpp @@ -0,0 +1,121 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class ICompositeNodeProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::ICompositeNodeProxy; + +#include "XMPCore/Interfaces/ICompositeNode.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include <assert.h> +#include "XMPCore/Interfaces/IPath.h" +#include "XMPCore/Interfaces/INodeIterator.h" + +namespace AdobeXMPCore { + ICompositeNodeProxy::ICompositeNodeProxy( pICompositeNode ptr ) + : mRawPtr( ptr ) + , INodeProxy( ptr ) {} + + ICompositeNodeProxy::~ICompositeNodeProxy() __NOTHROW__ {} + + pICompositeNode APICALL ICompositeNodeProxy::GetActualICompositeNode() __NOTHROW__ { return mRawPtr; } + + AdobeXMPCore_Int::pICompositeNode_I APICALL ICompositeNodeProxy::GetICompositeNode_I() __NOTHROW__ { + return mRawPtr->GetICompositeNode_I(); + } + + INode_v1::eNodeType APICALL ICompositeNodeProxy::GetNodeTypeAtPath( const spcIPath & path ) const { + return CallConstSafeFunction< ICompositeNode_v1, eNodeType, uint32, pcIPath_base >( + mRawPtr, &ICompositeNode_v1::getNodeTypeAtPath, path ? path->GetActualIPath() : NULL ); + } + + spINode APICALL ICompositeNodeProxy::GetNodeAtPath( const spcIPath & path ) { + return CallSafeFunctionReturningPointer< ICompositeNode_v1, pINode_base, INode, pcIPath_base >( + mRawPtr, &ICompositeNode_v1::getNodeAtPath, path ? path->GetActualIPath() : NULL ); + } + + void APICALL ICompositeNodeProxy::AppendNode( const spINode & node ) { + return CallSafeFunctionReturningVoid< ICompositeNode_v1, pINode_base >( + mRawPtr, &ICompositeNode_v1::appendNode, node ? node->GetActualINode() : NULL ); + } + + void APICALL ICompositeNodeProxy::InsertNodeAtPath( const spINode & node, const spcIPath & path ) { + return CallSafeFunctionReturningVoid< ICompositeNode_v1, pINode_base, pcIPath_base >( + mRawPtr, &ICompositeNode_v1::insertNodeAtPath, node ? node->GetActualINode() : NULL, path ? path->GetActualIPath() : NULL ); + } + + spINode APICALL ICompositeNodeProxy::ReplaceNodeAtPath( const spINode & node, const spcIPath & path ) { + return CallSafeFunctionReturningPointer< ICompositeNode_v1, pINode_base, INode, pINode_base, pcIPath_base >( + mRawPtr, &ICompositeNode_v1::replaceNodeAtPath, node ? node->GetActualINode() : NULL, path ? path->GetActualIPath() : NULL ); + } + + spINode APICALL ICompositeNodeProxy::RemoveNodeAtPath( const spcIPath & path ) { + return CallSafeFunctionReturningPointer< ICompositeNode_v1, pINode_base, INode, pcIPath_base >( + mRawPtr, &ICompositeNode_v1::removeNodeAtPath, path ? path->GetActualIPath() : NULL ); + } + + spINodeIterator APICALL ICompositeNodeProxy::Iterator() { + return CallSafeFunctionReturningPointer< ICompositeNode_v1, pINodeIterator_base, INodeIterator >( + mRawPtr, &ICompositeNode_v1::iterator ); + } + + sizet APICALL ICompositeNodeProxy::ChildCount() const __NOTHROW__ { + return mRawPtr->ChildCount(); + } + + uint32 APICALL ICompositeNodeProxy::getNodeTypeAtPath( pcIPath_base path, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getNodeTypeAtPath( path, error ); + } + + pINode_base APICALL ICompositeNodeProxy::getNodeAtPath( pcIPath_base path, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getNodeAtPath( path, error ); + } + + void APICALL ICompositeNodeProxy::appendNode( pINode_base node, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->appendNode( node, error ); + } + + void APICALL ICompositeNodeProxy::insertNodeAtPath( pINode_base node, pcIPath_base path, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->insertNodeAtPath( node, path, error ); + } + + pINode_base APICALL ICompositeNodeProxy::replaceNodeAtPath( pINode_base node, pcIPath_base path, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->replaceNodeAtPath( node, path, error ); + } + + pINode_base APICALL ICompositeNodeProxy::removeNodeAtPath( pcIPath_base path, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->removeNodeAtPath( path, error ); + } + + pINodeIterator_base APICALL ICompositeNodeProxy::iterator( pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->iterator( error ); + } + + spICompositeNode ICompositeNode_v1::MakeShared( pICompositeNode_base ptr ) { + if ( !ptr ) return spICompositeNode(); + pICompositeNode p = ICompositeNode::GetInterfaceVersion() > 1 ? + ptr->GetInterfacePointer< ICompositeNode >() : ptr; + return shared_ptr< ICompositeNode >( new ICompositeNodeProxy( p ) ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/ICoreConfigurationManager.cpp b/public/include/XMPCore/source/ICoreConfigurationManager.cpp new file mode 100644 index 0000000..af4f74c --- /dev/null +++ b/public/include/XMPCore/source/ICoreConfigurationManager.cpp @@ -0,0 +1,88 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class ICoreConfigurationManagerProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::ICoreConfigurationManagerProxy; + +#include "XMPCore/Interfaces/ICoreConfigurationManager.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCore/Interfaces/ICoreObjectFactory.h" +#include <assert.h> + +namespace AdobeXMPCore { + +#if XMP_WinBuild + #pragma warning( push ) + #pragma warning( disable : 4250 ) +#endif + + class ICoreConfigurationManagerProxy + : public virtual ICoreConfigurationManager + , public virtual IConfigurationManagerProxy + { + private: + pICoreConfigurationManager mRawPtr; + + public: + ICoreConfigurationManagerProxy( pICoreConfigurationManager ptr ) + : IConfigurationManagerProxy( ptr ) + , mRawPtr( ptr ) {} + + ~ICoreConfigurationManagerProxy() __NOTHROW__ {} + + pICoreConfigurationManager APICALL GetActualICoreConfigurationManager() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pICoreConfigurationManager_I APICALL GetICoreConfigurationManager_I() __NOTHROW__ { + return mRawPtr->GetICoreConfigurationManager_I(); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + }; + + spICoreConfigurationManager ICoreConfigurationManager_v1::MakeShared( pICoreConfigurationManager_base ptr ) { + if ( !ptr ) return spICoreConfigurationManager(); + pICoreConfigurationManager p = ICoreConfigurationManager::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< ICoreConfigurationManager >() : ptr; + return shared_ptr< ICoreConfigurationManager >( new ICoreConfigurationManagerProxy( p ) ); + } + + spICoreConfigurationManager ICoreConfigurationManager_v1::GetCoreConfigurationManager() { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pICoreConfigurationManager_base, ICoreConfigurationManager >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::GetCoreConfigurationManager ); + } + +#if XMP_WinBuild + #pragma warning( pop ) +#endif + +} + +#endif // !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/ICoreObjectFactory.cpp b/public/include/XMPCore/source/ICoreObjectFactory.cpp new file mode 100644 index 0000000..b7e12e8 --- /dev/null +++ b/public/include/XMPCore/source/ICoreObjectFactory.cpp @@ -0,0 +1,83 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +#include "XMPCore/Interfaces/ICoreObjectFactory.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include <assert.h> + +#if LINKING_XMPCORE_LIB + extern "C" AdobeXMPCore::pICoreObjectFactory_base WXMPMeta_GetXMPDOMFactoryInstance_1(); +#endif + +namespace AdobeXMPCore { + + pICoreObjectFactory ICoreObjectFactory_v1::MakeCoreObjectFactory( pICoreObjectFactory_base ptr ) { + if ( ICoreObjectFactory::GetInterfaceVersion() == 1 ) + return ptr; + else + return ptr->GetInterfacePointer< ICoreObjectFactory >(); + } + +#if LINKING_XMPCORE_LIB + static pICoreObjectFactory ManageCoreObjectFactory( bool destroy = false ) { + static pICoreObjectFactory sCoreObjectFactoryPtr( NULL ); + if ( destroy && sCoreObjectFactoryPtr ) { + sCoreObjectFactoryPtr = NULL; + return sCoreObjectFactoryPtr; + } + + if ( !sCoreObjectFactoryPtr ) { + if ( ICoreObjectFactory::GetInterfaceVersion() != 1 ) + sCoreObjectFactoryPtr = WXMPMeta_GetXMPDOMFactoryInstance_1()->GetInterfacePointer< ICoreObjectFactory >(); + else + sCoreObjectFactoryPtr = WXMPMeta_GetXMPDOMFactoryInstance_1(); + } + return sCoreObjectFactoryPtr; + } + + + void ICoreObjectFactory_v1::SetupCoreObjectFactory() { + ManageCoreObjectFactory(); + } +#else + static pICoreObjectFactory ManageCoreObjectFactory( bool destroy = false, pICoreObjectFactory_base coreObjectFactory = NULL ) { + static pICoreObjectFactory sCoreObjectFactoryPtr( NULL ); + if ( destroy && sCoreObjectFactoryPtr ) { + sCoreObjectFactoryPtr = NULL; + return sCoreObjectFactoryPtr; + } + + if ( !sCoreObjectFactoryPtr && coreObjectFactory ) { + if ( ICoreObjectFactory::GetInterfaceVersion() != 1 ) + sCoreObjectFactoryPtr = coreObjectFactory->GetInterfacePointer< ICoreObjectFactory >(); + else + sCoreObjectFactoryPtr = coreObjectFactory; + } + return sCoreObjectFactoryPtr; + } + + void ICoreObjectFactory_v1::SetupCoreObjectFactory( pICoreObjectFactory_base coreObjectFactory ) { + ManageCoreObjectFactory( false, coreObjectFactory ); + } +#endif + + pICoreObjectFactory ICoreObjectFactory_v1::GetCoreObjectFactory() { + return ManageCoreObjectFactory(); + } + + void ICoreObjectFactory_v1::DestroyCoreObjectFactory() { + ManageCoreObjectFactory( true ); + } + +} + +#endif // BUILDING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/IDOMImplementationRegistry.cpp b/public/include/XMPCore/source/IDOMImplementationRegistry.cpp new file mode 100644 index 0000000..35934e2 --- /dev/null +++ b/public/include/XMPCore/source/IDOMImplementationRegistry.cpp @@ -0,0 +1,122 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class IDOMImplementationRegistryProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IDOMImplementationRegistryProxy; + +#include "XMPCore/Interfaces/IDOMImplementationRegistry.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include <assert.h> +#include "XMPCore/Interfaces/IDOMParser.h" +#include "XMPCore/Interfaces/IDOMSerializer.h" +#include "XMPCore/Interfaces/ICoreObjectFactory.h" + +namespace AdobeXMPCore { + + class IDOMImplementationRegistryProxy + : public virtual IDOMImplementationRegistry + { + private: + pIDOMImplementationRegistry mRawPtr; + + public: + IDOMImplementationRegistryProxy( pIDOMImplementationRegistry ptr ) + : mRawPtr( ptr ) + { + mRawPtr->Acquire(); + } + + ~IDOMImplementationRegistryProxy() __NOTHROW__ { mRawPtr->Release(); } + + pIDOMImplementationRegistry APICALL GetActualIDOMImplementationRegistry() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pIDOMImplementationRegistry_I APICALL GetIDOMImplementationRegistry_I() __NOTHROW__ { + return mRawPtr->GetIDOMImplementationRegistry_I(); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + virtual spIDOMParser APICALL GetParser( const char * key ) const { + return CallConstSafeFunctionReturningPointer< IDOMImplementationRegistry, pIDOMParser_base, IDOMParser, const char * >( + mRawPtr, &IDOMImplementationRegistry::getParser, key ); + } + + virtual spIDOMSerializer APICALL GetSerializer( const char * key ) const { + return CallConstSafeFunctionReturningPointer< IDOMImplementationRegistry, pIDOMSerializer_base, IDOMSerializer, const char * >( + mRawPtr, &IDOMImplementationRegistry::getSerializer, key ); + } + + virtual bool APICALL RegisterParser( const char * key, pIClientDOMParser_base parser ) { + return CallSafeFunction< IDOMImplementationRegistry, bool, uint32, const char *, pIClientDOMParser_base >( + mRawPtr, &IDOMImplementationRegistry::registerParser, key, parser ); + } + + virtual bool APICALL RegisterSerializer( const char * key, pIClientDOMSerializer_base serializer ) { + return CallSafeFunction< IDOMImplementationRegistry, bool, uint32, const char *, pIClientDOMSerializer_base >( + mRawPtr, &IDOMImplementationRegistry::registerSerializer, key, serializer ); + } + + virtual pIDOMParser_base APICALL getParser( const char * key, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getParser( key, error ); + } + + virtual pIDOMSerializer_base APICALL getSerializer( const char * key, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getSerializer( key, error ); + } + + virtual uint32 APICALL registerParser( const char * key, pIClientDOMParser_base parser, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->registerParser( key, parser, error ); + } + + virtual uint32 APICALL registerSerializer( const char * key, pIClientDOMSerializer_base serializer, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->registerSerializer( key, serializer, error ); + } + + }; + + spIDOMImplementationRegistry IDOMImplementationRegistry_v1::GetDOMImplementationRegistry() { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIDOMImplementationRegistry_base, IDOMImplementationRegistry >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::GetDOMImplementationRegistry ); + } + + spIDOMImplementationRegistry IDOMImplementationRegistry_v1::MakeShared( pIDOMImplementationRegistry_base ptr ) { + if ( !ptr ) return spIDOMImplementationRegistry(); + pIDOMImplementationRegistry p = IDOMImplementationRegistry::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< IDOMImplementationRegistry >() : ptr; + return shared_ptr< IDOMImplementationRegistry >( new IDOMImplementationRegistryProxy( p ) ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/IDOMParser.cpp b/public/include/XMPCore/source/IDOMParser.cpp new file mode 100644 index 0000000..a077a5c --- /dev/null +++ b/public/include/XMPCore/source/IDOMParser.cpp @@ -0,0 +1,116 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class IDOMParserProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IDOMParserProxy; + +#include "XMPCore/Interfaces/IDOMParser.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include <assert.h> +#include "XMPCore/Interfaces/IMetadata.h" + +namespace AdobeXMPCore { + +#if XMP_WinBuild + #pragma warning( push ) + #pragma warning( disable : 4250 ) +#endif + + class IDOMParserProxy + : public virtual IDOMParser + , public virtual IConfigurableProxy + { + private: + pIDOMParser mRawPtr; + + public: + IDOMParserProxy( pIDOMParser ptr ) + : IConfigurableProxy( ptr ) + , mRawPtr( ptr ) + { + mRawPtr->Acquire(); + } + + ~IDOMParserProxy() __NOTHROW__ { mRawPtr->Release(); } + + pIDOMParser APICALL GetActualIDOMParser() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pIDOMParser_I APICALL GetIDOMParser_I() __NOTHROW__ { + return mRawPtr->GetIDOMParser_I(); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + virtual spIDOMParser APICALL Clone() const { + return CallConstSafeFunctionReturningPointer< IDOMParser, pIDOMParser_base, IDOMParser >( + mRawPtr, &IDOMParser::clone ); + } + + virtual spIMetadata APICALL Parse( const char * buffer, sizet bufferLength ) { + return CallSafeFunctionReturningPointer< IDOMParser, pIMetadata_base, IMetadata, const char *, sizet >( + mRawPtr, &IDOMParser::parse, buffer, bufferLength ); + } + + virtual void APICALL ParseWithSpecificAction( const char * buffer, sizet bufferLength, eActionType actionType, spINode & node ) { + return CallSafeFunctionReturningVoid< IDOMParser, const char *, sizet, uint32, pINode_base >( + mRawPtr, &IDOMParser::parseWithSpecificAction, buffer, bufferLength, static_cast< uint32 >( actionType ), node ? node->GetActualINode() : NULL ); + } + + virtual pIDOMParser_base APICALL clone( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->clone( error ); + } + + virtual pIMetadata_base APICALL parse( const char * buffer, sizet bufferLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->parse( buffer, bufferLength, error ); + } + + virtual void APICALL parseWithSpecificAction( const char * buffer, sizet bufferLength, uint32 actionType, pINode_base node, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->parseWithSpecificAction( buffer, bufferLength, actionType, node, error ); + } + + }; + +#if XMP_WinBuild + #pragma warning( pop ) +#endif + + spIDOMParser IDOMParser_v1::MakeShared( pIDOMParser_base ptr ) { + if ( !ptr ) return spIDOMParser(); + pIDOMParser p = IDOMParser::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< IDOMParser >() : ptr; + return shared_ptr< IDOMParser >( new IDOMParserProxy( p ) ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/IDOMSerializer.cpp b/public/include/XMPCore/source/IDOMSerializer.cpp new file mode 100644 index 0000000..481477a --- /dev/null +++ b/public/include/XMPCore/source/IDOMSerializer.cpp @@ -0,0 +1,109 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class IDOMSerializerProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IDOMSerializerProxy; + +#include "XMPCore/Interfaces/IDOMSerializer.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCommon/Interfaces/IUTF8String.h" +#include "XMPCore/Interfaces/INode.h" +#include "XMPCore/Interfaces/INameSpacePrefixMap.h" + +#include <assert.h> + +namespace AdobeXMPCore { + +#if XMP_WinBuild + #pragma warning( push ) + #pragma warning( disable : 4250 ) +#endif + + class IDOMSerializerProxy + : public virtual IDOMSerializer + , public virtual IConfigurableProxy + { + private: + pIDOMSerializer mRawPtr; + + public: + IDOMSerializerProxy( pIDOMSerializer ptr ) + : IConfigurableProxy( ptr ) + , mRawPtr( ptr ) + { + mRawPtr->Acquire(); + } + + ~IDOMSerializerProxy() __NOTHROW__ { mRawPtr->Release(); } + + pIDOMSerializer APICALL GetActualIDOMSerializer() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pIDOMSerializer_I APICALL GetIDOMSerializer_I() __NOTHROW__ { + return mRawPtr->GetIDOMSerializer_I(); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + virtual spIDOMSerializer APICALL Clone() const { + return CallConstSafeFunctionReturningPointer< IDOMSerializer, pIDOMSerializer_base, IDOMSerializer >( + mRawPtr, &IDOMSerializer_v1::clone ); + } + + virtual spIUTF8String APICALL Serialize( const spINode & node, const spcINameSpacePrefixMap & map ) { + return CallSafeFunctionReturningPointer< IDOMSerializer, pIUTF8String_base, IUTF8String, pINode_base, pcINameSpacePrefixMap_base >( + mRawPtr, &IDOMSerializer_v1::serialize, node ? node->GetActualINode() : NULL , map ? map->GetActualINameSpacePrefixMap() : NULL ); + } + + virtual pIDOMSerializer_base APICALL clone( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->clone( error ); + } + + virtual pIUTF8String_base APICALL serialize( pINode_base node, pcINameSpacePrefixMap_base map, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->serialize( node, map, error ); + } + + }; + +#if XMP_WinBuild + #pragma warning( pop ) +#endif + + spIDOMSerializer IDOMSerializer_v1::MakeShared( pIDOMSerializer_base ptr ) { + if ( !ptr ) return spIDOMSerializer(); + pIDOMSerializer p = ptr->GetInterfacePointer< IDOMSerializer >(); + return shared_ptr< IDOMSerializer >( new IDOMSerializerProxy( p ) ); + } + +} + +#endif // !BUILDING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/IMetadata.cpp b/public/include/XMPCore/source/IMetadata.cpp new file mode 100644 index 0000000..9b4eef5 --- /dev/null +++ b/public/include/XMPCore/source/IMetadata.cpp @@ -0,0 +1,113 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class IMetadataProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IMetadataProxy; + +#include "XMPCore/Interfaces/IMetadata.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCommon/Interfaces/IUTF8String.h" +#include "XMPCore/Interfaces/ICoreObjectFactory.h" + +#include <assert.h> + +namespace AdobeXMPCore { + +#if XMP_WinBuild + #pragma warning( push ) + #pragma warning( disable : 4250 ) +#endif + + class IMetadataProxy + : public virtual IMetadata + , public virtual IStructureNodeProxy + { + private: + pIMetadata mRawPtr; + + public: + IMetadataProxy( pIMetadata ptr ) + : mRawPtr( ptr ) + , IStructureNodeProxy( ptr ) + , ICompositeNodeProxy( ptr ) + , INodeProxy( ptr ) {} + + ~IMetadataProxy() __NOTHROW__ {} + + pIMetadata APICALL GetActualIMetadata() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pIMetadata_I APICALL GetIMetadata_I() __NOTHROW__ { + return mRawPtr->GetIMetadata_I(); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + virtual spcIUTF8String APICALL GetAboutURI() const { + return CallConstSafeFunctionReturningPointer< IMetadata_v1, pcIUTF8String_base, const IUTF8String >( + mRawPtr, &IMetadata_v1::getAboutURI ); + } + + virtual void APICALL SetAboutURI( const char * uri, sizet uriLength ) __NOTHROW__ { + mRawPtr->SetAboutURI( uri, uriLength ); + } + + virtual pcIUTF8String_base APICALL getAboutURI( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getAboutURI( error ); + } + + virtual void APICALL EnableFeature( const char * key, sizet keyLength ) const __NOTHROW__ { + return mRawPtr->EnableFeature( key, keyLength ); + } + + virtual void APICALL DisableFeature( const char * key, sizet keyLength ) const __NOTHROW__ { + return mRawPtr->DisableFeature( key, keyLength ); + } + }; + +#if XMP_WinBuild + #pragma warning( pop ) +#endif + + spIMetadata IMetadata_v1::MakeShared( pIMetadata_base ptr ) { + if ( !ptr ) return spIMetadata(); + pIMetadata p = IMetadata::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< IMetadata >() : ptr; + return shared_ptr< IMetadata >( new IMetadataProxy( p ) ); + } + + spIMetadata IMetadata_v1::CreateMetadata() { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIMetadata, IMetadata >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateMetadata ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/INameSpacePrefixMap.cpp b/public/include/XMPCore/source/INameSpacePrefixMap.cpp new file mode 100644 index 0000000..8dee5b7 --- /dev/null +++ b/public/include/XMPCore/source/INameSpacePrefixMap.cpp @@ -0,0 +1,187 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class INameSpacePrefixMapProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::INameSpacePrefixMapProxy; + +#include "XMPCore/Interfaces/INameSpacePrefixMap.h" +#include "XMPCore/Interfaces/ICoreObjectFactory.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCommon/Interfaces/IUTF8String.h" + +#include <assert.h> + +namespace AdobeXMPCore { + + + bool INameSpacePrefixMap::IsEmpty() const __NOTHROW__{ + return this->Size() == 0; + } + + class INameSpacePrefixMapProxy + : public virtual INameSpacePrefixMap + { + private: + pINameSpacePrefixMap mRawPtr; + + public: + INameSpacePrefixMapProxy( pINameSpacePrefixMap ptr ) + : mRawPtr( ptr ) + { + mRawPtr->Acquire(); + } + + ~INameSpacePrefixMapProxy() __NOTHROW__ { mRawPtr->Release(); } + + pINameSpacePrefixMap APICALL GetActualINameSpacePrefixMap() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pINameSpacePrefixMap_I APICALL GetINameSpacePrefixMap_I() __NOTHROW__ { + return mRawPtr->GetINameSpacePrefixMap_I(); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + virtual bool APICALL Insert( const char * prefix, sizet prefixLength, const char * nameSpace, sizet nameSpaceLength ) { + return CallSafeFunction< INameSpacePrefixMap_v1, bool, uint32, const char *, sizet, const char *, sizet >( + mRawPtr, &INameSpacePrefixMap_v1::insert, prefix, prefixLength, nameSpace, nameSpaceLength ); + } + + virtual uint32 APICALL insert( const char * prefix, sizet prefixLength, const char * nameSpace, sizet nameSpaceLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->insert( prefix, prefixLength, nameSpace, nameSpaceLength, error ); + } + + virtual bool APICALL RemovePrefix( const char * prefix, sizet prefixLength ) { + return CallSafeFunction< INameSpacePrefixMap_v1, bool, uint32, uint32, const char *, sizet >( + mRawPtr, &INameSpacePrefixMap_v1::remove, kPrefixIsParameter, prefix, prefixLength ); + } + + virtual bool APICALL RemoveNameSpace( const char * nameSpace, sizet nameSpaceLength ) { + return CallSafeFunction< INameSpacePrefixMap_v1, bool, uint32, uint32, const char *, sizet >( + mRawPtr, &INameSpacePrefixMap_v1::remove, kNameSpaceIsParameter, nameSpace, nameSpaceLength ); + } + + virtual bool APICALL IsPrefixPresent( const char * prefix, sizet prefixLength ) const { + return CallConstSafeFunction< INameSpacePrefixMap_v1, bool, uint32, uint32, const char *, sizet >( + mRawPtr, &INameSpacePrefixMap_v1::isPresent, kPrefixIsParameter, prefix, prefixLength ); + } + + virtual bool APICALL IsNameSpacePresent( const char * nameSpace, sizet nameSpaceLength ) const { + return CallConstSafeFunction< INameSpacePrefixMap_v1, bool, uint32, uint32, const char *, sizet >( + mRawPtr, &INameSpacePrefixMap_v1::isPresent, kNameSpaceIsParameter, nameSpace, nameSpaceLength ); + } + + virtual spcIUTF8String APICALL GetNameSpace( const char * prefix, sizet prefixLength ) const { + return CallConstSafeFunctionReturningPointer< INameSpacePrefixMap_v1, pcIUTF8String_base, const IUTF8String, uint32, const char *, sizet >( + mRawPtr, &INameSpacePrefixMap_v1::get, kPrefixIsParameter, prefix, prefixLength ); + } + + virtual spcIUTF8String APICALL GetPrefix( const char * nameSpace, sizet nameSpaceLength ) const { + return CallConstSafeFunctionReturningPointer< INameSpacePrefixMap_v1, pcIUTF8String_base, const IUTF8String, uint32, const char *, sizet >( + mRawPtr, &INameSpacePrefixMap_v1::get, kNameSpaceIsParameter, nameSpace, nameSpaceLength ); + } + + virtual sizet APICALL Size() const __NOTHROW__ { + return mRawPtr->Size(); + } + + virtual void APICALL Clear() __NOTHROW__ { + return mRawPtr->Clear(); + } + + virtual spINameSpacePrefixMap APICALL Clone() const { + return CallConstSafeFunctionReturningPointer< INameSpacePrefixMap_v1, pINameSpacePrefixMap_base, INameSpacePrefixMap >( + mRawPtr, &INameSpacePrefixMap_v1::clone ); + } + + virtual pINameSpacePrefixMap_base APICALL clone( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->clone( error ); + } + + virtual uint32 APICALL remove( uint32 keyType, const char * key, sizet keyLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->remove( keyType, key, keyLength, error ); + } + + virtual uint32 APICALL isPresent( uint32 keyType, const char * key, sizet keyLength, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->isPresent( keyType, key, keyLength, error ); + } + + virtual pcIUTF8String_base APICALL get( uint32 keyType, const char * key, sizet keyLength, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->get( keyType, key, keyLength, error ); + } + + virtual void APICALL EnableThreadSafety() const __NOTHROW__ { + return mRawPtr->EnableThreadSafety(); + } + + virtual void APICALL DisableThreadSafety() const __NOTHROW__ { + return mRawPtr->DisableThreadSafety(); + } + + virtual bool APICALL IsThreadSafe() const { + return mRawPtr->isThreadSafe() != 0; + } + + virtual uint32 APICALL isThreadSafe( ) const __NOTHROW__ { + assert( false ); + return mRawPtr->isThreadSafe(); + } + + virtual AdobeXMPCommon_Int::pIThreadSafe_I APICALL GetIThreadSafe_I() __NOTHROW__ override { + return mRawPtr->GetIThreadSafe_I(); + } + + }; + + spINameSpacePrefixMap INameSpacePrefixMap_v1::MakeShared( pINameSpacePrefixMap_base ptr ) { + if ( !ptr ) return spINameSpacePrefixMap(); + pINameSpacePrefixMap p = INameSpacePrefixMap::GetInterfaceVersion() > 1 ? + ptr->GetInterfacePointer< INameSpacePrefixMap >() : ptr; + return shared_ptr< INameSpacePrefixMap >( new INameSpacePrefixMapProxy( p ) ); + } + + spINameSpacePrefixMap INameSpacePrefixMap_v1::CreateNameSpacePrefixMap() { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pINameSpacePrefixMap_base, INameSpacePrefixMap >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateNameSpacePrefixMap ); + } + + spcINameSpacePrefixMap INameSpacePrefixMap_v1::GetDefaultNameSpacePrefixMap() { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pcINameSpacePrefixMap_base, const INameSpacePrefixMap >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::GetDefaultNameSpacePrefixMap ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/INode.cpp b/public/include/XMPCore/source/INode.cpp new file mode 100644 index 0000000..9d0126c --- /dev/null +++ b/public/include/XMPCore/source/INode.cpp @@ -0,0 +1,377 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class INodeProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::INodeProxy; + +#include "XMPCore/Interfaces/INode.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCommon/Interfaces/IUTF8String.h" +#include "XMPCore/Interfaces/IPath.h" +#include "XMPCore/Interfaces/ISimpleNode.h" +#include "XMPCore/Interfaces/INodeIterator.h" +#include "XMPCore/Interfaces/IArrayNode.h" +#include "XMPCore/Interfaces/IMetadata.h" + +#include <assert.h> + +namespace AdobeXMPCore { + + INodeProxy::INodeProxy( pINode ptr ) : mRawPtr( ptr ) { + mRawPtr->Acquire(); + } + + INodeProxy::~INodeProxy() __NOTHROW__ { + mRawPtr->Release(); + } + + pINode APICALL INodeProxy::GetActualINode() __NOTHROW__ { + return mRawPtr; + } + + void APICALL INodeProxy::Acquire() const __NOTHROW__ { + assert( false ); + } + + void APICALL INodeProxy::Release() const __NOTHROW__ { + assert( false ); + } + + AdobeXMPCommon_Int::pISharedObject_I APICALL INodeProxy::GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pINode_I APICALL INodeProxy::GetINode_I() __NOTHROW__ { + return mRawPtr->GetINode_I(); + } + + pvoid APICALL INodeProxy::getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + spINode APICALL INodeProxy::GetParent() { + return CallSafeFunctionReturningPointer< INode_v1, pINode_base, INode >( + mRawPtr, &INode_v1::getParent ); + } + + void APICALL INodeProxy::SetName( const char * name, sizet nameLength ) { + return CallSafeFunctionReturningVoid< INode_v1, const char *, sizet >( + mRawPtr, &INode_v1::setName, name, nameLength ); + } + + spcIUTF8String APICALL INodeProxy::GetName() const { + return CallConstSafeFunctionReturningPointer< INode_v1, pcIUTF8String_base, const IUTF8String >( + mRawPtr, &INode_v1::getName ); + } + + void APICALL INodeProxy::SetNameSpace( const char * nameSpace, sizet nameSpaceLength ) { + return CallSafeFunctionReturningVoid< INode_v1, const char *, sizet >( + mRawPtr, &INode_v1::setNameSpace, nameSpace, nameSpaceLength ); + + } + + spcIUTF8String APICALL INodeProxy::GetNameSpace() const { + return CallConstSafeFunctionReturningPointer< INode_v1, pcIUTF8String_base, const IUTF8String >( + mRawPtr, &INode_v1::getNameSpace ); + } + + spIPath APICALL INodeProxy::GetPath() const { + return CallConstSafeFunctionReturningPointer< INode_v1, pIPath_base, IPath >( + mRawPtr, &INode_v1::getPath ); + } + + sizet APICALL INodeProxy::QualifiersCount() const __NOTHROW__ { + return mRawPtr->QualifiersCount(); + } + + spINodeIterator APICALL INodeProxy::QualifiersIterator() { + return CallSafeFunctionReturningPointer< INode_v1, pINodeIterator_base, INodeIterator >( + mRawPtr, &INode_v1::qualifiersIterator ); + } + + spINode APICALL INodeProxy::GetQualifier( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< INode_v1, pINode_base, INode, const char *, sizet, const char *, sizet >( + mRawPtr, &INode_v1::getQualifier, nameSpace, nameSpaceLength, name, nameLength ); + } + + void APICALL INodeProxy::InsertQualifier( const spINode & node ) { + return CallSafeFunctionReturningVoid< INode_v1, pINode_base >( + mRawPtr, &INode_v1::insertQualifier, node ? node->GetActualINode() : NULL ); + } + + spINode APICALL INodeProxy::ReplaceQualifier( const spINode & node ) { + return CallSafeFunctionReturningPointer< INode_v1, pINode_base, INode, pINode_base >( + mRawPtr, &INode_v1::replaceQualifier, node ? node->GetActualINode() : NULL ); + } + + spINode APICALL INodeProxy::RemoveQualifier( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< INode_v1, pINode_base, INode, const char *, sizet, const char *, sizet >( + mRawPtr, &INode_v1::removeQualifier, nameSpace, nameSpaceLength, name, nameLength ); + } + + INode_v1::eNodeType APICALL INodeProxy::GetNodeType() const { + return CallConstSafeFunction< INode_v1, eNodeType, uint32 >( + mRawPtr, &INode_v1::getNodeType ); + } + + bool APICALL INodeProxy::IsArrayItem() const { + return CallConstSafeFunction< INode_v1, bool, uint32 >( + mRawPtr, &INode_v1::isArrayItem ); + } + + bool APICALL INodeProxy::IsQualifierNode() const { + return CallConstSafeFunction< INode_v1, bool, uint32 >( + mRawPtr, &INode_v1::isQualifierNode ); + } + + sizet APICALL INodeProxy::GetIndex() const { + return CallConstSafeFunction< INode_v1, sizet, sizet >( + mRawPtr, &INode_v1::getIndex ); + } + + bool APICALL INodeProxy::HasQualifiers() const { + return CallConstSafeFunction< INode_v1, bool, uint32 >( + mRawPtr, &INode_v1::hasQualifiers ); + } + + bool APICALL INodeProxy::HasContent() const { + return CallConstSafeFunction< INode_v1, bool, uint32 >( + mRawPtr, &INode_v1::hasContent ); + } + + bool APICALL INodeProxy::IsEmpty() const { + return CallConstSafeFunction< INode_v1, bool, uint32 >( + mRawPtr, &INode_v1::isEmpty ); + } + + bool APICALL INodeProxy::HasChanged() const { + return CallConstSafeFunction< INode_v1, bool, uint32 >( + mRawPtr, &INode_v1::hasChanged ); + } + + void APICALL INodeProxy::AcknowledgeChanges() const __NOTHROW__ { + return mRawPtr->AcknowledgeChanges( ); + } + + void APICALL INodeProxy::Clear( bool contents, bool qualifiers ) { + return CallSafeFunctionReturningVoid< INode_v1, uint32, uint32 >( + mRawPtr, &INode_v1::clear, static_cast< uint32 >( contents ), static_cast< uint32 >( qualifiers ) ); + } + + spINode APICALL INodeProxy::Clone( bool ignoreEmptyNodes, bool ignoreNodesWithOnlyQualifiers ) const { + return CallConstSafeFunctionReturningPointer< INode_v1, pINode_base, INode, uint32, uint32 >( + mRawPtr, &INode_v1::clone, static_cast< uint32 >( ignoreEmptyNodes ), static_cast< uint32 >( ignoreNodesWithOnlyQualifiers ) ); + } + + pINode_base APICALL INodeProxy::getParent( pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getParent( error ); + } + + void APICALL INodeProxy::setName( const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->setName( name, nameLength, error ); + } + + AdobeXMPCommon::pcIUTF8String_base APICALL INodeProxy::getName( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getName( error ); + } + + void APICALL INodeProxy::setNameSpace( const char * nameSpace, sizet nameSpaceLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->setNameSpace( nameSpace, nameSpaceLength, error ); + } + + pcIUTF8String_base APICALL INodeProxy::getNameSpace( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getNameSpace( error ); + } + + pIPath_base APICALL INodeProxy::getPath( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getPath( error ); + } + + pINodeIterator_base APICALL INodeProxy::qualifiersIterator( pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->qualifiersIterator( error ); + } + + pINode_base APICALL INodeProxy::getQualifier( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getQualifier( nameSpace, nameSpaceLength, name, nameLength, error ); + } + + void APICALL INodeProxy::insertQualifier( pINode_base base, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->insertQualifier( base, error ); + } + + pINode_base APICALL INodeProxy::replaceQualifier( pINode_base node, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->replaceQualifier( node, error ); + } + + pINode_base APICALL INodeProxy::removeQualifier( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->removeQualifier( nameSpace, nameSpaceLength, name, nameLength, error ); + } + + uint32 APICALL INodeProxy::getNodeType( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getNodeType( error ); + } + + uint32 APICALL INodeProxy::isArrayItem( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->isArrayItem( error ); + } + + uint32 APICALL INodeProxy::isQualifierNode( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->isQualifierNode( error ); + } + + sizet APICALL INodeProxy::getIndex( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getIndex( error ); + } + + uint32 APICALL INodeProxy::hasQualifiers( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->hasQualifiers( error ); + } + + uint32 APICALL INodeProxy::hasContent( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->hasContent( error ); + } + + uint32 APICALL INodeProxy::isEmpty( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->isEmpty( error ); + } + + uint32 APICALL INodeProxy::hasChanged( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->hasChanged( error ); + } + + void APICALL INodeProxy::clear( uint32 contents, uint32 qualifiers, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->clear( contents, qualifiers, error ); + } + + pINode_base APICALL INodeProxy::clone( uint32 igoreEmptyNodes, uint32 ignoreNodesWithOnlyQualifiers, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->clone( igoreEmptyNodes, ignoreNodesWithOnlyQualifiers, error ); + } + + void APICALL INodeProxy::EnableThreadSafety() const __NOTHROW__ { + return mRawPtr->EnableThreadSafety( ); + } + + void APICALL INodeProxy::DisableThreadSafety() const __NOTHROW__ { + return mRawPtr->DisableThreadSafety( ); + } + + bool APICALL INodeProxy::IsThreadSafe() const { + return mRawPtr->isThreadSafe() != 0; + } + + uint32 APICALL INodeProxy::isThreadSafe() const __NOTHROW__ { + assert( false ); + return mRawPtr->isThreadSafe(); + } + + spISimpleNode APICALL INodeProxy::ConvertToSimpleNode() { + return CallSafeFunctionReturningPointer< INode_v1, pISimpleNode_base, ISimpleNode >( + mRawPtr, &INode_v1::convertToSimpleNode ); + } + + spIStructureNode APICALL INodeProxy::ConvertToStructureNode() { + return CallSafeFunctionReturningPointer< INode_v1, pIStructureNode_base, IStructureNode >( + mRawPtr, &INode_v1::convertToStructureNode ); + } + + spIArrayNode APICALL INodeProxy::ConvertToArrayNode() { + return CallSafeFunctionReturningPointer< INode_v1, pIArrayNode_base, IArrayNode >( + mRawPtr, &INode_v1::convertToArrayNode ); + } + + spIMetadata APICALL INodeProxy::ConvertToMetadata() { + return CallSafeFunctionReturningPointer< INode_v1, pIMetadata_base, IMetadata >( + mRawPtr, &INode_v1::convertToMetadata ); + } + + pISimpleNode_base APICALL INodeProxy::convertToSimpleNode( pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->convertToSimpleNode( error ); + } + + pIStructureNode_base APICALL INodeProxy::convertToStructureNode( pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->convertToStructureNode( error ); } + + pIArrayNode_base APICALL INodeProxy::convertToArrayNode( pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->convertToArrayNode( error ); + } + + pIMetadata_base APICALL INodeProxy::convertToMetadata( pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->convertToMetadata( error ); + } + + uint32 APICALL INodeProxy::getParentNodeType( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getParentNodeType( error ); + } + + uint32 APICALL INodeProxy::getQualifierNodeType( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getQualifierNodeType( nameSpace, nameSpaceLength, name, nameLength, error ); + } + + INode_v1::eNodeType APICALL INodeProxy::GetParentNodeType() const { + return CallConstSafeFunction< INode_v1, eNodeType, uint32 >( + mRawPtr, &INode_v1::getParentNodeType ); + } + + INode_v1::eNodeType APICALL INodeProxy::GetQualifierNodeType( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) const { + return CallConstSafeFunction< INode_v1, eNodeType, uint32, const char *, sizet, const char *, sizet >( + mRawPtr, &INode_v1::getQualifierNodeType, nameSpace, nameSpaceLength, name, nameLength ); + } + + AdobeXMPCommon_Int::pIThreadSafe_I APICALL INodeProxy::GetIThreadSafe_I() __NOTHROW__ { + return mRawPtr->GetIThreadSafe_I( ); + } + + pvoid APICALL INodeProxy::GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + spINode INode_v1::MakeShared( pINode_base ptr ) { + if ( !ptr ) return spINode(); + pINode p = INode::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< INode >() : ptr; + return shared_ptr< INode >( new INodeProxy( p ) ); + } + +} + +#endif // !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/INodeIterator.cpp b/public/include/XMPCore/source/INodeIterator.cpp new file mode 100644 index 0000000..f2f43a3 --- /dev/null +++ b/public/include/XMPCore/source/INodeIterator.cpp @@ -0,0 +1,105 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class INodeIteratorProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::INodeIteratorProxy; + +#include "XMPCore/Interfaces/INodeIterator.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include <assert.h> + +namespace AdobeXMPCore { + + class INodeIteratorProxy + : public virtual INodeIterator + { + private: + pINodeIterator mRawPtr; + + public: + INodeIteratorProxy( pINodeIterator ptr ) + : mRawPtr( ptr ) + { + mRawPtr->Acquire(); + } + + ~INodeIteratorProxy() __NOTHROW__ { mRawPtr->Release(); } + + pINodeIterator APICALL GetActualINodeIterator() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pINodeIterator_I APICALL GetINodeIterator_I() __NOTHROW__ { + return mRawPtr->GetINodeIterator_I(); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + virtual spINode APICALL GetNode() { + return CallSafeFunctionReturningPointer< INodeIterator_v1, pINode_base, INode >( + mRawPtr, &INodeIterator_v1::getNode ); + } + + virtual INode_v1::eNodeType APICALL GetNodeType() const { + return CallConstSafeFunction< INodeIterator_v1, INode_v1::eNodeType, uint32 >( + mRawPtr, &INodeIterator_v1::getNodeType ); + } + + virtual spINodeIterator APICALL Next() { + return CallSafeFunctionReturningPointer< INodeIterator_v1, pINodeIterator, INodeIterator >( + mRawPtr, &INodeIterator_v1::next ); + } + + virtual uint32 APICALL getNodeType( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getNodeType( error ); + } + + virtual pINode_base APICALL getNode( pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getNode( error ); + } + + virtual pINodeIterator_base APICALL next( pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->next( error ); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + }; + + spINodeIterator INodeIterator_v1::MakeShared( pINodeIterator_base ptr ) { + if ( !ptr ) return spINodeIterator(); + //return shared_ptr< INodeIterator >( new INodeIteratorProxy( ptr ) ); + pINodeIterator p = INodeIterator::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< INodeIterator >() : ptr; + return shared_ptr< INodeIterator >( new INodeIteratorProxy( p ) ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/IPath.cpp b/public/include/XMPCore/source/IPath.cpp new file mode 100644 index 0000000..f0b99c3 --- /dev/null +++ b/public/include/XMPCore/source/IPath.cpp @@ -0,0 +1,157 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class IPathProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IPathProxy; + +#include "XMPCore/Interfaces/IPath.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCore/Interfaces/INameSpacePrefixMap.h" +#include "XMPCommon/Interfaces/IUTF8String.h" +#include "XMPCore/Interfaces/IPathSegment.h" +#include "XMPCore/Interfaces/ICoreObjectFactory.h" + +#include <assert.h> + +namespace AdobeXMPCore { + + class IPathProxy + : public virtual IPath + { + private: + pIPath mRawPtr; + + public: + IPathProxy( pIPath ptr ) + : mRawPtr( ptr ) + { + mRawPtr->Acquire(); + } + + ~IPathProxy() __NOTHROW__ { mRawPtr->Release(); } + + pIPath APICALL GetActualIPath() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pIPath_I APICALL GetIPath_I() __NOTHROW__ { + return mRawPtr->GetIPath_I(); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + virtual spcINameSpacePrefixMap APICALL RegisterNameSpacePrefixMap( const spcINameSpacePrefixMap & map ) { + return CallSafeFunctionReturningPointer< IPath_v1, pcINameSpacePrefixMap_base, const INameSpacePrefixMap, pcINameSpacePrefixMap_base >( + mRawPtr, &IPath_v1::registerNameSpacePrefixMap, map ? map->GetActualINameSpacePrefixMap() : NULL ); + } + + virtual pcINameSpacePrefixMap_base APICALL registerNameSpacePrefixMap( pcINameSpacePrefixMap_base map, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->registerNameSpacePrefixMap( map, error ); + } + + virtual spIUTF8String APICALL Serialize( const spcINameSpacePrefixMap & map ) const { + return CallConstSafeFunctionReturningPointer< IPath_v1, pIUTF8String_base, IUTF8String, pcINameSpacePrefixMap_base >( + mRawPtr, &IPath_v1::serialize, map ? map->GetActualINameSpacePrefixMap() : NULL ); + } + + virtual pIUTF8String_base APICALL serialize( pcINameSpacePrefixMap_base map, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->serialize( map, error ); + } + + virtual void APICALL AppendPathSegment( const spcIPathSegment & segment ) { + return CallSafeFunctionReturningVoid< IPath_v1, pcIPathSegment_base >( + mRawPtr, &IPath_v1::appendPathSegment, segment ? segment->GetActualIPathSegment() : NULL ); + } + + virtual void APICALL appendPathSegment( pcIPathSegment_base segment, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->appendPathSegment( segment, error ); + } + + virtual spcIPathSegment APICALL RemovePathSegment( sizet index ) { + return CallSafeFunctionReturningPointer< IPath_v1, pcIPathSegment_base, const IPathSegment, sizet >( + mRawPtr, &IPath_v1::removePathSegment, index ); + } + + virtual pcIPathSegment_base APICALL removePathSegment( sizet index, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->removePathSegment( index, error ); + } + + virtual spcIPathSegment APICALL GetPathSegment( sizet index ) const { + return CallConstSafeFunctionReturningPointer< IPath_v1, pcIPathSegment_base, const IPathSegment, sizet >( + mRawPtr, &IPath_v1::getPathSegment, index ); + } + + virtual pcIPathSegment_base APICALL getPathSegment( sizet index, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getPathSegment( index, error ); + } + + virtual sizet APICALL Size() const __NOTHROW__ { + return mRawPtr->Size( ); + } + + virtual void APICALL Clear() __NOTHROW__ { + return mRawPtr->Clear( ); + } + + virtual spIPath APICALL Clone( sizet startingIndex, sizet countOfSegments ) const { + return CallConstSafeFunctionReturningPointer< IPath_v1, pIPath_base, IPath, sizet, sizet >( + mRawPtr, &IPath_v1::clone, startingIndex, countOfSegments ); + } + + virtual pIPath_base APICALL clone( sizet startingIndex, sizet countOfSegemetns, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->clone( startingIndex, countOfSegemetns, error ); + } + + }; + + spIPath IPath_v1::MakeShared( pIPath_base ptr ) { + if ( !ptr ) return spIPath(); + pIPath p = IPath::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< IPath >() : ptr; + return shared_ptr< IPath >( new IPathProxy( p ) ); + } + + spIPath IPath_v1::CreatePath() { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIPath_base, IPath >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreatePath ); + } + + spIPath IPath_v1::ParsePath( const char * path, sizet pathLength, const spcINameSpacePrefixMap & map ) { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIPath_base, IPath, const char *, sizet, pcINameSpacePrefixMap_base >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::ParsePath, path, pathLength, map ? map->GetActualINameSpacePrefixMap() : NULL ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/IPathSegment.cpp b/public/include/XMPCore/source/IPathSegment.cpp new file mode 100644 index 0000000..4228492 --- /dev/null +++ b/public/include/XMPCore/source/IPathSegment.cpp @@ -0,0 +1,146 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class IPathSegmentProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IPathSegmentProxy; + +#include "XMPCore/Interfaces/IPathSegment.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCommon/Interfaces/IUTF8String.h" +#include "XMPCommon/Interfaces/IError.h" +#include "XMPCore/Interfaces/ICoreObjectFactory.h" + +#include <assert.h> + +namespace AdobeXMPCore { + + class IPathSegmentProxy + : public virtual IPathSegment + { + private: + pIPathSegment mRawPtr; + + public: + IPathSegmentProxy( pIPathSegment ptr ) + : mRawPtr( ptr ) + { + mRawPtr->Acquire(); + } + + ~IPathSegmentProxy() __NOTHROW__ { mRawPtr->Release(); } + + pIPathSegment APICALL GetActualIPathSegment() __NOTHROW__ { return mRawPtr; } + + void APICALL Acquire() const __NOTHROW__ { assert( false ); } + + void APICALL Release() const __NOTHROW__ { assert( false ); } + + AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { + return mRawPtr->GetISharedObject_I(); + } + + AdobeXMPCore_Int::pIPathSegment_I APICALL GetIPathSegment_I() __NOTHROW__ { + return mRawPtr->GetIPathSegment_I(); + } + + pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) { + return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >( + mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion ); + } + + pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error ); + } + + virtual spcIUTF8String APICALL GetNameSpace() const { + return CallConstSafeFunctionReturningPointer< IPathSegment_v1, pcIUTF8String_base, const IUTF8String >( + mRawPtr, &IPathSegment_v1::getNameSpace ); + } + + virtual pcIUTF8String_base APICALL getNameSpace( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getNameSpace( error ); + } + + virtual spcIUTF8String APICALL GetName() const { + return CallConstSafeFunctionReturningPointer< IPathSegment_v1, pcIUTF8String_base, const IUTF8String >( + mRawPtr, &IPathSegment_v1::getName ); + } + + virtual pcIUTF8String_base APICALL getName( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getName( error ); + } + + virtual ePathSegmentType APICALL GetType() const { + return CallConstSafeFunction< IPathSegment_v1, ePathSegmentType, uint32 >( + mRawPtr, &IPathSegment_v1::getType ); + } + + virtual uint32 APICALL getType( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getType( error ); + } + + virtual sizet APICALL GetIndex() const __NOTHROW__ { + return mRawPtr->GetIndex(); + } + + virtual spcIUTF8String APICALL GetValue() const { + return CallConstSafeFunctionReturningPointer< IPathSegment_v1, pcIUTF8String_base, const IUTF8String >( + mRawPtr, &IPathSegment_v1::getValue ); + } + + virtual pcIUTF8String_base APICALL getValue( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getValue( error ); + } + + }; + + spIPathSegment IPathSegment_v1::MakeShared( pIPathSegment_base ptr ) { + if ( !ptr ) return spIPathSegment(); + pIPathSegment p = IPathSegment::GetInterfaceVersion() > 1 ? + ptr->GetInterfacePointer< IPathSegment >() : ptr; + return shared_ptr< IPathSegment >( new IPathSegmentProxy( p ) ); + } + + spcIPathSegment IPathSegment_v1::CreatePropertyPathSegment( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pcIPathSegment_base, const IPathSegment, const char *, sizet, const char *, sizet >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreatePropertyPathSegment, nameSpace, nameSpaceLength, name, nameLength ); + } + + spcIPathSegment IPathSegment_v1::CreateArrayIndexPathSegment( const char * nameSpace, sizet nameSpaceLength, sizet index ) { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pcIPathSegment_base, const IPathSegment, const char *, sizet, sizet >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateArrayIndexPathSegment, nameSpace, nameSpaceLength, index ); + } + + spcIPathSegment IPathSegment_v1::CreateQualifierPathSegment( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pcIPathSegment_base, const IPathSegment, const char *, sizet, const char *, sizet >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateQualifierPathSegment, nameSpace, nameSpaceLength, name, nameLength ); + } + + spcIPathSegment IPathSegment_v1::CreateQualifierSelectorPathSegment( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, + const char * value, sizet valueLength ) + { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pcIPathSegment_base, const IPathSegment, const char *, sizet, const char *, sizet, const char *, sizet >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateQualifierSelectorPathSegment, nameSpace, nameSpaceLength, name, nameLength, value, valueLength ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + diff --git a/public/include/XMPCore/source/ISimpleNode.cpp b/public/include/XMPCore/source/ISimpleNode.cpp new file mode 100644 index 0000000..170192f --- /dev/null +++ b/public/include/XMPCore/source/ISimpleNode.cpp @@ -0,0 +1,111 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class ISimpleNodeProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::ISimpleNodeProxy; + +#include "XMPCore/Interfaces/ISimpleNode.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCommon/Interfaces/IUTF8String.h" +#include "XMPCore/Interfaces/ICoreObjectFactory.h" + +#include <assert.h> + +namespace AdobeXMPCore { + +#if XMP_WinBuild + #pragma warning( push ) + #pragma warning( disable : 4250 ) +#endif + + class ISimpleNodeProxy + : public virtual ISimpleNode + , public virtual INodeProxy + { + private: + pISimpleNode mRawPtr; + + public: + ISimpleNodeProxy( pISimpleNode ptr ) + : mRawPtr( ptr ) + , INodeProxy( ptr ) {} + + ~ISimpleNodeProxy() __NOTHROW__ {} + + pISimpleNode APICALL GetActualISimpleNode() __NOTHROW__ { return mRawPtr; } + + AdobeXMPCore_Int::pISimpleNode_I APICALL GetISimpleNode_I() __NOTHROW__ { + return mRawPtr->GetISimpleNode_I(); + } + + virtual spcIUTF8String APICALL GetValue() const { + return CallConstSafeFunctionReturningPointer< ISimpleNode_v1, pcIUTF8String_base, const IUTF8String >( + mRawPtr, &ISimpleNode_v1::getValue ); + } + + virtual void APICALL SetValue( const char * value, sizet valueLength ) { + return CallSafeFunctionReturningVoid< ISimpleNode_v1, const char *, sizet >( + mRawPtr, &ISimpleNode_v1::setValue, value, valueLength ); + } + + virtual bool APICALL IsURIType() const { + return CallConstSafeFunction< ISimpleNode_v1, bool, uint32 >( + mRawPtr, &ISimpleNode_v1::isURIType ); + } + + virtual void APICALL SetURIType( bool isURI ) { + return CallSafeFunctionReturningVoid< ISimpleNode_v1, uint32 >( + mRawPtr, &ISimpleNode_v1::setURIType, isURI ? 1 : 0 ); + } + + virtual pcIUTF8String_base APICALL getValue( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getValue( error ); + } + + virtual void APICALL setValue( const char * value, sizet valueLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->setValue( value, valueLength, error ); + } + + virtual uint32 APICALL isURIType( pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->isURIType( error ); + } + + virtual void APICALL setURIType( uint32 isURI, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->setURIType( isURI, error ); + } + + }; + + spISimpleNode ISimpleNode_v1::CreateSimpleNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, const char * value, sizet valueLength ) { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pISimpleNode_base, ISimpleNode, const char *, sizet, const char *, sizet, const char *, sizet >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateSimpleNode, nameSpace, nameSpaceLength, name, nameLength, value, valueLength ); + } + + spISimpleNode ISimpleNode_v1::MakeShared( pISimpleNode_base ptr ) { + if ( !ptr ) return spISimpleNode(); + pISimpleNode p = ISimpleNode::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< ISimpleNode >() : ptr; + return shared_ptr< ISimpleNode >( new ISimpleNodeProxy( p ) ); + } + +#if XMP_WinBuild + #pragma warning( pop ) +#endif +} + +#endif // !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB diff --git a/public/include/XMPCore/source/IStructureNode.cpp b/public/include/XMPCore/source/IStructureNode.cpp new file mode 100644 index 0000000..32aa76d --- /dev/null +++ b/public/include/XMPCore/source/IStructureNode.cpp @@ -0,0 +1,104 @@ +// ================================================================================================= +// ADOBE SYSTEMS INCORPORATED +// Copyright 2015 Adobe Systems Incorporated +// All Rights Reserved +// +// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms +// of the Adobe license agreement accompanying it. +// ================================================================================================= + +namespace AdobeXMPCore { + class IStructureNodeProxy; +} + +#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IStructureNodeProxy; + +#include "XMPCore/Interfaces/IStructureNode.h" + +#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB + +#include "XMPCommon/Utilities/TWrapperFunctions.h" +#include "XMPCore/Interfaces/ICoreObjectFactory.h" +#include <assert.h> + +namespace AdobeXMPCore { + + + IStructureNodeProxy::IStructureNodeProxy( pIStructureNode ptr ) : mRawPtr( ptr ) + , ICompositeNodeProxy( ptr ) + , INodeProxy( ptr ) { } + + IStructureNodeProxy::~IStructureNodeProxy() __NOTHROW__ { } + + AdobeXMPCore_Int::pIStructureNode_I APICALL IStructureNodeProxy::GetIStructureNode_I() __NOTHROW__ { + return mRawPtr->GetIStructureNode_I(); + } + + INode_v1::eNodeType APICALL IStructureNodeProxy::GetChildNodeType( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) const { + return CallConstSafeFunction< IStructureNode_v1, eNodeType, uint32, const char *, sizet, const char *, sizet >( + mRawPtr, &IStructureNode_v1::getChildNodeType, nameSpace, nameSpaceLength, name, nameLength ); + } + + spINode APICALL IStructureNodeProxy::GetNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< IStructureNode_v1, pINode_base, INode, const char *, sizet, const char *, sizet >( + mRawPtr, &IStructureNode_v1::getNode, nameSpace, nameSpaceLength, name, nameLength ); + } + + void APICALL IStructureNodeProxy::InsertNode( const spINode & node ) { + return CallSafeFunctionReturningVoid< IStructureNode_v1, pINode_base >( + mRawPtr, &IStructureNode_v1::insertNode, node ? node->GetActualINode() : NULL ); + } + + spINode APICALL IStructureNodeProxy::ReplaceNode( const spINode & node ) { + return CallSafeFunctionReturningPointer< IStructureNode_v1, pINode_base, INode, pINode_base >( + mRawPtr, &IStructureNode_v1::replaceNode, node ? node->GetActualINode() : NULL ); + } + + spINode APICALL IStructureNodeProxy::RemoveNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< IStructureNode_v1, pINode_base, INode, const char *, sizet, const char *, sizet >( + mRawPtr, &IStructureNode_v1::removeNode, nameSpace, nameSpaceLength, name, nameLength ); + } + + uint32 APICALL IStructureNodeProxy::getChildNodeType( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) const __NOTHROW__ { + assert( false ); + return mRawPtr->getChildNodeType( nameSpace, nameSpaceLength, name, nameLength, error ); + } + + pINode_base APICALL IStructureNodeProxy::getNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->getNode( nameSpace, nameSpaceLength, name, nameLength, error ); + } + + void APICALL IStructureNodeProxy::insertNode( pINode_base node, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->insertNode( node, error ); + } + + pINode_base APICALL IStructureNodeProxy::replaceNode( pINode_base node, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->replaceNode( node, error ); + } + + pINode_base APICALL IStructureNodeProxy::removeNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ { + assert( false ); + return mRawPtr->removeNode( nameSpace, nameSpaceLength, name, nameLength, error ); + } + + pIStructureNode APICALL IStructureNodeProxy::GetActualIStructureNode() __NOTHROW__ { + return mRawPtr; + } + + spIStructureNode IStructureNode_v1::MakeShared( pIStructureNode_base ptr ) { + if ( !ptr ) return spIStructureNode(); + pIStructureNode p = IStructureNode::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< IStructureNode >() : ptr; + return shared_ptr< IStructureNode >( new IStructureNodeProxy( p ) ); + } + + spIStructureNode IStructureNode_v1::CreateStructureNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) { + return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIStructureNode_base, IStructureNode, const char *, sizet, const char *, sizet >( + ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateStructureNode, nameSpace, nameSpaceLength, name, nameLength ); + } + +} + +#endif // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB |