/** * Associates an alias name with an actual name. * * <p>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 * * @param aliasNS The namespace URI for the alias. Must not be null or the empty string. * @param aliasProp The name of the alias. Must be a simple name, not null or the empty string and * not a general path expression. * @param actualNS The namespace URI for the actual. Must not be null or the empty string. * @param actualProp The name of the actual. Must be a simple name, not null or the empty string * and not a general path expression. * @param 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 {@link AliasOptions}). * @throws XMPException for inconsistant aliases. */ synchronized void registerAlias( String aliasNS, String aliasProp, final String actualNS, final String actualProp, final AliasOptions aliasForm) throws XMPException { ParameterAsserts.assertSchemaNS(aliasNS); ParameterAsserts.assertPropName(aliasProp); ParameterAsserts.assertSchemaNS(actualNS); ParameterAsserts.assertPropName(actualProp); // Fix the alias options final AliasOptions aliasOpts = aliasForm != null ? new AliasOptions( XMPNodeUtils.verifySetOptions(aliasForm.toPropertyOptions(), null).getOptions()) : new AliasOptions(); if (p.matcher(aliasProp).find() || p.matcher(actualProp).find()) { throw new XMPException("Alias and actual property names must be simple", XMPError.BADXPATH); } // check if both namespaces are registered final String aliasPrefix = getNamespacePrefix(aliasNS); final 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.containsKey(key)) { throw new XMPException("Alias is already existing", XMPError.BADPARAM); } else if (aliasMap.containsKey(actualPrefix + actualProp)) { throw new XMPException( "Actual property is already an alias, use the base property", XMPError.BADPARAM); } XMPAliasInfo aliasInfo = new XMPAliasInfo() { /** @see XMPAliasInfo#getNamespace() */ public String getNamespace() { return actualNS; } /** @see XMPAliasInfo#getPrefix() */ public String getPrefix() { return actualPrefix; } /** @see XMPAliasInfo#getPropName() */ public String getPropName() { return actualProp; } /** @see XMPAliasInfo#getAliasForm() */ public AliasOptions getAliasForm() { return aliasOpts; } public String toString() { return actualPrefix + actualProp + " NS(" + actualNS + "), FORM (" + getAliasForm() + ")"; } }; aliasMap.put(key, aliasInfo); }