// EMPTY
 /// <summary>Normalizes a raw parsed XMPMeta-Object</summary>
 /// <param name="xmp">the raw metadata object</param>
 /// <param name="options">the parsing options</param>
 /// <returns>Returns the normalized metadata object</returns>
 /// <exception cref="Com.Adobe.Xmp.XMPException">Collects all severe processing errors.</exception>
 internal static XMPMeta Process(XMPMetaImpl xmp, ParseOptions options)
 {
     XMPNode tree = xmp.GetRoot();
     TouchUpDataModel(xmp);
     MoveExplicitAliases(tree, options);
     TweakOldXMP(tree);
     DeleteEmptySchemas(tree);
     return xmp;
 }
 /// <summary>Static method to serialize the metadata object.</summary>
 /// <remarks>
 /// Static method to serialize the metadata object. For each serialisation, a new XMPSerializer
 /// instance is created, either XMPSerializerRDF or XMPSerializerPlain so thats its possible to
 /// serialialize the same XMPMeta objects in two threads.
 /// </remarks>
 /// <param name="xmp">a metadata implementation object</param>
 /// <param name="out">the output stream to serialize to</param>
 /// <param name="options">serialization options, can be <code>null</code> for default.</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException"/>
 public static void Serialize(XMPMetaImpl xmp, OutputStream @out, SerializeOptions options)
 {
     options = options != null ? options : new SerializeOptions();
     // sort the internal data model on demand
     if (options.GetSort())
     {
         xmp.Sort();
     }
     new XMPSerializerRDF().Serialize(xmp, @out, options);
 }
 /// <summary>Serializes an <code>XMPMeta</code>-object as RDF into a string.</summary>
 /// <remarks>
 /// Serializes an <code>XMPMeta</code>-object as RDF into a string.
 /// <em>Note:</em> Encoding is forced to UTF-16 when serializing to a
 /// string to ensure the correctness of &quot;exact packet size&quot;.
 /// </remarks>
 /// <param name="xmp">a metadata implementation object</param>
 /// <param name="options">
 /// Options to control the serialization (see
 /// <see cref="Com.Adobe.Xmp.Options.SerializeOptions"/>
 /// ).
 /// </param>
 /// <returns>Returns a string containing the serialized RDF.</returns>
 /// <exception cref="Com.Adobe.Xmp.XMPException">on serializsation errors.</exception>
 public static string SerializeToString(XMPMetaImpl xmp, SerializeOptions options)
 {
     // forces the encoding to be UTF-16 to get the correct string length
     options = options != null ? options : new SerializeOptions();
     options.SetEncodeUTF16BE(true);
     ByteArrayOutputStream @out = new ByteArrayOutputStream(2048);
     Serialize(xmp, @out, options);
     try
     {
         return @out.ToString(options.GetEncoding());
     }
     catch (UnsupportedEncodingException)
     {
         // cannot happen as UTF-8/16LE/BE is required to be implemented in
         // Java
         return @out.ToString();
     }
 }
예제 #4
0
 /// <summary>
 /// 7.2.18 parseTypeResourcePropertyElt
 /// start-element ( URI == propertyElementURIs,
 /// attributes == set ( idAttr?, parseResource ) )
 /// propertyEltList
 /// end-element()
 /// Add a new struct node with a qualifier for the possible rdf:ID attribute.
 /// </summary>
 /// <remarks>
 /// 7.2.18 parseTypeResourcePropertyElt
 /// start-element ( URI == propertyElementURIs,
 /// attributes == set ( idAttr?, parseResource ) )
 /// propertyEltList
 /// end-element()
 /// Add a new struct node with a qualifier for the possible rdf:ID attribute.
 /// Then process the XML child nodes to get the struct fields.
 /// </remarks>
 /// <param name="xmp">the xmp metadata object that is generated</param>
 /// <param name="xmpParent">the parent xmp node</param>
 /// <param name="xmlNode">the currently processed XML node</param>
 /// <param name="isTopLevel">Flag if the node is a top-level node</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
 private static void Rdf_ParseTypeResourcePropertyElement(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode xmlNode, bool isTopLevel)
 {
     XMPNode newStruct = AddChildNode(xmp, xmpParent, xmlNode, string.Empty, isTopLevel);
     newStruct.GetOptions().SetStruct(true);
     for (int i = 0; i < xmlNode.Attributes.Count; i++)
     {
         XmlNode attribute = xmlNode.Attributes.Item(i);
         if ("xmlns".Equals(attribute.Prefix) || (attribute.Prefix == null && "xmlns".Equals(attribute.Name)))
         {
             continue;
         }
         string attrLocal = attribute.LocalName;
         string attrNS = attribute.NamespaceURI;
         if (XMPConstConstants.XmlLang.Equals(attribute.Name))
         {
             AddQualifierNode(newStruct, XMPConstConstants.XmlLang, attribute.Value);
         }
         else
         {
             if (XMPConstConstants.NsRdf.Equals(attrNS) && ("ID".Equals(attrLocal) || "parseType".Equals(attrLocal)))
             {
                 continue;
             }
             else
             {
                 // The caller ensured the value is "Resource".
                 // Ignore all rdf:ID attributes.
                 throw new XMPException("Invalid attribute for ParseTypeResource property element", XMPErrorConstants.Badrdf);
             }
         }
     }
     Rdf_PropertyElementList(xmp, newStruct, xmlNode, false);
     if (newStruct.GetHasValueChild())
     {
         FixupQualifiedNode(newStruct);
     }
 }
예제 #5
0
 /// <summary>
 /// 7.2.10 nodeElementList<br />
 /// ws* ( nodeElement ws* )
 /// Note: this method is only called from the rdf:RDF-node (top level)
 /// </summary>
 /// <param name="xmp">the xmp metadata object that is generated</param>
 /// <param name="xmpParent">the parent xmp node</param>
 /// <param name="rdfRdfNode">the top-level xml node</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
 private static void Rdf_NodeElementList(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode rdfRdfNode)
 {
     for (int i = 0; i < rdfRdfNode.ChildNodes.Count; i++)
     {
         XmlNode child = rdfRdfNode.ChildNodes.Item(i);
         // filter whitespaces (and all text nodes)
         if (!IsWhitespaceNode(child))
         {
             Rdf_NodeElement(xmp, xmpParent, child, true);
         }
     }
 }
예제 #6
0
        /// <summary>
        /// 7.2.7 propertyAttributeURIs
        /// anyURI - ( coreSyntaxTerms | rdf:Description | rdf:li | oldTerms )
        /// 7.2.11 nodeElement
        /// start-element ( URI == nodeElementURIs,
        /// attributes == set ( ( idAttr | nodeIdAttr | aboutAttr )?, propertyAttr* ) )
        /// propertyEltList
        /// end-element()
        /// Process the attribute list for an RDF node element.
        /// </summary>
        /// <remarks>
        /// 7.2.7 propertyAttributeURIs
        /// anyURI - ( coreSyntaxTerms | rdf:Description | rdf:li | oldTerms )
        /// 7.2.11 nodeElement
        /// start-element ( URI == nodeElementURIs,
        /// attributes == set ( ( idAttr | nodeIdAttr | aboutAttr )?, propertyAttr* ) )
        /// propertyEltList
        /// end-element()
        /// Process the attribute list for an RDF node element. A property attribute URI is
        /// anything other than an RDF term. The rdf:ID and rdf:nodeID attributes are simply ignored,
        /// as are rdf:about attributes on inner nodes.
        /// </remarks>
        /// <param name="xmp">the xmp metadata object that is generated</param>
        /// <param name="xmpParent">the parent xmp node</param>
        /// <param name="xmlNode">the currently processed XML node</param>
        /// <param name="isTopLevel">Flag if the node is a top-level node</param>
        /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
        private static void Rdf_NodeElementAttrs(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode xmlNode, bool isTopLevel)
        {
            // Used to detect attributes that are mutually exclusive.
            int exclusiveAttrs = 0;
            for (int i = 0; i < xmlNode.Attributes.Count; i++)
            {
                XmlNode attribute = xmlNode.Attributes.Item(i);
                // quick hack, ns declarations do not appear in C++
                // ignore "ID" without namespace
                if ("xmlns".Equals(attribute.Prefix) || (attribute.Prefix == null && "xmlns".Equals(attribute.Name)))
                {
                    continue;
                }
                int attrTerm = GetRDFTermKind(attribute);
                switch (attrTerm)
                {
                    case RdftermId:
                    case RdftermNodeId:
                    case RdftermAbout:
                    {
                        if (exclusiveAttrs > 0)
                        {
                            throw new XMPException("Mutally exclusive about, ID, nodeID attributes", XMPErrorConstants.Badrdf);
                        }
                        exclusiveAttrs++;
                        if (isTopLevel && (attrTerm == RdftermAbout))
                        {
                            // This is the rdf:about attribute on a top level node. Set
                            // the XMP tree name if
                            // it doesn't have a name yet. Make sure this name matches
                            // the XMP tree name.
                            if (xmpParent.GetName() != null && xmpParent.GetName().Length > 0)
                            {
                                if (!xmpParent.GetName().Equals(attribute.Value))
                                {
                                    throw new XMPException("Mismatched top level rdf:about values", XMPErrorConstants.Badxmp);
                                }
                            }
                            else
                            {
                                xmpParent.SetName(attribute.Value);
                            }
                        }
                        break;
                    }

                    case RdftermOther:
                    {
                        AddChildNode(xmp, xmpParent, attribute, attribute.Value, isTopLevel);
                        break;
                    }

                    default:
                    {
                        throw new XMPException("Invalid nodeElement attribute", XMPErrorConstants.Badrdf);
                    }
                }
            }
        }
예제 #7
0
 /// <summary>The main parsing method.</summary>
 /// <remarks>
 /// The main parsing method. The XML tree is walked through from the root node and and XMP tree
 /// is created. This is a raw parse, the normalisation of the XMP tree happens outside.
 /// </remarks>
 /// <param name="xmlRoot">the XML root node</param>
 /// <returns>Returns an XMP metadata object (not normalized)</returns>
 /// <exception cref="Com.Adobe.Xmp.XMPException">Occurs if the parsing fails for any reason.</exception>
 internal static XMPMetaImpl Parse(XmlNode xmlRoot)
 {
     XMPMetaImpl xmp = new XMPMetaImpl();
     Rdf_RDF(xmp, xmlRoot);
     return xmp;
 }
예제 #8
0
		/// <summary>Utility to find or create the array used by <code>SeparateArrayItems()</code>.</summary>
		/// <param name="schemaNS">a the namespace fo the array</param>
		/// <param name="arrayName">the name of the array</param>
		/// <param name="arrayOptions">the options for the array if newly created</param>
		/// <param name="xmp">the xmp object</param>
		/// <returns>Returns the array node.</returns>
		/// <exception cref="Com.Adobe.Xmp.XMPException">Forwards exceptions</exception>
		private static XMPNode SeparateFindCreateArray(string schemaNS, string arrayName, PropertyOptions arrayOptions, XMPMetaImpl xmp)
		{
			arrayOptions = XMPNodeUtils.VerifySetOptions(arrayOptions, null);
			if (!arrayOptions.IsOnlyArrayOptions())
			{
				throw new XMPException("Options can only provide array form", XMPErrorConstants.Badoptions);
			}
			// Find the array node, make sure it is OK. Move the current children
			// aside, to be readded later if kept.
			XMPPath arrayPath = XMPPathParser.ExpandXPath(schemaNS, arrayName);
			XMPNode arrayNode = XMPNodeUtils.FindNode(xmp.GetRoot(), arrayPath, false, null);
			if (arrayNode != null)
			{
				// The array exists, make sure the form is compatible. Zero
				// arrayForm means take what exists.
				PropertyOptions arrayForm = arrayNode.GetOptions();
				if (!arrayForm.IsArray() || arrayForm.IsArrayAlternate())
				{
					throw new XMPException("Named property must be non-alternate array", XMPErrorConstants.Badxpath);
				}
				if (arrayOptions.EqualArrayTypes(arrayForm))
				{
					throw new XMPException("Mismatch of specified and existing array form", XMPErrorConstants.Badxpath);
				}
			}
			else
			{
				// *** Right error?
				// The array does not exist, try to create it.
				// don't modify the options handed into the method
				arrayNode = XMPNodeUtils.FindNode(xmp.GetRoot(), arrayPath, true, arrayOptions.SetArray(true));
				if (arrayNode == null)
				{
					throw new XMPException("Failed to create named array", XMPErrorConstants.Badxpath);
				}
			}
			return arrayNode;
		}
 /// <summary>Visit all schemas to do general fixes and handle special cases.</summary>
 /// <param name="xmp">the metadata object implementation</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">Thrown if the normalisation fails.</exception>
 private static void TouchUpDataModel(XMPMetaImpl xmp)
 {
     // make sure the DC schema is existing, because it might be needed within the normalization
     // if not touched it will be removed by removeEmptySchemas
     XMPNodeUtils.FindSchemaNode(xmp.GetRoot(), XMPConstConstants.NsDc, true);
     // Do the special case fixes within each schema.
     for (Iterator it = xmp.GetRoot().IterateChildren(); it.HasNext(); )
     {
         XMPNode currSchema = (XMPNode)it.Next();
         if (XMPConstConstants.NsDc.Equals(currSchema.GetName()))
         {
             NormalizeDCArrays(currSchema);
         }
         else
         {
             if (XMPConstConstants.NsExif.Equals(currSchema.GetName()))
             {
                 // Do a special case fix for exif:GPSTimeStamp.
                 FixGPSTimeStamp(currSchema);
                 XMPNode arrayNode = XMPNodeUtils.FindChildNode(currSchema, "exif:UserComment", false);
                 if (arrayNode != null)
                 {
                     RepairAltText(arrayNode);
                 }
             }
             else
             {
                 if (XMPConstConstants.NsDm.Equals(currSchema.GetName()))
                 {
                     // Do a special case migration of xmpDM:copyright to
                     // dc:rights['x-default'].
                     XMPNode dmCopyright = XMPNodeUtils.FindChildNode(currSchema, "xmpDM:copyright", false);
                     if (dmCopyright != null)
                     {
                         MigrateAudioCopyright(xmp, dmCopyright);
                     }
                 }
                 else
                 {
                     if (XMPConstConstants.NsXmpRights.Equals(currSchema.GetName()))
                     {
                         XMPNode arrayNode = XMPNodeUtils.FindChildNode(currSchema, "xmpRights:UsageTerms", false);
                         if (arrayNode != null)
                         {
                             RepairAltText(arrayNode);
                         }
                     }
                 }
             }
         }
     }
 }
예제 #10
0
 /// <summary>
 /// 7.2.15 resourcePropertyElt
 /// start-element ( URI == propertyElementURIs, attributes == set ( idAttr? ) )
 /// ws* nodeElement ws
 /// end-element()
 /// This handles structs using an rdf:Description node,
 /// arrays using rdf:Bag/Seq/Alt, and typedNodes.
 /// </summary>
 /// <remarks>
 /// 7.2.15 resourcePropertyElt
 /// start-element ( URI == propertyElementURIs, attributes == set ( idAttr? ) )
 /// ws* nodeElement ws
 /// end-element()
 /// This handles structs using an rdf:Description node,
 /// arrays using rdf:Bag/Seq/Alt, and typedNodes. It also catches and cleans up qualified
 /// properties written with rdf:Description and rdf:value.
 /// </remarks>
 /// <param name="xmp">the xmp metadata object that is generated</param>
 /// <param name="xmpParent">the parent xmp node</param>
 /// <param name="xmlNode">the currently processed XML node</param>
 /// <param name="isTopLevel">Flag if the node is a top-level node</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
 private static void Rdf_ResourcePropertyElement(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode xmlNode, bool isTopLevel)
 {
     if (isTopLevel && "iX:changes".Equals(xmlNode.Name))
     {
         // Strip old "punchcard" chaff which has on the prefix "iX:".
         return;
     }
     XMPNode newCompound = AddChildNode(xmp, xmpParent, xmlNode, string.Empty, isTopLevel);
     // walk through the attributes
     for (int i = 0; i < xmlNode.Attributes.Count; i++)
     {
         XmlNode attribute = xmlNode.Attributes.Item(i);
         if ("xmlns".Equals(attribute.Prefix) || (attribute.Prefix == null && "xmlns".Equals(attribute.Name)))
         {
             continue;
         }
         string attrLocal = attribute.LocalName;
         string attrNS = attribute.NamespaceURI;
         if (XMPConstConstants.XmlLang.Equals(attribute.Name))
         {
             AddQualifierNode(newCompound, XMPConstConstants.XmlLang, attribute.Value);
         }
         else
         {
             if ("ID".Equals(attrLocal) && XMPConstConstants.NsRdf.Equals(attrNS))
             {
                 continue;
             }
             else
             {
                 // Ignore all rdf:ID attributes.
                 throw new XMPException("Invalid attribute for resource property element", XMPErrorConstants.Badrdf);
             }
         }
     }
     // walk through the children
     XmlNode currChild = null;
     bool found = false;
     int i_1;
     for (i_1 = 0; i_1 < xmlNode.ChildNodes.Count; i_1++)
     {
         currChild = xmlNode.ChildNodes.Item(i_1);
         if (!IsWhitespaceNode(currChild))
         {
             if (currChild.NodeType == System.Xml.XmlNodeType.Element && !found)
             {
                 bool isRDF = XMPConstConstants.NsRdf.Equals(currChild.NamespaceURI);
                 string childLocal = currChild.LocalName;
                 if (isRDF && "Bag".Equals(childLocal))
                 {
                     newCompound.GetOptions().SetArray(true);
                 }
                 else
                 {
                     if (isRDF && "Seq".Equals(childLocal))
                     {
                         newCompound.GetOptions().SetArray(true).SetArrayOrdered(true);
                     }
                     else
                     {
                         if (isRDF && "Alt".Equals(childLocal))
                         {
                             newCompound.GetOptions().SetArray(true).SetArrayOrdered(true).SetArrayAlternate(true);
                         }
                         else
                         {
                             newCompound.GetOptions().SetStruct(true);
                             if (!isRDF && !"Description".Equals(childLocal))
                             {
                                 string typeName = currChild.NamespaceURI;
                                 if (typeName == null)
                                 {
                                     throw new XMPException("All XML elements must be in a namespace", XMPErrorConstants.Badxmp);
                                 }
                                 typeName += ':' + childLocal;
                                 AddQualifierNode(newCompound, "rdf:type", typeName);
                             }
                         }
                     }
                 }
                 Rdf_NodeElement(xmp, newCompound, currChild, false);
                 if (newCompound.GetHasValueChild())
                 {
                     FixupQualifiedNode(newCompound);
                 }
                 else
                 {
                     if (newCompound.GetOptions().IsArrayAlternate())
                     {
                         XMPNodeUtils.DetectAltText(newCompound);
                     }
                 }
                 found = true;
             }
             else
             {
                 if (found)
                 {
                     // found second child element
                     throw new XMPException("Invalid child of resource property element", XMPErrorConstants.Badrdf);
                 }
                 else
                 {
                     throw new XMPException("Children of resource property element must be XML elements", XMPErrorConstants.Badrdf);
                 }
             }
         }
     }
     if (!found)
     {
         // didn't found any child elements
         throw new XMPException("Missing child of resource property element", XMPErrorConstants.Badrdf);
     }
 }
예제 #11
0
 /// <summary>
 /// 7.2.13 propertyEltList
 /// ws* ( propertyElt ws* )
 /// </summary>
 /// <param name="xmp">the xmp metadata object that is generated</param>
 /// <param name="xmpParent">the parent xmp node</param>
 /// <param name="xmlParent">the currently processed XML node</param>
 /// <param name="isTopLevel">Flag if the node is a top-level node</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
 private static void Rdf_PropertyElementList(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode xmlParent, bool isTopLevel)
 {
     for (int i = 0; i < xmlParent.ChildNodes.Count; i++)
     {
         XmlNode currChild = xmlParent.ChildNodes.Item(i);
         if (IsWhitespaceNode(currChild))
         {
             continue;
         }
         else
         {
             if (currChild.NodeType != System.Xml.XmlNodeType.Element)
             {
                 throw new XMPException("Expected property element node not found", XMPErrorConstants.Badrdf);
             }
             else
             {
                 Rdf_PropertyElement(xmp, xmpParent, currChild, isTopLevel);
             }
         }
     }
 }
예제 #12
0
 /// <summary>Adds a child node.</summary>
 /// <param name="xmp">the xmp metadata object that is generated</param>
 /// <param name="xmpParent">the parent xmp node</param>
 /// <param name="xmlNode">the currently processed XML node</param>
 /// <param name="value">Node value</param>
 /// <param name="isTopLevel">Flag if the node is a top-level node</param>
 /// <returns>Returns the newly created child node.</returns>
 /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
 private static XMPNode AddChildNode(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode xmlNode, string value, bool isTopLevel)
 {
     XMPSchemaRegistry registry = XMPMetaFactory.GetSchemaRegistry();
     string @namespace = xmlNode.NamespaceURI;
     string childName;
     if (@namespace != null)
     {
         if (XMPConstConstants.NsDcDeprecated.Equals(@namespace))
         {
             // Fix a legacy DC namespace
             @namespace = XMPConstConstants.NsDc;
         }
         string prefix = registry.GetNamespacePrefix(@namespace);
         if (prefix == null)
         {
             prefix = xmlNode.Prefix != null ? xmlNode.Prefix : DefaultPrefix;
             prefix = registry.RegisterNamespace(@namespace, prefix);
         }
         childName = prefix + xmlNode.LocalName;
     }
     else
     {
         throw new XMPException("XML namespace required for all elements and attributes", XMPErrorConstants.Badrdf);
     }
     // create schema node if not already there
     PropertyOptions childOptions = new PropertyOptions();
     bool isAlias = false;
     if (isTopLevel)
     {
         // Lookup the schema node, adjust the XMP parent pointer.
         // Incoming parent must be the tree root.
         XMPNode schemaNode = XMPNodeUtils.FindSchemaNode(xmp.GetRoot(), @namespace, DefaultPrefix, true);
         schemaNode.SetImplicit(false);
         // Clear the implicit node bit.
         // need runtime check for proper 32 bit code.
         xmpParent = schemaNode;
         // If this is an alias set the alias flag in the node
         // and the hasAliases flag in the tree.
         if (registry.FindAlias(childName) != null)
         {
             isAlias = true;
             xmp.GetRoot().SetHasAliases(true);
             schemaNode.SetHasAliases(true);
         }
     }
     // Make sure that this is not a duplicate of a named node.
     bool isArrayItem = "rdf:li".Equals(childName);
     bool isValueNode = "rdf:value".Equals(childName);
     // Create XMP node and so some checks
     XMPNode newChild = new XMPNode(childName, value, childOptions);
     newChild.SetAlias(isAlias);
     // Add the new child to the XMP parent node, a value node first.
     if (!isValueNode)
     {
         xmpParent.AddChild(newChild);
     }
     else
     {
         xmpParent.AddChild(1, newChild);
     }
     if (isValueNode)
     {
         if (isTopLevel || !xmpParent.GetOptions().IsStruct())
         {
             throw new XMPException("Misplaced rdf:value element", XMPErrorConstants.Badrdf);
         }
         xmpParent.SetHasValueChild(true);
     }
     if (isArrayItem)
     {
         if (!xmpParent.GetOptions().IsArray())
         {
             throw new XMPException("Misplaced rdf:li element", XMPErrorConstants.Badrdf);
         }
         newChild.SetName(XMPConstConstants.ArrayItemName);
     }
     return newChild;
 }
예제 #13
0
 /// <summary>
 /// 7.2.14 propertyElt
 /// resourcePropertyElt | literalPropertyElt | parseTypeLiteralPropertyElt |
 /// parseTypeResourcePropertyElt | parseTypeCollectionPropertyElt |
 /// parseTypeOtherPropertyElt | emptyPropertyElt
 /// 7.2.15 resourcePropertyElt
 /// start-element ( URI == propertyElementURIs, attributes == set ( idAttr? ) )
 /// ws* nodeElement ws
 /// end-element()
 /// 7.2.16 literalPropertyElt
 /// start-element (
 /// URI == propertyElementURIs, attributes == set ( idAttr?, datatypeAttr?) )
 /// text()
 /// end-element()
 /// 7.2.17 parseTypeLiteralPropertyElt
 /// start-element (
 /// URI == propertyElementURIs, attributes == set ( idAttr?, parseLiteral ) )
 /// literal
 /// end-element()
 /// 7.2.18 parseTypeResourcePropertyElt
 /// start-element (
 /// URI == propertyElementURIs, attributes == set ( idAttr?, parseResource ) )
 /// propertyEltList
 /// end-element()
 /// 7.2.19 parseTypeCollectionPropertyElt
 /// start-element (
 /// URI == propertyElementURIs, attributes == set ( idAttr?, parseCollection ) )
 /// nodeElementList
 /// end-element()
 /// 7.2.20 parseTypeOtherPropertyElt
 /// start-element ( URI == propertyElementURIs, attributes == set ( idAttr?, parseOther ) )
 /// propertyEltList
 /// end-element()
 /// 7.2.21 emptyPropertyElt
 /// start-element ( URI == propertyElementURIs,
 /// attributes == set ( idAttr?, ( resourceAttr | nodeIdAttr )?, propertyAttr* ) )
 /// end-element()
 /// The various property element forms are not distinguished by the XML element name,
 /// but by their attributes for the most part.
 /// </summary>
 /// <remarks>
 /// 7.2.14 propertyElt
 /// resourcePropertyElt | literalPropertyElt | parseTypeLiteralPropertyElt |
 /// parseTypeResourcePropertyElt | parseTypeCollectionPropertyElt |
 /// parseTypeOtherPropertyElt | emptyPropertyElt
 /// 7.2.15 resourcePropertyElt
 /// start-element ( URI == propertyElementURIs, attributes == set ( idAttr? ) )
 /// ws* nodeElement ws
 /// end-element()
 /// 7.2.16 literalPropertyElt
 /// start-element (
 /// URI == propertyElementURIs, attributes == set ( idAttr?, datatypeAttr?) )
 /// text()
 /// end-element()
 /// 7.2.17 parseTypeLiteralPropertyElt
 /// start-element (
 /// URI == propertyElementURIs, attributes == set ( idAttr?, parseLiteral ) )
 /// literal
 /// end-element()
 /// 7.2.18 parseTypeResourcePropertyElt
 /// start-element (
 /// URI == propertyElementURIs, attributes == set ( idAttr?, parseResource ) )
 /// propertyEltList
 /// end-element()
 /// 7.2.19 parseTypeCollectionPropertyElt
 /// start-element (
 /// URI == propertyElementURIs, attributes == set ( idAttr?, parseCollection ) )
 /// nodeElementList
 /// end-element()
 /// 7.2.20 parseTypeOtherPropertyElt
 /// start-element ( URI == propertyElementURIs, attributes == set ( idAttr?, parseOther ) )
 /// propertyEltList
 /// end-element()
 /// 7.2.21 emptyPropertyElt
 /// start-element ( URI == propertyElementURIs,
 /// attributes == set ( idAttr?, ( resourceAttr | nodeIdAttr )?, propertyAttr* ) )
 /// end-element()
 /// The various property element forms are not distinguished by the XML element name,
 /// but by their attributes for the most part. The exceptions are resourcePropertyElt and
 /// literalPropertyElt. They are distinguished by their XML element content.
 /// NOTE: The RDF syntax does not explicitly include the xml:lang attribute although it can
 /// appear in many of these. We have to allow for it in the attibute counts below.
 /// </remarks>
 /// <param name="xmp">the xmp metadata object that is generated</param>
 /// <param name="xmpParent">the parent xmp node</param>
 /// <param name="xmlNode">the currently processed XML node</param>
 /// <param name="isTopLevel">Flag if the node is a top-level node</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
 private static void Rdf_PropertyElement(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode xmlNode, bool isTopLevel)
 {
     int nodeTerm = GetRDFTermKind(xmlNode);
     if (!IsPropertyElementName(nodeTerm))
     {
         throw new XMPException("Invalid property element name", XMPErrorConstants.Badrdf);
     }
     // remove the namespace-definitions from the list
     XmlAttributeCollection attributes = xmlNode.Attributes;
     IList nsAttrs = null;
     for (int i = 0; i < attributes.Count; i++)
     {
         XmlNode attribute = attributes.Item(i);
         if ("xmlns".Equals(attribute.Prefix) || (attribute.Prefix == null && "xmlns".Equals(attribute.Name)))
         {
             if (nsAttrs == null)
             {
                 nsAttrs = new ArrayList();
             }
             nsAttrs.Add(attribute.Name);
         }
     }
     if (nsAttrs != null)
     {
         for (Iterator it = nsAttrs.Iterator(); it.HasNext(); )
         {
             string ns = (string)it.Next();
             attributes.RemoveNamedItem(ns);
         }
     }
     if (attributes.Count > 3)
     {
         // Only an emptyPropertyElt can have more than 3 attributes.
         Rdf_EmptyPropertyElement(xmp, xmpParent, xmlNode, isTopLevel);
     }
     else
     {
         // Look through the attributes for one that isn't rdf:ID or xml:lang,
         // it will usually tell what we should be dealing with.
         // The called routines must verify their specific syntax!
         for (int i_1 = 0; i_1 < attributes.Count; i_1++)
         {
             XmlNode attribute = attributes.Item(i_1);
             string attrLocal = attribute.LocalName;
             string attrNS = attribute.NamespaceURI;
             string attrValue = attribute.Value;
             if (!(XMPConstConstants.XmlLang.Equals(attribute.Name) && !("ID".Equals(attrLocal) && XMPConstConstants.NsRdf.Equals(attrNS))))
             {
                 if ("datatype".Equals(attrLocal) && XMPConstConstants.NsRdf.Equals(attrNS))
                 {
                     Rdf_LiteralPropertyElement(xmp, xmpParent, xmlNode, isTopLevel);
                 }
                 else
                 {
                     if (!("parseType".Equals(attrLocal) && XMPConstConstants.NsRdf.Equals(attrNS)))
                     {
                         Rdf_EmptyPropertyElement(xmp, xmpParent, xmlNode, isTopLevel);
                     }
                     else
                     {
                         if ("Literal".Equals(attrValue))
                         {
                             Rdf_ParseTypeLiteralPropertyElement();
                         }
                         else
                         {
                             if ("Resource".Equals(attrValue))
                             {
                                 Rdf_ParseTypeResourcePropertyElement(xmp, xmpParent, xmlNode, isTopLevel);
                             }
                             else
                             {
                                 if ("Collection".Equals(attrValue))
                                 {
                                     Rdf_ParseTypeCollectionPropertyElement();
                                 }
                                 else
                                 {
                                     Rdf_ParseTypeOtherPropertyElement();
                                 }
                             }
                         }
                     }
                 }
                 return;
             }
         }
         // Only rdf:ID and xml:lang, could be a resourcePropertyElt, a literalPropertyElt,
         // or an emptyPropertyElt. Look at the child XML nodes to decide which.
         if (xmlNode.HasChildNodes)
         {
             for (int i_2 = 0; i_2 < xmlNode.ChildNodes.Count; i_2++)
             {
                 XmlNode currChild = xmlNode.ChildNodes.Item(i_2);
                 if (currChild.NodeType != System.Xml.XmlNodeType.Text)
                 {
                     Rdf_ResourcePropertyElement(xmp, xmpParent, xmlNode, isTopLevel);
                     return;
                 }
             }
             Rdf_LiteralPropertyElement(xmp, xmpParent, xmlNode, isTopLevel);
         }
         else
         {
             Rdf_EmptyPropertyElement(xmp, xmpParent, xmlNode, isTopLevel);
         }
     }
 }
 /// <summary>Serializes an <code>XMPMeta</code>-object as RDF into a byte buffer.</summary>
 /// <param name="xmp">a metadata implementation object</param>
 /// <param name="options">
 /// Options to control the serialization (see
 /// <see cref="Com.Adobe.Xmp.Options.SerializeOptions"/>
 /// ).
 /// </param>
 /// <returns>Returns a byte buffer containing the serialized RDF.</returns>
 /// <exception cref="Com.Adobe.Xmp.XMPException">on serializsation errors.</exception>
 public static sbyte[] SerializeToBuffer(XMPMetaImpl xmp, SerializeOptions options)
 {
     ByteArrayOutputStream @out = new ByteArrayOutputStream(2048);
     Serialize(xmp, @out, options);
     return @out.ToByteArray();
 }
예제 #15
0
 /// <summary>
 /// Each of these parsing methods is responsible for recognizing an RDF
 /// syntax production and adding the appropriate structure to the XMP tree.
 /// </summary>
 /// <remarks>
 /// Each of these parsing methods is responsible for recognizing an RDF
 /// syntax production and adding the appropriate structure to the XMP tree.
 /// They simply return for success, failures will throw an exception.
 /// </remarks>
 /// <param name="xmp">the xmp metadata object that is generated</param>
 /// <param name="rdfRdfNode">the top-level xml node</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
 internal static void Rdf_RDF(XMPMetaImpl xmp, XmlNode rdfRdfNode)
 {
     if (rdfRdfNode.HasAttributes())
     {
         Rdf_NodeElementList(xmp, xmp.GetRoot(), rdfRdfNode);
     }
     else
     {
         throw new XMPException("Invalid attributes of rdf:RDF element", XMPErrorConstants.Badrdf);
     }
 }
 /// <summary>Constructor with optionsl initial values.</summary>
 /// <remarks>
 /// Constructor with optionsl initial values. If <code>propName</code> is provided,
 /// <code>schemaNS</code> has also be provided.
 /// </remarks>
 /// <param name="xmp">the iterated metadata object.</param>
 /// <param name="schemaNS">the iteration is reduced to this schema (optional)</param>
 /// <param name="propPath">the iteration is redurce to this property within the <code>schemaNS</code></param>
 /// <param name="options">
 /// advanced iteration options, see
 /// <see cref="Com.Adobe.Xmp.Options.IteratorOptions"/>
 /// </param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">If the node defined by the paramters is not existing.</exception>
 public XMPIteratorImpl(XMPMetaImpl xmp, string schemaNS, string propPath, IteratorOptions options)
 {
     // make sure that options is defined at least with defaults
     this.options = options != null ? options : new IteratorOptions();
     // the start node of the iteration depending on the schema and property filter
     XMPNode startNode = null;
     string initialPath = null;
     bool baseSchema = schemaNS != null && schemaNS.Length > 0;
     bool baseProperty = propPath != null && propPath.Length > 0;
     if (!baseSchema && !baseProperty)
     {
         // complete tree will be iterated
         startNode = xmp.GetRoot();
     }
     else
     {
         if (baseSchema && baseProperty)
         {
             // Schema and property node provided
             XMPPath path = XMPPathParser.ExpandXPath(schemaNS, propPath);
             // base path is the prop path without the property leaf
             XMPPath basePath = new XMPPath();
             for (int i = 0; i < path.Size() - 1; i++)
             {
                 basePath.Add(path.GetSegment(i));
             }
             startNode = XMPNodeUtils.FindNode(xmp.GetRoot(), path, false, null);
             baseNS = schemaNS;
             initialPath = basePath.ToString();
         }
         else
         {
             if (baseSchema && !baseProperty)
             {
                 // Only Schema provided
                 startNode = XMPNodeUtils.FindSchemaNode(xmp.GetRoot(), schemaNS, false);
             }
             else
             {
                 // !baseSchema  &&  baseProperty
                 // No schema but property provided -> error
                 throw new XMPException("Schema namespace URI is required", XMPErrorConstants.Badschema);
             }
         }
     }
     // create iterator
     if (startNode != null)
     {
         if (!this.options.IsJustChildren())
         {
             nodeIterator = new XMPIteratorImpl.NodeIterator(this, startNode, initialPath, 1);
         }
         else
         {
             nodeIterator = new XMPIteratorImpl.NodeIteratorChildren(this, startNode, initialPath);
         }
     }
     else
     {
         // create null iterator
         nodeIterator = Sharpen.Collections.EmptyList().Iterator();
     }
 }
예제 #17
0
        /// <summary>
        /// 7.2.21 emptyPropertyElt
        /// start-element ( URI == propertyElementURIs,
        /// attributes == set (
        /// idAttr?, ( resourceAttr | nodeIdAttr )?, propertyAttr* ) )
        /// end-element()
        /// <ns:Prop1/>  <!-- a simple property with an empty value -->
        /// <ns:Prop2 rdf:resource="http: *www.adobe.com/"/> <!-- a URI value -->
        /// <ns:Prop3 rdf:value="..." ns:Qual="..."/> <!-- a simple qualified property -->
        /// <ns:Prop4 ns:Field1="..." ns:Field2="..."/> <!-- a struct with simple fields -->
        /// An emptyPropertyElt is an element with no contained content, just a possibly empty set of
        /// attributes.
        /// </summary>
        /// <remarks>
        /// 7.2.21 emptyPropertyElt
        /// start-element ( URI == propertyElementURIs,
        /// attributes == set (
        /// idAttr?, ( resourceAttr | nodeIdAttr )?, propertyAttr* ) )
        /// end-element()
        /// <ns:Prop1/>  <!-- a simple property with an empty value -->
        /// <ns:Prop2 rdf:resource="http: *www.adobe.com/"/> <!-- a URI value -->
        /// <ns:Prop3 rdf:value="..." ns:Qual="..."/> <!-- a simple qualified property -->
        /// <ns:Prop4 ns:Field1="..." ns:Field2="..."/> <!-- a struct with simple fields -->
        /// An emptyPropertyElt is an element with no contained content, just a possibly empty set of
        /// attributes. An emptyPropertyElt can represent three special cases of simple XMP properties: a
        /// simple property with an empty value (ns:Prop1), a simple property whose value is a URI
        /// (ns:Prop2), or a simple property with simple qualifiers (ns:Prop3).
        /// An emptyPropertyElt can also represent an XMP struct whose fields are all simple and
        /// unqualified (ns:Prop4).
        /// It is an error to use both rdf:value and rdf:resource - that can lead to invalid  RDF in the
        /// verbose form written using a literalPropertyElt.
        /// The XMP mapping for an emptyPropertyElt is a bit different from generic RDF, partly for
        /// design reasons and partly for historical reasons. The XMP mapping rules are:
        /// <ol>
        /// <li> If there is an rdf:value attribute then this is a simple property
        /// with a text value.
        /// All other attributes are qualifiers.
        /// <li> If there is an rdf:resource attribute then this is a simple property
        /// with a URI value.
        /// All other attributes are qualifiers.
        /// <li> If there are no attributes other than xml:lang, rdf:ID, or rdf:nodeID
        /// then this is a simple
        /// property with an empty value.
        /// <li> Otherwise this is a struct, the attributes other than xml:lang, rdf:ID,
        /// or rdf:nodeID are fields.
        /// </ol>
        /// </remarks>
        /// <param name="xmp">the xmp metadata object that is generated</param>
        /// <param name="xmpParent">the parent xmp node</param>
        /// <param name="xmlNode">the currently processed XML node</param>
        /// <param name="isTopLevel">Flag if the node is a top-level node</param>
        /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
        private static void Rdf_EmptyPropertyElement(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode xmlNode, bool isTopLevel)
        {
            bool hasPropertyAttrs = false;
            bool hasResourceAttr = false;
            bool hasNodeIDAttr = false;
            bool hasValueAttr = false;
            XmlNode valueNode = null;
            // ! Can come from rdf:value or rdf:resource.
            if (xmlNode.HasChildNodes)
            {
                throw new XMPException("Nested content not allowed with rdf:resource or property attributes", XMPErrorConstants.Badrdf);
            }
            // First figure out what XMP this maps to and remember the XML node for a simple value.
            for (int i = 0; i < xmlNode.Attributes.Count; i++)
            {
                XmlNode attribute = xmlNode.Attributes.Item(i);
                if ("xmlns".Equals(attribute.Prefix) || (attribute.Prefix == null && "xmlns".Equals(attribute.Name)))
                {
                    continue;
                }
                int attrTerm = GetRDFTermKind(attribute);
                switch (attrTerm)
                {
                    case RdftermId:
                    {
                        // Nothing to do.
                        break;
                    }

                    case RdftermResource:
                    {
                        if (hasNodeIDAttr)
                        {
                            throw new XMPException("Empty property element can't have both rdf:resource and rdf:nodeID", XMPErrorConstants.Badrdf);
                        }
                        else
                        {
                            if (hasValueAttr)
                            {
                                throw new XMPException("Empty property element can't have both rdf:value and rdf:resource", XMPErrorConstants.Badxmp);
                            }
                        }
                        hasResourceAttr = true;
                        if (!hasValueAttr)
                        {
                            valueNode = attribute;
                        }
                        break;
                    }

                    case RdftermNodeId:
                    {
                        if (hasResourceAttr)
                        {
                            throw new XMPException("Empty property element can't have both rdf:resource and rdf:nodeID", XMPErrorConstants.Badrdf);
                        }
                        hasNodeIDAttr = true;
                        break;
                    }

                    case RdftermOther:
                    {
                        if ("value".Equals(attribute.LocalName) && XMPConstConstants.NsRdf.Equals(attribute.NamespaceURI))
                        {
                            if (hasResourceAttr)
                            {
                                throw new XMPException("Empty property element can't have both rdf:value and rdf:resource", XMPErrorConstants.Badxmp);
                            }
                            hasValueAttr = true;
                            valueNode = attribute;
                        }
                        else
                        {
                            if (!XMPConstConstants.XmlLang.Equals(attribute.Name))
                            {
                                hasPropertyAttrs = true;
                            }
                        }
                        break;
                    }

                    default:
                    {
                        throw new XMPException("Unrecognized attribute of empty property element", XMPErrorConstants.Badrdf);
                    }
                }
            }
            // Create the right kind of child node and visit the attributes again
            // to add the fields or qualifiers.
            // ! Because of implementation vagaries,
            //   the xmpParent is the tree root for top level properties.
            // ! The schema is found, created if necessary, by addChildNode.
            XMPNode childNode = AddChildNode(xmp, xmpParent, xmlNode, string.Empty, isTopLevel);
            bool childIsStruct = false;
            if (hasValueAttr || hasResourceAttr)
            {
                childNode.SetValue(valueNode != null ? valueNode.Value : string.Empty);
                if (!hasValueAttr)
                {
                    // ! Might have both rdf:value and rdf:resource.
                    childNode.GetOptions().SetURI(true);
                }
            }
            else
            {
                if (hasPropertyAttrs)
                {
                    childNode.GetOptions().SetStruct(true);
                    childIsStruct = true;
                }
            }
            for (int i_1 = 0; i_1 < xmlNode.Attributes.Count; i_1++)
            {
                XmlNode attribute = xmlNode.Attributes.Item(i_1);
                if (attribute == valueNode || "xmlns".Equals(attribute.Prefix) || (attribute.Prefix == null && "xmlns".Equals(attribute.Name)))
                {
                    continue;
                }
                // Skip the rdf:value or rdf:resource attribute holding the value.
                int attrTerm = GetRDFTermKind(attribute);
                switch (attrTerm)
                {
                    case RdftermId:
                    case RdftermNodeId:
                    {
                        break;
                    }

                    case RdftermResource:
                    {
                        // Ignore all rdf:ID and rdf:nodeID attributes.
                        AddQualifierNode(childNode, "rdf:resource", attribute.Value);
                        break;
                    }

                    case RdftermOther:
                    {
                        if (!childIsStruct)
                        {
                            AddQualifierNode(childNode, attribute.Name, attribute.Value);
                        }
                        else
                        {
                            if (XMPConstConstants.XmlLang.Equals(attribute.Name))
                            {
                                AddQualifierNode(childNode, XMPConstConstants.XmlLang, attribute.Value);
                            }
                            else
                            {
                                AddChildNode(xmp, childNode, attribute, attribute.Value, false);
                            }
                        }
                        break;
                    }

                    default:
                    {
                        throw new XMPException("Unrecognized attribute of empty property element", XMPErrorConstants.Badrdf);
                    }
                }
            }
        }
예제 #18
0
 /// <summary>
 /// 7.2.16 literalPropertyElt
 /// start-element ( URI == propertyElementURIs,
 /// attributes == set ( idAttr?, datatypeAttr?) )
 /// text()
 /// end-element()
 /// Add a leaf node with the text value and qualifiers for the attributes.
 /// </summary>
 /// <param name="xmp">the xmp metadata object that is generated</param>
 /// <param name="xmpParent">the parent xmp node</param>
 /// <param name="xmlNode">the currently processed XML node</param>
 /// <param name="isTopLevel">Flag if the node is a top-level node</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
 private static void Rdf_LiteralPropertyElement(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode xmlNode, bool isTopLevel)
 {
     XMPNode newChild = AddChildNode(xmp, xmpParent, xmlNode, null, isTopLevel);
     for (int i = 0; i < xmlNode.Attributes.Count; i++)
     {
         XmlNode attribute = xmlNode.Attributes.Item(i);
         if ("xmlns".Equals(attribute.Prefix) || (attribute.Prefix == null && "xmlns".Equals(attribute.Name)))
         {
             continue;
         }
         string attrNS = attribute.NamespaceURI;
         string attrLocal = attribute.LocalName;
         if (XMPConstConstants.XmlLang.Equals(attribute.Name))
         {
             AddQualifierNode(newChild, XMPConstConstants.XmlLang, attribute.Value);
         }
         else
         {
             if (XMPConstConstants.NsRdf.Equals(attrNS) && ("ID".Equals(attrLocal) || "datatype".Equals(attrLocal)))
             {
                 continue;
             }
             else
             {
                 // Ignore all rdf:ID and rdf:datatype attributes.
                 throw new XMPException("Invalid attribute for literal property element", XMPErrorConstants.Badrdf);
             }
         }
     }
     string textValue = string.Empty;
     for (int i_1 = 0; i_1 < xmlNode.ChildNodes.Count; i_1++)
     {
         XmlNode child = xmlNode.ChildNodes.Item(i_1);
         if (child.NodeType == System.Xml.XmlNodeType.Text)
         {
             textValue += child.Value;
         }
         else
         {
             throw new XMPException("Invalid child of literal property element", XMPErrorConstants.Badrdf);
         }
     }
     newChild.SetValue(textValue);
 }
예제 #19
0
 /// <summary>
 /// 7.2.5 nodeElementURIs
 /// anyURI - ( coreSyntaxTerms | rdf:li | oldTerms )
 /// 7.2.11 nodeElement
 /// start-element ( URI == nodeElementURIs,
 /// attributes == set ( ( idAttr | nodeIdAttr | aboutAttr )?, propertyAttr* ) )
 /// propertyEltList
 /// end-element()
 /// A node element URI is rdf:Description or anything else that is not an RDF
 /// term.
 /// </summary>
 /// <param name="xmp">the xmp metadata object that is generated</param>
 /// <param name="xmpParent">the parent xmp node</param>
 /// <param name="xmlNode">the currently processed XML node</param>
 /// <param name="isTopLevel">Flag if the node is a top-level node</param>
 /// <exception cref="Com.Adobe.Xmp.XMPException">thown on parsing errors</exception>
 private static void Rdf_NodeElement(XMPMetaImpl xmp, XMPNode xmpParent, XmlNode xmlNode, bool isTopLevel)
 {
     int nodeTerm = GetRDFTermKind(xmlNode);
     if (nodeTerm != RdftermDescription && nodeTerm != RdftermOther)
     {
         throw new XMPException("Node element must be rdf:Description or typed node", XMPErrorConstants.Badrdf);
     }
     else
     {
         if (isTopLevel && nodeTerm == RdftermOther)
         {
             throw new XMPException("Top level typed node not allowed", XMPErrorConstants.Badxmp);
         }
         else
         {
             Rdf_NodeElementAttrs(xmp, xmpParent, xmlNode, isTopLevel);
             Rdf_PropertyElementList(xmp, xmpParent, xmlNode, isTopLevel);
         }
     }
 }
예제 #20
0
		/// <seealso cref="AppendProperties(Com.Adobe.Xmp.XMPMeta, Com.Adobe.Xmp.XMPMeta, bool, bool, bool)"/>
		/// <param name="destXMP">The destination XMP object.</param>
		/// <param name="sourceNode">the source node</param>
		/// <param name="destParent">the parent of the destination node</param>
		/// <param name="replaceOldValues">Replace the values of existing properties.</param>
		/// <param name="deleteEmptyValues">
		/// flag if properties with empty values should be deleted
		/// in the destination object.
		/// </param>
		/// <exception cref="Com.Adobe.Xmp.XMPException"/>
		private static void AppendSubtree(XMPMetaImpl destXMP, XMPNode sourceNode, XMPNode destParent, bool replaceOldValues, bool deleteEmptyValues)
		{
			XMPNode destNode = XMPNodeUtils.FindChildNode(destParent, sourceNode.GetName(), false);
			bool valueIsEmpty = false;
			if (deleteEmptyValues)
			{
				valueIsEmpty = sourceNode.GetOptions().IsSimple() ? sourceNode.GetValue() == null || sourceNode.GetValue().Length == 0 : !sourceNode.HasChildren();
			}
			if (deleteEmptyValues && valueIsEmpty)
			{
				if (destNode != null)
				{
					destParent.RemoveChild(destNode);
				}
			}
			else
			{
				if (destNode == null)
				{
					// The one easy case, the destination does not exist.
					destParent.AddChild((XMPNode)sourceNode.Clone());
				}
				else
				{
					if (replaceOldValues)
					{
						// The destination exists and should be replaced.
						destXMP.SetNode(destNode, sourceNode.GetValue(), sourceNode.GetOptions(), true);
						destParent.RemoveChild(destNode);
						destNode = (XMPNode)sourceNode.Clone();
						destParent.AddChild(destNode);
					}
					else
					{
						// The destination exists and is not totally replaced. Structs and
						// arrays are merged.
						PropertyOptions sourceForm = sourceNode.GetOptions();
						PropertyOptions destForm = destNode.GetOptions();
						if (sourceForm != destForm)
						{
							return;
						}
						if (sourceForm.IsStruct())
						{
							// To merge a struct process the fields recursively. E.g. add simple missing fields.
							// The recursive call to AppendSubtree will handle deletion for fields with empty 
							// values.
							for (Iterator it = sourceNode.IterateChildren(); it.HasNext(); )
							{
								XMPNode sourceField = (XMPNode)it.Next();
								AppendSubtree(destXMP, sourceField, destNode, replaceOldValues, deleteEmptyValues);
								if (deleteEmptyValues && !destNode.HasChildren())
								{
									destParent.RemoveChild(destNode);
								}
							}
						}
						else
						{
							if (sourceForm.IsArrayAltText())
							{
								// Merge AltText arrays by the "xml:lang" qualifiers. Make sure x-default is first. 
								// Make a special check for deletion of empty values. Meaningful in AltText arrays 
								// because the "xml:lang" qualifier provides unambiguous source/dest correspondence.
								for (Iterator it = sourceNode.IterateChildren(); it.HasNext(); )
								{
									XMPNode sourceItem = (XMPNode)it.Next();
									if (!sourceItem.HasQualifier() || !XMPConstConstants.XmlLang.Equals(sourceItem.GetQualifier(1).GetName()))
									{
										continue;
									}
									int destIndex = XMPNodeUtils.LookupLanguageItem(destNode, sourceItem.GetQualifier(1).GetValue());
									if (deleteEmptyValues && (sourceItem.GetValue() == null || sourceItem.GetValue().Length == 0))
									{
										if (destIndex != -1)
										{
											destNode.RemoveChild(destIndex);
											if (!destNode.HasChildren())
											{
												destParent.RemoveChild(destNode);
											}
										}
									}
									else
									{
										if (destIndex == -1)
										{
											// Not replacing, keep the existing item.						
											if (!XMPConstConstants.XDefault.Equals(sourceItem.GetQualifier(1).GetValue()) || !destNode.HasChildren())
											{
												sourceItem.CloneSubtree(destNode);
											}
											else
											{
												XMPNode destItem = new XMPNode(sourceItem.GetName(), sourceItem.GetValue(), sourceItem.GetOptions());
												sourceItem.CloneSubtree(destItem);
												destNode.AddChild(1, destItem);
											}
										}
									}
								}
							}
							else
							{
								if (sourceForm.IsArray())
								{
									// Merge other arrays by item values. Don't worry about order or duplicates. Source 
									// items with empty values do not cause deletion, that conflicts horribly with 
									// merging.
									for (Iterator @is = sourceNode.IterateChildren(); @is.HasNext(); )
									{
										XMPNode sourceItem = (XMPNode)@is.Next();
										bool match = false;
										for (Iterator id = destNode.IterateChildren(); id.HasNext(); )
										{
											XMPNode destItem = (XMPNode)id.Next();
											if (ItemValuesMatch(sourceItem, destItem))
											{
												match = true;
											}
										}
										if (!match)
										{
											destNode = (XMPNode)sourceItem.Clone();
											destParent.AddChild(destNode);
										}
									}
								}
							}
						}
					}
				}
			}
		}
		// UTF-8
		/// <summary>The actual serialization.</summary>
		/// <param name="xmp">the metadata object to be serialized</param>
		/// <param name="out">outputStream the output stream to serialize to</param>
		/// <param name="options">the serialization options</param>
		/// <exception cref="Com.Adobe.Xmp.XMPException">If case of wrong options or any other serialization error.</exception>
		public virtual void Serialize(XMPMeta xmp, OutputStream @out, SerializeOptions options)
		{
			try
			{
				outputStream = new CountOutputStream(@out);
				writer = new OutputStreamWriter(outputStream, options.GetEncoding());
				this.xmp = (XMPMetaImpl)xmp;
				this.options = options;
				this.padding = options.GetPadding();
				writer = new OutputStreamWriter(outputStream, options.GetEncoding());
				CheckOptionsConsistence();
				// serializes the whole packet, but don't write the tail yet 
				// and flush to make sure that the written bytes are calculated correctly
				string tailStr = SerializeAsRDF();
				writer.Flush();
				// adds padding
				AddPadding(tailStr.Length);
				// writes the tail
				Write(tailStr);
				writer.Flush();
				outputStream.Close();
			}
			catch (IOException)
			{
				throw new XMPException("Error writing to the OutputStream", XMPErrorConstants.Unknown);
			}
		}