cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/reference/ReferenceFactory.java

   1 /**
   2 * Copyright (C) 2009 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.model.reference;
  11
  12 import org.apache.log4j.Logger;
  13
  14 import eu.etaxonomy.cdm.model.agent.Person;
  15 import eu.etaxonomy.cdm.model.common.TimePeriod;
  16 import eu.etaxonomy.cdm.strategy.cache.reference.ArticleDefaultCacheStrategy;
  17 import eu.etaxonomy.cdm.strategy.cache.reference.BookDefaultCacheStrategy;
  18 import eu.etaxonomy.cdm.strategy.cache.reference.BookSectionDefaultCacheStrategy;
  19 import eu.etaxonomy.cdm.strategy.cache.reference.CdDvdDefaultCacheStrategy;
  20 import eu.etaxonomy.cdm.strategy.cache.reference.GenericDefaultCacheStrategy;
  21 import eu.etaxonomy.cdm.strategy.cache.reference.JournalDefaultCacheStrategy;
  22 import eu.etaxonomy.cdm.strategy.cache.reference.ReferenceBaseDefaultCacheStrategy;
  23 import eu.etaxonomy.cdm.strategy.cache.reference.ThesisDefaultCacheStrategy;
  24
  25 public class ReferenceFactory {
  26         private static final Logger logger = Logger.getLogger(ReferenceFactory.class);
  27
  28
  29         /**
  30          * @return
  31          * @deprecated //use static methods instead
  32          */
  33         public static ReferenceFactory newInstance(){
  34                 return new ReferenceFactory();
  35         }
  36
  37         public static ReferenceBase newArticle(){
  38                 ReferenceBase<ArticleDefaultCacheStrategy> article = new ReferenceBase(ReferenceType.Article);
  39                 article.setCacheStrategy(ReferenceType.Article.getCacheStrategy());
  40                 return article;
  41         }
  42
  43         public static ReferenceBase newJournal(){
  44                 ReferenceBase<JournalDefaultCacheStrategy<ReferenceBase>> journal = new ReferenceBase(ReferenceType.Journal);
  45                 journal.setCacheStrategy(ReferenceType.Journal.getCacheStrategy());
  46                 return journal;
  47         }
  48
  49         public static ReferenceBase newBook(){
  50                 ReferenceBase<BookDefaultCacheStrategy<ReferenceBase>> book = new ReferenceBase<BookDefaultCacheStrategy<ReferenceBase>>(ReferenceType.Book);
  51                 book.setCacheStrategy(ReferenceType.Book.getCacheStrategy());
  52                 return book;
  53         }
  54
  55         public static ReferenceBase newThesis(){
  56                 ReferenceBase<ThesisDefaultCacheStrategy<ReferenceBase>> thesis = new ReferenceBase<ThesisDefaultCacheStrategy<ReferenceBase>>(ReferenceType.Thesis);
  57                 thesis.setCacheStrategy(ReferenceType.Thesis.getCacheStrategy());
  58                 return thesis;
  59         }
  60
  61         public static ReferenceBase newInProceedings(){
  62                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> inProceedings = new ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>>(ReferenceType.InProceedings);
  63                 inProceedings.setCacheStrategy(ReferenceType.InProceedings.getCacheStrategy());
  64                 return inProceedings;
  65         }
  66
  67         public static ReferenceBase newProceedings(){
  68                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> proceedings = new ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>>(ReferenceType.Proceedings);
  69                 proceedings.setCacheStrategy(ReferenceType.Proceedings.getCacheStrategy());
  70                 return proceedings;
  71         }
  72
  73         public static ReferenceBase newBookSection(){
  74                 ReferenceBase<BookSectionDefaultCacheStrategy<ReferenceBase>> bookSection = new ReferenceBase<BookSectionDefaultCacheStrategy<ReferenceBase>>(ReferenceType.BookSection);
  75                 bookSection.setCacheStrategy(ReferenceType.BookSection.getCacheStrategy());
  76                 return bookSection;
  77         }
  78
  79         public static ReferenceBase newCdDvd(){
  80                 ReferenceBase<CdDvdDefaultCacheStrategy<ReferenceBase>> cdDvd= new ReferenceBase<CdDvdDefaultCacheStrategy<ReferenceBase>>(ReferenceType.CdDvd);
  81                 cdDvd.setCacheStrategy(ReferenceType.CdDvd.getCacheStrategy());
  82                 return cdDvd;
  83         }
  84
  85         public static ReferenceBase newGeneric(){
  86                 ReferenceBase generic = new ReferenceBase<GenericDefaultCacheStrategy>(ReferenceType.Generic);
  87                 generic.setCacheStrategy(ReferenceType.Generic.getCacheStrategy());
  88                 return generic;
  89         }
  90
  91         public static ReferenceBase newMap(){
  92                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> map = new ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>>(ReferenceType.Map);
  93                 map.setCacheStrategy(ReferenceType.Map.getCacheStrategy());
  94                 return map;
  95
  96         }
  97
  98         public static ReferenceBase newReport(){
  99                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> report = new ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>>(ReferenceType.Report);
 100                 report.setCacheStrategy(ReferenceType.Report.getCacheStrategy());
 101                 return report;
 102
 103         }
 104
 105         public static ReferenceBase newWebPage(){
 106                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> webPage = new ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>>(ReferenceType.WebPage);
 107                 webPage.setCacheStrategy(ReferenceType.WebPage.getCacheStrategy());
 108                 return webPage;
 109         }
 110
 111         public static ReferenceBase newDatabase(){
 112                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> db = new ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>>(ReferenceType.Database);
 113                 db.setCacheStrategy(ReferenceType.Database.getCacheStrategy());
 114                 return db;
 115         }
 116
 117
 118         /**
 119          * Creates a new empty print series instance.
 120          */
 121         public static ReferenceBase newPrintSeries() {
 122                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> refBase = new ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>>(ReferenceType.PrintSeries);
 123                 refBase.setCacheStrategy(ReferenceType.PrintSeries.getCacheStrategy());
 124                 return refBase;
 125         }
 126
 127         /**
 128          * Creates a new print series instance with a given title string.
 129          */
 130         public static ReferenceBase newPrintSeries(String series) {
 131                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> refBase = newPrintSeries();
 132                 refBase.setCacheStrategy(ReferenceType.PrintSeries.getCacheStrategy());
 133                 return refBase;
 134         }
 135
 136         public ReferenceBase newBookSection(ReferenceBase book, Person partAuthor,
 137                         String sectionTitle, String pages) {
 138                 ReferenceBase bookSection = newBookSection();
 139                 bookSection.setAuthorTeam(partAuthor);
 140                 bookSection.setTitle(sectionTitle);
 141                 bookSection.setPages(pages);
 142                 return bookSection;
 143         }
 144
 145         public static ReferenceBase newArticle(ReferenceBase inJournal, Person partAuthor,
 146                         String title, String pages, String series, String volume, TimePeriod datePublished) {
 147                 ReferenceBase article = newArticle();
 148                 article.setInReference(inJournal);
 149                 article.setAuthorTeam(partAuthor);
 150                 article.setTitle(title);
 151                 article.setPages(pages);
 152                 article.setVolume(volume);
 153                 article.setDatePublished(datePublished);
 154                 return article;
 155         }
 156
 157         /**
 158          * Returns a new reference for the according reference type. If reference type is <code>null</code>,
 159          * <code>null</code> is returned.
 160          * @param referenceType
 161          * @return
 162          */
 163         public static ReferenceBase newReference(ReferenceType referenceType) {
 164                 if (referenceType == null){
 165                         return null;
 166                 }
 167                 switch(referenceType){
 168                         case Article:
 169                                 return newArticle();
 170                         case Journal:
 171                                 return newJournal();
 172                         case BookSection:
 173                                 return newBookSection();
 174                         case CdDvd:
 175                                 return newCdDvd();
 176                         case Database:
 177                                 return newDatabase();
 178                         case InProceedings:
 179                                 return newInProceedings();
 180                         case Map:
 181                                 return newMap();
 182                         case Patent:
 183                                 return newPatent();
 184                         case PersonalCommunication:
 185                                 return newPersonalCommunication();
 186                         case PrintSeries:
 187                                 return newPrintSeries();
 188                         case Proceedings:
 189                                 return newProceedings();
 190                         case Report:
 191                                 return newReport();
 192                         case Thesis:
 193                                 return newThesis();
 194                         case WebPage:
 195                                 return newWebPage();
 196                         case Book:
 197                                 return newBook();
 198                         case Generic:
 199                                 return newGeneric();
 200                         default:
 201                                 logger.warn("Unknown reference type " + referenceType.getMessage() + ". Created generic reference instead.");
 202                                 return newGeneric();
 203                 }
 204         }
 205
 206         public static ReferenceBase newPersonalCommunication() {
 207                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> personalCommunication = new ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>>(ReferenceType.PersonalCommunication);
 208                 personalCommunication.setCacheStrategy(ReferenceType.PersonalCommunication.getCacheStrategy());
 209                 return personalCommunication;
 210         }
 211
 212         public static ReferenceBase newPatent() {
 213                 ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>> patent = new ReferenceBase<ReferenceBaseDefaultCacheStrategy<ReferenceBase>>(ReferenceType.Patent);
 214                 patent.setCacheStrategy(ReferenceType.Patent.getCacheStrategy());
 215                 return patent;
 216         }
 217
 218
 219
 220 }