Metadata to XMP conversion functionatlity
+ */
+public class TikaToXMPTest
+{
+ private Metadata tikaMetadata;
+
+ private static final String OOXML_MIMETYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+ private static final String GENERIC_MIMETYPE = "generic/mimetype";
+
+ // --- Set up ---
+ @Before
+ public void setup()
+ {
+ tikaMetadata = new Metadata();
+ }
+
+ private void setupOOXMLMetadata(Metadata metadata)
+ {
+ // simple property
+ metadata.set(TikaCoreProperties.LANGUAGE, "language");
+ // language alternative
+ metadata.set(TikaCoreProperties.TITLE, "title");
+ // comma separated array
+ metadata.set(TikaCoreProperties.KEYWORDS, "keyword1,keyword2");
+ // OOXML specific simple prop
+ metadata.set(TikaCoreProperties.LAST_AUTHOR, "lastModifiedBy");
+ }
+
+ private void checkOOXMLMetadata(XMPMeta xmp) throws XMPException
+ {
+ // check simple property
+ XMPProperty prop = xmp.getProperty(XMPConst.NS_DC, "language");
+ assertNotNull(prop);
+ assertEquals("language", prop.getValue());
+
+ // check lang alt
+ prop = xmp.getLocalizedText(XMPConst.NS_DC, "title", null, XMPConst.X_DEFAULT);
+ assertNotNull(prop);
+ assertEquals("title", prop.getValue());
+
+ // check array
+ prop = xmp.getArrayItem(XMPConst.NS_DC, "subject", 1);
+ assertNotNull(prop);
+ assertEquals("keyword1", prop.getValue());
+ prop = xmp.getArrayItem(XMPConst.NS_DC, "subject", 2);
+ assertNotNull(prop);
+ assertEquals("keyword2", prop.getValue());
+
+ // check OOXML specific simple property
+ prop = xmp.getProperty(OfficeOpenXMLCore.NAMESPACE_URI, "lastModifiedBy");
+ assertNotNull(prop);
+ assertEquals("lastModifiedBy", prop.getValue());
+ }
+
+
+ // --- TESTS ---
+ @Test
+ public void convert_OOXMLMetadataWithMimetype_everythingConverted() throws XMPException, TikaException
+ {
+ setupOOXMLMetadata(tikaMetadata);
+ tikaMetadata.set(Metadata.CONTENT_TYPE, OOXML_MIMETYPE);
+
+ XMPMeta xmp = TikaToXMP.convert(tikaMetadata);
+
+ checkOOXMLMetadata(xmp);
+ }
+
+
+ @Test
+ public void convert_OOXMLMetadataWithExtraMimetype_everythingConverted() throws XMPException, TikaException
+ {
+ setupOOXMLMetadata(tikaMetadata);
+
+ XMPMeta xmp = TikaToXMP.convert(tikaMetadata, OOXML_MIMETYPE);
+
+ checkOOXMLMetadata(xmp);
+ }
+
+
+ @Test
+ public void convert_OOXMLMetadataWithoutMimetype_onlyGeneralMetadataconverted() throws XMPException, TikaException
+ {
+ setupOOXMLMetadata(tikaMetadata);
+
+ XMPMeta xmp = TikaToXMP.convert(tikaMetadata, null);
+
+ // general metadata is converted
+ // check simple property
+ XMPProperty prop = xmp.getProperty(XMPConst.NS_DC, "language");
+ assertNotNull(prop);
+ assertEquals("language", prop.getValue());
+
+ // check lang alt
+ prop = xmp.getLocalizedText(XMPConst.NS_DC, "title", null, XMPConst.X_DEFAULT);
+ assertNotNull(prop);
+ assertEquals("title", prop.getValue());
+
+ // OOXML one is not, the namespace has also not been registiered as the converter has not been used
+ XMPMetaFactory.getSchemaRegistry().registerNamespace(OfficeOpenXMLCore.NAMESPACE_URI, OfficeOpenXMLCore.PREFIX);
+ prop = xmp.getProperty(OfficeOpenXMLCore.NAMESPACE_URI, "lastModifiedBy");
+ assertNull(prop);
+ }
+
+
+ @Test
+ public void convert_genericMetadataAllQualified_allConverted() throws XMPException, TikaException
+ {
+ // simple property
+ tikaMetadata.set(TikaCoreProperties.FORMAT, GENERIC_MIMETYPE);
+ // language alternative
+ tikaMetadata.set(TikaCoreProperties.TITLE, "title");
+ // array
+ tikaMetadata.set(TikaCoreProperties.SUBJECT, new String[] {"keyword1", "keyword2"});
+
+
+ XMPMeta xmp = TikaToXMP.convert(tikaMetadata, null);
+
+ // check simple property
+ XMPProperty prop = xmp.getProperty(XMPConst.NS_DC, "format");
+ assertNotNull(prop);
+ assertEquals(GENERIC_MIMETYPE, prop.getValue());
+
+ // check lang alt
+ prop = xmp.getLocalizedText(XMPConst.NS_DC, "title", null, XMPConst.X_DEFAULT);
+ assertNotNull(prop);
+ assertEquals("title", prop.getValue());
+
+ // check array
+ prop = xmp.getArrayItem(XMPConst.NS_DC, "subject", 1);
+ assertNotNull(prop);
+ assertEquals("keyword1", prop.getValue());
+ prop = xmp.getArrayItem(XMPConst.NS_DC, "subject", 2);
+ assertNotNull(prop);
+ assertEquals("keyword2", prop.getValue());
+ }
+
+
+ @Test
+ public void convert_wrongGenericMetadata_notConverted() throws XMPException, TikaException
+ {
+ // unknown prefix
+ tikaMetadata.set("unknown:key", "unknownPrefixValue");
+ // not qualified key
+ tikaMetadata.set("wrongKey", "wrongKeyValue");
+
+ XMPMeta xmp = TikaToXMP.convert(tikaMetadata, null);
+
+ // XMP is empty
+ XMPIterator iter = xmp.iterator();
+ assertFalse(iter.hasNext());
+ }
+
+ @Test(expected=IllegalArgumentException.class)
+ public void convert_nullInput_throw() throws TikaException
+ {
+ TikaToXMP.convert(null);
+ }
+
+ @Test
+ public void isConverterAvailable_availableMime_true()
+ {
+ assertTrue(TikaToXMP.isConverterAvailable(OOXML_MIMETYPE));
+ }
+
+ @Test
+ public void isConverterAvailable_noAvailableMime_false()
+ {
+ assertFalse(TikaToXMP.isConverterAvailable(GENERIC_MIMETYPE));
+ }
+
+ @Test
+ public void isConverterAvailable_nullInput_false()
+ {
+ assertFalse(TikaToXMP.isConverterAvailable(null));
+ }
+
+ @Test
+ public void getConverter_ConverterAvailable_class() throws TikaException
+ {
+ ITikaToXMPConverter converter = TikaToXMP.getConverter(OOXML_MIMETYPE);
+ assertNotNull(converter);
+ assertTrue(converter instanceof MSOfficeXMLConverter);
+ }
+
+ @Test
+ public void getConverter_noConverterAvailable_null() throws TikaException
+ {
+ ITikaToXMPConverter converter = TikaToXMP.getConverter(GENERIC_MIMETYPE);
+ assertNull(converter);
+ }
+
+ @Test(expected=IllegalArgumentException.class)
+ public void getConverter_nullInput_throw() throws TikaException
+ {
+ TikaToXMP.getConverter(null);
+ }
+}
Index: tika-xmp/src/test/java/org/apache/tika/xmp/XMPMetadataTest.java
===================================================================
--- tika-xmp/src/test/java/org/apache/tika/xmp/XMPMetadataTest.java (revision 0)
+++ tika-xmp/src/test/java/org/apache/tika/xmp/XMPMetadataTest.java (revision 0)
@@ -0,0 +1,283 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * IPTC Metadata Descriptions taken from the IPTC Photo Metadata (July 2010)
+ * standard. These parts Copyright 2010 International Press Telecommunications
+ * Council.
+ */
+package org.apache.tika.xmp;
+
+import static org.junit.Assert.*;
+
+import java.util.Date;
+import java.util.Properties;
+
+import org.apache.tika.exception.TikaException;
+import org.apache.tika.metadata.Metadata;
+import org.apache.tika.metadata.Property;
+import org.apache.tika.metadata.PropertyTypeException;
+import org.apache.tika.metadata.TikaCoreProperties;
+import org.apache.tika.metadata.XMPRights;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.adobe.xmp.XMPConst;
+import com.adobe.xmp.XMPException;
+import com.adobe.xmp.XMPMeta;
+import com.adobe.xmp.XMPUtils;
+import com.adobe.xmp.properties.XMPProperty;
+
+public class XMPMetadataTest
+{
+ private Metadata tikaMetadata;
+ private XMPMetadata xmpMeta;
+
+ private static final String GENERIC_MIMETYPE = "generic/mimetype";
+
+ // --- SETUP ---
+ @Before
+ public void setUp() throws Exception
+ {
+ xmpMeta = new XMPMetadata();
+ tikaMetadata = new Metadata();
+ setupMetadata(tikaMetadata);
+ }
+
+ private void setupMetadata(Metadata metadata)
+ {
+ // simple property
+ metadata.set(TikaCoreProperties.FORMAT, GENERIC_MIMETYPE);
+ // language alternative
+ metadata.set(TikaCoreProperties.TITLE, "title");
+ // array
+ metadata.set(TikaCoreProperties.SUBJECT, new String[] {"keyword1", "keyword2"});
+ // date
+ metadata.set(TikaCoreProperties.MODIFIED,"2001-01-01T01:01" );
+ // int simple property
+ metadata.set(Property.internalInteger("xmp:Integer"), "2");
+ }
+
+ // --- HELPER ---
+ private void checkArrayValues(String[] values, String baseValue)
+ {
+ int i = 1;
+ for(String value : values)
+ {
+ assertEquals(baseValue+i, value);
+ i++;
+ }
+ }
+
+
+ // --- TESTS ---
+ @Test
+ public void process_genericConversion_ok() throws TikaException, XMPException
+ {
+ xmpMeta.process(tikaMetadata, GENERIC_MIMETYPE);
+
+ XMPMeta xmp = xmpMeta.getXMPData();
+
+ // check simple property
+ XMPProperty prop = xmp.getProperty(XMPConst.NS_DC, "format");
+ assertNotNull(prop);
+ assertEquals(GENERIC_MIMETYPE, prop.getValue());
+
+ // check lang alt
+ prop = xmp.getLocalizedText(XMPConst.NS_DC, "title", null, XMPConst.X_DEFAULT);
+ assertNotNull(prop);
+ assertEquals("title", prop.getValue());
+
+ // check array
+ prop = xmp.getArrayItem(XMPConst.NS_DC, "subject", 1);
+ assertNotNull(prop);
+ assertEquals("keyword1", prop.getValue());
+ prop = xmp.getArrayItem(XMPConst.NS_DC, "subject", 2);
+ assertNotNull(prop);
+ assertEquals("keyword2", prop.getValue());
+ }
+
+ @Test
+ public void isMultiValued_multiProp_true() throws TikaException
+ {
+ xmpMeta.process(tikaMetadata);
+
+ assertTrue(xmpMeta.isMultiValued(TikaCoreProperties.SUBJECT));
+ }
+
+ @Test
+ public void isMultiValued_simpleProp_false() throws TikaException
+ {
+ xmpMeta.process(tikaMetadata);
+
+ assertFalse(xmpMeta.isMultiValued(TikaCoreProperties.FORMAT));
+ }
+
+ @Test
+ public void get_simpleProp_valueReturned() throws TikaException
+ {
+ xmpMeta.process(tikaMetadata);
+
+ assertEquals(GENERIC_MIMETYPE, xmpMeta.get(TikaCoreProperties.FORMAT));
+ }
+
+ @Test
+ public void get_arrayProp_firstValueReturned() throws TikaException
+ {
+ xmpMeta.process(tikaMetadata);
+
+ assertEquals("keyword1", xmpMeta.get(TikaCoreProperties.SUBJECT));
+ }
+
+ @Test
+ public void get_notExistingProp_null() throws TikaException
+ {
+ assertNull(xmpMeta.get(TikaCoreProperties.FORMAT));
+ }
+
+ @Test(expected=PropertyTypeException.class)
+ public void get_nullInput_throw()
+ {
+ String notInitialized = null;
+ xmpMeta.get(notInitialized);
+ }
+
+ @Test(expected=PropertyTypeException.class)
+ public void get_notQualifiedKey_throw()
+ {
+ xmpMeta.get("wrongKey");
+ }
+
+ @Test(expected=PropertyTypeException.class)
+ public void get_unknownPrefixKey_throw()
+ {
+ xmpMeta.get("unknown:key");
+ }
+
+ @Test
+ public void getInt_IntegerProperty_valueReturned() throws TikaException
+ {
+ xmpMeta.process(tikaMetadata);
+
+ assertEquals(new Integer(2), xmpMeta.getInt(Property.get("xmp:Integer")));
+ }
+
+ @Test
+ public void getDate_DateProperty_valueReturned() throws TikaException, XMPException
+ {
+ xmpMeta.process(tikaMetadata);
+
+ Date date = XMPUtils.convertToDate("2001-01-01T01:01").getCalendar().getTime();
+ assertTrue(date.equals(xmpMeta.getDate(TikaCoreProperties.MODIFIED)));
+ }
+
+ @Test
+ public void getValues_arrayProperty_allElementsReturned() throws TikaException
+ {
+ xmpMeta.process(tikaMetadata);
+
+ String[] values = xmpMeta.getValues(TikaCoreProperties.SUBJECT);
+ assertEquals(2, values.length);
+
+ checkArrayValues(values, "keyword");
+ }
+
+ @Test
+ public void testSetAll()
+ {
+ Properties props = new Properties();
+ props.put(TikaCoreProperties.FORMAT.getName(), "format");
+ props.put(TikaCoreProperties.SUBJECT.getName(), "keyword");
+
+ xmpMeta.setAll(props);
+
+ assertEquals("format", xmpMeta.get(TikaCoreProperties.FORMAT));
+
+ String[] values = xmpMeta.getValues(TikaCoreProperties.SUBJECT);
+ assertEquals(1, values.length);
+
+ assertEquals("keyword", values[0]);
+ }
+
+ @Test
+ public void set_simpleProp_ok()
+ {
+ xmpMeta.set(TikaCoreProperties.FORMAT, GENERIC_MIMETYPE);
+
+ assertEquals(GENERIC_MIMETYPE, xmpMeta.get(TikaCoreProperties.FORMAT));
+ }
+
+ @Test(expected=PropertyTypeException.class)
+ public void set_nullInput_throw()
+ {
+ String notInitialized = null;
+ xmpMeta.set(notInitialized,"value");
+ }
+
+ @Test(expected=PropertyTypeException.class)
+ public void set_notQualifiedKey_throw()
+ {
+ xmpMeta.set("wrongKey","value");
+ }
+
+ @Test(expected=PropertyTypeException.class)
+ public void set_unknownPrefixKey_throw()
+ {
+ xmpMeta.set("unknown:key","value");
+ }
+
+ @Test
+ public void set_arrayProperty_ok()
+ {
+ xmpMeta.set(TikaCoreProperties.SUBJECT, new String[] {"keyword1", "keyword2"});
+
+ String[] values = xmpMeta.getValues(TikaCoreProperties.SUBJECT);
+ assertEquals(2, values.length);
+
+ checkArrayValues(values, "keyword");
+ }
+
+ @Test(expected=PropertyTypeException.class)
+ public void set_simplePropWithMultipleValues_throw()
+ {
+ xmpMeta.set(TikaCoreProperties.FORMAT,new String[] {"value1", "value2"});
+ }
+
+
+ @Test
+ public void remove_existingProperty_propertyRemoved() throws TikaException
+ {
+ xmpMeta.process(tikaMetadata);
+
+ assertNotNull(xmpMeta.get(TikaCoreProperties.FORMAT));
+
+ xmpMeta.remove(TikaCoreProperties.FORMAT);
+
+ assertNull(xmpMeta.get(TikaCoreProperties.FORMAT));
+ }
+
+ @Test
+ public void size_numberOfNamespacesReturned() throws TikaException
+ {
+ xmpMeta.process(tikaMetadata);
+
+ assertEquals(2, xmpMeta.size());
+
+ xmpMeta.set(XMPRights.OWNER, "owner");
+
+ assertEquals(3, xmpMeta.size());
+ }
+
+}
Index: tika-xmp/src/main/java/org/apache/tika/xmp/convert/TikaToXMP.java
===================================================================
--- tika-xmp/src/main/java/org/apache/tika/xmp/convert/TikaToXMP.java (revision 0)
+++ tika-xmp/src/main/java/org/apache/tika/xmp/convert/TikaToXMP.java (revision 0)
@@ -0,0 +1,225 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * IPTC Metadata Descriptions taken from the IPTC Photo Metadata (July 2010)
+ * standard. These parts Copyright 2010 International Press Telecommunications
+ * Council.
+ */
+package org.apache.tika.xmp.convert;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.tika.exception.TikaException;
+import org.apache.tika.metadata.Metadata;
+import org.apache.tika.metadata.TikaCoreProperties;
+import org.apache.tika.mime.MediaType;
+import org.apache.tika.parser.ParseContext;
+import org.apache.tika.parser.microsoft.OfficeParser;
+import org.apache.tika.parser.microsoft.ooxml.OOXMLParser;
+import org.apache.tika.parser.odf.OpenDocumentParser;
+import org.apache.tika.parser.rtf.RTFParser;
+
+import com.adobe.xmp.XMPException;
+import com.adobe.xmp.XMPMeta;
+import com.adobe.xmp.XMPMetaFactory;
+
+public class TikaToXMP
+{
+ /**
+ * Map from mimetype to converter class
+ * Must only be accessed through getConverterMap
+ */
+ private static MapNamespace information with XMPCore.
+ * Any already registered namespace is not registered again.
+ *
+ * @param namespaces the list of namespaces to be registered
+ * @throws TikaException in case a namespace oculd not be registered
+ */
+ protected void registerNamespaces(SetMetadata to XMP converters
+ */
+public interface ITikaToXMPConverter
+{
+ /**
+ * Converts a Tika {@link Metadata}-object into an {@link XMPMeta} containing
+ * the useful properties.
+ *
+ * @param metadata a Tika Metadata object
+ * @return Returns an XMPMeta object.
+ * @throws XMPException If an error occurs during the creation of the XMP object.
+ */
+ XMPMeta process(Metadata metadata) throws XMPException;
+}
Index: tika-xmp/src/main/java/org/apache/tika/xmp/convert/RTFConverter.java
===================================================================
--- tika-xmp/src/main/java/org/apache/tika/xmp/convert/RTFConverter.java (revision 0)
+++ tika-xmp/src/main/java/org/apache/tika/xmp/convert/RTFConverter.java (revision 0)
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * IPTC Metadata Descriptions taken from the IPTC Photo Metadata (July 2010)
+ * standard. These parts Copyright 2010 International Press Telecommunications
+ * Council.
+ */
+package org.apache.tika.xmp.convert;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.apache.tika.exception.TikaException;
+import org.apache.tika.metadata.ClimateForcast;
+import org.apache.tika.metadata.HttpHeaders;
+import org.apache.tika.metadata.Metadata;
+import org.apache.tika.metadata.OfficeOpenXMLCore;
+import org.apache.tika.metadata.OfficeOpenXMLExtended;
+import org.apache.tika.metadata.TikaCoreProperties;
+
+import com.adobe.xmp.XMPConst;
+import com.adobe.xmp.XMPException;
+import com.adobe.xmp.XMPMeta;
+import com.adobe.xmp.options.PropertyOptions;
+
+/**
+ * Tika to XMP mapping for the RTF format.
+ */
+public class RTFConverter extends AbstractConverter
+{
+ protected static final SetMetadata map
+ * to XMP namespaces. only those properties will be cnverted where the name contains
+ * a prefix and this prefix correlates with a "known" prefix for a standard namespace.
+ * For example "dc:title" would be mapped to the "title" property in the DublinCore namespace.
+ */
+public class GenericConverter extends AbstractConverter
+{
+ public GenericConverter() throws TikaException
+ {
+ super();
+ }
+
+ @Override
+ public XMPMeta process(Metadata metadata) throws XMPException
+ {
+ setMetadata(metadata);
+ XMPSchemaRegistry registry = XMPMetaFactory.getSchemaRegistry();
+
+ String [] keys = metadata.names();
+ for( String key : keys)
+ {
+ String[] keyParts = key.split(Metadata.NAMESPACE_PREFIX_DELIMITER);
+ if (keyParts.length > 0 && keyParts.length <= 2)
+ {
+ String uri = registry.getNamespaceURI(keyParts[0]);
+
+ if( uri != null )
+ {
+ // Tika properties where the type differs from the XMP specification
+ if( key.equals(DublinCore.TITLE.getName()) ||
+ key.equals(DublinCore.DESCRIPTION.getName()) ||
+ key.equals(XMPRights.USAGE_TERMS.getName()) )
+ {
+ createLangAltProperty(key, uri, keyParts[1]);
+ }
+ else if( key.equals(DublinCore.CREATOR.getName()) )
+ {
+ createArrayProperty(key, uri, keyParts[1], PropertyOptions.ARRAY_ORDERED);
+ }
+ else
+ {
+ PropertyType type = Property.getPropertyType(key);
+ if( type != null )
+ {
+ switch( type )
+ {
+ case SIMPLE:
+ createProperty(key, uri, keyParts[1]);
+ break;
+ case BAG:
+ createArrayProperty(key, uri, keyParts[1], PropertyOptions.ARRAY);
+ break;
+ case SEQ:
+ createArrayProperty(key, uri, keyParts[1], PropertyOptions.ARRAY_ORDERED);
+ break;
+ case ALT:
+ createArrayProperty(key, uri, keyParts[1], PropertyOptions.ARRAY_ALTERNATE);
+ break;
+ // TODO Add support for structs and lang-alts, but those types are currently not used in Tika
+ }
+ }
+ }
+ }
+ } // ignore keys that are not qualified
+ }
+
+ return getXMPMeta();
+ }
+
+ @Override
+ public Set+ * Note: No checking is presently done on either the URI or the prefix. + * + * @param namespaceURI + * The URI for the namespace. Must be a valid XML URI. + * @param suggestedPrefix + * The suggested prefix to be used if the URI is not yet + * registered. Must be a valid XML name. + * @return Returns the registered prefix for this URI, is equal to the + * suggestedPrefix if the namespace hasn't been registered before, + * otherwise the existing prefix. + * @throws XMPException If the parameters are not accordingly set + */ + public static String registerNamespace(String namespaceURI, String suggestedPrefix) throws XMPException + { + return registry.registerNamespace(namespaceURI, suggestedPrefix); + } + + /** + * Obtain the prefix for a registered namespace URI. + *
+ * It is not an error if the namespace URI is not registered. + * + * @param namespaceURI + * The URI for the namespace. Must not be null or the empty + * string. + * @return Returns the prefix registered for this namespace URI or null. + */ + public static String getNamespacePrefix(String namespaceURI) + { + return registry.getNamespacePrefix(namespaceURI); + } + + + /** + * Obtain the URI for a registered namespace prefix. + *
+ * It is not an error if the namespace prefix is not registered.
+ *
+ * @param namespacePrefix
+ * The prefix for the namespace. Must not be null or the empty
+ * string.
+ * @return Returns the URI registered for this prefix or null.
+ */
+ public static String getNamespaceURI(String namespacePrefix)
+ {
+ return registry.getNamespaceURI(namespacePrefix);
+ }
+
+
+ /**
+ * @return Returns the registered prefix/namespace-pairs as map, where the keys are the
+ * namespaces and the values are the prefixes.
+ */
+ @SuppressWarnings("unchecked")
+ public static Map
+ * Does nothing if the URI is not registered, or if the namespaceURI
+ * parameter is null or the empty string.
+ *
+ * Note: Not yet implemented.
+ *
+ * @param namespaceURI
+ * The URI for the namespace.
+ */
+ public static void deleteNamespace(String namespaceURI)
+ {
+ registry.deleteNamespace(namespaceURI);
+ }
+
+
+ // === Metadata API === //
+ /**
+ * @see org.apache.tika.xmp.XMPMetadata#isMultiValued(java.lang.String)
+ */
+ @Override
+ public boolean isMultiValued(Property property)
+ {
+ return this.isMultiValued(property.getName());
+ }
+
+ /**
+ * Checks if the named property is an array.
+ * @see org.apache.tika.metadata.Metadata#isMultiValued(java.lang.String)
+ */
+ @Override
+ public boolean isMultiValued(String name)
+ {
+ checkKey(name);
+
+ String[] keyParts = splitKey(name);
+
+ String ns = registry.getNamespaceURI(keyParts[0]);
+ if( ns != null )
+ {
+ try
+ {
+ XMPProperty prop = xmpData.getProperty(ns, keyParts[1]);
+
+ return prop.getOptions().isArray();
+ }
+ catch (XMPException e)
+ {
+ // Ignore
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * For XMP it is not clear what that API should return, therefor not implemented
+ */
+ @Override
+ public String[] names()
+ {
+ throw new UnsupportedOperationException("Not implemented");
+ }
+
+ /**
+ * Returns the value of a simple property or the first one of an array.
+ * The given name must contain a namespace prefix of a registered namespace.
+ *
+ * @see org.apache.tika.metadata.Metadata#get(java.lang.String)
+ */
+ @Override
+ public String get(String name)
+ {
+ checkKey(name);
+
+ String value = null;
+ String[] keyParts = splitKey(name);
+
+ String ns = registry.getNamespaceURI(keyParts[0]);
+ if( ns != null )
+ {
+ try
+ {
+ XMPProperty prop = xmpData.getProperty(ns, keyParts[1]);
+
+ if( prop != null && prop.getOptions().isSimple() )
+ {
+ value = prop.getValue();
+ }
+ else if( prop != null && prop.getOptions().isArray() )
+ {
+ prop = xmpData.getArrayItem(ns, keyParts[1], 1);
+ value = prop.getValue();
+ }
+ // in all other cases, null is returned
+ }
+ catch (XMPException e)
+ {
+ // Ignore
+ }
+ }
+
+ return value;
+ }
+
+ /**
+ * @see org.apache.tika.xmp.XMPMetadata#get(java.lang.String)
+ */
+ @Override
+ public String get(Property property) {
+ return this.get(property.getName());
+ }
+
+ /**
+ * @see org.apache.tika.xmp.XMPMetadata#get(java.lang.String)
+ */
+ @Override
+ public Integer getInt(Property property)
+ {
+ Integer result = null;
+
+ try
+ {
+ result = new Integer(XMPUtils.convertToInteger(this.get(property.getName())));
+ }
+ catch (XMPException e)
+ {
+ //Ignore
+ }
+
+ return result;
+ }
+
+ /**
+ * @see org.apache.tika.xmp.XMPMetadata#get(java.lang.String)
+ */
+ @Override
+ public Date getDate(Property property)
+ {
+ Date result = null;
+
+ try
+ {
+ XMPDateTime xmpDate = XMPUtils.convertToDate(this.get(property.getName()));
+ if (xmpDate != null)
+ {
+ Calendar cal = xmpDate.getCalendar();
+ // TODO Timezone is currently lost
+ // need another solution that preserves the timezone
+ result = cal.getTime();
+ }
+ }
+ catch (XMPException e)
+ {
+ //Ignore
+ }
+
+ return result;
+ }
+
+ /**
+ * @see org.apache.tika.xmp.XMPMetadata#getValues(java.lang.String)
+ */
+ @Override
+ public String[] getValues(Property property)
+ {
+ return this.getValues(property.getName());
+ }
+
+ /**
+ * Returns the value of a simple property or all if the property is an array and the elements are of simple type.
+ * The given name must contain a namespace prefix of a registered namespace.
+ * @see org.apache.tika.metadata.Metadata#getValues(java.lang.String)
+ */
+ @Override
+ public String[] getValues(String name) {
+ checkKey(name);
+
+ String[] value = null;
+ String[] keyParts = splitKey(name);
+
+ String ns = registry.getNamespaceURI(keyParts[0]);
+ if( ns != null )
+ {
+ try
+ {
+ XMPProperty prop = xmpData.getProperty(ns, keyParts[1]);
+
+ if( prop != null && prop.getOptions().isSimple() )
+ {
+ value = new String[1];
+ value[0] = prop.getValue();
+ }
+ else if( prop != null && prop.getOptions().isArray() )
+ {
+ int size = xmpData.countArrayItems(ns, keyParts[1]);
+ value = new String[size];
+ boolean onlySimpleChildren = true;
+
+ for( int i = 0 ; i < size && onlySimpleChildren ; i++)
+ {
+ prop = xmpData.getArrayItem(ns, keyParts[1], i+1);
+ if( prop.getOptions().isSimple() )
+ {
+ value[i] = prop.getValue();
+ }
+ else
+ {
+ onlySimpleChildren = false;
+ }
+ }
+
+ if( ! onlySimpleChildren )
+ {
+ value = null;
+ }
+ }
+ // in all other cases, null is returned
+ }
+ catch (XMPException e)
+ {
+ // Ignore
+ }
+ }
+
+ return value;
+ }
+
+
+
+ /**
+ * As this API could only possibly work for simple properties in XMP,
+ * it just calls the set method, which replaces any existing value
+ * @see org.apache.tika.metadata.Metadata#add(java.lang.String, java.lang.String)
+ */
+ @Override
+ public void add(String name, String value)
+ {
+ set(name, value);
+ }
+
+ /**
+ * Sets the given property. If the property already exists, it is overwritten.
+ * Only simple properties that use a registered prefix are stored in the XMP.
+ *
+ * @see org.apache.tika.metadata.Metadata#set(java.lang.String, java.lang.String)
+ */
+ @Override
+ public void set(String name, String value)
+ {
+ checkKey(name);
+
+ String[] keyParts = splitKey(name);
+
+ String ns = registry.getNamespaceURI(keyParts[0]);
+ if( ns != null )
+ {
+ try
+ {
+ xmpData.setProperty(ns, keyParts[1], value);
+ }
+ catch (XMPException e)
+ {
+ // Ignore
+ }
+ }
+ }
+
+ /**
+ * @see org.apache.tika.xmp.XMPMetadata#set(java.lang.String, java.lang.String)
+ */
+ @Override
+ public void set(Property property, String value)
+ {
+ this.set(property.getName(), value);
+ }
+
+ /**
+ * @see org.apache.tika.xmp.XMPMetadata#set(java.lang.String, java.lang.String)
+ */
+ @Override
+ public void set(Property property, int value)
+ {
+ // Can reuse the checks from the base class implementation which will call
+ // the set(String, String) method in the end
+ super.set(property, value);
+ }
+
+ /**
+ * @see org.apache.tika.xmp.XMPMetadata#set(java.lang.String, java.lang.String)
+ */
+ @Override
+ public void set(Property property, double value)
+ {
+ super.set(property, value);
+ }
+
+ /**
+ * @see org.apache.tika.xmp.XMPMetadata#set(java.lang.String, java.lang.String)
+ */
+ @Override
+ public void set(Property property, Date date)
+ {
+ super.set(property, date);
+ }
+
+ /**
+ * Sets array properties. If the property already exists, it is overwritten.
+ * Only array properties that use a registered prefix are stored in the XMP.
+ * @see org.apache.tika.metadata.Metadata#set(org.apache.tika.metadata.Property, java.lang.String[])
+ */
+ @Override
+ public void set(Property property, String[] values)
+ {
+ checkKey(property.getName());
+
+ if( ! property.isMultiValuePermitted() )
+ {
+ throw new PropertyTypeException("Property is not of an array type");
+ }
+
+ String[] keyParts = splitKey(property.getName());
+
+ String ns = registry.getNamespaceURI(keyParts[0]);
+ if( ns != null )
+ {
+ try
+ {
+ int arrayType = tikaToXMPArrayType(property.getPrimaryProperty().getPropertyType());
+ xmpData.setProperty(ns, keyParts[1], null, new PropertyOptions(arrayType));
+
+ for( String value : values )
+ {
+ xmpData.appendArrayItem(ns, keyParts[1], value);
+ }
+ }
+ catch (XMPException e)
+ {
+ // Ignore
+ }
+ }
+ }
+
+ /**
+ * It will set all simple and array properties that have QName keys in registered namespaces.
+ * @see org.apache.tika.metadata.Metadata#setAll(java.util.Properties)
+ */
+ @Override
+ public void setAll(Properties properties)
+ {
+ @SuppressWarnings("unchecked")
+ Enumeration