/// <summary>Remove all schema children according to the flag <c>doAllProperties</c>.</summary>
/// <remarks>Empty schemas are automatically remove by <c>XMPNode</c>.</remarks>
/// <param name="schemaNode">a schema node</param>
/// <param name="doAllProperties">flag if all properties or only externals shall be removed.</param>
/// <returns>Returns true if the schema is empty after the operation.</returns>
private static bool RemoveSchemaChildren(XmpNode schemaNode, bool doAllProperties)
{
for (var it = schemaNode.IterateChildren(); it.HasNext();)
{
var currProp = (XmpNode)it.Next();
if (doAllProperties || !Utils.IsInternalProperty(schemaNode.Name, currProp.Name))
{
it.Remove();
}
}
return(!schemaNode.HasChildren);
}
/// <param name="source">The source XMP object.</param>
/// <param name="destination">The destination XMP object.</param>
/// <param name="doAllProperties">Do internal properties in addition to external properties.</param>
/// <param name="replaceOldValues">Replace the values of existing properties.</param>
/// <param name="deleteEmptyValues">Delete destination values if source property is empty.</param>
/// <exception cref="XmpException">Forwards the Exceptions from the metadata processing</exception>
public static void AppendProperties(IXmpMeta source, IXmpMeta destination, bool doAllProperties, bool replaceOldValues, bool deleteEmptyValues)
{
ParameterAsserts.AssertImplementation(source);
ParameterAsserts.AssertImplementation(destination);
var src = (XmpMeta)source;
var dest = (XmpMeta)destination;
for (var it = src.GetRoot().IterateChildren(); it.HasNext();)
{
var sourceSchema = (XmpNode)it.Next();
// Make sure we have a destination schema node
var destSchema = XmpNodeUtils.FindSchemaNode(dest.GetRoot(), sourceSchema.Name, false);
var createdSchema = false;
if (destSchema == null)
{
destSchema = new XmpNode(sourceSchema.Name, sourceSchema.Value, new PropertyOptions {
IsSchemaNode = true
});
dest.GetRoot().AddChild(destSchema);
createdSchema = true;
}
// Process the source schema's children.
for (var ic = sourceSchema.IterateChildren(); ic.HasNext();)
{
var sourceProp = (XmpNode)ic.Next();
if (doAllProperties || !Utils.IsInternalProperty(sourceSchema.Name, sourceProp.Name))
{
AppendSubtree(dest, sourceProp, destSchema, replaceOldValues, deleteEmptyValues);
}
}
if (!destSchema.HasChildren && (createdSchema || deleteEmptyValues))
{
// Don't create an empty schema / remove empty schema.
dest.GetRoot().RemoveChild(destSchema);
}
}
}
/// <param name="xmp">The XMP object containing the properties to be removed.</param>
/// <param name="schemaNs">
/// Optional schema namespace URI for the properties to be
/// removed.
/// </param>
/// <param name="propName">Optional path expression for the property to be removed.</param>
/// <param name="doAllProperties">
/// Option flag to control the deletion: do internal properties in
/// addition to external properties.
/// </param>
/// <param name="includeAliases">
/// Option flag to control the deletion: Include aliases in the
/// "named schema" case above.
/// </param>
/// <exception cref="XmpException">If metadata processing fails</exception>
public static void RemoveProperties(IXmpMeta xmp, string schemaNs, string propName, bool doAllProperties, bool includeAliases)
{
ParameterAsserts.AssertImplementation(xmp);
var xmpImpl = (XmpMeta)xmp;
if (!string.IsNullOrEmpty(propName))
{
// Remove just the one indicated property. This might be an alias,
// the named schema might not actually exist. So don't lookup the
// schema node.
if (string.IsNullOrEmpty(schemaNs))
{
throw new XmpException("Property name requires schema namespace", XmpErrorCode.BadParam);
}
var expPath = XmpPathParser.ExpandXPath(schemaNs, propName);
var propNode = XmpNodeUtils.FindNode(xmpImpl.GetRoot(), expPath, false, null);
if (propNode != null)
{
if (doAllProperties || !Utils.IsInternalProperty(expPath.GetSegment(XmpPath.StepSchema).Name, expPath.GetSegment(XmpPath.StepRootProp).Name))
{
var parent = propNode.Parent;
parent.RemoveChild(propNode);
if (parent.Options.IsSchemaNode && !parent.HasChildren)
{
// remove empty schema node
parent.Parent.RemoveChild(parent);
}
}
}
}
else
{
if (!string.IsNullOrEmpty(schemaNs))
{
// Remove all properties from the named schema. Optionally include
// aliases, in which case
// there might not be an actual schema node.
// XMP_NodePtrPos schemaPos;
var schemaNode = XmpNodeUtils.FindSchemaNode(xmpImpl.GetRoot(), schemaNs, false);
if (schemaNode != null && RemoveSchemaChildren(schemaNode, doAllProperties))
{
xmpImpl.GetRoot().RemoveChild(schemaNode);
}
if (includeAliases)
{
// We're removing the aliases also. Look them up by their namespace prefix.
// But that takes more code and the extra speed isn't worth it.
// Lookup the XMP node from the alias, to make sure the actual exists.
foreach (var info in XmpMetaFactory.SchemaRegistry.FindAliases(schemaNs))
{
var path = XmpPathParser.ExpandXPath(info.Namespace, info.PropName);
var actualProp = XmpNodeUtils.FindNode(xmpImpl.GetRoot(), path, false, null);
if (actualProp != null)
{
actualProp.Parent.RemoveChild(actualProp);
}
}
}
}
else
{
// Remove all appropriate properties from all schema. In this case
// we don't have to be
// concerned with aliases, they are handled implicitly from the
// actual properties.
for (var it = xmpImpl.GetRoot().IterateChildren(); it.HasNext();)
{
var schema = (XmpNode)it.Next();
if (RemoveSchemaChildren(schema, doAllProperties))
{
it.Remove();
}
}
}
}
}