xmp_toolkit_ruby 0.0.2

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

@@ -0,0 +1,377 @@
+// =================================================================================================
+// 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 INodeProxy;
+}
+
+#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::INodeProxy;
+
+#include "XMPCore/Interfaces/INode.h"
+
+#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB
+
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include "XMPCommon/Interfaces/IUTF8String.h"
+#include "XMPCore/Interfaces/IPath.h"
+#include "XMPCore/Interfaces/ISimpleNode.h"
+#include "XMPCore/Interfaces/INodeIterator.h"
+#include "XMPCore/Interfaces/IArrayNode.h"
+#include "XMPCore/Interfaces/IMetadata.h"
+
+#include <assert.h>
+
+namespace AdobeXMPCore {
+
+	INodeProxy::INodeProxy( pINode ptr ) : mRawPtr( ptr ) {
+		mRawPtr->Acquire();
+	}
+
+	INodeProxy::~INodeProxy() __NOTHROW__ {
+		mRawPtr->Release();
+	}
+
+	pINode APICALL INodeProxy::GetActualINode() __NOTHROW__ {
+		return mRawPtr;
+	}
+
+	void APICALL INodeProxy::Acquire() const __NOTHROW__ {
+		assert( false );
+	}
+
+	void APICALL INodeProxy::Release() const __NOTHROW__ {
+		assert( false );
+	}
+
+	AdobeXMPCommon_Int::pISharedObject_I APICALL INodeProxy::GetISharedObject_I() __NOTHROW__ {
+		return mRawPtr->GetISharedObject_I();
+	}
+
+	AdobeXMPCore_Int::pINode_I APICALL INodeProxy::GetINode_I() __NOTHROW__ {
+		return mRawPtr->GetINode_I();
+	}
+
+	pvoid APICALL INodeProxy::getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error );
+	}
+
+	spINode APICALL INodeProxy::GetParent() {
+		return CallSafeFunctionReturningPointer< INode_v1, pINode_base, INode >(
+			mRawPtr, &INode_v1::getParent );
+	}
+
+	void APICALL INodeProxy::SetName( const char * name, sizet nameLength ) {
+		return CallSafeFunctionReturningVoid< INode_v1, const char *, sizet >(
+			mRawPtr, &INode_v1::setName, name, nameLength );
+	}
+
+	spcIUTF8String APICALL INodeProxy::GetName() const {
+		return CallConstSafeFunctionReturningPointer< INode_v1, pcIUTF8String_base, const IUTF8String >(
+			mRawPtr, &INode_v1::getName );
+	}
+
+	void APICALL INodeProxy::SetNameSpace( const char * nameSpace, sizet nameSpaceLength ) {
+		return CallSafeFunctionReturningVoid< INode_v1, const char *, sizet >(
+			mRawPtr, &INode_v1::setNameSpace, nameSpace, nameSpaceLength );
+
+	}
+
+	spcIUTF8String APICALL INodeProxy::GetNameSpace() const {
+		return CallConstSafeFunctionReturningPointer< INode_v1, pcIUTF8String_base, const IUTF8String >(
+			mRawPtr, &INode_v1::getNameSpace );
+	}
+
+	spIPath APICALL INodeProxy::GetPath() const {
+		return CallConstSafeFunctionReturningPointer< INode_v1, pIPath_base, IPath >(
+			mRawPtr, &INode_v1::getPath );
+	}
+
+	sizet APICALL INodeProxy::QualifiersCount() const __NOTHROW__ {
+		return mRawPtr->QualifiersCount();
+	}
+
+	spINodeIterator APICALL INodeProxy::QualifiersIterator() {
+		return CallSafeFunctionReturningPointer< INode_v1, pINodeIterator_base, INodeIterator >(
+			mRawPtr, &INode_v1::qualifiersIterator );
+	}
+
+	spINode APICALL INodeProxy::GetQualifier( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) {
+		return CallSafeFunctionReturningPointer< INode_v1, pINode_base, INode, const char *, sizet, const char *, sizet >(
+			mRawPtr, &INode_v1::getQualifier, nameSpace, nameSpaceLength, name, nameLength );
+	}
+
+	void APICALL INodeProxy::InsertQualifier( const spINode & node ) {
+		return CallSafeFunctionReturningVoid< INode_v1, pINode_base >(
+			mRawPtr, &INode_v1::insertQualifier, node ? node->GetActualINode() : NULL );
+	}
+
+	spINode APICALL INodeProxy::ReplaceQualifier( const spINode & node ) {
+		return CallSafeFunctionReturningPointer< INode_v1, pINode_base, INode, pINode_base >(
+			mRawPtr, &INode_v1::replaceQualifier, node ? node->GetActualINode() : NULL );
+	}
+
+	spINode APICALL INodeProxy::RemoveQualifier( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) {
+		return CallSafeFunctionReturningPointer< INode_v1, pINode_base, INode, const char *, sizet, const char *, sizet >(
+			mRawPtr, &INode_v1::removeQualifier, nameSpace, nameSpaceLength, name, nameLength );
+	}
+
+	INode_v1::eNodeType APICALL INodeProxy::GetNodeType() const {
+		return CallConstSafeFunction< INode_v1, eNodeType, uint32 >(
+			mRawPtr, &INode_v1::getNodeType );
+	}
+
+	bool APICALL INodeProxy::IsArrayItem() const {
+		return CallConstSafeFunction< INode_v1, bool, uint32 >(
+			mRawPtr, &INode_v1::isArrayItem );
+	}
+
+	bool APICALL INodeProxy::IsQualifierNode() const {
+		return CallConstSafeFunction< INode_v1, bool, uint32 >(
+			mRawPtr, &INode_v1::isQualifierNode );
+	}
+
+	sizet APICALL INodeProxy::GetIndex() const {
+		return CallConstSafeFunction< INode_v1, sizet, sizet >(
+			mRawPtr, &INode_v1::getIndex );
+	}
+
+	bool APICALL INodeProxy::HasQualifiers() const {
+		return CallConstSafeFunction< INode_v1, bool, uint32 >(
+			mRawPtr, &INode_v1::hasQualifiers );
+	}
+
+	bool APICALL INodeProxy::HasContent() const {
+		return CallConstSafeFunction< INode_v1, bool, uint32 >(
+			mRawPtr, &INode_v1::hasContent );
+	}
+
+	bool APICALL INodeProxy::IsEmpty() const {
+		return CallConstSafeFunction< INode_v1, bool, uint32 >(
+			mRawPtr, &INode_v1::isEmpty );
+	}
+
+	bool APICALL INodeProxy::HasChanged() const {
+		return CallConstSafeFunction< INode_v1, bool, uint32 >(
+			mRawPtr, &INode_v1::hasChanged );
+	}
+
+	void APICALL INodeProxy::AcknowledgeChanges() const __NOTHROW__ {
+		return mRawPtr->AcknowledgeChanges(  );
+	}
+
+	void APICALL INodeProxy::Clear( bool contents, bool qualifiers ) {
+		return CallSafeFunctionReturningVoid< INode_v1, uint32, uint32 >(
+			mRawPtr, &INode_v1::clear, static_cast< uint32 >( contents ), static_cast< uint32 >( qualifiers ) );
+	}
+
+	spINode APICALL INodeProxy::Clone( bool ignoreEmptyNodes, bool ignoreNodesWithOnlyQualifiers ) const {
+		return CallConstSafeFunctionReturningPointer< INode_v1, pINode_base, INode, uint32, uint32 >(
+			mRawPtr, &INode_v1::clone, static_cast< uint32 >( ignoreEmptyNodes ), static_cast< uint32 >( ignoreNodesWithOnlyQualifiers ) );
+	}
+
+	pINode_base APICALL INodeProxy::getParent( pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getParent( error );
+	}
+
+	void APICALL INodeProxy::setName( const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->setName( name, nameLength, error );
+	}
+
+	AdobeXMPCommon::pcIUTF8String_base APICALL INodeProxy::getName( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getName( error );
+	}
+
+	void APICALL INodeProxy::setNameSpace( const char * nameSpace, sizet nameSpaceLength, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->setNameSpace( nameSpace, nameSpaceLength, error );
+	}
+
+	pcIUTF8String_base APICALL INodeProxy::getNameSpace( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getNameSpace( error );
+	}
+
+	pIPath_base APICALL INodeProxy::getPath( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getPath( error );
+	}
+
+	pINodeIterator_base APICALL INodeProxy::qualifiersIterator( pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->qualifiersIterator( error );
+	}
+
+	pINode_base APICALL INodeProxy::getQualifier( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getQualifier( nameSpace, nameSpaceLength, name, nameLength, error );
+	}
+
+	void APICALL INodeProxy::insertQualifier( pINode_base base, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->insertQualifier( base, error );
+	}
+
+	pINode_base APICALL INodeProxy::replaceQualifier( pINode_base node, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->replaceQualifier( node, error );
+	}
+
+	pINode_base APICALL INodeProxy::removeQualifier( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->removeQualifier( nameSpace, nameSpaceLength, name, nameLength, error );
+	}
+
+	uint32 APICALL INodeProxy::getNodeType( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getNodeType( error );
+	}
+
+	uint32 APICALL INodeProxy::isArrayItem( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->isArrayItem( error );
+	}
+
+	uint32 APICALL INodeProxy::isQualifierNode( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->isQualifierNode( error );
+	}
+
+	sizet APICALL INodeProxy::getIndex( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getIndex( error );
+	}
+
+	uint32 APICALL INodeProxy::hasQualifiers( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->hasQualifiers( error );
+	}
+
+	uint32 APICALL INodeProxy::hasContent( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->hasContent( error );
+	}
+
+	uint32 APICALL INodeProxy::isEmpty( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->isEmpty( error );
+	}
+
+	uint32 APICALL INodeProxy::hasChanged( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->hasChanged( error );
+	}
+
+	void APICALL INodeProxy::clear( uint32 contents, uint32 qualifiers, pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->clear( contents, qualifiers, error );
+	}
+
+	pINode_base APICALL INodeProxy::clone( uint32 igoreEmptyNodes, uint32 ignoreNodesWithOnlyQualifiers, pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->clone( igoreEmptyNodes, ignoreNodesWithOnlyQualifiers, error );
+	}
+
+	void APICALL INodeProxy::EnableThreadSafety() const __NOTHROW__ {
+		return mRawPtr->EnableThreadSafety(  );
+	}
+
+	void APICALL INodeProxy::DisableThreadSafety() const __NOTHROW__ {
+		return mRawPtr->DisableThreadSafety(  );
+	}
+
+	bool APICALL INodeProxy::IsThreadSafe() const {
+		return mRawPtr->isThreadSafe() != 0;
+	}
+
+	uint32 APICALL INodeProxy::isThreadSafe() const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->isThreadSafe();
+	}
+
+	spISimpleNode APICALL INodeProxy::ConvertToSimpleNode() {
+		return CallSafeFunctionReturningPointer< INode_v1, pISimpleNode_base, ISimpleNode >(
+			mRawPtr, &INode_v1::convertToSimpleNode );
+	}
+
+	spIStructureNode APICALL INodeProxy::ConvertToStructureNode() {
+		return CallSafeFunctionReturningPointer< INode_v1, pIStructureNode_base, IStructureNode >(
+			mRawPtr, &INode_v1::convertToStructureNode );
+	}
+
+	spIArrayNode APICALL INodeProxy::ConvertToArrayNode() {
+		return CallSafeFunctionReturningPointer< INode_v1, pIArrayNode_base, IArrayNode >(
+			mRawPtr, &INode_v1::convertToArrayNode );
+	}
+
+	spIMetadata APICALL INodeProxy::ConvertToMetadata() {
+		return CallSafeFunctionReturningPointer< INode_v1, pIMetadata_base, IMetadata >(
+			mRawPtr, &INode_v1::convertToMetadata );
+	}
+
+	pISimpleNode_base APICALL INodeProxy::convertToSimpleNode( pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->convertToSimpleNode( error );
+	}
+
+	pIStructureNode_base APICALL INodeProxy::convertToStructureNode( pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->convertToStructureNode( error );	}
+
+	pIArrayNode_base APICALL INodeProxy::convertToArrayNode( pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->convertToArrayNode( error );
+	}
+
+	pIMetadata_base APICALL INodeProxy::convertToMetadata( pcIError_base & error ) __NOTHROW__ {
+		assert( false );
+		return mRawPtr->convertToMetadata( error );
+	}
+
+	uint32 APICALL INodeProxy::getParentNodeType( pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getParentNodeType( error );
+	}
+
+	uint32 APICALL INodeProxy::getQualifierNodeType( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength, pcIError_base & error ) const __NOTHROW__ {
+		assert( false );
+		return mRawPtr->getQualifierNodeType( nameSpace, nameSpaceLength, name, nameLength, error );
+	}
+
+	INode_v1::eNodeType APICALL INodeProxy::GetParentNodeType() const {
+		return CallConstSafeFunction< INode_v1, eNodeType, uint32 >(
+			mRawPtr, &INode_v1::getParentNodeType );
+	}
+
+	INode_v1::eNodeType APICALL INodeProxy::GetQualifierNodeType( const char * nameSpace, sizet nameSpaceLength, const char * name, sizet nameLength ) const {
+		return CallConstSafeFunction< INode_v1, eNodeType, uint32, const char *, sizet, const char *, sizet >(
+			mRawPtr, &INode_v1::getQualifierNodeType, nameSpace, nameSpaceLength, name, nameLength );
+	}
+
+	AdobeXMPCommon_Int::pIThreadSafe_I APICALL INodeProxy::GetIThreadSafe_I() __NOTHROW__ {
+		return mRawPtr->GetIThreadSafe_I(  );
+	}
+
+	pvoid APICALL INodeProxy::GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) {
+		return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >(
+			mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion );
+	}
+
+	spINode INode_v1::MakeShared( pINode_base ptr ) {
+		if ( !ptr ) return spINode();
+		pINode p = INode::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< INode >() : ptr;
+		return shared_ptr< INode >( new INodeProxy( p ) );
+	}
+
+}
+
+#endif  // !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB

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

@@ -0,0 +1,105 @@
+// =================================================================================================
+// 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 INodeIteratorProxy;
+}
+
+#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::INodeIteratorProxy;
+
+#include "XMPCore/Interfaces/INodeIterator.h"
+
+#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB
+
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include <assert.h>
+
+namespace AdobeXMPCore {
+
+	class INodeIteratorProxy
+		: public virtual INodeIterator
+	{
+	private:
+		pINodeIterator mRawPtr;
+
+	public:
+		INodeIteratorProxy( pINodeIterator ptr )
+			: mRawPtr( ptr )
+		{
+			mRawPtr->Acquire();
+		}
+
+		~INodeIteratorProxy() __NOTHROW__ { mRawPtr->Release(); }
+
+		pINodeIterator APICALL GetActualINodeIterator() __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::pINodeIterator_I APICALL GetINodeIterator_I() __NOTHROW__ {
+			return mRawPtr->GetINodeIterator_I();
+		}
+
+		pvoid APICALL getInterfacePointer( uint64 interfaceID, uint32 interfaceVersion, pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getInterfacePointer( interfaceID, interfaceVersion, error );
+		}
+
+		virtual spINode APICALL GetNode() {
+			return CallSafeFunctionReturningPointer< INodeIterator_v1, pINode_base, INode >(
+				mRawPtr, &INodeIterator_v1::getNode );
+		}
+
+		virtual INode_v1::eNodeType APICALL GetNodeType() const {
+			return CallConstSafeFunction< INodeIterator_v1, INode_v1::eNodeType, uint32 >(
+				mRawPtr, &INodeIterator_v1::getNodeType );
+		}
+
+		virtual spINodeIterator APICALL Next() {
+			return CallSafeFunctionReturningPointer< INodeIterator_v1, pINodeIterator, INodeIterator >(
+				mRawPtr, &INodeIterator_v1::next );
+		}
+
+		virtual uint32 APICALL getNodeType( pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getNodeType( error );
+		}
+
+		virtual pINode_base APICALL getNode( pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getNode( error );
+		}
+
+		virtual pINodeIterator_base APICALL next( pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->next( error );
+		}
+
+		pvoid APICALL GetInterfacePointer( uint64 interfaceID, uint32 interfaceVersion ) {
+		return CallSafeFunction< IVersionable, pvoid, pvoid, uint64, uint32 >(
+			mRawPtr, &IVersionable::getInterfacePointer, interfaceID, interfaceVersion );
+		}
+
+	};
+
+	spINodeIterator INodeIterator_v1::MakeShared( pINodeIterator_base ptr ) {
+		if ( !ptr ) return spINodeIterator();
+		//return shared_ptr< INodeIterator >( new INodeIteratorProxy( ptr ) );
+		pINodeIterator p = INodeIterator::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< INodeIterator >() : ptr;
+		return shared_ptr< INodeIterator >( new INodeIteratorProxy( p ) );
+	}
+
+}
+
+#endif  // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB

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

@@ -0,0 +1,157 @@
+// =================================================================================================
+// 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 IPathProxy;
+}
+
+#define FRIEND_CLASS_DECLARATION() friend class AdobeXMPCore::IPathProxy;
+
+#include "XMPCore/Interfaces/IPath.h"
+
+#if !BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB
+
+#include "XMPCommon/Utilities/TWrapperFunctions.h"
+#include "XMPCore/Interfaces/INameSpacePrefixMap.h"
+#include "XMPCommon/Interfaces/IUTF8String.h"
+#include "XMPCore/Interfaces/IPathSegment.h"
+#include "XMPCore/Interfaces/ICoreObjectFactory.h"
+
+#include <assert.h>
+
+namespace AdobeXMPCore {
+
+	class IPathProxy
+		: public virtual IPath
+	{
+	private:
+		pIPath mRawPtr;
+
+	public:
+		IPathProxy( pIPath ptr )
+			: mRawPtr( ptr )
+		{
+			mRawPtr->Acquire();
+		}
+
+		~IPathProxy() __NOTHROW__ { mRawPtr->Release(); }
+
+		pIPath APICALL GetActualIPath() __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::pIPath_I APICALL GetIPath_I() __NOTHROW__ {
+			return mRawPtr->GetIPath_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 spcINameSpacePrefixMap APICALL RegisterNameSpacePrefixMap( const spcINameSpacePrefixMap & map ) {
+			return CallSafeFunctionReturningPointer< IPath_v1, pcINameSpacePrefixMap_base, const INameSpacePrefixMap, pcINameSpacePrefixMap_base >(
+				mRawPtr, &IPath_v1::registerNameSpacePrefixMap, map ? map->GetActualINameSpacePrefixMap() : NULL );
+		}
+
+		virtual pcINameSpacePrefixMap_base APICALL registerNameSpacePrefixMap( pcINameSpacePrefixMap_base map, pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->registerNameSpacePrefixMap( map, error );
+		}
+
+		virtual spIUTF8String APICALL Serialize( const spcINameSpacePrefixMap & map ) const {
+			return CallConstSafeFunctionReturningPointer< IPath_v1, pIUTF8String_base, IUTF8String, pcINameSpacePrefixMap_base >(
+				mRawPtr, &IPath_v1::serialize, map ? map->GetActualINameSpacePrefixMap() : NULL );
+		}
+
+		virtual pIUTF8String_base APICALL serialize( pcINameSpacePrefixMap_base map, pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->serialize( map, error );
+		}
+
+		virtual void APICALL AppendPathSegment( const spcIPathSegment & segment ) {
+			return CallSafeFunctionReturningVoid< IPath_v1, pcIPathSegment_base >(
+				mRawPtr, &IPath_v1::appendPathSegment, segment ? segment->GetActualIPathSegment() : NULL );
+		}
+
+		virtual void APICALL appendPathSegment( pcIPathSegment_base segment, pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->appendPathSegment( segment, error );
+		}
+
+		virtual spcIPathSegment APICALL RemovePathSegment( sizet index ) {
+			return CallSafeFunctionReturningPointer< IPath_v1, pcIPathSegment_base, const IPathSegment, sizet >(
+				mRawPtr, &IPath_v1::removePathSegment, index );
+		}
+
+		virtual pcIPathSegment_base APICALL removePathSegment( sizet index, pcIError_base & error ) __NOTHROW__ {
+			assert( false );
+			return mRawPtr->removePathSegment( index, error );
+		}
+
+		virtual spcIPathSegment APICALL GetPathSegment( sizet index ) const {
+			return CallConstSafeFunctionReturningPointer< IPath_v1, pcIPathSegment_base, const IPathSegment, sizet >(
+				mRawPtr, &IPath_v1::getPathSegment, index );
+		}
+
+		virtual pcIPathSegment_base APICALL getPathSegment( sizet index, pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->getPathSegment( index, error );
+		}
+
+		virtual sizet APICALL Size() const __NOTHROW__ {
+			return mRawPtr->Size(  );
+		}
+
+		virtual void APICALL Clear() __NOTHROW__ {
+			return mRawPtr->Clear(  );
+		}
+
+		virtual spIPath APICALL Clone( sizet startingIndex, sizet countOfSegments ) const {
+			return CallConstSafeFunctionReturningPointer< IPath_v1, pIPath_base, IPath, sizet, sizet >(
+				mRawPtr, &IPath_v1::clone, startingIndex, countOfSegments );
+		}
+
+		virtual pIPath_base APICALL clone( sizet startingIndex, sizet countOfSegemetns, pcIError_base & error ) const __NOTHROW__ {
+			assert( false );
+			return mRawPtr->clone( startingIndex, countOfSegemetns, error );
+		}
+
+	};
+
+	spIPath IPath_v1::MakeShared( pIPath_base ptr ) {
+		if ( !ptr ) return spIPath();
+		pIPath p = IPath::GetInterfaceVersion() > 1 ? ptr->GetInterfacePointer< IPath >() : ptr;
+		return shared_ptr< IPath >( new IPathProxy( p ) );
+	}
+
+	spIPath IPath_v1::CreatePath() {
+		return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIPath_base, IPath >(
+			ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::CreatePath );
+	}
+
+	spIPath IPath_v1::ParsePath( const char * path, sizet pathLength, const spcINameSpacePrefixMap & map ) {
+		return CallSafeFunctionReturningPointer< ICoreObjectFactory, pIPath_base, IPath, const char *, sizet, pcINameSpacePrefixMap_base >(
+			ICoreObjectFactory::GetCoreObjectFactory(), &ICoreObjectFactory::ParsePath, path, pathLength, map ? map->GetActualINameSpacePrefixMap() : NULL );
+	}
+
+}
+
+#endif  // BUILDING_XMPCORE_LIB && !SOURCE_COMPILING_XMPCORE_LIB