// -------------------------------------------------------------------------------------
// private
/// <summary>Locate or create the item node and set the value.</summary>
/// <remarks>
/// Locate or create the item node and set the value. Note the index
/// parameter is one-based! The index can be in the range [1..size + 1] or
/// "last()", normalize it and check the insert flags. The order of the
/// normalization checks is important. If the array is empty we end up with
/// an index and location to set item size + 1.
/// </remarks>
/// <param name="arrayNode">an array node</param>
/// <param name="itemIndex">the index where to insert the item</param>
/// <param name="itemValue">the item value</param>
/// <param name="itemOptions">the options for the new item</param>
/// <param name="insert">insert oder overwrite at index position?</param>
/// <exception cref="iText.Kernel.XMP.XMPException">array item cannot be set</exception>
private void DoSetArrayItem(XMPNode arrayNode, int itemIndex, String itemValue, PropertyOptions
itemOptions, bool insert)
{
XMPNode itemNode = new XMPNode(ARRAY_ITEM_NAME, null);
itemOptions = XMPNodeUtils.VerifySetOptions(itemOptions, itemValue);
// in insert mode the index after the last is allowed,
// even ARRAY_LAST_ITEM points to the index *after* the last.
int maxIndex = insert ? arrayNode.GetChildrenLength() + 1 : arrayNode.GetChildrenLength
();
if (itemIndex == ARRAY_LAST_ITEM)
{
itemIndex = maxIndex;
}
if (1 <= itemIndex && itemIndex <= maxIndex)
{
if (!insert)
{
arrayNode.RemoveChild(itemIndex);
}
arrayNode.AddChild(itemIndex, itemNode);
SetNode(itemNode, itemValue, itemOptions, false);
}
else
{
throw new XMPException("Array index out of bounds", XMPError.BADINDEX);
}
}
public virtual void AppendArrayItem(String schemaNS, String arrayName, PropertyOptions
arrayOptions, String itemValue, PropertyOptions itemOptions)
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertArrayName(arrayName);
if (arrayOptions == null)
{
arrayOptions = new PropertyOptions();
}
if (!arrayOptions.IsOnlyArrayOptions())
{
throw new XMPException("Only array form flags allowed for arrayOptions", XMPError
.BADOPTIONS);
}
// Check if array options are set correctly.
arrayOptions = XMPNodeUtils.VerifySetOptions(arrayOptions, null);
// Locate or create the array. If it already exists, make sure the array
// form from the options
// parameter is compatible with the current state.
XMPPath arrayPath = XMPPathParser.ExpandXPath(schemaNS, arrayName);
// Just lookup, don't try to create.
XMPNode arrayNode = XMPNodeUtils.FindNode(tree, arrayPath, false, null);
if (arrayNode != null)
{
// The array exists, make sure the form is compatible. Zero
// arrayForm means take what exists.
if (!arrayNode.GetOptions().IsArray())
{
throw new XMPException("The named property is not an array", XMPError.BADXPATH);
}
}
else
{
// if (arrayOptions != null && !arrayOptions.equalArrayTypes(arrayNode.getOptions()))
// {
// throw new XMPException("Mismatch of existing and specified array form", BADOPTIONS);
// }
// The array does not exist, try to create it.
if (arrayOptions.IsArray())
{
arrayNode = XMPNodeUtils.FindNode(tree, arrayPath, true, arrayOptions);
if (arrayNode == null)
{
throw new XMPException("Failure creating array node", XMPError.BADXPATH);
}
}
else
{
// array options missing
throw new XMPException("Explicit arrayOptions required to create new array", XMPError
.BADOPTIONS);
}
}
DoSetArrayItem(arrayNode, ARRAY_LAST_ITEM, itemValue, itemOptions, true);
}
/// <summary>Associates an alias name with an actual name.</summary>
/// <remarks>
/// Associates an alias name with an actual name.
/// <para>
/// Define a alias mapping from one namespace/property to another. Both
/// property names must be simple names. An alias can be a direct mapping,
/// where the alias and actual have the same data type. It is also possible
/// to map a simple alias to an item in an array. This can either be to the
/// first item in the array, or to the 'x-default' item in an alt-text array.
/// Multiple alias names may map to the same actual, as long as the forms
/// match. It is a no-op to reregister an alias in an identical fashion.
/// Note: This method is not locking because only called by registerStandardAliases
/// which is only called by the constructor.
/// Note2: The method is only package-private so that it can be tested with unittests
/// </para>
/// </remarks>
/// <param name="aliasNS">
/// The namespace URI for the alias. Must not be null or the empty
/// string.
/// </param>
/// <param name="aliasProp">
/// The name of the alias. Must be a simple name, not null or the
/// empty string and not a general path expression.
/// </param>
/// <param name="actualNS">
/// The namespace URI for the actual. Must not be null or the
/// empty string.
/// </param>
/// <param name="actualProp">
/// The name of the actual. Must be a simple name, not null or the
/// empty string and not a general path expression.
/// </param>
/// <param name="aliasForm">
/// Provides options for aliases for simple aliases to array
/// items. This is needed to know what kind of array to create if
/// set for the first time via the simple alias. Pass
/// <code>XMP_NoOptions</code>, the default value, for all
/// direct aliases regardless of whether the actual data type is
/// an array or not (see
/// <see cref="iText.Kernel.XMP.Options.AliasOptions"/>
/// ).
/// </param>
/// <exception cref="iText.Kernel.XMP.XMPException">for inconsistant aliases.</exception>
internal void RegisterAlias(String aliasNS, String aliasProp, String actualNS, String
actualProp, AliasOptions aliasForm)
{
lock (this)
{
ParameterAsserts.AssertSchemaNS(aliasNS);
ParameterAsserts.AssertPropName(aliasProp);
ParameterAsserts.AssertSchemaNS(actualNS);
ParameterAsserts.AssertPropName(actualProp);
// Fix the alias options
AliasOptions aliasOpts = aliasForm != null ? new AliasOptions(XMPNodeUtils.VerifySetOptions
(aliasForm.ToPropertyOptions(), null).GetOptions()) : new AliasOptions();
if (_regex.IsMatch(aliasProp) || _regex.IsMatch(actualProp))
{
throw new XMPException("Alias and actual property names must be simple", XMPError.BADXPATH);
}
// check if both namespaces are registered
String aliasPrefix = GetNamespacePrefix(aliasNS);
String actualPrefix = GetNamespacePrefix(actualNS);
if (aliasPrefix == null)
{
throw new XMPException("Alias namespace is not registered", XMPError.BADSCHEMA);
}
else
{
if (actualPrefix == null)
{
throw new XMPException("Actual namespace is not registered", XMPError.BADSCHEMA);
}
}
String key = aliasPrefix + aliasProp;
// check if alias is already existing
if (aliasMap.Contains(key))
{
throw new XMPException("Alias is already existing", XMPError.BADPARAM);
}
else
{
if (aliasMap.Contains(actualPrefix + actualProp))
{
throw new XMPException("Actual property is already an alias, use the base property"
, XMPError.BADPARAM);
}
}
XMPAliasInfo aliasInfo = new _XMPAliasInfo_409(actualNS, actualPrefix, actualProp
, aliasOpts);
aliasMap[key] = aliasInfo;
}
}
public virtual void SetProperty(String schemaNS, String propName, Object propValue
, PropertyOptions options)
{
ParameterAsserts.AssertSchemaNS(schemaNS);
ParameterAsserts.AssertPropName(propName);
options = XMPNodeUtils.VerifySetOptions(options, propValue);
XMPPath expPath = XMPPathParser.ExpandXPath(schemaNS, propName);
XMPNode propNode = XMPNodeUtils.FindNode(tree, expPath, true, options);
if (propNode != null)
{
SetNode(propNode, propValue, options, false);
}
else
{
throw new XMPException("Specified property does not exist", XMPError.BADXPATH);
}
}