static private VerifySetOptions ( |
||
options | the PropertyOptions |
|
itemValue | object | the node value to set |
Résultat |
// ------------------------------------------------------------------------------------- // private /// <summary> /// 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. /// </summary> /// <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="XmpException"> </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.ChildrenLength + 1 : arrayNode.ChildrenLength; 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); } }
private void RegisterAlias(string aliasNs, string aliasProp, string actualNs, string actualProp, AliasOptions aliasForm) { 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). Options) : 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); } 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); } if (_aliasMap.Contains(actualPrefix + actualProp)) { throw new XmpException("Actual property is already an alias, use the base property", XmpError.BADPARAM); } IXmpAliasInfo aliasInfo = new XmpAliasInfoImpl(actualNs, actualPrefix, actualProp, aliasOpts); _aliasMap[key] = aliasInfo; }
/// <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="XmpException"> Forwards exceptions </exception> private static XmpNode SeparateFindCreateArray(string schemaNs, string arrayName, PropertyOptions arrayOptions, XmpMetaImpl xmp) { arrayOptions = XmpNodeUtils.VerifySetOptions(arrayOptions, null); if (!arrayOptions.OnlyArrayOptions) { throw new XmpException("Options can only provide array form", XmpError.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.Root, arrayPath, false, null); if (arrayNode != null) { // The array exists, make sure the form is compatible. Zero // arrayForm means take what exists. PropertyOptions arrayForm = arrayNode.Options; if (!arrayForm.Array || arrayForm.ArrayAlternate) { throw new XmpException("Named property must be non-alternate array", XmpError.BADXPATH); } if (arrayOptions.EqualArrayTypes(arrayForm)) { throw new XmpException("Mismatch of specified and existing array form", XmpError.BADXPATH); // *** Right error? } } else { // The array does not exist, try to create it. // don't modify the options handed into the method arrayOptions.Array = true; arrayNode = XmpNodeUtils.FindNode(xmp.Root, arrayPath, true, arrayOptions); if (arrayNode == null) { throw new XmpException("Failed to create named array", XmpError.BADXPATH); } } return(arrayNode); }
/// <exception cref="XmpException"> </exception> /// <seealso cref= XMPMeta#SetProperty(String, String, Object, PropertyOptions) </seealso> 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); } }
/// <seealso cref= XMPMeta#appendArrayItem(String, String, PropertyOptions, String, /// PropertyOptions) </seealso> 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.OnlyArrayOptions) { 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.Options.Array) { throw new XmpException("The named property is not an array", XmpError.BADXPATH); } // if (arrayOptions != null && !arrayOptions.equalArrayTypes(arrayNode.getOptions())) // { // throw new XmpException("Mismatch of existing and specified array form", BADOPTIONS); // } } else { // The array does not exist, try to create it. if (arrayOptions.Array) { 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); }