xmp_toolkit_ruby 0.0.2

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

@@ -0,0 +1,109 @@
+// =================================================================================================
+// 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 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

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

@@ -0,0 +1,113 @@
+// =================================================================================================
+// 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 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

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

@@ -0,0 +1,92 @@
+// =================================================================================================
+// 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 IMetadataConverterUtilsProxy;
+}
+
+#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IMetadataConverterUtilsProxy;
+
+#include "XMPCore/Interfaces/IMetadataConverterUtils.h"
+
+#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB
+
+#include "XMPCore/Interfaces/IMetadata.h"
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include "XMPCommon/Interfaces/IUTF8String.h"
+#include "XMPCore/Interfaces/ICoreObjectFactory.h"
+#include "XMPCore/XMPCoreFwdDeclarations.h"
+
+#include <assert.h>
+namespace AdobeXMPCore {
+    
+    class IMetadataConverterUtilsProxy
+    : public virtual IMetadataConverterUtils
+    {
+    private:
+        pIMetadataConverterUtils mRawPtr;
+        
+    public:
+        IMetadataConverterUtilsProxy( pIMetadataConverterUtils ptr ):
+        mRawPtr( ptr )
+        {
+            mRawPtr->Acquire();
+        }
+        
+        virtual ~IMetadataConverterUtilsProxy() __NOTHROW__ { mRawPtr->Release(); }
+        
+        pIMetadataConverterUtils APICALL GetActualIMetadataConverterUtils() __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::pIMetadataConverterUtils_I APICALL GetIMetadataConverterUtils_I() __NOTHROW__ {
+            return mRawPtr->GetIMetadataConverterUtils_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 );
+        }
+    };
+    
+    spIMetadataConverterUtils IMetadataConverterUtils_v1::MakeShared( pIMetadataConverterUtils_base ptr ) {
+        if ( !ptr ) return spIMetadataConverterUtils();
+        pIMetadataConverterUtils p = IMetadataConverterUtils::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< IMetadataConverterUtils >() : ptr;
+        return shared_ptr< IMetadataConverterUtils >( new IMetadataConverterUtilsProxy( p ) );
+    }
+
+    AdobeXMPCore::spIMetadata IMetadataConverterUtils_v1::ConvertXMPMetatoIMetadata(const SXMPMeta* inOldXMP)
+    {
+        if(!inOldXMP) return  AdobeXMPCore::spIMetadata();
+        return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIMetadata, IMetadata, XMPMetaRef >(
+        ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::ConvertXMPMetatoIMetadata ,inOldXMP->GetInternalRef());
+    }
+    
+    SXMPMeta IMetadataConverterUtils_v1::ConvertIMetadatatoXMPMeta(AdobeXMPCore::spIMetadata inNewXMP)
+    {
+        if(!inNewXMP) return SXMPMeta();
+        pcIError_base error( NULL );
+        XMPMetaRef returnValue = ICoreObjectFactory::GetCoreObjectFactory()->ConvertIMetadatatoXMPMeta(inNewXMP->GetActualIMetadata(),error);
+        if ( error ) throw IError::MakeShared( error );
+        return SXMPMeta( returnValue );
+    }
+    
+}
+
+#endif  // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB

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

@@ -0,0 +1,187 @@
+// =================================================================================================
+// 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 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__ override { return mRawPtr; }
+
+		void APICALL Acquire() const __NOTHROW__ override { assert( false ); }
+
+		void APICALL Release() const __NOTHROW__ override { assert( false ); }
+
+		AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ override {
+			return mRawPtr->GetISharedObject_I();
+		}
+
+		AdobeXMPCore_Int::pINameSpacePrefixMap_I APICALL GetINameSpacePrefixMap_I() __NOTHROW__ override {
+			return mRawPtr->GetINameSpacePrefixMap_I();
+		}
+
+		pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) override {
+			return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >(
+				mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion );
+		}
+
+		pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ override {
+			assert( false );
+			return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error );
+		}
+
+		virtual bool APICALL Insert( const char * prefix, sizet prefixLength, const char * nameSpace, sizet nameSpaceLength ) override {
+			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__ override {
+			assert( false );
+			return mRawPtr->insert( prefix, prefixLength, nameSpace, nameSpaceLength, error );
+		}
+
+		virtual bool APICALL RemovePrefix( const char * prefix, sizet prefixLength ) override {
+			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 ) override {
+			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 override {
+			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 override {
+			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 override {
+			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 override {
+			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__ override {
+			return mRawPtr->Size();
+		}
+
+		virtual void APICALL Clear() __NOTHROW__ override {
+			return mRawPtr->Clear();
+		}
+
+		virtual spINameSpacePrefixMap APICALL Clone() const override {
+			return CallConstSafeFunctionReturningPointer< INameSpacePrefixMap_v1, pINameSpacePrefixMap_base, INameSpacePrefixMap >(
+				mRawPtr, &INameSpacePrefixMap_v1::clone );
+		}
+
+		virtual pINameSpacePrefixMap_base APICALL clone( pcIError_base & error ) const __NOTHROW__ override {
+			assert( false );
+			return mRawPtr->clone( error );
+		}
+
+		virtual uint32 APICALL remove( uint32 keyType, const char * key, sizet keyLength, pcIError_base & error ) __NOTHROW__ override {
+			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__ override {
+			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__ override {
+			assert( false );
+			return mRawPtr->get( keyType, key, keyLength, error );
+		}
+
+		virtual void APICALL EnableThreadSafety() const __NOTHROW__  override {
+			return mRawPtr->EnableThreadSafety();
+		}
+
+		virtual void APICALL DisableThreadSafety() const __NOTHROW__  override {
+			return mRawPtr->DisableThreadSafety();
+		}
+
+		virtual bool APICALL IsThreadSafe() const override {
+			return mRawPtr->isThreadSafe() != 0;
+		}
+
+		virtual uint32 APICALL isThreadSafe( ) const __NOTHROW__ override {
+			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