xmp_toolkit_ruby 0.0.2

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

@@ -0,0 +1,146 @@
+// =================================================================================================
+// 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 IPathSegmentProxy;
+}
+
+#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IPathSegmentProxy;
+
+#include "XMPCore/Interfaces/IPathSegment.h"
+
+#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB
+
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include "XMPCommon/Interfaces/IUTF8String.h"
+#include "XMPCommon/Interfaces/IError.h"
+#include "XMPCore/Interfaces/ICoreObjectFactory.h"
+
+#include <assert.h>
+
+namespace AdobeXMPCore {
+
+	class IPathSegmentProxy
+		: public virtual IPathSegment
+	{
+	private:
+		pIPathSegment mRawPtr;
+
+	public:
+		IPathSegmentProxy( pIPathSegment ptr )
+			: mRawPtr( ptr )
+		{
+			mRawPtr->Acquire();
+		}
+
+		~IPathSegmentProxy() __NOTHROW__ { mRawPtr->Release(); }
+
+		pIPathSegment APICALL GetActualIPathSegment() __NOTHROW__ { return mRawPtr; }
+
+		void APICALL Acquire() const __NOTHROW__ { assert( false ); }
+
+		void APICALL Release() const __NOTHROW__ { assert( false ); }
+
+		AdobeXMPCommon_Int::pISharedObject_I APICALL GetISharedObject_I() __NOTHROW__ {
+			return mRawPtr->GetISharedObject_I();
+		}
+
+		AdobeXMPCore_Int::pIPathSegment_I APICALL GetIPathSegment_I() __NOTHROW__ {
+			return mRawPtr->GetIPathSegment_I();
+		}
+
+		pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) {
+			return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >(
+				mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion );
+		}
+
+		pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error );
+		}
+
+		virtual spcIUTF8String APICALL GetNameSpace() const {
+			return CallConstSafeFunctionReturningPointer< IPathSegment_v1, pcIUTF8String_base, const IUTF8String >(
+				mRawPtr, &IPathSegment_v1::getNameSpace );
+		}
+
+		virtual pcIUTF8String_base APICALL getNameSpace( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getNameSpace( error );
+		}
+
+		virtual spcIUTF8String APICALL GetName() const {
+			return CallConstSafeFunctionReturningPointer< IPathSegment_v1, pcIUTF8String_base, const IUTF8String >(
+				mRawPtr, &IPathSegment_v1::getName );
+		}
+
+		virtual pcIUTF8String_base APICALL getName( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getName( error );
+		}
+
+		virtual ePathSegmentType APICALL GetType() const {
+			return CallConstSafeFunction< IPathSegment_v1, ePathSegmentType, uint32 >(
+				mRawPtr, &IPathSegment_v1::getType );
+		}
+
+		virtual uint32 APICALL getType( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getType( error );
+		}
+
+		virtual sizet APICALL GetIndex() const __NOTHROW__ {
+			return mRawPtr->GetIndex();
+		}
+
+		virtual spcIUTF8String APICALL GetValue() const {
+			return CallConstSafeFunctionReturningPointer< IPathSegment_v1, pcIUTF8String_base, const IUTF8String >(
+				mRawPtr, &IPathSegment_v1::getValue );
+		}
+
+		virtual pcIUTF8String_base APICALL getValue( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getValue( error );
+		}
+
+	};
+
+	spIPathSegment IPathSegment_v1::MakeShared( pIPathSegment_base ptr ) {
+		if ( !ptr ) return spIPathSegment();
+		pIPathSegment p = IPathSegment::GetInterfaceVersion() > 1 ?
+			ptr->GetInterfacePointer< IPathSegment >() : ptr;
+		return shared_ptr< IPathSegment >( new IPathSegmentProxy( p ) );
+	}
+
+	spcIPathSegment IPathSegment_v1::CreatePropertyPathSegment( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) {
+		return CallSafeFunctionReturningPointer< ICoreObjectFactory, pcIPathSegment_base, const IPathSegment, const char *, sizet, const char *, sizet >(
+			ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreatePropertyPathSegment, nameSpace, nameSpaceLength, name, nameLength );
+	}
+
+	spcIPathSegment IPathSegment_v1::CreateArrayIndexPathSegment( const char * nameSpace, sizet nameSpaceLength, sizet index ) {
+		return CallSafeFunctionReturningPointer< ICoreObjectFactory, pcIPathSegment_base, const IPathSegment, const char *, sizet, sizet >(
+			ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateArrayIndexPathSegment, nameSpace, nameSpaceLength, index );
+	}
+
+	spcIPathSegment IPathSegment_v1::CreateQualifierPathSegment( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) {
+		return CallSafeFunctionReturningPointer< ICoreObjectFactory, pcIPathSegment_base, const IPathSegment, const char *, sizet, const char *, sizet >(
+			ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateQualifierPathSegment, nameSpace, nameSpaceLength, name, nameLength );
+	}
+
+	spcIPathSegment IPathSegment_v1::CreateQualifierSelectorPathSegment( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength,
+		const char * value, sizet valueLength )
+	{
+		return CallSafeFunctionReturningPointer< ICoreObjectFactory, pcIPathSegment_base, const IPathSegment, const char *, sizet, const char *, sizet, const char *, sizet >(
+			ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateQualifierSelectorPathSegment, nameSpace, nameSpaceLength, name, nameLength, value, valueLength );
+	}
+
+}
+
+#endif  // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB
+

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

@@ -0,0 +1,111 @@
+// =================================================================================================
+// 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 ISimpleNodeProxy;
+}
+
+#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::ISimpleNodeProxy;
+
+#include "XMPCore/Interfaces/ISimpleNode.h"
+
+#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB
+
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include "XMPCommon/Interfaces/IUTF8String.h"
+#include "XMPCore/Interfaces/ICoreObjectFactory.h"
+
+#include <assert.h>
+
+namespace AdobeXMPCore {
+
+#if XMP_WinBuild
+	#pragma warning( push )
+	#pragma warning( disable : 4250 )
+#endif
+
+	class ISimpleNodeProxy
+		: public virtual ISimpleNode
+		, public virtual INodeProxy
+	{
+	private:
+		pISimpleNode mRawPtr;
+
+	public:
+		ISimpleNodeProxy( pISimpleNode ptr )
+			: mRawPtr( ptr )
+			, INodeProxy( ptr ) {}
+
+		~ISimpleNodeProxy() __NOTHROW__ {}
+
+		pISimpleNode APICALL GetActualISimpleNode() __NOTHROW__ { return mRawPtr; }
+
+		AdobeXMPCore_Int::pISimpleNode_I APICALL GetISimpleNode_I() __NOTHROW__ {
+			return mRawPtr->GetISimpleNode_I();
+		}
+
+		virtual spcIUTF8String APICALL GetValue() const {
+			return CallConstSafeFunctionReturningPointer< ISimpleNode_v1, pcIUTF8String_base, const IUTF8String >(
+				mRawPtr, &ISimpleNode_v1::getValue );
+		}
+
+		virtual void APICALL SetValue( const char * value, sizet valueLength ) {
+			return CallSafeFunctionReturningVoid< ISimpleNode_v1, const char *, sizet >(
+				mRawPtr, &ISimpleNode_v1::setValue, value, valueLength );
+		}
+
+		virtual bool APICALL IsURIType() const {
+			return CallConstSafeFunction< ISimpleNode_v1, bool, uint32 >(
+				mRawPtr, &ISimpleNode_v1::isURIType );
+		}
+
+		virtual void APICALL SetURIType( bool isURI ) {
+			return CallSafeFunctionReturningVoid< ISimpleNode_v1, uint32 >(
+				mRawPtr, &ISimpleNode_v1::setURIType, isURI ? 1 : 0 );
+		}
+
+		virtual pcIUTF8String_base APICALL getValue( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getValue( error );
+		}
+
+		virtual void APICALL setValue( const char * value, sizet valueLength, pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->setValue( value, valueLength, error );
+		}
+
+		virtual uint32 APICALL isURIType( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->isURIType( error );
+		}
+
+		virtual void APICALL setURIType( uint32 isURI, pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->setURIType( isURI, error );
+		}
+
+	};
+
+	spISimpleNode ISimpleNode_v1::CreateSimpleNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, const char * value, sizet valueLength ) {
+		return CallSafeFunctionReturningPointer< ICoreObjectFactory, pISimpleNode_base, ISimpleNode, const char *, sizet, const char *, sizet, const char *, sizet >(
+			ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateSimpleNode, nameSpace, nameSpaceLength, name, nameLength, value, valueLength );
+	}
+
+	spISimpleNode ISimpleNode_v1::MakeShared( pISimpleNode_base ptr ) {
+		if ( !ptr ) return spISimpleNode();
+		pISimpleNode p = ISimpleNode::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< ISimpleNode >() : ptr;
+		return shared_ptr< ISimpleNode >( new ISimpleNodeProxy( p ) );
+	}
+
+#if XMP_WinBuild
+	#pragma warning( pop )
+#endif
+}
+
+#endif  // !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB

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

@@ -0,0 +1,104 @@
+// =================================================================================================
+// 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 IStructureNodeProxy;
+}
+
+#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IStructureNodeProxy;
+
+#include "XMPCore/Interfaces/IStructureNode.h"
+
+#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB
+
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include "XMPCore/Interfaces/ICoreObjectFactory.h"
+#include <assert.h>
+
+namespace AdobeXMPCore {
+
+
+	IStructureNodeProxy::IStructureNodeProxy( pIStructureNode ptr ) : mRawPtr( ptr )
+		, ICompositeNodeProxy( ptr )
+		, INodeProxy( ptr ) { }
+
+	IStructureNodeProxy::~IStructureNodeProxy() __NOTHROW__ { }
+
+	AdobeXMPCore_Int::pIStructureNode_I APICALL IStructureNodeProxy::GetIStructureNode_I() __NOTHROW__ {
+		return mRawPtr->GetIStructureNode_I();
+	}
+
+	INode_v1::eNodeType APICALL IStructureNodeProxy::GetChildNodeType( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) const {
+		return CallConstSafeFunction< IStructureNode_v1, eNodeType, uint32, const char *, sizet, const char *, sizet >(
+			mRawPtr, &IStructureNode_v1::getChildNodeType, nameSpace, nameSpaceLength, name, nameLength );
+	}
+
+	spINode APICALL IStructureNodeProxy::GetNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) {
+		return CallSafeFunctionReturningPointer< IStructureNode_v1, pINode_base, INode, const char *, sizet, const char *, sizet >(
+			mRawPtr, &IStructureNode_v1::getNode, nameSpace, nameSpaceLength, name, nameLength );
+	}
+
+	void APICALL IStructureNodeProxy::InsertNode( const spINode & node ) {
+		return CallSafeFunctionReturningVoid< IStructureNode_v1, pINode_base >(
+			mRawPtr, &IStructureNode_v1::insertNode, node ? node->GetActualINode() : NULL );
+	}
+
+	spINode APICALL IStructureNodeProxy::ReplaceNode( const spINode & node ) {
+		return CallSafeFunctionReturningPointer< IStructureNode_v1, pINode_base, INode, pINode_base >(
+			mRawPtr, &IStructureNode_v1::replaceNode, node ? node->GetActualINode() : NULL );
+	}
+
+	spINode APICALL IStructureNodeProxy::RemoveNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) {
+		return CallSafeFunctionReturningPointer< IStructureNode_v1, pINode_base, INode, const char *, sizet, const char *, sizet >(
+			mRawPtr, &IStructureNode_v1::removeNode, nameSpace, nameSpaceLength, name, nameLength );
+	}
+
+	uint32 APICALL IStructureNodeProxy::getChildNodeType( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getChildNodeType( nameSpace, nameSpaceLength, name, nameLength, error );
+	}
+
+	pINode_base APICALL IStructureNodeProxy::getNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getNode( nameSpace, nameSpaceLength, name, nameLength, error );
+	}
+
+	void APICALL IStructureNodeProxy::insertNode( pINode_base node, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->insertNode( node, error );
+	}
+
+	pINode_base APICALL IStructureNodeProxy::replaceNode( pINode_base node, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->replaceNode( node, error );
+	}
+
+	pINode_base APICALL IStructureNodeProxy::removeNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->removeNode( nameSpace, nameSpaceLength, name, nameLength, error );
+	}
+
+	pIStructureNode APICALL IStructureNodeProxy::GetActualIStructureNode() __NOTHROW__ {
+		return mRawPtr;
+	}
+
+	spIStructureNode IStructureNode_v1::MakeShared( pIStructureNode_base ptr ) {
+		if ( !ptr ) return spIStructureNode();
+		pIStructureNode p = IStructureNode::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< IStructureNode >() : ptr;
+		return shared_ptr< IStructureNode >( new IStructureNodeProxy( p ) );
+	}
+
+	spIStructureNode IStructureNode_v1::CreateStructureNode( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) {
+		return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIStructureNode_base, IStructureNode, const char *, sizet, const char *, sizet >(
+			ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreateStructureNode, nameSpace, nameSpaceLength, name, nameLength );
+	}
+
+}
+
+#endif  // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB