// =================================================================================================
// Copyright 2002-2008 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.
// =================================================================================================
// *** Should change "type * inParam" to "type & inParam"
#include "XMP_Environment.h" // ! This must be the first include!
#include "XMPCore_Impl.hpp"
#include "XMPUtils.hpp"
#include "client-glue/WXMPUtils.hpp"
#if XMP_WinBuild
#ifdef _MSC_VER
#pragma warning ( disable : 4101 ) // unreferenced local variable
#pragma warning ( disable : 4189 ) // local variable is initialized but not referenced
#pragma warning ( disable : 4800 ) // forcing value to bool 'true' or 'false' (performance warning)
#if XMP_DebugBuild
#pragma warning ( disable : 4297 ) // function assumed not to throw an exception but does
#endif
#endif
#endif
#if __cplusplus
extern "C" {
#endif
// =================================================================================================
// Class Static Wrappers
// =====================
void
WXMPUtils_Unlock_1 ( XMP_OptionBits options )
{
WXMP_Result * wResult = &void_wResult; // ! Needed to "fool" the EnterWrapper macro.
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_Unlock_1" )
XMPUtils::Unlock ( options );
XMP_EXIT_WRAPPER_NO_THROW
}
// =================================================================================================
void
WXMPUtils_ComposeArrayItemPath_1 ( XMP_StringPtr schemaNS,
XMP_StringPtr arrayName,
XMP_Index itemIndex,
XMP_StringPtr * fullPath,
XMP_StringLen * pathSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ComposeArrayItemPath_1" )
if ( (schemaNS == 0) || (*schemaNS == 0) ) XMP_Throw ( "Empty schema namespace URI", kXMPErr_BadSchema );
if ( (arrayName == 0) || (*arrayName == 0) ) XMP_Throw ( "Empty array name", kXMPErr_BadXPath );
if ( fullPath == 0 ) fullPath = &voidStringPtr;
if ( pathSize == 0 ) pathSize = &voidStringLen;
XMPUtils::ComposeArrayItemPath ( schemaNS, arrayName, itemIndex, fullPath, pathSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ComposeStructFieldPath_1 ( XMP_StringPtr schemaNS,
XMP_StringPtr structName,
XMP_StringPtr fieldNS,
XMP_StringPtr fieldName,
XMP_StringPtr * fullPath,
XMP_StringLen * pathSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ComposeStructFieldPath_1" )
if ( (schemaNS == 0) || (*schemaNS == 0) ) XMP_Throw ( "Empty schema namespace URI", kXMPErr_BadSchema );
if ( (structName == 0) || (*structName == 0) ) XMP_Throw ( "Empty struct name", kXMPErr_BadXPath );
if ( (fieldNS == 0) || (*fieldNS == 0) ) XMP_Throw ( "Empty field namespace URI", kXMPErr_BadSchema );
if ( (fieldName == 0) || (*fieldName == 0) ) XMP_Throw ( "Empty field name", kXMPErr_BadXPath );
if ( fullPath == 0 ) fullPath = &voidStringPtr;
if ( pathSize == 0 ) pathSize = &voidStringLen;
XMPUtils::ComposeStructFieldPath ( schemaNS, structName, fieldNS, fieldName, fullPath, pathSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ComposeQualifierPath_1 ( XMP_StringPtr schemaNS,
XMP_StringPtr propName,
XMP_StringPtr qualNS,
XMP_StringPtr qualName,
XMP_StringPtr * fullPath,
XMP_StringLen * pathSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ComposeQualifierPath_1" )
if ( (schemaNS == 0) || (*schemaNS == 0) ) XMP_Throw ( "Empty schema namespace URI", kXMPErr_BadSchema );
if ( (propName == 0) || (*propName == 0) ) XMP_Throw ( "Empty property name", kXMPErr_BadXPath );
if ( (qualNS == 0) || (*qualNS == 0) ) XMP_Throw ( "Empty qualifier namespace URI", kXMPErr_BadSchema );
if ( (qualName == 0) || (*qualName == 0) ) XMP_Throw ( "Empty qualifier name", kXMPErr_BadXPath );
if ( fullPath == 0 ) fullPath = &voidStringPtr;
if ( pathSize == 0 ) pathSize = &voidStringLen;
XMPUtils::ComposeQualifierPath ( schemaNS, propName, qualNS, qualName, fullPath, pathSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ComposeLangSelector_1 ( XMP_StringPtr schemaNS,
XMP_StringPtr arrayName,
XMP_StringPtr langName,
XMP_StringPtr * fullPath,
XMP_StringLen * pathSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ComposeLangSelector_1" )
if ( (schemaNS == 0) || (*schemaNS == 0) ) XMP_Throw ( "Empty schema namespace URI", kXMPErr_BadSchema );
if ( (arrayName == 0) || (*arrayName == 0) ) XMP_Throw ( "Empty array name", kXMPErr_BadXPath );
if ( (langName == 0) || (*langName == 0) ) XMP_Throw ( "Empty language name", kXMPErr_BadParam );
if ( fullPath == 0 ) fullPath = &voidStringPtr;
if ( pathSize == 0 ) pathSize = &voidStringLen;
XMPUtils::ComposeLangSelector ( schemaNS, arrayName, langName, fullPath, pathSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ComposeFieldSelector_1 ( XMP_StringPtr schemaNS,
XMP_StringPtr arrayName,
XMP_StringPtr fieldNS,
XMP_StringPtr fieldName,
XMP_StringPtr fieldValue,
XMP_StringPtr * fullPath,
XMP_StringLen * pathSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ComposeFieldSelector_1" )
if ( (schemaNS == 0) || (*schemaNS == 0) ) XMP_Throw ( "Empty schema namespace URI", kXMPErr_BadSchema );
if ( (arrayName == 0) || (*arrayName == 0) ) XMP_Throw ( "Empty array name", kXMPErr_BadXPath );
if ( (fieldNS == 0) || (*fieldNS == 0) ) XMP_Throw ( "Empty field namespace URI", kXMPErr_BadSchema );
if ( (fieldName == 0) || (*fieldName == 0) ) XMP_Throw ( "Empty field name", kXMPErr_BadXPath );
if ( fieldValue == 0 ) fieldValue = "";
if ( fullPath == 0 ) fullPath = &voidStringPtr;
if ( pathSize == 0 ) pathSize = &voidStringLen;
XMPUtils::ComposeFieldSelector ( schemaNS, arrayName, fieldNS, fieldName, fieldValue, fullPath, pathSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// =================================================================================================
void
WXMPUtils_ConvertFromBool_1 ( XMP_Bool binValue,
XMP_StringPtr * strValue,
XMP_StringLen * strSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ConvertFromBool_1" )
if ( strValue == 0 ) strValue = &voidStringPtr;
if ( strSize == 0 ) strSize = &voidStringLen;
XMPUtils::ConvertFromBool ( binValue, strValue, strSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertFromInt_1 ( XMP_Int32 binValue,
XMP_StringPtr format,
XMP_StringPtr * strValue,
XMP_StringLen * strSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ConvertFromInt_1" )
if ( format == 0 ) format = "";
if ( strValue == 0 ) strValue = &voidStringPtr;
if ( strSize == 0 ) strSize = &voidStringLen;
XMPUtils::ConvertFromInt ( binValue, format, strValue, strSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertFromInt64_1 ( XMP_Int64 binValue,
XMP_StringPtr format,
XMP_StringPtr * strValue,
XMP_StringLen * strSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ConvertFromInt64_1" )
if ( format == 0 ) format = "";
if ( strValue == 0 ) strValue = &voidStringPtr;
if ( strSize == 0 ) strSize = &voidStringLen;
XMPUtils::ConvertFromInt64 ( binValue, format, strValue, strSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertFromFloat_1 ( double binValue,
XMP_StringPtr format,
XMP_StringPtr * strValue,
XMP_StringLen * strSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ConvertFromFloat_1" )
if ( format == 0 ) format = "";
if ( strValue == 0 ) strValue = &voidStringPtr;
if ( strSize == 0 ) strSize = &voidStringLen;
XMPUtils::ConvertFromFloat ( binValue, format, strValue, strSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertFromDate_1 ( const XMP_DateTime & binValue,
XMP_StringPtr * strValue,
XMP_StringLen * strSize,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_ConvertFromDate_1" )
if ( strValue == 0 ) strValue = &voidStringPtr;
if ( strSize == 0 ) strSize = &voidStringLen;
XMPUtils::ConvertFromDate( binValue, strValue, strSize );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// =================================================================================================
void
WXMPUtils_ConvertToBool_1 ( XMP_StringPtr strValue,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_ConvertToBool_1" )
if ( (strValue == 0) || (*strValue == 0) ) XMP_Throw ( "Empty string value", kXMPErr_BadParam);
XMP_Bool result = XMPUtils::ConvertToBool ( strValue );
wResult->int32Result = result;
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertToInt_1 ( XMP_StringPtr strValue,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_ConvertToInt_1" )
if ( (strValue == 0) || (*strValue == 0) ) XMP_Throw ( "Empty string value", kXMPErr_BadParam);
XMP_Int32 result = XMPUtils::ConvertToInt ( strValue );
wResult->int32Result = result;
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertToInt64_1 ( XMP_StringPtr strValue,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_ConvertToInt64_1" )
if ( (strValue == 0) || (*strValue == 0) ) XMP_Throw ( "Empty string value", kXMPErr_BadParam);
XMP_Int64 result = XMPUtils::ConvertToInt64 ( strValue );
wResult->int64Result = result;
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertToFloat_1 ( XMP_StringPtr strValue,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_ConvertToFloat_1")
if ( (strValue == 0) || (*strValue == 0) ) XMP_Throw ( "Empty string value", kXMPErr_BadParam);
double result = XMPUtils::ConvertToFloat ( strValue );
wResult->floatResult = result;
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertToDate_1 ( XMP_StringPtr strValue,
XMP_DateTime * binValue,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_ConvertToDate_1" )
if ( binValue == 0 ) XMP_Throw ( "Null output date", kXMPErr_BadParam); // ! Pointer is from the client.
XMPUtils::ConvertToDate ( strValue, binValue );
XMP_EXIT_WRAPPER
}
// =================================================================================================
void
WXMPUtils_CurrentDateTime_1 ( XMP_DateTime * time,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_CurrentDateTime_1" )
if ( time == 0 ) XMP_Throw ( "Null output date", kXMPErr_BadParam);
XMPUtils::CurrentDateTime ( time );
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_SetTimeZone_1 ( XMP_DateTime * time,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_SetTimeZone_1" )
if ( time == 0 ) XMP_Throw ( "Null output date", kXMPErr_BadParam);
XMPUtils::SetTimeZone ( time );
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertToUTCTime_1 ( XMP_DateTime * time,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_ConvertToUTCTime_1" )
if ( time == 0 ) XMP_Throw ( "Null output date", kXMPErr_BadParam);
XMPUtils::ConvertToUTCTime ( time );
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_ConvertToLocalTime_1 ( XMP_DateTime * time,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_ConvertToLocalTime_1" )
if ( time == 0 ) XMP_Throw ( "Null output date", kXMPErr_BadParam);
XMPUtils::ConvertToLocalTime ( time );
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_CompareDateTime_1 ( const XMP_DateTime & left,
const XMP_DateTime & right,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER_NO_LOCK ( "WXMPUtils_CompareDateTime_1" )
int result = XMPUtils::CompareDateTime ( left, right );
wResult->int32Result = result;
XMP_EXIT_WRAPPER
}
// =================================================================================================
void
WXMPUtils_EncodeToBase64_1 ( XMP_StringPtr rawStr,
XMP_StringLen rawLen,
XMP_StringPtr * encodedStr,
XMP_StringLen * encodedLen,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_EncodeToBase64_1" )
if ( encodedStr == 0 ) encodedStr = &voidStringPtr;
if ( encodedLen == 0 ) encodedLen = &voidStringLen;
XMPUtils::EncodeToBase64 ( rawStr, rawLen, encodedStr, encodedLen );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_DecodeFromBase64_1 ( XMP_StringPtr encodedStr,
XMP_StringLen encodedLen,
XMP_StringPtr * rawStr,
XMP_StringLen * rawLen,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_DecodeFromBase64_1" )
if ( rawStr == 0 ) rawStr = &voidStringPtr;
if ( rawLen == 0 ) rawLen = &voidStringLen;
XMPUtils::DecodeFromBase64 ( encodedStr, encodedLen, rawStr, rawLen );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// =================================================================================================
void
WXMPUtils_PackageForJPEG_1 ( XMPMetaRef wxmpObj,
XMP_StringPtr * stdStr,
XMP_StringLen * stdLen,
XMP_StringPtr * extStr,
XMP_StringLen * extLen,
XMP_StringPtr * digestStr,
XMP_StringLen * digestLen,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_PackageForJPEG_1" )
if ( stdStr == 0 ) stdStr = &voidStringPtr;
if ( stdLen == 0 ) stdLen = &voidStringLen;
if ( extStr == 0 ) extStr = &voidStringPtr;
if ( extLen == 0 ) extLen = &voidStringLen;
if ( digestStr == 0 ) digestStr = &voidStringPtr;
if ( digestLen == 0 ) digestLen = &voidStringLen;
const XMPMeta & xmpObj = WtoXMPMeta_Ref ( wxmpObj );
XMPUtils::PackageForJPEG ( xmpObj, stdStr, stdLen, extStr, extLen, digestStr, digestLen );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_MergeFromJPEG_1 ( XMPMetaRef wfullXMP,
XMPMetaRef wextendedXMP,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_MergeFromJPEG_1" )
if ( wfullXMP == 0 ) XMP_Throw ( "Output XMP pointer is null", kXMPErr_BadParam );
XMPMeta * fullXMP = WtoXMPMeta_Ptr ( wfullXMP );
const XMPMeta & extendedXMP = WtoXMPMeta_Ref ( wextendedXMP );
XMPUtils::MergeFromJPEG ( fullXMP, extendedXMP );
XMP_EXIT_WRAPPER
}
// =================================================================================================
void
WXMPUtils_CatenateArrayItems_1 ( XMPMetaRef wxmpObj,
XMP_StringPtr schemaNS,
XMP_StringPtr arrayName,
XMP_StringPtr separator,
XMP_StringPtr quotes,
XMP_OptionBits options,
XMP_StringPtr * catedStr,
XMP_StringLen * catedLen,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_CatenateArrayItems_1" )
if ( (schemaNS == 0) || (*schemaNS == 0) ) XMP_Throw ( "Empty schema namespace URI", kXMPErr_BadSchema );
if ( (arrayName == 0) || (*arrayName == 0) ) XMP_Throw ( "Empty array name", kXMPErr_BadXPath );
if ( separator == 0 ) separator = "; ";
if ( quotes == 0 ) quotes = "\"";
if ( catedStr == 0 ) catedStr = &voidStringPtr;
if ( catedLen == 0 ) catedLen = &voidStringLen;
const XMPMeta & xmpObj = WtoXMPMeta_Ref ( wxmpObj );
XMPUtils::CatenateArrayItems ( xmpObj, schemaNS, arrayName, separator, quotes, options, catedStr, catedLen );
XMP_EXIT_WRAPPER_KEEP_LOCK ( true )
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_SeparateArrayItems_1 ( XMPMetaRef wxmpObj,
XMP_StringPtr schemaNS,
XMP_StringPtr arrayName,
XMP_OptionBits options,
XMP_StringPtr catedStr,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_SeparateArrayItems_1" )
if ( wxmpObj == 0 ) XMP_Throw ( "Output XMP pointer is null", kXMPErr_BadParam );
if ( (schemaNS == 0) || (*schemaNS == 0) ) XMP_Throw ( "Empty schema namespace URI", kXMPErr_BadSchema );
if ( (arrayName == 0) || (*arrayName == 0) ) XMP_Throw ( "Empty array name", kXMPErr_BadXPath );
if ( catedStr == 0 ) catedStr = "";
XMPMeta * xmpObj = WtoXMPMeta_Ptr ( wxmpObj );
XMPUtils::SeparateArrayItems ( xmpObj, schemaNS, arrayName, options, catedStr );
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_RemoveProperties_1 ( XMPMetaRef wxmpObj,
XMP_StringPtr schemaNS,
XMP_StringPtr propName,
XMP_OptionBits options,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_RemoveProperties_1" )
if ( wxmpObj == 0 ) XMP_Throw ( "Output XMP pointer is null", kXMPErr_BadParam );
if ( schemaNS == 0 ) schemaNS = "";
if ( propName == 0 ) propName = "";
XMPMeta * xmpObj = WtoXMPMeta_Ptr ( wxmpObj );
XMPUtils::RemoveProperties ( xmpObj, schemaNS, propName, options );
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_AppendProperties_1 ( XMPMetaRef wSource,
XMPMetaRef wDest,
XMP_OptionBits options,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_AppendProperties_1" )
if ( wDest == 0 ) XMP_Throw ( "Output XMP pointer is null", kXMPErr_BadParam );
const XMPMeta & source = WtoXMPMeta_Ref ( wSource );
XMPMeta * dest = WtoXMPMeta_Ptr ( wDest );
XMPUtils::AppendProperties ( source, dest, options );
XMP_EXIT_WRAPPER
}
// -------------------------------------------------------------------------------------------------
void
WXMPUtils_DuplicateSubtree_1 ( XMPMetaRef wSource,
XMPMetaRef wDest,
XMP_StringPtr sourceNS,
XMP_StringPtr sourceRoot,
XMP_StringPtr destNS,
XMP_StringPtr destRoot,
XMP_OptionBits options,
WXMP_Result * wResult )
{
XMP_ENTER_WRAPPER ( "WXMPUtils_DuplicateSubtree_1" )
if ( wDest == 0 ) XMP_Throw ( "Output XMP pointer is null", kXMPErr_BadParam );
if ( (sourceNS == 0) || (*sourceNS == 0) ) XMP_Throw ( "Empty source schema URI", kXMPErr_BadSchema );
if ( (sourceRoot == 0) || (*sourceRoot == 0) ) XMP_Throw ( "Empty source root name", kXMPErr_BadXPath );
if ( destNS == 0 ) destNS = sourceNS;
if ( destRoot == 0 ) destRoot = sourceRoot;
const XMPMeta & source = WtoXMPMeta_Ref ( wSource );
XMPMeta * dest = WtoXMPMeta_Ptr ( wDest );
XMPUtils::DuplicateSubtree ( source, dest, sourceNS, sourceRoot, destNS, destRoot, options );
XMP_EXIT_WRAPPER
}
// =================================================================================================
#if __cplusplus
} /* extern "C" */
#endif