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

//

// Adobe patent application tracking #P435, entitled 'Unique markers to simplify embedding data of

// one format in a file with a different format', inventors: Sean Parent, Greg Gilley.

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

#include "XMP_Environment.h"	// ! This must be the first include!

#include "XMPCore_Impl.hpp"

#include "XMPMeta.hpp"

#include "XMP_Version.h"

#include "UnicodeInlines.incl_cpp"

#include "UnicodeConversions.hpp"

#if XMP_DebugBuild

	#include <iostream>

#endif

using namespace std;

#if XMP_WinBuild

#ifdef _MSC_VER

	#pragma warning ( disable : 4533 )	// initialization of '...' is skipped by 'goto ...'

	#pragma warning ( disable : 4702 )	// unreachable code

	#pragma warning ( disable : 4800 )	// forcing value to bool 'true' or 'false' (performance warning)

#endif

#endif

// *** Use the XMP_PropIsXyz (Schema, Simple, Struct, Array, ...) macros

// *** Add debug codegen checks, e.g. that typical masking operations really work

// *** Change all uses of strcmp and strncmp to XMP_LitMatch and XMP_LitNMatch

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

// Local Types and Constants

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

static const char * kPacketHeader  = "";

static const char * kPacketTrailer = "";	// ! The w/r is at [size-4].

static const char * kRDF_XMPMetaStart = "

static const char * kRDF_XMPMetaEnd   = "</x:xmpmeta>";

static const char * kRDF_RDFStart     = "<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">";

static const char * kRDF_RDFEnd       = "</rdf:RDF>";

static const char * kRDF_SchemaStart  = "

static const char * kRDF_SchemaEnd    = "</rdf:Description>";

static const char * kRDF_StructStart  = "<rdf:Description>";

static const char * kRDF_StructEnd    = "</rdf:Description>";

static const char * kRDF_BagStart     = "<rdf:Bag>";

static const char * kRDF_ItemStart    = "<rdf:li>";

static const char * kRDF_ValueStart   = "<rdf:value>";

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

// Static Variables

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

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

// Local Utilities

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

// -------------------------------------------------------------------------------------------------

// EstimateRDFSize

// ---------------

//  *** Pull the strlen(kXyz) calls into constants.

static size_t

EstimateRDFSize ( const XMP_Node * currNode, XMP_Index indent, size_t indentLen )

{

	size_t outputLen = 2 * (indent*indentLen + currNode->name.size() + 4);	// The property element tags.

	if ( ! currNode->qualifiers.empty() ) {

		// This node has qualifiers, assume it is written using rdf:value and estimate the qualifiers.

		indent += 2;	// Everything else is indented inside the rdf:Description element.

		outputLen += 2 * ((indent-1)*indentLen + strlen(kRDF_StructStart) + 2);	// The rdf:Description tags.

		outputLen += 2 * (indent*indentLen + strlen(kRDF_ValueStart) + 2);		// The rdf:value tags.

		for ( size_t qualNum = 0, qualLim = currNode->qualifiers.size(); qualNum < qualLim; ++qualNum ) {

			const XMP_Node * currQual = currNode->qualifiers[qualNum];

			outputLen += EstimateRDFSize ( currQual, indent, indentLen );

		}

	}

	if ( currNode->options & kXMP_PropValueIsStruct ) {

		indent += 1;

		outputLen += 2 * (indent*indentLen + strlen(kRDF_StructStart) + 2);	// The rdf:Description tags.

	} else if ( currNode->options & kXMP_PropValueIsArray ) {

		indent += 2;

		outputLen += 2 * ((indent-1)*indentLen + strlen(kRDF_BagStart) + 2);		// The rdf:Bag/Seq/Alt tags.

		outputLen += 2 * currNode->children.size() * (strlen(kRDF_ItemStart) + 2);	// The rdf:li tags, indent counted in children.

	} else if ( ! (currNode->options & kXMP_SchemaNode) ) {

		outputLen += currNode->value.size();	// This is a leaf value node.

	}

	for ( size_t childNum = 0, childLim = currNode->children.size(); childNum < childLim; ++childNum ) {

		const XMP_Node * currChild = currNode->children[childNum];

		outputLen += EstimateRDFSize ( currChild, indent+1, indentLen );

	}

	return outputLen;

}	// EstimateRDFSize

// -------------------------------------------------------------------------------------------------

// DeclareOneNamespace

// -------------------

static void

DeclareOneNamespace	( const XMP_VarString &	nsPrefix,

					  const XMP_VarString &	nsURI,

					  XMP_VarString	&		usedNS,		// ! A catenation of the prefixes with colons.

					  XMP_VarString &		outputStr,

					  XMP_StringPtr			newline,

					  XMP_StringPtr			indentStr,

					  XMP_Index				indent )

{

	size_t nsPos = usedNS.find ( nsPrefix );

	if ( nsPos == XMP_VarString::npos ) {

		outputStr += newline;

		for ( ; indent > 0; --indent ) outputStr += indentStr;

		outputStr += "xmlns:";

		outputStr += nsPrefix;

		outputStr[outputStr.size()-1] = '=';	// Change the colon to =.

		outputStr += '"';

		outputStr += nsURI;

		outputStr += '"';

		usedNS += nsPrefix;

	}

}	// DeclareOneNamespace

// -------------------------------------------------------------------------------------------------

// DeclareElemNamespace

// --------------------

static void

DeclareElemNamespace ( const XMP_VarString & elemName,

					   XMP_VarString &		 usedNS,

					   XMP_VarString &		 outputStr,

					   XMP_StringPtr		 newline,

					   XMP_StringPtr		 indentStr,

					   XMP_Index			 indent )

{

	size_t colonPos = elemName.find ( ':' );

	if ( colonPos != XMP_VarString::npos ) {

		XMP_VarString nsPrefix ( elemName.substr ( 0, colonPos+1 ) );

		XMP_StringMapPos prefixPos = sNamespacePrefixToURIMap->find ( nsPrefix );

		XMP_Enforce ( prefixPos != sNamespacePrefixToURIMap->end() );

		DeclareOneNamespace ( nsPrefix, prefixPos->second, usedNS, outputStr, newline, indentStr, indent );

	}

}	// DeclareElemNamespace

// -------------------------------------------------------------------------------------------------

// DeclareUsedNamespaces

// ---------------------

// ??? Should iterators be passed by reference to avoid temp copies?

static void

DeclareUsedNamespaces ( const XMP_Node * currNode,

						XMP_VarString &  usedNS,

						XMP_VarString &	 outputStr,

						XMP_StringPtr	 newline,

						XMP_StringPtr	 indentStr,

						XMP_Index		 indent )

{

	if ( currNode->options & kXMP_SchemaNode ) {

		// The schema node name is the URI, the value is the prefix.

		DeclareOneNamespace ( currNode->value, currNode->name, usedNS, outputStr, newline, indentStr, indent );

	} else if ( currNode->options & kXMP_PropValueIsStruct ) {

		for ( size_t fieldNum = 0, fieldLim = currNode->children.size(); fieldNum < fieldLim; ++fieldNum ) {

			const XMP_Node * currField = currNode->children[fieldNum];

			DeclareElemNamespace ( currField->name, usedNS, outputStr, newline, indentStr, indent );

		}

	}

	for ( size_t childNum = 0, childLim = currNode->children.size(); childNum < childLim; ++childNum ) {

		const XMP_Node * currChild = currNode->children[childNum];

		DeclareUsedNamespaces ( currChild, usedNS, outputStr, newline, indentStr, indent );

	}

	for ( size_t qualNum = 0, qualLim = currNode->qualifiers.size(); qualNum < qualLim; ++qualNum ) {

		const XMP_Node * currQual = currNode->qualifiers[qualNum];

		DeclareElemNamespace ( currQual->name, usedNS, outputStr, newline, indentStr, indent );

		DeclareUsedNamespaces ( currQual, usedNS, outputStr, newline, indentStr, indent );

	}

}	// DeclareUsedNamespaces

// -------------------------------------------------------------------------------------------------

// EmitRDFArrayTag

// ---------------

// ??? Should iterators be passed by reference to avoid temp copies?

enum {

	kIsStartTag = true,

	kIsEndTag   = false

};

static void

EmitRDFArrayTag	( XMP_OptionBits  arrayForm,

				  XMP_VarString & outputStr,

				  XMP_StringPtr	  newline,

				  XMP_StringPtr	  indentStr,

				  XMP_Index		  indent,

				  XMP_Index		  arraySize,

				  bool			  isStartTag )

{

	if ( (! isStartTag) && (arraySize == 0) ) return;

	for ( XMP_Index level = indent; level > 0; --level ) outputStr += indentStr;

	if ( isStartTag ) {

		outputStr += "

	} else {

		outputStr += "

	}

	if ( arrayForm & kXMP_PropArrayIsAlternate ) {

		outputStr += "Alt";

	} else if ( arrayForm & kXMP_PropArrayIsOrdered ) {

		outputStr += "Seq";

	} else {

		outputStr += "Bag";

	}

	if ( isStartTag && (arraySize == 0) ) outputStr += '/';

	outputStr += '>';

	outputStr += newline;

}	// EmitRDFArrayTag

// -------------------------------------------------------------------------------------------------

// AppendNodeValue

// ---------------

//

// Append a property or qualifier value to the output with appropriate XML escaping. The escaped

// characters for elements and attributes are '&', '<', '>', and ASCII controls (tab, LF, CR). In

// addition, '"' is escaped for attributes. For efficiency, this is done in a double loop. The outer

// loop makes sure the whole value is processed. The inner loop does a contiguous unescaped run

// followed by one escaped character (if we're not at the end).

//

// We depend on parsing and SetProperty logic to make sure there are no invalid ASCII controls in

// the XMP values. The XML spec only allows tab, LF, and CR. Others are not even allowed as

// numeric escape sequences.

enum {

	kForAttribute = true,

	kForElement   = false

};

static void

AppendNodeValue ( XMP_VarString & outputStr, const XMP_VarString & value, bool forAttribute )

{

	unsigned char * runStart = (unsigned char *) value.c_str();

	unsigned char * runLimit  = runStart + value.size();

	unsigned char * runEnd;

	unsigned char   ch=0;

	while ( runStart < runLimit ) {

		for ( runEnd = runStart; runEnd < runLimit; ++runEnd ) {

			ch = *runEnd;

			if ( forAttribute && (ch == '"') ) break;

			if ( (ch < 0x20) || (ch == '&') || (ch == '<') || (ch == '>') ) break;

		}

		outputStr.append ( (char *) runStart, (runEnd - runStart) );

		if ( runEnd < runLimit ) {

			if ( ch < 0x20 ) {

				XMP_Assert ( (ch == kTab) || (ch == kLF) || (ch == kCR) );

				char hexBuf[16];

				memcpy ( hexBuf, "&#x;;", 5 );

				hexBuf[3] = kHexDigits[ch&0xF];

				outputStr.append ( hexBuf, 5 );

			} else {

				if ( ch == '"' ) {

					outputStr += """;

				} else if ( ch == '<' ) {

					outputStr += "<";

				} else if ( ch == '>' ) {

					outputStr += ">";

				} else {

					XMP_Assert ( ch == '&' );

					outputStr += "&";

				}

			}

			++runEnd;

		}

		runStart = runEnd;

	}

}	// AppendNodeValue

// -------------------------------------------------------------------------------------------------

// CanBeRDFAttrProp

// ----------------

static bool

CanBeRDFAttrProp ( const XMP_Node * propNode )

{

	if ( propNode->name[0] == '[' ) return false;

	if ( ! propNode->qualifiers.empty() ) return false;

	if ( propNode->options & kXMP_PropValueIsURI ) return false;

	if ( propNode->options & kXMP_PropCompositeMask ) return false;

	return true;

}	// CanBeRDFAttrProp

// -------------------------------------------------------------------------------------------------

// IsRDFAttrQualifier

// ------------------

static XMP_StringPtr sAttrQualifiers[] = { "xml:lang", "rdf:resource", "rdf:ID", "rdf:bagID", "rdf:nodeID", "" };

static bool

IsRDFAttrQualifier ( XMP_VarString qualName )

{

	for ( size_t i = 0; *sAttrQualifiers[i] != 0; ++i ) {

		if ( qualName == sAttrQualifiers[i] ) return true;

	}

	return false;

}	// IsRDFAttrQualifier

// -------------------------------------------------------------------------------------------------

// SerializePrettyRDFProperty

// --------------------------

//

// Recursively handles the "value" for a node. It does not matter if it is a top level property, a

// field of a struct, or an item of an array.  The indent is that for the property element. An

// xml:lang qualifier is written as an attribute of the property start tag, not by itself forcing

// the qualified property form. The patterns below mostly ignore attribute qualifiers like xml:lang.

// Except for the one struct case, attribute qualifiers don't affect the output form.

//

//	<ns:UnqualifiedSimpleProperty>value</ns:UnqualifiedSimpleProperty>

//

//	<ns:UnqualifiedStructProperty rdf:parseType="Resource">	(If no rdf:resource qualifier)

//		... Fields, same forms as top level properties

//	</ns:UnqualifiedStructProperty>

//

//	

//		... Fields as attributes

//	>

//

//	<ns:UnqualifiedArrayProperty>

//		<rdf:Bag> or Seq or Alt

//			... Array items as rdf:li elements, same forms as top level properties

//		</rdf:Bag>

//	</ns:UnqualifiedArrayProperty>

//

//	<ns:QualifiedProperty rdf:parseType="Resource">

//		<rdf:value> ... Property "value" following the unqualified forms ... </rdf:value>

//		... Qualifiers looking like named struct fields

//	</ns:QualifiedProperty>

static void

SerializePrettyRDFProperty ( const XMP_Node * propNode,

							 XMP_VarString &  outputStr,

							 XMP_StringPtr	  newline,

							 XMP_StringPtr	  indentStr,

							 XMP_Index		  indent,

							 bool			  emitAsRDFValue = false )

{

	XMP_Index level;

	bool emitEndTag   = true;

	bool indentEndTag = true;

	XMP_OptionBits propForm = propNode->options & kXMP_PropCompositeMask;

	// ------------------------------------------------------------------------------------------

	// Determine the XML element name. Open the start tag with the name and attribute qualifiers.

	XMP_StringPtr elemName = propNode->name.c_str();

	if ( emitAsRDFValue ) {

		elemName= "rdf:value";

	} else if ( *elemName == '[' ) {

		elemName = "rdf:li";

	}

	for ( level = indent; level > 0; --level ) outputStr += indentStr;

	outputStr += '<';

	outputStr += elemName;

	#define isCompact	false

	bool hasGeneralQualifiers = isCompact;	// Might also become true later.

	bool hasRDFResourceQual   = false;

	for ( size_t qualNum = 0, qualLim = propNode->qualifiers.size(); qualNum < qualLim; ++qualNum ) {

		const XMP_Node * currQual = propNode->qualifiers[qualNum];

		if ( ! IsRDFAttrQualifier ( currQual->name ) ) {

			hasGeneralQualifiers = true;

		} else {

			if ( currQual->name == "rdf:resource" ) hasRDFResourceQual = true;

			if ( ! emitAsRDFValue ) {

				outputStr += ' ';

				outputStr += currQual->name;

				outputStr += "=\"";

				AppendNodeValue ( outputStr, currQual->value, kForAttribute );

				outputStr += '"';

			}

		}

	}

	// --------------------------------------------------------

	// Process the property according to the standard patterns.

	if ( hasGeneralQualifiers && (! emitAsRDFValue) ) {

		// -----------------------------------------------------------------------------------------

		// This node has general, non-attribute, qualifiers. Emit using the qualified property form.

		// ! The value is output by a recursive call ON THE SAME NODE with emitAsRDFValue set.

		if ( hasRDFResourceQual ) {

			XMP_Throw ( "Can't mix rdf:resource and general qualifiers", kXMPErr_BadRDF );

		}

		outputStr += " rdf:parseType=\"Resource\">";

		outputStr += newline;

		SerializePrettyRDFProperty ( propNode, outputStr, newline, indentStr, indent+1, true );

		for ( size_t qualNum = 0, qualLim = propNode->qualifiers.size(); qualNum < qualLim; ++qualNum ) {

			const XMP_Node * currQual = propNode->qualifiers[qualNum];

			if ( IsRDFAttrQualifier ( currQual->name ) ) continue;

			SerializePrettyRDFProperty ( currQual, outputStr, newline, indentStr, indent+1 );

		}

	} else {

		// --------------------------------------------------------------------

		// This node has no general qualifiers. Emit using an unqualified form.

		if ( propForm == 0 ) {

			// --------------------------

			// This is a simple property.

			if ( propNode->options & kXMP_PropValueIsURI ) {

				outputStr += " rdf:resource=\"";

				AppendNodeValue ( outputStr, propNode->value, kForAttribute );

				outputStr += "\"/>";

				outputStr += newline;

				emitEndTag = false;

			} else if ( propNode->value.empty() ) {

				outputStr += "/>";

				outputStr += newline;

				emitEndTag = false;

			} else {

				outputStr += '>';

				AppendNodeValue ( outputStr, propNode->value, kForElement );

				indentEndTag = false;

			}

		} else if ( propForm & kXMP_PropValueIsArray ) {

			// This is an array.

			outputStr += '>';

			outputStr += newline;

			EmitRDFArrayTag ( propForm, outputStr, newline, indentStr, indent+1, propNode->children.size(), kIsStartTag );

			if ( XMP_ArrayIsAltText(propNode->options) ) NormalizeLangArray ( (XMP_Node*)propNode );

			for ( size_t childNum = 0, childLim = propNode->children.size(); childNum < childLim; ++childNum ) {

				const XMP_Node * currChild = propNode->children[childNum];

				SerializePrettyRDFProperty ( currChild, outputStr, newline, indentStr, indent+2 );

			}

			EmitRDFArrayTag ( propForm, outputStr, newline, indentStr, indent+1, propNode->children.size(), kIsEndTag );

		} else if ( ! hasRDFResourceQual ) {

			// This is a "normal" struct, use the rdf:parseType="Resource" form.

			XMP_Assert ( propForm & kXMP_PropValueIsStruct );

			if ( propNode->children.size() == 0 ) {

				outputStr += " rdf:parseType=\"Resource\"/>";

				outputStr += newline;

				emitEndTag = false;

			} else {

				outputStr += " rdf:parseType=\"Resource\">";

				outputStr += newline;

				for ( size_t childNum = 0, childLim = propNode->children.size(); childNum < childLim; ++childNum ) {

					const XMP_Node * currChild = propNode->children[childNum];

					SerializePrettyRDFProperty ( currChild, outputStr, newline, indentStr, indent+1 );

				}

			}

		} else {

			// This is a struct with an rdf:resource attribute, use the "empty property element" form.

			XMP_Assert ( propForm & kXMP_PropValueIsStruct );

			for ( size_t childNum = 0, childLim = propNode->children.size(); childNum < childLim; ++childNum ) {

				const XMP_Node * currChild = propNode->children[childNum];

				if ( ! CanBeRDFAttrProp ( currChild ) ) {

					XMP_Throw ( "Can't mix rdf:resource and complex fields", kXMPErr_BadRDF );

				}

				outputStr += newline;

				for ( level = indent+1; level > 0; --level ) outputStr += indentStr;

				outputStr += ' ';

				outputStr += currChild->name;

				outputStr += "=\"";

				outputStr += currChild->value;

				outputStr += '"';

			}

			outputStr += "/>";

			outputStr += newline;

			emitEndTag = false;

		}

	}

	// ----------------------------------

	// Emit the property element end tag.

	if ( emitEndTag ) {

		if ( indentEndTag ) for ( level = indent; level > 0; --level ) outputStr += indentStr;

		outputStr += "</";

		outputStr += elemName;

		outputStr += '>';

		outputStr += newline;

	}

}	// SerializePrettyRDFProperty

// -------------------------------------------------------------------------------------------------

// SerializePrettyRDFSchema

// ------------------------

//

// Each schema's properties are written in a separate rdf:Description element. All of the necessary

// namespaces are declared in the rdf:Description element. The baseIndent is the base level for the

// entire serialization, that of the x:xmpmeta element. An xml:lang qualifier is written as an

// attribute of the property start tag, not by itself forcing the qualified property form.

//

//	

//			xmlns:ns="URI" ... >

//

//		... The actual properties of the schema, see SerializePrettyRDFProperty

//

//		  ... If alias comments are wanted

//

//	</rdf:Description>

static void

SerializePrettyRDFSchema ( const XMP_VarString & treeName,

						   const XMP_Node *		 schemaNode,

						   XMP_VarString &		 outputStr,

						   XMP_OptionBits		 options,

						   XMP_StringPtr		 newline,

						   XMP_StringPtr		 indentStr,

						   XMP_Index			 baseIndent )

{

	XMP_Assert ( schemaNode->options & kXMP_SchemaNode );

	XMP_Assert ( schemaNode->qualifiers.empty() );

	// Write the rdf:Description start tag with the namespace declarations.

	XMP_Index level;

	for ( level = baseIndent+2; level > 0; --level ) outputStr += indentStr;

	outputStr += kRDF_SchemaStart;

	outputStr += '"';

	outputStr += treeName;

	outputStr += '"';

	size_t totalLen = 8;	// Start at 8 for "xml:rdf:".

	XMP_cStringMapPos currPos = sNamespacePrefixToURIMap->begin();

	XMP_cStringMapPos endPos  = sNamespacePrefixToURIMap->end();

	for ( ; currPos != endPos; ++currPos ) totalLen += currPos->first.size();

	XMP_VarString usedNS;

	usedNS.reserve ( totalLen );

	usedNS = "xml:rdf:";

	DeclareUsedNamespaces ( schemaNode, usedNS, outputStr, newline, indentStr, baseIndent+4 );

	outputStr += ">";

	outputStr += newline;

	// Write alias comments, if wanted.

	if ( options & kXMP_WriteAliasComments ) {	// *** Hoist into a routine, used for Plain XMP also.

		#if 0	// *** Buggy, disable for now.

		XMP_cAliasMapPos aliasPos = sRegisteredAliasMap->begin();

		XMP_cAliasMapPos aliasEnd = sRegisteredAliasMap->end();

		for ( ; aliasPos != aliasEnd; ++aliasPos ) {

			size_t nsPos = aliasPos->first.find ( schemaNode->value );

			if ( nsPos == XMP_VarString::npos ) continue;

			XMP_Assert ( nsPos == 0 );

			for ( level = baseIndent+3; level > 0; --level ) outputStr += indentStr;

			outputStr += "

			outputStr += aliasPos->first;

			outputStr += " is aliased to ";

			for ( size_t step = 1, stepLim = aliasPos->second.size(); step != stepLim; ++step ) {

				outputStr += aliasPos->second[step].step;

			}

			outputStr += " -->";

			outputStr += newline;

		}

		#endif

	}

	// Write each of the schema's actual properties.

	for ( size_t propNum = 0, propLim = schemaNode->children.size(); propNum < propLim; ++propNum ) {

		const XMP_Node * currProp = schemaNode->children[propNum];

		SerializePrettyRDFProperty ( currProp, outputStr, newline, indentStr, baseIndent+3 );

	}

	// Write the rdf:Description end tag.

	for ( level = baseIndent+2; level > 0; --level ) outputStr += indentStr;

	outputStr += kRDF_SchemaEnd;

	outputStr += newline;

}	// SerializePrettyRDFSchema

// -------------------------------------------------------------------------------------------------

// SerializeCompactRDFAttrProps

// ----------------------------

//

// Write each of the parent's simple unqualified properties as an attribute. Returns true if all

// of the properties are written as attributes.

static bool

SerializeCompactRDFAttrProps ( const XMP_Node *	parentNode,

							   XMP_VarString &	outputStr,

							   XMP_StringPtr	newline,

							   XMP_StringPtr	indentStr,

							   XMP_Index		indent )

{

	size_t prop, propLim;

	bool allAreAttrs = true;

	for ( prop = 0, propLim = parentNode->children.size(); prop != propLim; ++prop ) {

		const XMP_Node * currProp = parentNode->children[prop];

		if ( ! CanBeRDFAttrProp ( currProp ) ) {

			allAreAttrs = false;

			continue;

		}

		outputStr += newline;

		for ( XMP_Index level = indent; level > 0; --level ) outputStr += indentStr;

		outputStr += currProp->name;

		outputStr += "=\"";

		AppendNodeValue ( outputStr, currProp->value, kForAttribute );

		outputStr += '"';

	}

	return allAreAttrs;

}	// SerializeCompactRDFAttrProps

// -------------------------------------------------------------------------------------------------

// SerializeCompactRDFElemProps

// ----------------------------

//

// Recursively handles the "value" for a node that must be written as an RDF property element. It

// does not matter if it is a top level property, a field of a struct, or an item of an array.  The

// indent is that for the property element. The patterns bwlow ignore attribute qualifiers such as

// xml:lang, they don't affect the output form.

//

//	

//		... The fields as attributes, if all are simple and unqualified

//	/>

//

//	<ns:UnqualifiedStructProperty-2 rdf:parseType="Resource">

//		... The fields as elements, if none are simple and unqualified

//	</ns:UnqualifiedStructProperty-2>

//

//	<ns:UnqualifiedStructProperty-3>

//		

//			... The simple and unqualified fields as attributes

//		>

//			... The compound or qualified fields as elements

//		</rdf:Description>

//	</ns:UnqualifiedStructProperty-3>

//

//	<ns:UnqualifiedArrayProperty>

//		<rdf:Bag> or Seq or Alt

//			... Array items as rdf:li elements, same forms as top level properties

//		</rdf:Bag>

//	</ns:UnqualifiedArrayProperty>

//

//	<ns:QualifiedProperty rdf:parseType="Resource">

//		<rdf:value> ... Property "value" following the unqualified forms ... </rdf:value>

//		... Qualifiers looking like named struct fields

//	</ns:QualifiedProperty>

// *** Consider numbered array items, but has compatibility problems.

// *** Consider qualified form with rdf:Description and attributes.

static void

SerializeCompactRDFElemProps ( const XMP_Node *	parentNode,

							   XMP_VarString &	outputStr,

							   XMP_StringPtr	newline,

							   XMP_StringPtr	indentStr,

							   XMP_Index		indent )

{

	XMP_Index level;

	for ( size_t prop = 0, propLim = parentNode->children.size(); prop != propLim; ++prop ) {

		const XMP_Node * propNode = parentNode->children[prop];

		if ( CanBeRDFAttrProp ( propNode ) ) continue;

		bool emitEndTag = true;

		bool indentEndTag = true;

		XMP_OptionBits propForm = propNode->options & kXMP_PropCompositeMask;

		// -----------------------------------------------------------------------------------

		// Determine the XML element name, write the name part of the start tag. Look over the

		// qualifiers to decide on "normal" versus "rdf:value" form. Emit the attribute

		// qualifiers at the same time.

		XMP_StringPtr elemName = propNode->name.c_str();

		if ( *elemName == '[' ) elemName = "rdf:li";

		for ( level = indent; level > 0; --level ) outputStr += indentStr;

		outputStr += '<';

		outputStr += elemName;

		#define isCompact	false

		bool hasGeneralQualifiers = isCompact;	// Might also become true later.

		bool hasRDFResourceQual   = false;

		for ( size_t qualNum = 0, qualLim = propNode->qualifiers.size(); qualNum < qualLim; ++qualNum ) {

			const XMP_Node * currQual = propNode->qualifiers[qualNum];

			if ( ! IsRDFAttrQualifier ( currQual->name ) ) {

				hasGeneralQualifiers = true;

			} else {

				if ( currQual->name == "rdf:resource" ) hasRDFResourceQual = true;

				outputStr += ' ';

				outputStr += currQual->name;

				outputStr += "=\"";

				AppendNodeValue ( outputStr, currQual->value, kForAttribute );

				outputStr += '"';

			}

		}

		// --------------------------------------------------------

		// Process the property according to the standard patterns.

		if ( hasGeneralQualifiers ) {

			// -------------------------------------------------------------------------------------

			// The node has general qualifiers, ones that can't be attributes on a property element.

			// Emit using the qualified property pseudo-struct form. The value is output by a call

			// to SerializePrettyRDFProperty with emitAsRDFValue set.

			// *** We're losing compactness in the calls to SerializePrettyRDFProperty.

			// *** Should refactor to have SerializeCompactRDFProperty that does one node.

			outputStr += " rdf:parseType=\"Resource\">";

			outputStr += newline;

			SerializePrettyRDFProperty ( propNode, outputStr, newline, indentStr, indent+1, true );

			size_t qualNum = 0;

			size_t qualLim = propNode->qualifiers.size();

			if ( propNode->options & kXMP_PropHasLang ) ++qualNum;

			for ( ; qualNum < qualLim; ++qualNum ) {

				const XMP_Node * currQual = propNode->qualifiers[qualNum];

				SerializePrettyRDFProperty ( currQual, outputStr, newline, indentStr, indent+1 );

			}

		} else {

			// --------------------------------------------------------------------

			// This node has only attribute qualifiers. Emit as a property element.

			if ( propForm == 0 ) {

				// --------------------------

				// This is a simple property.

				if ( propNode->options & kXMP_PropValueIsURI ) {

					outputStr += " rdf:resource=\"";

					AppendNodeValue ( outputStr, propNode->value, kForAttribute );

					outputStr += "\"/>";

					outputStr += newline;

					emitEndTag = false;

				} else if ( propNode->value.empty() ) {

					outputStr += "/>";

					outputStr += newline;

					emitEndTag = false;

				} else {

					outputStr += '>';

					AppendNodeValue ( outputStr, propNode->value, kForElement );

					indentEndTag = false;

				}

			} else if ( propForm & kXMP_PropValueIsArray ) {

				// -----------------

				// This is an array.

				outputStr += '>';

				outputStr += newline;

				EmitRDFArrayTag ( propForm, outputStr, newline, indentStr, indent+1, propNode->children.size(), kIsStartTag );

				if ( XMP_ArrayIsAltText(propNode->options) ) NormalizeLangArray ( (XMP_Node*)propNode );

				SerializeCompactRDFElemProps ( propNode, outputStr, newline, indentStr, indent+2 );

				EmitRDFArrayTag ( propForm, outputStr, newline, indentStr, indent+1, propNode->children.size(), kIsEndTag );

			} else {

				// ----------------------

				// This must be a struct.

				XMP_Assert ( propForm & kXMP_PropValueIsStruct );

				bool hasAttrFields = false;

				bool hasElemFields = false;

				size_t field, fieldLim;

				for ( field = 0, fieldLim = propNode->children.size(); field != fieldLim; ++field ) {

					XMP_Node * currField = propNode->children[field];

					if ( CanBeRDFAttrProp ( currField ) ) {

						hasAttrFields = true;

						if ( hasElemFields ) break;	// No sense looking further.

					} else {

						hasElemFields = true;