DtoMetadata.java

/*
 * DtoMetadata.java
 *
 * Version: $Revision: 3984 $
 *
 * Date: $Date: 2009-06-29 22:33:25 -0400 (Mon, 29 Jun 2009) $
 *
 * Copyright (c) 2002-2009, The DSpace Foundation.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * - Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * - Neither the name of the DSpace Foundation nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */
package org.dspace.app.itemupdate;

import java.text.ParseException;
import org.dspace.content.Item;

/**
 *   A data transfer object class enhancement of org.dspace.content.DCValue, which is deprecated
 *   Name intended to not conflict with DSpace API classes for similar concepts but not usable in this context
 *   
 *   Adds some utility methods
 *   
 *   Really not at all general enough but supports Dublin Core and the compound form notation <schema>.<element>[.<qualifier>]
 *   
 *   Does not support wildcard for qualifier
 * 
 *
 */
class DtoMetadata 
{
	final String schema;   
	final String element;
	final String qualifier;
	final String language;
	final String value;
	
	private DtoMetadata(String schema, String element, String qualifier, String language, String value) 
	{
		this.schema = schema;
		this.element = element;
		this.qualifier = qualifier;
		this.language = language;
		this.value = value;
	}
	
	/**
	 *  Factory method
	 *  
	 *  
	 * @param schema     not null, not empty -  'dc' is the standard case
	 * @param element    not null, not empty
	 * @param qualifier  null; don't allow empty string or * indicating 'any'
	 * @param language   null or empty
	 * @param value      
	 * @return DtoMetadata object
	 */
	public static DtoMetadata create(String schema,
			    String element,
			    String qualifier,
			    String language,
			    String value)
	throws IllegalArgumentException
    {
		if ((qualifier != null) &&  (qualifier.equals(Item.ANY) || qualifier.equals("")))
		{
			throw new IllegalArgumentException("Invalid qualifier: " + qualifier);
		}
		return new DtoMetadata(schema, element, qualifier, language, value);
    }

	/**
	 *   Factory method to create metadata object
	 *   
	 * 
	 * @param compoundForm   of the form <schema>.<element>[.<qualifier>]
	 * @param language   null or empty
	 * @param value      
	 */
	public static DtoMetadata create(String compoundForm, String language, String value)
	throws ParseException, IllegalArgumentException  
    {
		String[] ar = MetadataUtilities.parseCompoundForm(compoundForm);
		
		String qual = null;
		if (ar.length > 2)
		{
    		qual = ar[2];
		}
		
		return create(ar[0], ar[1], qual, language, value);
    }

	/**
	 *   Determine if this metadata field matches the specified type:
	 *    schema.element or schema.element.qualifier
	 *    
	 * 
	 * @param compoundForm   of the form <schema>.<element>[.<qualifier>|.*]
	 * @param wildcard       allow wildcards in compoundForm param
	 * @return whether matches
	 */
	public boolean matches(String compoundForm, boolean wildcard)
	{
		String[] ar = compoundForm.split("\\s*\\.\\s*"); //MetadataUtilities.parseCompoundForm(compoundForm);
		
		if ((ar.length < 2) || (ar.length > 3))
		{
			return false;
		}
		
		if (!this.schema.equals(ar[0]) || !this.element.equals(ar[1]))
		{
			return false;
		}
		
		if (ar.length == 2)
		{
			if (this.qualifier != null)
			{
				return false;
			}
		}
		
		if (ar.length == 3)	
		{
			if (this.qualifier == null)
			{
				return false;
			}
			if (wildcard && ar[2].equals(Item.ANY))
			{
				return true;
			}
			if (!this.qualifier.equals(ar[2]))
			{
				return false;
			}
		}
		return true;		
	}
	
	public String toString()
	{
		String s =  "\tSchema: " + schema + " Element: " + element;
		if (qualifier != null)
		{
			s+= " Qualifier: " + qualifier;
		}
		s+= " Language: " + ((language == null) ? "[null]" : language);
        s += " Value: " + value;
        
        return s;
	}
	
	public String getValue()
	{
		return value;
	}
		
}