EDIT

cdmlib-commons/src/main/java/eu/etaxonomy/cdm/common/DOI.java -text

cdmlib-commons/src/main/java/eu/etaxonomy/cdm/common/UrlUtf8Coder.java -text

cdmlib-commons/src/test/java/eu/etaxonomy/cdm/common/DoiTest.java -text

cdmlib-model/src/main/java/eu/etaxonomy/cdm/hibernate/DOIUserType.java -text

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.common;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

/**

 * A class for handling DOIs (http://www.doi.org).

 * It offers parsing and formatting functionality as well as validation.

 * A {@link DOI} object can only be created by syntactic valid input.

 * It internally stores a doi 2 strings, the first one being the registrant number

 * (including sub numbers), the second being the suffix.

 * 

 * 

 * @author a.mueller

 * @created 2013-09-04

 */

public final class DOI implements java.io.Serializable{

	/**

     * Explicit serialVersionUID for interoperability.

     */

	private static final long serialVersionUID = -3871039785359980553L;

	/**

	 * The default public DOI proxy server

	 */

	public static final String HTTP_DOI_ORG = "http://doi.org/";

	/**

	 * The former default public DOI proxy server, still supported but no longer preferred.

	 * @see #HTTP_DOI_ORG

	 */

	public static final String HTTP_OLD_DOI_ORG = "http://dx.doi.org/";

    private volatile transient int hashCode = -1;	// Zero ==> undefined

	//http://www.doi.org/doi_handbook/2_Numbering.html#2.2.1

//	prefix + suffix, no defined length, case-insensitive, any printable characters

//********************************* VARIABLES *************************************/	

	/**

	 * The directory indicator for DOIs as registered at 

	 */

	public static final String DIRECTORY_INDICATOR = "10";

	private String prefix_registrantCode;

	private String suffix;

// ***************************** FACTORY METHODS ***************************************/

	public static DOI fromString(String doi) throws IllegalArgumentException{

		return new DOI(doi);

	}

	public static DOI fromRegistrantCodeAndSuffix(String registrantCode, String suffix) throws IllegalArgumentException{

		return new DOI(registrantCode, suffix);

	}

// ******************************* CONSTRUCTOR ************************************/	

    /**

     * Creates a doi by its registrantCode and its suffix

     * @param registrantCode the registrant code, the is the part following the directoryIndicator "10." 

     * 	and preceding the first forward slash (followed by the suffix)

     * @param suffix the suffix is the part of the DOI following the first forward slash. It is provided 

     * by the registrant

     */

    private DOI(String registrantCode, String suffix) {

    	//preliminary until prefix_registrantCode and suffix validation is implemented

		this("10." + registrantCode + "/" + suffix);

		//use only after validation of both parts

//		this.prefix_registrantCode = registrantCode;

//		this.suffix = suffix;

	}

    private DOI(String doiString) {

		super();

		parseDoiString(doiString);

	}

//************************************ GETTER ***********************************/    

	public String getPrefix() {

		return makePrefix();

	}

	public String getPrefix_registrantCode() {

		return prefix_registrantCode;

	}

	public String getSuffix() {

		return suffix;

	}

	private static Pattern doiPattern = Pattern.compile("^doi:\\s*", Pattern.CASE_INSENSITIVE); 

// ********************************************* PARSER *******************************/

	private void parseDoiString(String doi){

		boolean isUrn = false;

		if (StringUtils.isBlank(doi)){

			throw new IllegalArgumentException("Doi string must not be null or blank");

		}

		doi = doi.trim();

		if (doi.startsWith("https") ){

			doi = doi.replaceFirst("https", "http").trim();

		}

		Matcher matcher = doiPattern.matcher(doi);

		if (matcher.find()){

			doi = matcher.replaceFirst("").trim();

		}

		//replace URI prefix

		if (doi.startsWith(HTTP_DOI_ORG)){

			doi = doi.replaceFirst(HTTP_DOI_ORG,"");

		}else if (doi.startsWith(HTTP_OLD_DOI_ORG)){

			doi = doi.replaceFirst(HTTP_OLD_DOI_ORG,"");

		}

		//handle URN prefix

		if (doi.startsWith("urn:doi:")){

			doi = doi.replaceFirst("urn:doi:","");

			isUrn = true;

		}

		//now we should have the pure doi

		if (doi.length() > 1000){

			//for persistence reason we currently restrict the length of DOIs to 1000

			throw new IllegalArgumentException("DOIs may have a maximum length of 1000 in the CDM.");

		}

		if (! doi.startsWith("10.")){

			throw new IllegalArgumentException("DOI not parsable. DOI must start with 10. or an URI or URN prefix ");

		}

		doi = doi.substring(3);

		String sep = isUrn? ":" : "/";

//		registrant

		String registrant = doi.split(sep)[0];

		if (!registrant.matches("[0-9]{2,}(?:[.][0-9]+)*")){   //per definition the number of digits may also be 1, however the lowest known number is 3 so we may be on the safe side here 

			String message = "Invalid prefix '10.%s'";

			throw new IllegalArgumentException(String.format(message, registrant));

		}

		//suffix

		String suffix = doi.replaceFirst(registrant + sep,"");

		if (! suffix.matches("\\p{Print}+")){

			String message = "Suffix should only include printable characters";

			throw new IllegalArgumentException(message);

		}

		if (isUrn){

			//TODO do some other replacements according to http://www.doi.org/doi_handbook/2_Numbering.html#2.6.3

			//e.g. slash becomes : in URN

			//TODO do we need this also for other URIs? According to http://www.doi.org/doi_handbook/2_Numbering.html#2.6 it is only required for URNs

			suffix = UrlUtf8Coder.unescape(suffix);

		}

		//success

		this.prefix_registrantCode = registrant;

		this.suffix = suffix;

	}

	private String makePrefix(){

		return DIRECTORY_INDICATOR + "." + this.prefix_registrantCode;

	}

	private String makeDoi(){

		return makePrefix() + "/" + this.suffix;

	}

	public String asURI(){

		return HTTP_DOI_ORG + makePrefix() + "/" + uriEncodedSuffix();

	}

	private String uriEncodedSuffix() {

		String result = UrlUtf8Coder.encode(this.suffix);

		return result;

	}

//************************************************* toString/equals /hashCode *********************/	

	@Override

	public int hashCode() {

		if (hashCode == -1) {

            hashCode = 31 * prefix_registrantCode.toUpperCase().hashCode() + suffix.toUpperCase().hashCode();

        }

        return hashCode;

	}

	@Override

	public boolean equals(Object obj) {

		if (obj instanceof DOI){

			DOI doi = (DOI)obj;

			if (this.prefix_registrantCode.toUpperCase().equals(doi.prefix_registrantCode.toUpperCase()) &&

					this.suffix.toUpperCase().equals(doi.suffix.toUpperCase())){

				return true;

			}

		}

		return false;

	}

	@Override

	public String toString(){

		return makeDoi();

	}

}

/**

 * Provides a method to encode any string into a URL-safe

 * form.

 * Non-ASCII characters are first encoded as sequences of

 * two or three bytes, using the UTF-8 algorithm, before being

 * encoded as %HH escapes.

 *

 * Created: 17 April 1997

 * Author: Bert Bos <bert@w3.org>

 *

 * URLUTF8Encoder: http://www.w3.org/International/URLUTF8Encoder.java

 *

 * Copyright © 1997 World Wide Web Consortium, (Massachusetts

 * Institute of Technology, European Research Consortium for

 * Informatics and Mathematics, Keio University). All Rights Reserved. 

 * This work is distributed under the W3C® Software License [1] in the

 * hope that it will be useful, but WITHOUT ANY WARRANTY; without even

 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE.

 *

 * [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231

 */

package eu.etaxonomy.cdm.common;

public class UrlUtf8Coder{

  final static String[] hex = {

    "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",

    "%08", "%09", "%0a", "%0b", "%0c", "%0d", "%0e", "%0f",

    "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",

    "%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f",

    "%20", "%21", "%22", "%23", "%24", "%25", "%26", "%27",

    "%28", "%29", "%2a", "%2b", "%2c", "%2d", "%2e", "%2f",

    "%30", "%31", "%32", "%33", "%34", "%35", "%36", "%37",

    "%38", "%39", "%3a", "%3b", "%3c", "%3d", "%3e", "%3f",

    "%40", "%41", "%42", "%43", "%44", "%45", "%46", "%47",

    "%48", "%49", "%4a", "%4b", "%4c", "%4d", "%4e", "%4f",

    "%50", "%51", "%52", "%53", "%54", "%55", "%56", "%57",

    "%58", "%59", "%5a", "%5b", "%5c", "%5d", "%5e", "%5f",

    "%60", "%61", "%62", "%63", "%64", "%65", "%66", "%67",

    "%68", "%69", "%6a", "%6b", "%6c", "%6d", "%6e", "%6f",

    "%70", "%71", "%72", "%73", "%74", "%75", "%76", "%77",

    "%78", "%79", "%7a", "%7b", "%7c", "%7d", "%7e", "%7f",

    "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",

    "%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f",

    "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",

    "%98", "%99", "%9a", "%9b", "%9c", "%9d", "%9e", "%9f",

    "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%a7",

    "%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af",

    "%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7",

    "%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf",

    "%c0", "%c1", "%c2", "%c3", "%c4", "%c5", "%c6", "%c7",

    "%c8", "%c9", "%ca", "%cb", "%cc", "%cd", "%ce", "%cf",

    "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",

    "%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df",

    "%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7",

    "%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee", "%ef",

    "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",

    "%f8", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff"

  };

  /**

   * Encode a string to the "x-www-form-urlencoded" form, enhanced

   * with the UTF-8-in-URL proposal. This is what happens:

   *

   * <ul>

   * <li><p>The ASCII characters 'a' through 'z', 'A' through 'Z',

   *        and '0' through '9' remain the same.

   *

   * <li><p>The unreserved characters - _ . ! ~ * ' ( ) remain the same.

   *

   * <li><p>The space character ' ' is converted into a plus sign '+'.

   *

   * <li><p>All other ASCII characters are converted into the

   *        3-character string "%xy", where xy is

   *        the two-digit hexadecimal representation of the character

   *        code

   *

   * <li><p>All non-ASCII characters are encoded in two steps: first

   *        to a sequence of 2 or 3 bytes, using the UTF-8 algorithm;

   *        secondly each of these bytes is encoded as "%xx".

   * </ul>

   *

   * @param s The string to be encoded

   * @return The encoded string

   */

  public static String encode(String s)

  {

    StringBuffer sbuf = new StringBuffer();

    int len = s.length();

    for (int i = 0; i < len; i++) {

      int ch = s.charAt(i);

      if ('A' <= ch && ch <= 'Z') {		// 'A'..'Z'

        sbuf.append((char)ch);

      } else if ('a' <= ch && ch <= 'z') {	// 'a'..'z'

	       sbuf.append((char)ch);

      } else if ('0' <= ch && ch <= '9') {	// '0'..'9'

	       sbuf.append((char)ch);

      } else if (ch == ' ') {			// space

	       sbuf.append(hex[ch]);     //Note: changed from + to %20 for use according to http://www.doi.org/doi_handbook/2_Numbering.html#2.5.2.4

      } else if (ch == '-' || ch == '_'		// unreserved

          || ch == '.' || ch == '!'

          || ch == '~' || ch == '*'

          || ch == '\'' || ch == '('

          || ch == ')') {

        sbuf.append((char)ch);

      } else if (ch <= 0x007f) {		// other ASCII

	       sbuf.append(hex[ch]);

      } else if (ch <= 0x07FF) {		// non-ASCII <= 0x7FF

	       sbuf.append(hex[0xc0 | (ch >> 6)]);

	       sbuf.append(hex[0x80 | (ch & 0x3F)]);

      } else {					// 0x7FF < ch <= 0xFFFF

	       sbuf.append(hex[0xe0 | (ch >> 12)]);

	       sbuf.append(hex[0x80 | ((ch >> 6) & 0x3F)]);

	       sbuf.append(hex[0x80 | (ch & 0x3F)]);

      }

    }

    return sbuf.toString();

  }

	/*

	 * Created: 17 April 1997

	 * Author: Bert Bos <bert@w3.org>

	 *

	 * unescape: http://www.w3.org/International/unescape.java

	 *

	 * Copyright © 1997 World Wide Web Consortium, (Massachusetts

	 * Institute of Technology, European Research Consortium for

	 * Informatics and Mathematics, Keio University). All Rights Reserved. 

	 * This work is distributed under the W3C® Software License [1] in the

	 * hope that it will be useful, but WITHOUT ANY WARRANTY; without even

	 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

	 * PURPOSE.

	 *

	 * [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231

	 */

  public static String unescape(String s) {

	    StringBuffer sbuf = new StringBuffer () ;

	    int l  = s.length() ;

	    int ch = -1 ;

	    int b, sumb = 0;

	    for (int i = 0, more = -1 ; i < l ; i++) {

	      /* Get next byte b from URL segment s */

	      switch (ch = s.charAt(i)) {

		case '%':

		  ch = s.charAt (++i) ;

		  int hb = (Character.isDigit ((char) ch) 

			    ? ch - '0'

			    : 10+Character.toLowerCase((char) ch) - 'a') & 0xF ;

		  ch = s.charAt (++i) ;

		  int lb = (Character.isDigit ((char) ch)

			    ? ch - '0'

			    : 10+Character.toLowerCase ((char) ch)-'a') & 0xF ;

		  b = (hb << 4) | lb ;

		  break ;

		case '+':

		  b = ' ' ;

		  break ;

		default:

		  b = ch ;

	      }

	      /* Decode byte b as UTF-8, sumb collects incomplete chars */

	      if ((b & 0xc0) == 0x80) {			// 10xxxxxx (continuation byte)

		sumb = (sumb << 6) | (b & 0x3f) ;	// Add 6 bits to sumb

		if (--more == 0) sbuf.append((char) sumb) ; // Add char to sbuf

	      } else if ((b & 0x80) == 0x00) {		// 0xxxxxxx (yields 7 bits)

		sbuf.append((char) b) ;			// Store in sbuf

	      } else if ((b & 0xe0) == 0xc0) {		// 110xxxxx (yields 5 bits)

		sumb = b & 0x1f;

		more = 1;				// Expect 1 more byte

	      } else if ((b & 0xf0) == 0xe0) {		// 1110xxxx (yields 4 bits)

		sumb = b & 0x0f;

		more = 2;				// Expect 2 more bytes

	      } else if ((b & 0xf8) == 0xf0) {		// 11110xxx (yields 3 bits)

		sumb = b & 0x07;

		more = 3;				// Expect 3 more bytes

	      } else if ((b & 0xfc) == 0xf8) {		// 111110xx (yields 2 bits)

		sumb = b & 0x03;

		more = 4;				// Expect 4 more bytes

	      } else /*if ((b & 0xfe) == 0xfc)*/ {	// 1111110x (yields 1 bit)

		sumb = b & 0x01;

		more = 5;				// Expect 5 more bytes

	      }

	      /* We don't test if the UTF-8 encoding is well-formed */

	    }

	    return sbuf.toString() ;

	  }

}

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.common;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

/**

 * 

 * Test class for testing the {@link DOI} class.

 * 

 * For doi syntax see also http://www.doi.org/doi_handbook/2_Numbering.html

 * or

 * http://stackoverflow.com/questions/27910/finding-a-doi-in-a-document-or-page  

 * 

 * @author a.mueller

 *

 */

public class DoiTest {

	/**

	 * @throws java.lang.Exception

	 */

	@Before

	public void setUp() throws Exception {

	}

	@Test

	public void testValidParser() {

		String validDoi = "10.1002/1234";

		DOI doi = DOI.fromString(validDoi);

		Assert.assertEquals("10.1002", doi.getPrefix());

		Assert.assertEquals("1234", doi.getSuffix());

		validDoi = "10.1002/(SICI)1522-2594(199911)42:5<952::AID-MRM16>3.0.CO;2-S";

		doi = DOI.fromString(validDoi);

		Assert.assertEquals("10.1002", doi.getPrefix());

		Assert.assertEquals("(SICI)1522-2594(199911)42:5<952::AID-MRM16>3.0.CO;2-S", doi.getSuffix());

		validDoi = "10.1007.10/978-3-642-28108-2_19";

		doi = DOI.fromString(validDoi);

		Assert.assertEquals("10.1007.10", doi.getPrefix());

		Assert.assertEquals("978-3-642-28108-2_19", doi.getSuffix());

		validDoi="10.1579/0044-7447(2006)35\\[89:RDUICP\\]2.0.CO;2";

		doi = DOI.fromString(validDoi);

		Assert.assertEquals("10.1579", doi.getPrefix());

		Assert.assertEquals("0044-7447(2006)35\\[89:RDUICP\\]2.0.CO;2", doi.getSuffix());

	}

	@Test

	public void testFromRegistrantCodeAndSuffix() {

		DOI doi = DOI.fromRegistrantCodeAndSuffix("1579", "978-3-642-28108-2_19");

		Assert.assertEquals("10.1579", doi.getPrefix());

		Assert.assertEquals("978-3-642-28108-2_19", doi.getSuffix());

		Assert.assertNotEquals("1234", doi.getSuffix());

	}

	@Test

	public void testParserFail() {

		String invalidDoi = "10.4515260,51.1656910";  //must never match to avoid matches with geo coordinates

		testInvalid(invalidDoi);

		invalidDoi = "4210.1000/123456";  //directoryIndicator must always be 10

		testInvalid(invalidDoi);

		invalidDoi = "10.1002/12\u0004345";  //control characters (here U+0004) must fail

		testInvalid(invalidDoi);

		invalidDoi = "10.1a02/12345";  //registrant code must include only number and dots (to separate sub codes)

		testInvalid(invalidDoi);

		invalidDoi = "10.1002:12345";  //column separator is only allowed (+required) in URNs

		testInvalid(invalidDoi);

		invalidDoi = "10.1002/";  //doi must always have a suffix length > 0 (if this should changed in future, please do adapt equals and hashCode)

		testInvalid(invalidDoi);

		invalidDoi = "10./1234";  //doi must always have a registrant prefix length > 0 (if this should changed in future, please do adapt equals and hashCode)

		testInvalid(invalidDoi);

	}

	@Test

	public void testParserWithPrefixes() {

		String validDoi = "DOI: 10.1002/1234";

		DOI doi = DOI.fromString(validDoi);

		Assert.assertEquals("10.1002", doi.getPrefix());

		Assert.assertEquals("1234", doi.getSuffix());

		validDoi = "http://doi.org/10.1002/1234";

		doi = DOI.fromString(validDoi);

		Assert.assertEquals("10.1002", doi.getPrefix());

		Assert.assertEquals("1234", doi.getSuffix());

		validDoi = "http://doi.org/urn:doi:10.123:456ABC%2Fzyz";

		doi = DOI.fromString(validDoi);

		Assert.assertEquals("10.123", doi.getPrefix());

		Assert.assertEquals("456ABC/zyz", doi.getSuffix());  //urn must be percentage encoded ( / -> %2F)

	}

	@Test

	public void testEquals() {

		String validDoi = "10.1002/12a4";

		DOI doi1 = DOI.fromString(validDoi);

		validDoi = "10.1002/12A4";

		DOI doi2 = DOI.fromString(validDoi);

		Assert.assertEquals("DOIs must be equal case insensitive", doi1, doi2);

		validDoi = "10.1002/12b4";

		DOI doi3 = DOI.fromString(validDoi);

		Assert.assertNotEquals("Different DOIs must not be equal", doi1, doi3);

	}

	@Test

	public void testAsURI() {

		//mandatory encoding according to http://www.doi.org/doi_handbook/2_Numbering.html#2.5.2.4

		String validDoi = "10.1002/1234%56\"78#90 12?34";

		DOI doi1 = DOI.fromString(validDoi);

		String uri = doi1.asURI();

		Assert.assertEquals(DOI.HTTP_DOI_ORG + "10.1002/1234%2556%2278%2390%2012%3f34", uri);

		//recommendedEncoding

		validDoi = "10.1002/1234<56>78{90}12^34";

		doi1 = DOI.fromString(validDoi);

		uri = doi1.asURI();

		Assert.assertEquals(DOI.HTTP_DOI_ORG + "10.1002/1234%3c56%3e78%7b90%7d12%5e34", uri);

		//recommendedEncoding (cont.)

		validDoi = "10.1002/1234[56]78`90|12\\34+56";

		doi1 = DOI.fromString(validDoi);

		uri = doi1.asURI();

		Assert.assertEquals(DOI.HTTP_DOI_ORG + "10.1002/1234%5b56%5d78%6090%7c12%5c34%2b56", uri);

	}

	private void testInvalid(String invalidDoi) {

		try {

			DOI.fromString(invalidDoi);

			Assert.fail("DOI should not be parsable: " + invalidDoi);

		} catch (IllegalArgumentException e) {

			//OK

		}

	}		

}

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy 

* http://www.e-taxonomy.eu

* 

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.hibernate;

import java.io.Serializable;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Types;

import org.apache.log4j.Logger;

import org.hibernate.HibernateException;

import org.hibernate.engine.spi.SessionImplementor;

import org.hibernate.type.StandardBasicTypes;

import org.hibernate.usertype.UserType;

import org.jadira.usertype.dateandtime.shared.spi.AbstractUserType;

import eu.etaxonomy.cdm.common.DOI;

/**

 * Hibernate user type for the {@link DOI} class.

 * @author a.mueller

 * @created 05.09.2013

 */

public class DOIUserType  extends AbstractUserType implements UserType {

	private static final long serialVersionUID = 2227841000128722278L;

	@SuppressWarnings("unused")

	private static final Logger logger = Logger.getLogger(DOIUserType.class);

	private static final int[] SQL_TYPES = { Types.VARCHAR };

	@Override

	public Object deepCopy(Object o) throws HibernateException {

		if (o == null) {

            return null;

        }

		DOI doi = (DOI) o;

        try {

			return DOI.fromString(doi.toString());

		} catch (IllegalArgumentException e) {

			throw new HibernateException(e);

		}

	}

	@Override

	public Serializable disassemble(Object value) throws HibernateException {

		if(value == null) {

			return null;

		} else {

		    DOI doi = (DOI) value;

		    return doi.toString();

		}

	}

	@Override

	public DOI nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner) 

			throws HibernateException, SQLException {

        String val = (String) StandardBasicTypes.STRING.nullSafeGet(rs, names, session, owner);

		if(val == null) {

			return null;

		} else {

            try {

			    return DOI.fromString(val);

		    } catch (IllegalArgumentException e) {

			    throw new HibernateException(e);

		    }

		}

	}

	@Override

	public void nullSafeSet(PreparedStatement statement, Object value, int index, SessionImplementor session) 

			throws HibernateException, SQLException {

		if (value == null) { 

            StandardBasicTypes.STRING.nullSafeSet(statement, value, index, session);

        } else { 

        	DOI doi = (DOI)value;

            StandardBasicTypes.STRING.nullSafeSet(statement, doi.toString(), index, session);

        }

	}

	/* (non-Javadoc)

	 * @see org.jadira.usertype.dateandtime.shared.spi.AbstractSingleColumnUserType#returnedClass()

	 */

	@Override

	public Class returnedClass() {

		return DOI.class;

	}

	@Override

	public int[] sqlTypes() {

		return SQL_TYPES;

	}

}

	@org.hibernate.annotations.TypeDef(name="enumUserType", typeClass=eu.etaxonomy.cdm.hibernate.EnumUserType.class),	

	@org.hibernate.annotations.TypeDef(name="doiUserType", typeClass=eu.etaxonomy.cdm.hibernate.DOIUserType.class)	

import eu.etaxonomy.cdm.common.DOI;

	public DOI getDoi();

	public void setDoi(DOI doi);

import eu.etaxonomy.cdm.common.DOI;

//    @NullOrNotEmpty

//	@Length(max = 1000)

    @Type(type="doiUserType")

    protected DOI doi;

	public DOI getDoi() {

	public void setDoi(DOI doi) {

import eu.etaxonomy.cdm.common.DOI;

				}else if(fieldType == DOI.class){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);