xmp_toolkit_ruby 0.0.2

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCommon/Interfaces/IConfigurationManager.h

@@ -0,0 +1,167 @@
+//! @file IConfigurationManager.h
+
+#ifndef IConfigurationManager_h__
+#define IConfigurationManager_h__ 1
+
+//
+// =================================================================================================
+// 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/ISharedObject.h"
+#include "XMPCommon/Interfaces/BaseInterfaces/IVersionable.h"
+
+#include "XMPCommon/XMPCommonFwdDeclarations.h"
+
+namespace AdobeXMPCommon {
+
+	//!
+	//! @class IConfigurationManager_v1
+	//! \brief Version1 of the interface that represents configuration settings controllable by the client.
+	//! \details Provides functions through which client can plug in its own memory allocators, error notifiers.
+	//! \attention Not Thread Safe as this functionality is generally used at the initialization phase.
+	//!
+	class XMP_PUBLIC IConfigurationManager_v1
+		: public virtual ISharedObject
+		, public virtual IVersionable
+	{
+	public:
+
+		//!
+		//! @brief Allows the client to plug in its own memory allocation procedures which will be used to allocate/deallocate memory from the heap.
+		//! 
+		//! \param[in] memoryAllocator A pointer to an object of type AdobeXMPCommon::IMemoryAllocator.
+		//! NULL pointer will switch to default allocator built in the library.
+		//! \return A value of bool type; true means successful and false otherwise.
+		//!
+		virtual bool APICALL RegisterMemoryAllocator( pIMemoryAllocator memoryAllocator ) = 0;
+
+		//!
+		//! @brief Allows the client to plug in its own error notification procedures which will be used to
+		//! inform client about various warnings and errors.
+		//! \param[in] clientErrorNotifier A pointer to an object of type AdobeXMPCommon::IErrorNotifier. NULL
+		//! pointer means client no longer wants to be notified of any warnings or errors.
+		//! \return a value of bool type; true means successful and false otherwise.
+		//!
+		virtual bool APICALL RegisterErrorNotifier( pIErrorNotifier_base clientErrorNotifier ) = 0;
+
+		//!
+		//! @brief Allows the client to disable the support for multi threading inside the library.
+		//! By default library supports multi-threading.
+		//! \return A value of bool type; true means successful and false otherwise.
+		//!
+		virtual bool APICALL DisableMultiThreading() = 0;
+
+		//!
+		//! @brief Returns whether library supports multi threading or not
+		//! \return A value of bool type; true means it supports multi threading and false otherwise.
+		//!
+		virtual bool APICALL IsMultiThreaded() const = 0;
+
+		//!
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		//! @{
+		//!  @brief Returns the actual raw pointer from the shared pointer, which can be a shared pointer of a proxy class.
+		//!  \return Either a const or non const pointer to IConfigurationManager interface.
+		//!
+		virtual pIConfigurationManager APICALL GetActualIConfigurationManager() __NOTHROW__ = 0;
+		XMP_PRIVATE pcIConfigurationManager GetActualIConfigurationManager() const __NOTHROW__ {
+			return const_cast< IConfigurationManager_v1 * >( this )->GetActualIConfigurationManager();
+		}
+		//!
+		//! @}
+
+		//!
+		//! @{
+		//! @brief Convert raw pointer to shared pointer. 
+		//! @detail The raw pointer is of version 1 interface where as the returned shared pointer depends on the version client is interested in.
+		//! 
+		//! \return Shared pointer to const or non constant IConfigurationManager interface.
+		//!
+		XMP_PRIVATE static spIConfigurationManager MakeShared( pIConfigurationManager_base ptr );
+		XMP_PRIVATE static spcIConfigurationManager MakeShared( pcIConfigurationManager_base ptr ) {
+			return MakeShared( const_cast< pIConfigurationManager_base >( ptr ) );
+		}
+		//!
+		//! @}
+
+		//!
+		//!  @brief Return the unique ID assigned to the interface.
+		//! \return 64 bit unsigned integer representing the unique ID assigned to the interface.
+		//!
+		XMP_PRIVATE static uint64 GetInterfaceID() { return kIConfigurationManagerID; }
+
+		//!
+		//! @brief Returns the version of the interface.
+		//! \return 32 bit unsigned integer representing the version of the interface.
+		//!
+		XMP_PRIVATE static uint32 GetInterfaceVersion() { return 1; }
+		//! \endcond
+
+        virtual ~IConfigurationManager_v1() __NOTHROW__ {}
+    
+	protected:
+    
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		virtual uint32 APICALL registerMemoryAllocator( pIMemoryAllocator_base memoryAllocator, pcIError_base & error ) __NOTHROW__ = 0;
+		virtual uint32 APICALL registerErrorNotifier( pIErrorNotifier_base clientErrorNotifier, pcIError_base & error ) __NOTHROW__ = 0;
+		virtual uint32 APICALL disableMultiThreading( pcIError_base & error ) __NOTHROW__ = 0;
+		virtual uint32 APICALL isMultiThreaded( pcIError_base & error ) const __NOTHROW__ = 0;
+		//! \endcond
+
+		#ifdef FRIEND_CLASS_DECLARATION
+			FRIEND_CLASS_DECLARATION();
+		#endif
+		REQ_FRIEND_CLASS_DECLARATION();
+		//! \endcond
+	};
+}
+
+
+#if !BUILDING_XMPCOMMON_LIB && !SOURCE_COMPILING_XMP_ALL
+
+namespace AdobeXMPCommon {
+	class IConfigurationManagerProxy
+		: public virtual IConfigurationManager
+	{
+	private:
+		pIConfigurationManager mRawPtr;
+
+	public:
+		IConfigurationManagerProxy( pIConfigurationManager ptr )
+			: mRawPtr( ptr )
+		{
+			mRawPtr->Acquire();
+		}
+
+		~IConfigurationManagerProxy() __NOTHROW__ { mRawPtr->Release(); }
+		pIConfigurationManager APICALL GetActualIConfigurationManager() __NOTHROW__ { return mRawPtr; }
+		AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ { return mRawPtr->GetISharedObject_I(); }
+
+		void APICALL Acquire() const __NOTHROW__;
+		void APICALL Release() const __NOTHROW__;
+		pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion );
+		virtual bool APICALL RegisterMemoryAllocator( pIMemoryAllocator memoryAllocator );
+		virtual bool APICALL RegisterErrorNotifier( pIErrorNotifier_base clientErrorNotifier );
+		virtual bool APICALL DisableMultiThreading();
+		virtual bool APICALL IsMultiThreaded() const;
+
+	protected:
+		virtual uint32 APICALL registerMemoryAllocator( pIMemoryAllocator_base memoryAllocator, pcIError_base & error ) __NOTHROW__;
+		virtual uint32 APICALL registerErrorNotifier( pIErrorNotifier_base clientErrorNotifier, pcIError_base & error ) __NOTHROW__;
+		virtual uint32 APICALL disableMultiThreading( pcIError_base & error ) __NOTHROW__;
+		virtual uint32 APICALL isMultiThreaded( pcIError_base & error ) const __NOTHROW__;
+		pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__;
+	};
+
+}
+
+#endif  // BUILDING_XMPCOMMON_LIB && !SOURCE_COMPILING_XMP_LIB
+
+#endif // IConfigurationManager_h__

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCommon/Interfaces/IError.h

@@ -0,0 +1,377 @@
+//! @file IError.h
+#ifndef __IError_h__
+#define __IError_h__ 1
+
+// =================================================================================================
+// 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/ISharedObject.h"
+#include "XMPCommon/Interfaces/BaseInterfaces/IVersionable.h"
+
+#include "XMPCommon/XMPCommonFwdDeclarations.h"
+
+namespace AdobeXMPCommon {
+
+	//!
+	//!  @brief Version1 of the interface that represents an error/warning encountered during processing.
+	//! \details Provides all the functions to get required information regarding error scenario.
+	//! \attention Do Not support Multi-threading at object level.
+	//! \attention Multi-threading not required since clients will only be provided const objects.
+	//!
+	class XMP_PUBLIC IError_v1
+		: public virtual ISharedObject
+		, public virtual IVersionable
+	{
+	public:
+		//!
+		//! @brief Indicates various types of errors.
+		//!
+		typedef enum {
+			//! No severity, not to be used.
+			kESNone				= 0,
+
+			//! Recovery is possible, client can choose to ignore and let library continue with the best possible way.
+			kESWarning			= 1 << 0,
+
+			//! Recovery is not possible, an exception of type pcIError_base will be thrown aborting the API call.
+			kESOperationFatal	= 1 << 1,
+
+			//! Recovery is not possible, an exception of type pcIError_base will be thrown, client should abort the process.
+			kESProcessFatal		= 1 << 2,
+
+			// Add new severities here
+
+			//! Maximum value this enum can hold, should be treated as invalid value.
+			kESMaxValue			= 1 << 31,
+
+			//! Union of all severities
+			kESAll				= kAllBits,
+		} eErrorSeverity;
+
+
+		//!
+		//! @brief Indicates various types of error domains.
+		//!
+		typedef enum {
+			//! No Domain
+			kEDNone							= 0,
+
+			//! Indicates error related to general conditions.
+			kEDGeneral						= 1,
+
+			//! Indicates error related to memory allocation-deallocation conditions.
+			kEDMemoryManagement				= 2,
+
+			//! Indicates error related to configurable APIs.
+			kEDConfigurable					= 3,
+
+			//! Indicates error releated to multithreading.
+			kEDMultiThreading				= 4,
+
+			//! Indicates error related to XMP Data Model Management.
+			kEDDataModel					= 100,
+
+			//! Indicates error related to XMP Parsing.
+			kEDParser						= 101,
+
+			//! Indicates error related to XMP Serializing.
+			kEDSerializer					= 102,
+
+
+			//! Indicates error related to dealing with XMP in various file formats.
+			kEDXMPFiles						= 200,
+
+
+			//! Indicates error related to Conflict Identification.
+			kEDConflictIdentification		= 400,
+
+			//! Indicates error related to Conflict Resolution.
+			kEDConflictResolution			= 500,
+
+			//! Indicates error related to 3 Way Merge.
+			kEDThreeWayMerge				= 600,
+
+			//! Indicates error related to Generic Strategy Database
+			kEDGenericStrategyDatabase		= 601,
+
+			//! Indicates error related to Asset Management.
+			kEDAssetManagement				= 10000,
+
+			//! Maximum value this enum can hold, should be treated as invalid value.
+			kEDMaxValue						= kMaxEnumValue
+		} eErrorDomain;
+
+		typedef uint32 eErrorCode;
+
+		//!
+		//! @brief Get the error code.
+		//! \return An object of type #eErrorCode indicating the error code.
+		//!
+		virtual eErrorCode APICALL GetCode() const = 0;
+
+		//!
+		//! @brief Get the error domain.
+		//! \return An object of type #eErrorDomain indicating the error domain.
+		//!
+		virtual eErrorDomain APICALL GetDomain() const = 0;
+
+		//!
+		//! @brief Get the error severity.
+		//! \return An object of type #eErrorSeverity indicating the severity of error.
+		//!
+		virtual eErrorSeverity APICALL GetSeverity() const = 0;
+
+		//!
+		//! @brief Get the error message.
+		//! \details Error message contains a descriptive string, for debugging use only. It must not be shown to users
+		//! in a final product. It is written for developers, not users, and never localized.
+		//! \return A shared pointer to const AdobeXMPCommon::IUTF8String object containing message string.
+		//!
+		virtual spcIUTF8String APICALL GetMessage() const = 0;
+
+		//!
+		//! @brief Get the location of the error origin.
+		//! \return A shared pointer to const AdobeXMPCommon::IUTF8String object containing location as like file name
+		//!  and line number.
+		//! \note For debugging use only.
+		//!
+		virtual spcIUTF8String APICALL GetLocation() const = 0;
+
+		//!
+		//! @brief Get the value of a parameter at a particular index.
+		//! \details Based on each error condition various parameters are stored along with the error object. Clients can 
+		//! one by one get access to each parameter that can be later used for debugging.
+		//! \param[in] index A value of \#AdobeXMPCommon::sizet indicating the index of the parameter client is
+		//!  interested in retrieving.
+		//! \return A shared pointer to const \#AdobeXMPCommon::IUTF8String object containing some string.
+		//! \attention Throws \#AdobeXMPCommon::pcIError_base in case index is out of bounds.
+		//! \note For debugging use only.
+		//!
+		virtual spcIUTF8String APICALL GetParameter( sizet index ) const = 0;
+
+		//!
+		//! @brief Get the count of parameters.
+		//! \return An object of type \#AdobeXMPCommon::sizet containing the count of paramaters associated with the error object.
+		//!
+		virtual sizet APICALL GetParametersCount() const __NOTHROW__ = 0;
+
+		//!
+		//! @{
+		//! @brief Get the next error in the chain.
+		//! \return A pointer to const/non-const \#AdobeXMPCommon::IError object which is the next error in the chain.
+		//! \note Return an invalid shared pointer in case it is the last error object in the chain.
+		//!
+		virtual spIError APICALL GetNextError() = 0;
+
+		XMP_PRIVATE spcIError GetNextError() const {
+			return const_cast< IError_v1 * >( this )->GetNextError();
+		}
+		//! @}
+
+		//!
+		//! @brief Set the next error in the chain.
+		//! \param[in] error A pointer to \#AdobeXMP::IError object which will be the next error in the chain.
+		//! \return A pointer to \#AdobeXMPCommon::IError object which is the current next error in the chain.
+		//! \note Return an invalid pointer in case there is no current next error in the chain.
+		//!
+		virtual spIError APICALL SetNextError( const spIError & error ) = 0;
+
+		//!
+		//! @brief Set the error message.
+		//! \param[in] message Pointer to a constant char buffer containing message. It can be null terminated or not.
+		//!                    NULL pointer will be treated as empty message string.
+		//! \param[in] len A value of \#AdobeXMPCommon::sizet indicating the length in case message is not null
+		//!                terminated. In case message is null terminated it can be set to its default value ( npos ).
+		//!
+		virtual void APICALL SetMessage( const char * message, sizet len = npos ) __NOTHROW__  = 0;
+
+		//!
+		//! @brief Set the location of origin of error.
+		//! \param[in] fileName Pointer to a null terminated char buffer containing the file name from which the error
+		//! originated. NULL pointer will be treated as empty fileName.
+		//! \param[in] lineNumber A value of \#AdobeXMPCommon::sizet indicating the line in source file from which the error
+		//! originated.
+		//!
+		virtual void APICALL SetLocation( const char * fileName, sizet lineNumber ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Appends a parameter to the list of parameters.
+		//! \param[in] parameter Pointer to a constant char buffer containing parameter. It can be null terminated or not.
+		//!  NULL pointer will be treated as empty message string.
+		//! \param[in] len A value of AdobeXMPCommon::sizet indicating the length in case parameter is not null
+		//!  terminated. In case parameter is null terminated it can be set to its default value ( npos ).
+		//!
+		virtual void APICALL AppendParameter( const char * parameter, sizet len = npos ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Appends an address as a string to the list of parameters.
+		//! \param[in] addressParameter A value of void * type containing the address of the location to be used as parameter.
+		//!
+		virtual void APICALL AppendParameter( void * addressParameter ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Appends a 32 bit unsigned integer value as a string to the list of parameters.
+		//! \param[in] integerValue A value of AdobeXMPCommon::uint32 type containing the integral value to be used as parameter.
+		//!
+		virtual void APICALL AppendParameter( const uint32 & integerValue ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Appends a 64 bit unsigned integer value as a string to the list of parameters.
+		//! \param[in] integerValue A value of AdobeXMPCommon::uint64 type containing the integral value to be used as parameter.
+		//!
+		virtual void APICALL AppendParameter( const uint64 & integerValue ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Appends a 32 bit integer value as a string to the list of parameters.
+		//! \param[in] integerValue A value of AdobeXMPCommon::int32 type containing the integral value to be used as parameter.
+		//!
+		virtual void APICALL AppendParameter( const int32 & integerValue ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Appends a 64 bit integer value as a string to the list of parameters.
+		//! \param[in] integerValue A value of AdobeXMPCommon::uint64 type containing the integral value to be used as parameter.
+		//!
+		virtual void APICALL AppendParameter( const int64 & integerValue ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Appends a floating value as a string to the list of parameters.
+		//! \param[in] floatValue A value of float type containing the floating value to be used as parameter.
+		//!
+		virtual void APICALL AppendParameter( const float & floatValue ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Appends a double floating value as a string to the list of parameters.
+		//! \param[in] doubleValue A value of double type containing the floating value to be used as parameter.
+		//!
+		virtual void APICALL AppendParameter( const double & doubleValue ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Appends a boolean value as a string to the list of parameters.
+		//! \param[in] booleanValue A value of bool type containing the boolean value to be used as parameter.
+		//!
+		virtual void APICALL AppendParameter( bool booleanValue ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Creates an error object.
+		//! \param[in] objFactory A pointer to IObjectFactory object.
+		//! \param[in] errDomain A value of #eErrorDomain indicating the error domain.
+		//! \param[in] errCode A value of #eErrorCode indicating the error code.
+		//! \param[in] errSeverity A value of #eErrorSeverity indicating the severity of the error.
+		//! \return A shared pointer to an object of IError_v1.
+		//!
+		static spIError CreateError( pIObjectFactory objFactory, eErrorDomain errDomain,
+			eErrorCode errCode, eErrorSeverity errSeverity );
+
+		//!
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		//! @{
+		//! @brief Return the actual raw pointer from the pointer available to client, which can be of a proxy class.
+		//! \return Either a const or non const pointer to IError interface.
+		//!
+		virtual pIError APICALL GetActualIError() __NOTHROW__ = 0;
+		XMP_PRIVATE pcIError GetActualIError() const __NOTHROW__ {
+			return const_cast< IError_v1 * >( this )->GetActualIError();
+		}
+		//!
+		//! @}
+
+		//!
+		//! @{
+		//! @brief Convert raw pointer to shared pointer.
+		//! @details The raw pointer is of version 1 interface where as the returned shared pointer depends on the version client who is interested in.
+		//! 
+		//! \return Shared pointer to const or non constant IError interface.
+		//!
+		XMP_PRIVATE static spIError MakeShared( pIError_base ptr );
+		XMP_PRIVATE static spcIError MakeShared( pcIError_base ptr ) {
+			return MakeShared( const_cast< pIError_base >( ptr ) );
+		}
+		//!
+		//! @}
+
+		//!
+		//! @brief Returns the unique ID assigned to the interface.
+		//! \return 64 bit unsigned integer representing the unique ID assigned to the interface.
+		//!
+		XMP_PRIVATE static uint64 GetInterfaceID() { return kIErrorID; }
+
+		//!
+		//! @brief Returns the version of the interface.
+		//! \return 32 bit unsigned integer representing the version of the interface.
+		//!
+		XMP_PRIVATE static uint32 GetInterfaceVersion() { return 1; }
+		//! \endcond
+
+	protected:
+		//!
+		//! Destructor
+		//! 
+		virtual ~IError_v1() __NOTHROW__ {}
+
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		virtual uint32 APICALL getCode( pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual uint32 APICALL getDomain( pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual uint32 APICALL getSeverity( pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual pcIUTF8String_base APICALL getMessage( pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual pcIUTF8String_base APICALL getLocation( pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual pcIUTF8String_base APICALL getParameter( sizet index, pcIError_base & error ) const __NOTHROW__ = 0;
+		virtual pIError_base APICALL getNextError( pcIError_base & error ) __NOTHROW__ = 0;
+		virtual pIError_base APICALL setNextError( pIError_base nextError, pcIError_base & error ) __NOTHROW__ = 0;
+
+		#ifdef FRIEND_CLASS_DECLARATION
+			FRIEND_CLASS_DECLARATION();
+		#endif
+		REQ_FRIEND_CLASS_DECLARATION();
+		//! \endcond
+	};
+
+	//!
+	//! @brief A function pointer to report back errors and warnings to the library encountered during the serialization operation.
+	//! @details Based on the error condition library can return 0 or non zero to indicate that a particular warning can be ignored
+	//!          and operation can continue.
+	//! \param[in] errorDomain An unsigned 32 bit integer indicating the domain of the error.
+	//! \param[in] errorCode An unsigned 32 bit integer indicating the code of the error.
+	//! \param[in] errorSeverity An unsigned 32 bit integer indicating the severity of the error.
+	//! \param[out] error A reference to a pointer to const IError object which will be filled with the error object in case of any error.
+	//! \return non zero value indicating that process can continue ignoring the warning, otherwise return 0 to indicate it should stop immediately.
+	//!
+	typedef uint32( *ReportErrorAndContinueABISafeProc )( uint32 errorDomain, uint32 errorCode, uint32 errorSeverity, const char * message, pcIError_base & error );
+
+	//!
+	//! @brief A Function object used by the client to report back and warnings to the library encountered during the serialization operation.
+	//! @details Based on the error condition library can return 0 or non zero to indicate that a particular warning can be ignored
+	//!          and operation can continue.
+	//!
+	class ReportErrorAndContinueFunctor {
+	public:
+		ReportErrorAndContinueFunctor( ReportErrorAndContinueABISafeProc safeProc )
+			: mSafeProc( safeProc ) {}
+
+		//!
+		//! \param[in] errorDomain A value of \#IError_v1::eErrorDomain indicating the domain of the error.
+		//! \param[in] errorCode A value of \#IError_v1::eErrorCode indicating the code of the error.
+		//! \param[in] errorSeverity A value of \#IError_v1::eErrorSeverity indicating the severity of the error.
+		//! \param[in] message Pointer to a constant char buffer containing message. 
+		//! \return true value indicating that process can continue ignoring the warning, otherwise return false to indicate it should stop immediately.
+		//!
+		bool operator()( IError_v1::eErrorDomain errorDomain, IError_v1::eErrorCode errorCode, IError_v1::eErrorSeverity errorSeverity, const char * message ) {
+			pcIError_base error( NULL );
+			auto retValue = mSafeProc( static_cast< uint32 >( errorDomain ), static_cast< uint32 >( errorCode ), static_cast< uint32 >( errorSeverity ), message, error );
+			if ( error )
+				throw IError_v1::MakeShared( error );
+			return retValue != 0 ? true : false;
+		}
+
+	protected:
+		ReportErrorAndContinueABISafeProc		mSafeProc;
+	};
+
+
+}
+
+#endif  // __IError_h__

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCommon/Interfaces/IErrorNotifier.h

@@ -0,0 +1,52 @@
+#ifndef IErrorNotifier_h__
+#define IErrorNotifier_h__ 1
+
+// =================================================================================================
+// 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/XMPCommonFwdDeclarations.h"
+
+namespace AdobeXMPCommon {
+
+	//!
+	//! \brief Version1 of the interface that represents an interface to be implemented by client
+	//! in case he is interested in getting notifications with respect to errors/warnings encountered
+	//! by library.
+	//! \details In case client is interested in error notifications he can implement this interface
+	//! and register the same with the \#AdobeXMPCommon::IConfigurationManager. For every warning or error
+	//! encountered the NotifyError function will be called by the library. In case of warnings ( indicated
+	//! by the severity of the error ) the client has the option to continue ignoring the warning by returning
+	//! true else he can return false and the warning will be thrown aborting the current operation.
+	//!
+	class XMP_PUBLIC IErrorNotifier_v1
+	{
+	public:
+		//!
+		//! @brief Called by the library to notify the client about the warning/error.
+		//! \param[in] error const pointer to a \#AdobeXMPCommon::IError. Client can use the information
+		//! in the error to decide what should be the future course of action.
+		//! \return A value of bool type that will indicate the future course of action.
+		//!
+		virtual bool APICALL Notify( const spcIError & error ) = 0;
+        virtual ~IErrorNotifier_v1() {}
+
+	protected:
+		//! \cond XMP_INTERNAL_DOCUMENTATION
+		virtual uint32 APICALL notify( pcIError_base error, uint32 & exceptionThrown ) __NOTHROW__;
+		//! \endcond
+
+		#ifdef FRIEND_CLASS_DECLARATION
+			FRIEND_CLASS_DECLARATION();
+		#endif
+		REQ_FRIEND_CLASS_DECLARATION();
+		//! \endcond
+	};
+}
+
+#endif  // IErrorNotifier_h__

data/ext/xmp_toolkit_ruby/XMP-Toolkit-SDK/public/include/XMPCommon/Interfaces/IMemoryAllocator.h

@@ -0,0 +1,65 @@
+#ifndef IMemoryAllocator_h__
+#define IMemoryAllocator_h__ 1
+
+// =================================================================================================
+// 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/IVersionable.h"
+
+#include "XMPCommon/XMPCommonFwdDeclarations.h"
+
+namespace AdobeXMPCommon {
+
+	//!
+	//! \brief Version1 of the interface that represents an interface to be implemented by client in case
+	//! he is interested in controlling the memory allocation and deallocation on the heap.
+	//! \details In case client is interested in controlling the memory allocation and deallocation on
+	//! the heap he can implement this interface and register the same with the
+	//! \#AdobeXMPCommon::IConfigurationManager. For every request of memory allocation or deallocation on
+	//! the heap corresponding function will be called by the library.
+	//! \attention Support for Multi threading is under clients hand.
+	//!
+	class XMP_PUBLIC IMemoryAllocator_v1
+	{
+	public:
+		//!
+		//! @brief Called by the library whenever it needs some space on the heap.
+		//! \param[in] size A value of type \#AdobeXMPCommon::sizet indicating the number of bytes
+		//! required by the library on the heap.
+		//! \return A pointer to memory location on the heap.
+		//!
+		virtual void * APICALL allocate( sizet size ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Called by the library whenever there is no further need for a previously allocated space on the heap.
+		//! \param[in] ptr A pointer to a memory location which is no longer needed.
+		//!
+		virtual void APICALL deallocate( void * ptr ) __NOTHROW__ = 0;
+
+		//!
+		//! @brief Called by the library whenever it needs to expand or contract some space already allocated on
+		//! the heap, preserving the contents.
+		//! \param[in] ptr A pointer to a memory location which was previously allocated on the heap.
+		//! \param[in] size A value of type \#AdobeXMPCommon::sizet indicating the new number of bytes
+		//! required by the library on the heap.
+		//! \return A pointer to memory location on the heap which is of new size and previous contents are
+		//!  preserved.
+		//!
+		virtual void * APICALL reallocate( void * ptr, sizet size ) __NOTHROW__ = 0;
+        virtual ~IMemoryAllocator_v1(){}
+
+	protected:
+
+	#ifdef FRIEND_CLASS_DECLARATION
+		FRIEND_CLASS_DECLARATION();
+	#endif
+		REQ_FRIEND_CLASS_DECLARATION();
+	};
+};
+
+#endif  // IMemoryAllocator_h__