1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
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
|
