xmp_toolkit_ruby 0.0.2

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCommon/source/IConfigurable.cpp

@@ -0,0 +1,204 @@
+// =================================================================================================
+// Copyright Adobe
+// Copyright 2014 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 "XMPCommon/Interfaces/BaseInterfaces/IConfigurable.h"
+
+#if !BUILDING_XMPCOMMON_LIB && !SOURCE_COMPILING_XMP_ALL
+
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include <assert.h>
+
+namespace AdobeXMPCommon {
+
+	IConfigurableProxy::IConfigurableProxy( pIConfigurable configurable )
+		: mConfigurableRawPtr( configurable ) { }
+
+	void APICALL IConfigurableProxy::SetParameter( const uint64 & key, bool value ) {
+		CombinedDataValue combinedValue;
+		combinedValue.uint32Value = value ? 1 : 0;
+		CallSafeFunctionReturningVoid< IConfigurable, const uint64 &, uint32, const CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::setParameter, key, static_cast< uint32 >( IConfigurable::kDTBool ), combinedValue
+		);
+	}
+
+	void APICALL IConfigurableProxy::setParameter( const uint64 & key, uint32 dataType, const CombinedDataValue & dataValue, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mConfigurableRawPtr->setParameter( key, dataType, dataValue, error );
+	}
+
+	bool APICALL IConfigurableProxy::RemoveParameter( const uint64 & key ) {
+		return CallSafeFunction< IConfigurable, bool, uint32, const uint64 & >(
+			mConfigurableRawPtr, &IConfigurable::removeParameter, key );
+	}
+
+	uint32 APICALL IConfigurableProxy::removeParameter( const uint64 & key, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mConfigurableRawPtr->removeParameter( key, error );
+	}
+
+	bool APICALL IConfigurableProxy::GetParameter( const uint64 & key, bool & value ) const {
+		CombinedDataValue combinedValue;
+		bool returnValue = CallConstSafeFunction< IConfigurable, bool, uint32, const uint64 &, uint32, CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::getParameter, key, static_cast< uint32 >( IConfigurable::kDTBool ), combinedValue
+		);
+		value = combinedValue.uint32Value != 0 ? 1 : 0;
+		return returnValue;
+	}
+
+	uint32 APICALL IConfigurableProxy::getParameter( const uint64 & key, uint32 dataType, CombinedDataValue & value, pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mConfigurableRawPtr->getParameter( key, dataType, value, error );
+	}
+
+	std::vector< uint64 > APICALL IConfigurableProxy::GetAllParameters() const {
+		sizet nElements = mConfigurableRawPtr->Size();
+		std::vector< uint64 > vec( nElements );
+		if ( nElements > 0 )
+			mConfigurableRawPtr->getAllParameters( vec.data(), nElements );
+		return vec;
+	}
+
+	void APICALL IConfigurableProxy::getAllParameters( uint64 * array, sizet count ) const __NOTHROW__ {
+		assert( false );
+		return mConfigurableRawPtr->getAllParameters( array, count );
+	}
+
+	sizet APICALL IConfigurableProxy::Size() const __NOTHROW__ {
+		return mConfigurableRawPtr->Size();
+	}
+
+	IConfigurable::eDataType APICALL IConfigurableProxy::GetDataType( const uint64 & key ) const {
+		return CallConstSafeFunction< IConfigurable, eDataType, uint32, const uint64 & >(
+			mConfigurableRawPtr, &IConfigurable::getDataType, key );
+	}
+
+	uint32 APICALL IConfigurableProxy::getDataType( const uint64 & key, pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mConfigurableRawPtr->getDataType( key, error );
+	}
+
+	bool APICALL IConfigurableProxy::GetParameter( const uint64 & key, const void * & value ) const {
+		CombinedDataValue combinedValue;
+		bool returnValue = CallConstSafeFunction< IConfigurable, bool, uint32, const uint64 &, uint32, CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::getParameter, key, static_cast< uint32 >( IConfigurable::kDTConstVoidPtr ), combinedValue
+		);
+		value = combinedValue.constVoidPtrValue;
+		return returnValue;
+	}
+
+	bool APICALL IConfigurableProxy::GetParameter( const uint64 & key, const char * & value ) const {
+		CombinedDataValue combinedValue;
+		bool returnValue = CallConstSafeFunction< IConfigurable, bool, uint32, const uint64 &, uint32, CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::getParameter, key, static_cast< uint32 >( IConfigurable::kDTConstCharBuffer ), combinedValue
+		);
+		value = combinedValue.constCharPtrValue;
+		return returnValue;
+	}
+
+	bool APICALL IConfigurableProxy::GetParameter( const uint64 & key, char & value ) const {
+		CombinedDataValue combinedValue;
+		bool returnValue = CallConstSafeFunction< IConfigurable, bool, uint32, const uint64 &, uint32, CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::getParameter, key, static_cast< uint32 >( IConfigurable::kDTChar ), combinedValue
+		);
+		value = combinedValue.charValue;
+		return returnValue;
+	}
+
+	bool APICALL IConfigurableProxy::GetParameter( const uint64 & key, double & value ) const {
+		CombinedDataValue combinedValue;
+		bool returnValue = CallConstSafeFunction< IConfigurable, bool, uint32, const uint64 &, uint32, CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::getParameter, key, static_cast< uint32 >( IConfigurable::kDTDouble ), combinedValue
+		);
+		value = combinedValue.doubleValue;
+		return returnValue;
+	}
+
+	bool APICALL IConfigurableProxy::GetParameter( const uint64 & key, int64 & value ) const {
+		CombinedDataValue combinedValue;
+		bool returnValue = CallConstSafeFunction< IConfigurable, bool, uint32, const uint64 &, uint32, CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::getParameter, key, static_cast< uint32 >( IConfigurable::kDTInt64 ), combinedValue
+		);
+		value = combinedValue.int64Value;
+		return returnValue;
+	}
+
+	bool APICALL IConfigurableProxy::GetParameter( const uint64 & key, uint64 & value ) const {
+		CombinedDataValue combinedValue;
+		bool returnValue = CallConstSafeFunction< IConfigurable, bool, uint32, const uint64 &, uint32, CombinedDataValue &
+		>(
+		mConfigurableRawPtr, &IConfigurable::getParameter, key, static_cast< uint32 >( IConfigurable::kDTUint64 ), combinedValue
+		);
+		value = combinedValue.uint64Value;
+		return returnValue;
+	}
+
+	void APICALL IConfigurableProxy::SetParameter( const uint64 & key, const void * value ) {
+		CombinedDataValue combinedValue;
+		combinedValue.constVoidPtrValue= value;
+		return CallSafeFunctionReturningVoid< IConfigurable, const uint64 &, uint32, const CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::setParameter, key, static_cast< uint32 >( IConfigurable::kDTConstVoidPtr ), combinedValue
+		);
+	}
+
+	void APICALL IConfigurableProxy::SetParameter( const uint64 & key, const char * value ) {
+		CombinedDataValue combinedValue;
+		combinedValue.constCharPtrValue = value;
+		return CallSafeFunctionReturningVoid< IConfigurable, const uint64 &, uint32, const CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::setParameter, key, static_cast< uint32 >( IConfigurable::kDTConstCharBuffer ), combinedValue
+		);
+	}
+
+	void APICALL IConfigurableProxy::SetParameter( const uint64 & key, char value ) {
+		CombinedDataValue combinedValue;
+		combinedValue.charValue = value;
+		return CallSafeFunctionReturningVoid< IConfigurable, const uint64 &, uint32, const CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::setParameter, key, static_cast< uint32 >( IConfigurable::kDTChar ), combinedValue
+		);
+	}
+
+	void APICALL IConfigurableProxy::SetParameter( const uint64 & key, double value ) {
+		CombinedDataValue combinedValue;
+		combinedValue.doubleValue = value;
+		return CallSafeFunctionReturningVoid< IConfigurable, const uint64 &, uint32, const CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::setParameter, key, static_cast< uint32 >( IConfigurable::kDTDouble ), combinedValue
+		);
+	}
+
+	void APICALL IConfigurableProxy::SetParameter( const uint64 & key, int64 value ) {
+		CombinedDataValue combinedValue;
+		combinedValue.int64Value = value;
+		return CallSafeFunctionReturningVoid< IConfigurable, const uint64 &, uint32, const CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::setParameter, key, static_cast< uint32 >( IConfigurable::kDTInt64 ), combinedValue
+		);
+	}
+
+	void APICALL IConfigurableProxy::SetParameter( const uint64 & key, uint64 value ) {
+		CombinedDataValue combinedValue;
+		combinedValue.uint64Value = value;
+		return CallSafeFunctionReturningVoid< IConfigurable, const uint64 &, uint32, const CombinedDataValue &
+		>(
+			mConfigurableRawPtr, &IConfigurable::setParameter, key, static_cast< uint32 >( IConfigurable::kDTUint64 ), combinedValue
+		);
+	}
+
+}
+
+#endif  // !BUILDING_XMPCOMMON_LIB && !SOURCE_COMPILING_XMP_ALL

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCommon/source/IConfigurationManager.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. 
+// =================================================================================================
+
+#define FRIEND_CLASS_DECLARATION() friend class IConfigurationManagerProxy;
+
+#include "XMPCommon/Interfaces/IConfigurationManager.h"
+
+#if !BUILDING_XMPCOMMON_LIB && !SOURCE_COMPILING_XMP_ALL
+
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include "XMPCommon/Interfaces/IError.h"
+
+#include <assert.h>
+
+namespace AdobeXMPCommon {
+
+	void APICALL IConfigurationManagerProxy::Acquire() const __NOTHROW__ {
+		assert( false );
+	}
+
+	void APICALL IConfigurationManagerProxy::Release() const __NOTHROW__ {
+		assert( false );
+	}
+
+	pvoid APICALL IConfigurationManagerProxy::getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error );
+	}
+
+	pvoid APICALL IConfigurationManagerProxy::GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) {
+		return AdobeXMPCommon::CallSafeFunction<
+			IVersionable, pvoid, pvoid, uint64, uint32
+		>( mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion );
+	}
+
+	uint32 APICALL IConfigurationManagerProxy::registerMemoryAllocator( pIMemoryAllocator_base memoryAllocator, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->registerMemoryAllocator( memoryAllocator, error );
+	}
+
+	bool APICALL IConfigurationManagerProxy::RegisterMemoryAllocator( pIMemoryAllocator memoryAllocator ) {
+		return CallSafeFunction< IConfigurationManager, bool, uint32, pIMemoryAllocator_base >(
+			mRawPtr, &IConfigurationManager::registerMemoryAllocator, memoryAllocator );
+	}
+
+	uint32 APICALL IConfigurationManagerProxy::registerErrorNotifier( pIErrorNotifier_base clientErrorNotifier, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->registerErrorNotifier( clientErrorNotifier, error );
+	}
+
+	bool APICALL IConfigurationManagerProxy::RegisterErrorNotifier( pIErrorNotifier_base clientErrorNotifier ) {
+		return CallSafeFunction< IConfigurationManager, bool, uint32, pIErrorNotifier_base >(
+			mRawPtr, &IConfigurationManager::registerErrorNotifier, clientErrorNotifier );
+	}
+
+	uint32 APICALL IConfigurationManagerProxy::disableMultiThreading( pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->disableMultiThreading( error );
+	}
+
+	bool APICALL IConfigurationManagerProxy::DisableMultiThreading() {
+		return CallSafeFunction< IConfigurationManager, bool, uint32 >(
+			mRawPtr, &IConfigurationManager::disableMultiThreading );
+	}
+
+	uint32 APICALL IConfigurationManagerProxy::isMultiThreaded( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->isMultiThreaded( error );
+	}
+
+	bool APICALL IConfigurationManagerProxy::IsMultiThreaded() const {
+		return CallConstSafeFunction< IConfigurationManager, bool, uint32 >(
+			mRawPtr, &IConfigurationManager::isMultiThreaded );
+	}
+
+	spIConfigurationManager IConfigurationManager_v1::MakeShared( pIConfigurationManager_base ptr ) {
+		if ( !ptr ) return spIConfigurationManager();
+		pIConfigurationManager p = IConfigurationManager::GetInterfaceVersion() > 1 ?
+			ptr->GetInterfacePointer< IConfigurationManager >() : ptr;
+		return shared_ptr< IConfigurationManager >( new IConfigurationManagerProxy( p ) );
+	}
+
+}
+
+#endif  // !BUILDING_XMPCOMMON_LIB && !SOURCE_COMPILING_XMP_LIB
+

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCommon/source/IError.cpp

@@ -0,0 +1,207 @@
+// =================================================================================================
+// 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. 
+// =================================================================================================
+
+#define FRIEND_CLASS_DECLARATION() friend class IErrorProxy;
+
+#include "XMPCommon/Interfaces/IError.h"
+
+#if !BUILDING_XMPCOMMON_LIB && !SOURCE_COMPILING_XMP_ALL
+
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include "XMPCommon/Interfaces/IUTF8String.h"
+#include "XMPCommon/Interfaces/IObjectFactory.h"
+
+#include <assert.h>
+
+namespace AdobeXMPCommon {
+	class IErrorProxy
+		: public virtual IError
+	{
+	private:
+		pIError mRawPtr;
+
+	public:
+		IErrorProxy( pIError ptr )
+			: mRawPtr( ptr )
+		{
+			mRawPtr->Acquire();
+		}
+
+		~IErrorProxy() __NOTHROW__ { mRawPtr->Release(); }
+
+		pIError APICALL GetActualIError() __NOTHROW__ { return mRawPtr; }
+
+		void APICALL Acquire() const __NOTHROW__ { assert( false ); }
+
+		void APICALL Release() const __NOTHROW__ { assert( false ); }
+
+		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 );
+		}
+
+		eErrorCode APICALL GetCode() const {
+			return CallConstSafeFunction< IError, eErrorCode, uint32 >(
+				mRawPtr, &IError::getCode );
+		}
+
+		uint32 APICALL getCode( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getCode( error );
+		}
+
+		eErrorDomain APICALL GetDomain() const {
+			return CallConstSafeFunction< IError, eErrorDomain, uint32 >(
+				mRawPtr, &IError::getDomain );
+		}
+
+		uint32 APICALL getDomain( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getDomain( error );
+		}
+
+		eErrorSeverity APICALL GetSeverity() const {
+			return CallConstSafeFunction< IError, eErrorSeverity, uint32 >(
+				mRawPtr, &IError::getSeverity );
+		}
+
+		uint32 APICALL getSeverity( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getSeverity( error );
+		}
+
+		spcIUTF8String APICALL GetMessage() const {
+			return CallConstSafeFunctionReturningPointer< IError, pcIUTF8String_base, const IUTF8String >(
+				mRawPtr, &IError::getMessage );
+		}
+
+		pcIUTF8String_base APICALL getMessage( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getMessage( error );
+		}
+
+		spcIUTF8String APICALL GetLocation() const {
+			return CallConstSafeFunctionReturningPointer< IError, pcIUTF8String_base, const IUTF8String >(
+				mRawPtr, &IError::getLocation );
+		}
+
+		pcIUTF8String_base APICALL getLocation( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getLocation( error );
+		}
+
+		spcIUTF8String APICALL GetParameter( sizet index ) const {
+			return CallConstSafeFunctionReturningPointer< IError, pcIUTF8String_base, const IUTF8String, sizet >(
+				mRawPtr, &IError::getParameter, index );
+		}
+
+		pcIUTF8String_base APICALL getParameter( sizet index, pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getParameter( index, error );
+		}
+
+		sizet APICALL GetParametersCount() const __NOTHROW__ {
+			return mRawPtr->GetParametersCount();
+		}
+
+		spIError APICALL GetNextError() {
+			pcIError_base error( NULL );
+			pIError_base ptr = mRawPtr->getNextError( error );
+			if ( error ) throw MakeShared( error );
+			return MakeShared( ptr );
+		}
+
+		pIError_base APICALL getNextError( pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getNextError( error );
+		}
+
+		spIError APICALL SetNextError( const spIError & nextError ) {
+			pcIError_base error( NULL );
+			pIError_base ptr = mRawPtr->setNextError( nextError ? nextError->GetActualIError() : NULL, error );
+			if ( error ) throw MakeShared( error );
+			return MakeShared( ptr );
+		}
+
+		pIError_base APICALL setNextError( pIError_base nextError, pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->setNextError( nextError, error );
+		}
+
+		void APICALL SetMessage( const char * message, sizet len ) __NOTHROW__ {
+			mRawPtr->SetMessage( message, len );
+		}
+
+		void APICALL SetLocation( const char * fileName, sizet lineNumber ) __NOTHROW__ {
+			mRawPtr->SetLocation( fileName, lineNumber );
+		}
+
+		void APICALL AppendParameter( const char * parameter, sizet len ) __NOTHROW__ {
+			mRawPtr->AppendParameter( parameter, len );
+		}
+
+		void APICALL AppendParameter( void * addressParameter ) __NOTHROW__ {
+			return mRawPtr->AppendParameter( addressParameter );
+		}
+
+		void APICALL AppendParameter( const uint32 & integerValue ) __NOTHROW__ {
+			return mRawPtr->AppendParameter( integerValue );
+		}
+
+		void APICALL AppendParameter( const uint64 & integerValue ) __NOTHROW__ {
+			return mRawPtr->AppendParameter( integerValue );
+		}
+
+		void APICALL AppendParameter( const int32 & integerValue ) __NOTHROW__ {
+			return mRawPtr->AppendParameter( integerValue );
+		}
+
+		void APICALL AppendParameter( const int64 & integerValue ) __NOTHROW__ {
+			return mRawPtr->AppendParameter( integerValue );
+		}
+
+		void APICALL AppendParameter( const float & floatValue ) __NOTHROW__ {
+			return mRawPtr->AppendParameter( floatValue );
+		}
+
+		void APICALL AppendParameter( const double & doubleValue ) __NOTHROW__ {
+			return mRawPtr->AppendParameter( doubleValue );
+		}
+
+		void APICALL AppendParameter( bool booleanValue ) __NOTHROW__ {
+			return mRawPtr->AppendParameter( booleanValue );
+		}
+
+		AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ {
+			return mRawPtr->GetISharedObject_I();
+		}
+
+	};
+
+	spIError IError_v1::CreateError( pIObjectFactory objFactory, eErrorDomain errDomain, eErrorCode errCode, eErrorSeverity errSeverity ) {
+		pIError_base temp = CallSafeFunction< IObjectFactory_base, pIError_base, pIError_base, uint32, uint32, uint32 >(
+			objFactory, &IObjectFactory_base::CreateError, static_cast< uint32 >( errDomain ),
+			static_cast< uint32 >( errCode ), static_cast< uint32 >( errSeverity ) );
+		return MakeShared( temp );
+	}
+
+	spIError IError_v1::MakeShared( pIError_base ptr ) {
+		if ( !ptr ) return spIError();
+		pIError p = IError::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer<IError>() : ptr;
+		return shared_ptr< IError >( new IErrorProxy( p ) );
+	}
+}
+
+#endif  // !BUILDING_XMPCOMMON_LIB && !SOURCE_COMPILING_XMP_ALL

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCommon/source/IErrorNotifier.cpp

@@ -0,0 +1,26 @@
+// =================================================================================================
+// 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 "XMPCommon/Interfaces/IErrorNotifier.h"
+#include "XMPCommon/Interfaces/IError.h"
+
+namespace AdobeXMPCommon {
+	uint32 APICALL IErrorNotifier_v1::notify( pcIError_base error, uint32 & exceptionThrown ) __NOTHROW__ {
+		exceptionThrown = 0;
+		bool retValue( false );
+		try {
+			retValue = Notify( IError::MakeShared( error ) );
+		} catch ( ... ) {
+			exceptionThrown = 1;
+		}
+		return retValue ? 1 : 0;
+	}
+
+}
+