// =================================================================================================

// 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