xmp_toolkit_ruby 0.0.2

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCore/source/IClientDOMSerializer.cpp

@@ -0,0 +1,73 @@
+// =================================================================================================
+// Copyright Adobe
+// Copyright 2015 Adobe
+// 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

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCore/source/ICompositeNode.cpp

@@ -0,0 +1,121 @@
+// =================================================================================================
+// Copyright Adobe
+// Copyright 2015 Adobe
+// 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

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCore/source/ICoreConfigurationManager.cpp

@@ -0,0 +1,88 @@
+// =================================================================================================
+// Copyright Adobe
+// Copyright 2015 Adobe
+// 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

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCore/source/ICoreObjectFactory.cpp

@@ -0,0 +1,83 @@
+// =================================================================================================
+// Copyright Adobe
+// Copyright 2015 Adobe
+// 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

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCore/source/IDOMImplementationRegistry.cpp

@@ -0,0 +1,122 @@
+// =================================================================================================
+// Copyright Adobe
+// Copyright 2015 Adobe
+// 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

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCore/source/IDOMParser.cpp

@@ -0,0 +1,116 @@
+// =================================================================================================
+// Copyright Adobe
+// Copyright 2015 Adobe
+// 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