EDIT

/**

* 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.model.reference;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.net.URI;

import java.util.List;

import javax.persistence.Basic;

import javax.persistence.Column;

import javax.persistence.Embedded;

import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.Inheritance;

import javax.persistence.InheritanceType;

import javax.persistence.Lob;

import javax.persistence.ManyToOne;

import javax.persistence.Transient;

import javax.validation.constraints.NotNull;

import javax.validation.constraints.Pattern;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlAttribute;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlIDREF;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlSchemaType;

import javax.xml.bind.annotation.XmlTransient;

import javax.xml.bind.annotation.XmlType;

import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.hibernate.annotations.Cascade;

import org.hibernate.annotations.CascadeType;

import org.hibernate.annotations.Table;

import org.hibernate.annotations.Type;

import org.hibernate.envers.Audited;

import org.hibernate.search.annotations.Analyze;

import org.hibernate.search.annotations.Field;

import org.hibernate.search.annotations.FieldBridge;

import org.hibernate.search.annotations.IndexedEmbedded;

import org.joda.time.DateTime;

import eu.etaxonomy.cdm.common.DOI;

import eu.etaxonomy.cdm.hibernate.search.DateTimeBridge;

import eu.etaxonomy.cdm.hibernate.search.DoiBridge;

import eu.etaxonomy.cdm.jaxb.DateTimeAdapter;

import eu.etaxonomy.cdm.model.agent.Institution;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

import eu.etaxonomy.cdm.model.common.IIntextReferenceTarget;

import eu.etaxonomy.cdm.model.common.TimePeriod;

import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;

import eu.etaxonomy.cdm.model.media.IdentifiableMediaEntity;

import eu.etaxonomy.cdm.strategy.cache.reference.DefaultReferenceCacheStrategy;

import eu.etaxonomy.cdm.strategy.cache.reference.INomenclaturalReferenceCacheStrategy;

import eu.etaxonomy.cdm.strategy.match.Match;

import eu.etaxonomy.cdm.strategy.match.MatchMode;

import eu.etaxonomy.cdm.strategy.merge.Merge;

import eu.etaxonomy.cdm.strategy.merge.MergeMode;

import eu.etaxonomy.cdm.strategy.parser.ParserProblem;

import eu.etaxonomy.cdm.validation.Level2;

import eu.etaxonomy.cdm.validation.Level3;

import eu.etaxonomy.cdm.validation.annotation.InReference;

import eu.etaxonomy.cdm.validation.annotation.NoRecursiveInReference;

import eu.etaxonomy.cdm.validation.annotation.NullOrNotEmpty;

import eu.etaxonomy.cdm.validation.annotation.ReferenceCheck;

/**

 * The class for references (information sources). Originally

 * an abstract class with many subclasses. Not it is only

 * one class implementing many interfaces for safe use.

 * <P>

 * This class corresponds to: <ul>

 * <li> PublicationCitation according to the TDWG ontology

 * <li> Publication according to the TCS

 * <li> Reference according to the ABCD schema

 * </ul>

 *

 * @author m.doering

 * @since 08-Nov-2007 13:06:47

 */

@XmlAccessorType(XmlAccessType.FIELD)

@XmlType(name = "Reference", propOrder = {

	"type",

	"uri",

    "abbrevTitleCache",

    "protectedAbbrevTitleCache",

	"nomenclaturallyRelevant",

    "authorship",

    "referenceAbstract",

    "title",

    "abbrevTitle",

    "editor",

	"volume",

	"pages",

	"edition",

    "isbn",

    "issn",

    "doi",

    "seriesPart",

    "datePublished",

    "publisher",

    "placePublished",

    "institution",

    "school",

    "organization",

    "inReference",

    "accessed",

    "lastRetrieved",

    "externalId",

    "externalLink",

    "authorityType"

})

@XmlRootElement(name = "Reference")

@Entity

@Inheritance(strategy=InheritanceType.SINGLE_TABLE)

@Audited

@Table(appliesTo="Reference", indexes = { @org.hibernate.annotations.Index(name = "ReferenceTitleCacheIndex", columnNames = { "titleCache" }) })

//@InReference(groups=Level3.class)

@ReferenceCheck(groups=Level2.class)

@InReference(groups=Level3.class)

@NoRecursiveInReference(groups=Level3.class)  //may become Level1 in future  #

public class Reference

        extends IdentifiableMediaEntity<INomenclaturalReferenceCacheStrategy>

        implements IArticle, IBook, IPatent, IDatabase, IJournal, IBookSection,ICdDvd,

                   IGeneric,IInProceedings, IProceedings, IPrintSeries, IReport,

                   IThesis,IWebPage, IPersonalCommunication,

                   INomenclaturalReference, IReference, IIntextReferenceTarget,

                   Cloneable {

    private static final long serialVersionUID = -2034764545042691295L;

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

	@XmlAttribute(name ="type")

	@Column(name="refType")

	@NotNull

    @Type(type = "eu.etaxonomy.cdm.hibernate.EnumUserType",

    	parameters = {@org.hibernate.annotations.Parameter(name  = "enumClass", value = "eu.etaxonomy.cdm.model.reference.ReferenceType")}

    )

	@Audited

	protected ReferenceType type;

	//Title of the reference

	@XmlElement(name ="Title" )

	@Column(length=4096, name="title")

	@Lob

	@Field

	@Match(MatchMode.EQUAL_REQUIRED) //TODO correct? was EQUAL_REQUIRED before, but with abbrevTitle this is not realistic anymore

    //TODO Val #3379

//	@NullOrNotEmpty

	private String title;

	//Title of the reference

	@XmlElement(name ="AbbrevTitle" )

	@Field

	@Match(MatchMode.EQUAL)  //TODO check if this is correct

	@NullOrNotEmpty

	@Column(length=255)

	private String abbrevTitle;

	//Title of the reference

	@XmlElement(name ="AbbrevTitleCache" )

	@Field

	@Match(MatchMode.CACHE)

    //TODO Val #3379

//	@NotNull

	@Column(length=1024)

	private String abbrevTitleCache;

	@XmlElement(name = "protectedAbbrevTitleCache")

	@Merge(MergeMode.OR)

	private boolean protectedAbbrevTitleCache;

//********************************************************/

    @XmlElement(name = "Editor")

    @Field

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

	protected String editor;

    @XmlElement(name = "Volume")

    @Field

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

	protected String volume;

    @XmlElement(name = "Pages")

    @Field

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

	protected String pages;

    @XmlElement(name = "Edition")

    @Field

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

	protected String edition;

    @XmlElement(name = "ISBN")

    @Field

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

	@Pattern(regexp = "(?=.{13}$)\\d{1,5}([- ])\\d{1,7}\\1\\d{1,6}\\1(\\d|X)$", groups = Level2.class, message = "{eu.etaxonomy.cdm.model.reference.Reference.isbn.message}")

	protected String isbn;

    @XmlElement(name = "Doi")

    @Field

    @FieldBridge(impl = DoiBridge.class)

    @Type(type="doiUserType")

    @Column(length=DOI.MAX_LENGTH)

    protected DOI doi;

	@XmlElement(name = "ISSN")

    @Field

    //TODO Val #3379

//	@NullOrNotEmpty

    @Column(length=255)

	@Pattern(regexp = "(?=.{9}$)\\d{4}([- ])\\d{4} (\\d|X)$", groups = Level2.class, message = "{eu.etaxonomy.cdm.model.reference.Reference.issn.message}")

	protected String issn;

    @XmlElement(name = "SeriesPart")

    @Field

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

	protected String seriesPart;

	@XmlElement(name = "Organization")

    @Field

    //TODO Val #3379

//	@NullOrNotEmpty

    @Column(length=255)

	protected String organization;

	@XmlElement(name = "Publisher")

    @Field

    //TODO Val #3379

//	@NullOrNotEmpty

    @Column(length=255)

	protected String publisher;

	@XmlElement(name = "PlacePublished")

    @Field

    //TODO Val #3379

//	@NullOrNotEmpty

    @Column(length=255)

	protected String placePublished;

	@XmlElement(name = "Institution")

	@XmlIDREF

	@XmlSchemaType(name = "IDREF")

	@ManyToOne(fetch = FetchType.LAZY)

	@IndexedEmbedded

	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

	protected Institution institution;

	@XmlElement(name = "School")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

	@ManyToOne(fetch = FetchType.LAZY)

	@IndexedEmbedded

	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

	protected Institution school;

    @XmlElement(name = "InReference")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

    @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

//  @InReference(groups=Level2.class)

   	protected Reference inReference;

//********************************************************/

	//The date range assigned to the reference. ISO Date range like. Flexible, year can be left out, etc

	@XmlElement(name ="DatePublished" )

	@Embedded

	@IndexedEmbedded

	private VerbatimTimePeriod datePublished = VerbatimTimePeriod.NewVerbatimInstance();

    //#5258

    @XmlElement (name = "Accessed", type= String.class)

    @XmlJavaTypeAdapter(DateTimeAdapter.class)

    @Type(type="dateTimeUserType")

    @Basic(fetch = FetchType.LAZY)

    @Match(MatchMode.EQUAL)

    @FieldBridge(impl = DateTimeBridge.class)

    private DateTime accessed;

    @XmlElement(name ="Abstract" )

	@Column(length=65536, name="referenceAbstract")

	@Lob

    @Field

    //TODO Val #3379

//	@NullOrNotEmpty

	private String referenceAbstract;  //abstract is a reserved term in Java

	//URIs like DOIs, LSIDs or Handles for this reference

	@XmlElement(name = "URI")

	@Field(analyze = Analyze.NO)

	@Type(type="uriUserType")

	private URI uri;

	//flag to subselect only references that could be useful for nomenclatural citations.

	//If a reference is used as a

	//nomenclatural reference in a name this flag should be automatically set

	@XmlElement(name = "IsNomenclaturallyRelevant")

	@Merge(MergeMode.OR)

	private boolean nomenclaturallyRelevant;

	@XmlElement(name = "Authorship")

	@XmlIDREF

	@XmlSchemaType(name = "IDREF")

	@ManyToOne(fetch = FetchType.LAZY)

	@IndexedEmbedded

	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

	private TeamOrPersonBase<?> authorship;

	@XmlAttribute

    @Match(MatchMode.IGNORE)

	private int parsingProblem = 0;

	@XmlAttribute

    @Match(MatchMode.IGNORE)

    private int problemStarts = -1;

    @XmlAttribute

    @Match(MatchMode.IGNORE)

    private int problemEnds = -1;

    @Transient

    @XmlAttribute

    @Match(MatchMode.IGNORE)

	private boolean cacheStrategyRectified = false;

    //attributes for externally managed

//    @XmlElement (name = "LastRetrieved", type= String.class)

    @XmlJavaTypeAdapter(DateTimeAdapter.class)

    @Type(type="dateTimeUserType")

    //TODO needed??

    @Basic(fetch = FetchType.LAZY)

    private DateTime lastRetrieved;

    @XmlElement(name ="ExternalId" )

//    @Field

//    @Match(MatchMode.EQUAL)  //TODO check if this is correct

    @NullOrNotEmpty

    @Column(length=255)

    private String externalId;

    //Actionable link on e.g. on a webservice

    @XmlElement(name = "ExternalLink")

    @Field(analyze = Analyze.NO)

    @Type(type="uriUserType")

    private URI externalLink;

    @XmlAttribute(name ="authority")

    @Column(name="authorityType", length=10)

    @Type(type = "eu.etaxonomy.cdm.hibernate.EnumUserType",

        parameters = {@org.hibernate.annotations.Parameter(name  = "enumClass", value = "eu.etaxonomy.cdm.model.reference.AuthorityType")}

    )

//    @NotNull

    private AuthorityType authorityType;

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

    protected Reference(){

		this(ReferenceType.Generic);  //just in case someone uses constructor

	}

	protected Reference(ReferenceType type) {

		super();

	    if (type == null){

			this.type = ReferenceType.Generic;

		} else{

			this.type = type;

		}

		this.setCacheStrategy(DefaultReferenceCacheStrategy.NewInstance());

	}

// *********************** LISTENER ************************/

	@Override

    public void initListener(){

        PropertyChangeListener listener = new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent ev) {

            	if (!ev.getPropertyName().equals("titleCache") && !ev.getPropertyName().equals("abbrevTitleCache") && !ev.getPropertyName().equals("cacheStrategy")){

            		if (! isProtectedTitleCache()){

            			titleCache = null;

            		}

            		if (! isProtectedAbbrevTitleCache()){

            			abbrevTitleCache = null;

            		}

            	}

            }

        };

        addPropertyChangeListener(listener);

    }

//*************************** GETTER / SETTER ******************************************/

    // @Transient  - must not be transient, since this property needs to to be included in all serializations produced by the remote layer

    @Override

    public String getTitleCache(){

        String result = super.getTitleCache();

        if (isBlank(result)){

            this.titleCache = this.getAbbrevTitleCache(true);

        }

        return titleCache;

    }

	@Override

	public String getAbbrevTitleCache() {

		return getAbbrevTitleCache(false);

	}

	/**

	 * Implements {@link #getAbbrevTitleCache()} but allows to

	 * avoid never ending recursions if both caches are empty

	 * avoidRecursion should only be <code>true</code> if called

	 * by {@link #getTitleCache()}

	 * @param avoidRecursion

	 * @return

	 */

	private String getAbbrevTitleCache(boolean avoidRecursion) {

        if (protectedAbbrevTitleCache){

            return this.abbrevTitleCache;

        }

        // is reference dirty, i.e. equal NULL?

        if (abbrevTitleCache == null){

            this.abbrevTitleCache = generateAbbrevTitle();

            this.abbrevTitleCache = getTruncatedCache(this.abbrevTitleCache) ;

        }

        if (isBlank(abbrevTitleCache) && !avoidRecursion){

            this.abbrevTitleCache = this.getTitleCache();

        }

        return abbrevTitleCache;

    }

    @Override

	@Deprecated

	public void setAbbrevTitleCache(String abbrevTitleCache) {

		this.abbrevTitleCache = abbrevTitleCache;

	}

	@Override

	public void setAbbrevTitleCache(String abbrevTitleCache, boolean isProtected) {

		this.protectedAbbrevTitleCache = isProtected;

		setAbbrevTitleCache(abbrevTitleCache);

	}

	@Override

	public boolean isProtectedAbbrevTitleCache() {

		return protectedAbbrevTitleCache;

	}

	@Override

	public void setProtectedAbbrevTitleCache(boolean protectedAbbrevTitleCache) {

		this.protectedAbbrevTitleCache = protectedAbbrevTitleCache;

	}

	@Override

	public String getAbbrevTitle() {

		return abbrevTitle;

	}

	@Override

	public void setAbbrevTitle(String abbrevTitle) {

		this.abbrevTitle = StringUtils.isBlank(abbrevTitle) ? null : abbrevTitle;

	}

	@Override

    public String getEditor() {

		return editor;

	}

	@Override

    public void setEditor(String editor) {

		this.editor = StringUtils.isBlank(editor)? null : editor;

	}

	@Override

    public String getVolume() {

		return volume;

	}

	@Override

    public void setVolume(String volume) {

		this.volume = StringUtils.isBlank(volume)? null : volume;

	}

	@Override

    public String getPages() {

		return pages;

	}

	@Override

    public void setPages(String pages) {

		this.pages = StringUtils.isBlank(pages)? null : pages;

	}

	@Override

    public String getEdition() {

		return edition;

	}

	@Override

    public void setEdition(String edition) {

		this.edition = StringUtils.isBlank(edition)? null : edition;

	}

	@Override

    public String getIsbn() {

		return isbn;

	}

	@Override

    public void setIsbn(String isbn) {

		this.isbn = StringUtils.isBlank(isbn)? null : isbn;

	}

	@Override

    public String getIssn() {

		return issn;

	}

	@Override

    public void setIssn(String issn) {

		this.issn = StringUtils.isBlank(issn)? null : issn;

	}

    @Override

	public DOI getDoi() {

		return doi;

	}

    @Override

	public void setDoi(DOI doi) {

		this.doi = doi;

	}

    /**

     * Convenience method to retrieve doi as string

     */

    @Transient @XmlTransient @java.beans.Transient

    public String getDoiString() {

        return doi == null? null : doi.toString();

    }

	@Override

    public String getSeriesPart() {

		return seriesPart;

	}

	@Override

    public void setSeriesPart(String seriesPart) {

		this.seriesPart = StringUtils.isBlank(seriesPart)? null : seriesPart;

	}

	@Override

    public String getOrganization() {

		return organization;

	}

	@Override

    public void setOrganization(String organization) {

		this.organization = StringUtils.isBlank(organization)? null : organization;

	}

	@Override

    public String getPublisher() {

		return publisher;

	}

	@Override

    public void setPublisher(String publisher) {

		this.publisher = StringUtils.isBlank(publisher)? null : publisher;

	}

	@Override

    public void setPublisher(String publisher, String placePublished){

		this.publisher = publisher;

		this.placePublished = placePublished;

	}

	@Override

    public String getPlacePublished() {

		return placePublished;

	}

	@Override

    public void setPlacePublished(String placePublished) {

		this.placePublished = StringUtils.isBlank(placePublished)? null: placePublished;

	}

	@Override

    public Institution getInstitution() {

		return institution;

	}

	@Override

    public void setInstitution(Institution institution) {

		this.institution = institution;

	}

	@Override

    public Institution getSchool() {

		return school;

	}

	@Override

    public void setSchool(Institution school) {

		this.school = school;

	}

	@Override

    public Reference getInReference() {

		return inReference;

	}

	@Override

    public void setInReference(Reference inReference) {

		this.inReference = inReference;

	}

	@Override

    public void setType(ReferenceType type) {

		if (type == null){

			this.type = ReferenceType.Generic;

		} else{

			this.type = type;

		}

	}

	@Override

    public ReferenceType getType() {

		return type;

	}

	/**

	 * Whether this reference is of the given type

	 *

	 * @param type

	 * @return

	 */

	@Override

    public boolean isOfType(ReferenceType type){

		return type == getType();

	}

	/**

	 * Returns a string representing the title of <i>this</i> reference. If a

	 * reference has different titles (for instance abbreviated and not

	 * abbreviated) then for each title a new instance must be created.

	 *

	 * @return  the title string of <i>this</i> reference

	 * @see 	#getCitation()

	 */

	@Override

    public String getTitle(){

		return this.title;

	}

	/**

	 * @see 	#getTitle()

	 */

	@Override

    public void setTitle(String title){

		this.title = StringUtils.isBlank(title)? null : title;

	}

	/**

	 * Returns the date (mostly only the year) of publication / creation of

	 * <i>this</i> reference.

	 */

	@Override

    public VerbatimTimePeriod getDatePublished(){

		return this.datePublished;

	}

	/**

	 * @see 	#getDatePublished()

	 */

	@Override

    public void setDatePublished(VerbatimTimePeriod datePublished){

		this.datePublished = datePublished;

	}

    @Override

    @Transient

    @Deprecated

    public VerbatimTimePeriod setDatePublished(TimePeriod datePublished){

        VerbatimTimePeriod newTimePeriod = VerbatimTimePeriod.toVerbatim(datePublished);

        setDatePublished(newTimePeriod);

        return newTimePeriod;

    }

	public boolean hasDatePublished(){

		boolean result =  ! ( (this.datePublished == null) || StringUtils.isBlank(datePublished.toString()));

		return result;

	}

	@Override

    public DateTime getAccessed() {

        return accessed;

    }

	@Override

    public void setAccessed(DateTime accessed) {

        this.accessed = accessed;

    }

	/**

	 * Returns the {@link eu.etaxonomy.cdm.model.agent.TeamOrPersonBase author (team)} who created the

	 * content of <i>this</i> reference.

	 *

	 * @return  the author (team) of <i>this</i> reference

	 * @see 	eu.etaxonomy.cdm.model.agent.TeamOrPersonBase

	 */

	@Override

    public TeamOrPersonBase getAuthorship(){

		return this.authorship;

	}

	/**

	 * @see #getAuthorship()

	 */

	@Override

    public void setAuthorship(TeamOrPersonBase authorship){

		this.authorship = authorship;

	}

	/**

	 * Returns the Uniform Resource Identifier (URI) corresponding to <i>this</i>

	 * reference. An URI is a string of characters used to identify a resource

	 * on the Internet.

	 *

	 * @return  the URI of <i>this</i> reference

	 */

	@Override

    public URI getUri(){

		return this.uri;

	}

	/**

	 * @see #getUri()

	 */

	@Override

    public void setUri(URI uri){

		this.uri = uri;

	}

	/**

	 * @return the referenceAbstract

	 */

	@Override

    public String getReferenceAbstract() {

		return referenceAbstract;

	}

	/**

	 * @param referenceAbstract the referenceAbstract to set

	 */

	@Override

    public void setReferenceAbstract(String referenceAbstract) {

		this.referenceAbstract = StringUtils.isBlank(referenceAbstract)? null : referenceAbstract;

	}

	/**

	 * Returns "true" if the isNomenclaturallyRelevant flag is set. This

	 * indicates that a {@link TaxonName taxon name} has been originally

	 * published in <i>this</i> reference following the rules of a

	 * {@link eu.etaxonomy.cdm.model.name.NomenclaturalCode nomenclature code} and is therefore used for

	 * nomenclatural citations. This flag will be set as soon as <i>this</i>

	 * reference is used as a nomenclatural reference for any taxon name.<BR>

	 * FIXME what happens if the only taxon name referencing this reference is not

	 * any longer using this reference as a nomenclatural reference. How does the

	 * reference get informed about the fact that it is not nomenclaturally relevant

	 * anymore?

	 */

	public boolean isNomenclaturallyRelevant(){

		return this.nomenclaturallyRelevant;

	}

	/**

	 * @see #isNomenclaturallyRelevant()

	 */

	public void setNomenclaturallyRelevant(boolean nomenclaturallyRelevant){

		this.nomenclaturallyRelevant = nomenclaturallyRelevant;

	}

//****************************************************  /

	@Transient

	@Override

	public void setTitleCaches(String cache){

	    this.setAbbrevTitleCache(cache, true);

	    this.setTitleCache(cache, true);

	}

	/**

	 * Returns a formatted string containing the entire reference citation,

	 * including authors, corresponding to <i>this</i> reference.

	 *

	 * @see  #generateTitle()

	 */

	// TODO implement

	@Transient

	public String getCitation(){

		if (getCacheStrategy() == null){

			logger.warn("No CacheStrategy defined for "+ this.getClass() + ": " + this.getUuid());

			return null;

		}else{

			return getCacheStrategy().getTitleCache(this);

		}

	}

	@Override

    public String generateTitle() {

		return super.generateTitle();

	}

    public String generateAbbrevTitle() {

		return getCacheStrategy().getFullAbbrevTitleString(this);

	}

	/**

	 * Returns a string representation for the year of publication / creation

	 * of <i>this</i> reference. If the {@link #getDatePublished() datePublished}

	 * of this reference contains more date information then (starting) year

	 * only the year is returned.

	 * than  attribute.

	 */

	@Override

    @Transient

	public String getYear(){

		VerbatimTimePeriod datePublished = this.getDatePublished();

		if (datePublished != null ){

			String result = getDatePublished().getYear();

			return result;

		}else{

			return null;

		}

	}

	/**

	 * Convenience method that returns a string representation for the publication date / creation

	 * of <i>this</i> reference. The string is obtained by

	 * {@link #getDatePublished()#toString() the string representation

	 * of the date published}.

	 */

	@Transient

	public String getDatePublishedString(){

		VerbatimTimePeriod datePublished = this.getDatePublished();

		if (datePublished != null ){

			return getDatePublished().toString();

		}else{

			return null;

		}

	}

	/**

     * Convenience method that returns a string representation for the publication date / creation

     * of <i>this</i> reference. The string is obtained by

     * {@link #getDatePublished()#toString() the string representation

     * of the date published}.

     */

    @Transient

    public String getTimePeriodPublishedString(){

        VerbatimTimePeriod datePublished = this.getDatePublished();

        if (datePublished != null ){

            return getDatePublished().getTimePeriod();

        }else{

            return null;

        }

    }

	@Override

    public int getParsingProblem(){

		return this.parsingProblem;

	}

	@Override

    public void setParsingProblem(int parsingProblem){

		this.parsingProblem = parsingProblem;

	}

	@Override

    public boolean hasProblem(){

		return parsingProblem != 0;

	}

	@Override

    public boolean hasProblem(ParserProblem problem) {

		return getParsingProblems().contains(problem);

	}

	@Override

    public int getProblemStarts(){

		return this.problemStarts;

	}

	@Override

    public void setProblemStarts(int start) {

		this.problemStarts = start;

	}

	@Override

    public int getProblemEnds(){

		return this.problemEnds;

	}

	@Override

    public void setProblemEnds(int end) {

		this.problemEnds = end;

	}

	@Override

    public void addParsingProblem(ParserProblem warning){

		parsingProblem = ParserProblem.addProblem(parsingProblem, warning);

	}

	@Override

    public void removeParsingProblem(ParserProblem problem) {

		parsingProblem = ParserProblem.removeProblem(parsingProblem, problem);

	}

	@Override

    @Transient

	public List<ParserProblem> getParsingProblems() {

		return ParserProblem.warningList(this.parsingProblem);

	}