You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
378 lines
13 KiB
C++
378 lines
13 KiB
C++
// =================================================================================================
|
|
// ADOBE SYSTEMS INCORPORATED
|
|
// Copyright 2015 Adobe Systems Incorporated
|
|
// 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
|