001    /*
002     Copyright (c) 2012, Regents of the University of Colorado
003     All rights reserved.
004    
005     Redistribution and use in source and binary forms, with or without modification, 
006     are permitted provided that the following conditions are met:
007    
008     * Redistributions of source code must retain the above copyright notice, this 
009        list of conditions and the following disclaimer.
010       
011     * Redistributions in binary form must reproduce the above copyright notice, 
012        this list of conditions and the following disclaimer in the documentation 
013        and/or other materials provided with the distribution.
014       
015     * Neither the name of the University of Colorado nor the names of its 
016        contributors may be used to endorse or promote products derived from this 
017        software without specific prior written permission.
018    
019     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
020     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
021     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
022     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
023     ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
024     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
025     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
026     ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
027     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
028     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
029     */
030    package edu.ucdenver.ccp.medline.parser;
031    
032    import java.util.List;
033    
034    import lombok.EqualsAndHashCode;
035    import lombok.Getter;
036    import lombok.Setter;
037    import lombok.ToString;
038    
039    import com.thoughtworks.xstream.annotations.XStreamAlias;
040    import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
041    import com.thoughtworks.xstream.annotations.XStreamConverter;
042    import com.thoughtworks.xstream.annotations.XStreamImplicit;
043    import com.thoughtworks.xstream.converters.Converter;
044    import com.thoughtworks.xstream.converters.MarshallingContext;
045    import com.thoughtworks.xstream.converters.UnmarshallingContext;
046    import com.thoughtworks.xstream.io.HierarchicalStreamReader;
047    import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
048    
049    import edu.ucdenver.ccp.common.string.StringUtil;
050    
051    /**
052     * 
053     * The code in this class is complies with the 2012 NLM MedlineCitationSet DTD. Snippets of the DTD
054     * have been copied and pasted into the comments of the classes below.
055     * 
056     * DTD Key:<br>
057     * * = 0 or more occurrences (optional element, repeatable)<br>
058     * ? = 0 or 1 occurrences (optional element, at most 1)<br>
059     * + = 1 or more occurrences (required element, repeatable)<br>
060     * | = choice, one or the other but not both<br>
061     * no symbol = required element<br>
062     * 
063     * <pre>
064     * <!ELEMENT    MedlineCitation (PMID, DateCreated, DateCompleted?, DateRevised?,
065     *                               Article, MedlineJournalInfo, ChemicalList?,SupplMeshList?,
066     *                               CitationSubset*, CommentsCorrectionsList?, GeneSymbolList?,
067     *                               MeshHeadingList?,NumberOfReferences?, PersonalNameSubjectList?,
068     *                               OtherID*, OtherAbstract*, KeywordList*, SpaceFlightMission*, 
069     *                               InvestigatorList?, GeneralNote*)>
070     *                 
071     * <!ATTLIST    MedlineCitation 
072     *                     Owner  (NLM | NASA | PIP | KIE | HSR | HMD | NOTNLM) "NLM"
073     *                     Status (Completed | In-Process | PubMed-not-MEDLINE | 
074     *                             In-Data-Review | Publisher | MEDLINE | 
075     *                             OLDMEDLINE) #REQUIRED
076     *                     VersionID CDATA #IMPLIED
077     *                     VersionDate CDATA #IMPLIED>
078     *                 
079     * <!ELEMENT    PMID (#PCDATA)>
080     * <!ATTLIST    PMID Version CDATA #REQUIRED>
081     * <!ELEMENT DateCompleted (Year,Month,Day)>
082     * <!ELEMENT DateCreated (Year,Month,Day)>
083     * <!ELEMENT DateRevised (Year,Month,Day)>
084     * <!ELEMENT Article (Journal,ArticleTitle,((Pagination, ELocationID*) | 
085     *                       ELocationID+),Abstract?, Affiliation?, AuthorList?, 
086     *                       Language+, DataBankList?, GrantList?,PublicationTypeList, 
087     *                       VernacularTitle?, ArticleDate*)>
088     * <!ATTLIST Article 
089     *                 PubModel (Print | Print-Electronic | Electronic | 
090     *                           Electronic-Print) #REQUIRED>
091     * <!ELEMENT MedlineJournalInfo (Country?, MedlineTA, NlmUniqueID?,ISSNLinking?)>
092     * <!ELEMENT ChemicalList (Chemical+)>
093     * <!ELEMENT       SupplMeshList (SupplMeshName+)>
094     * <!ELEMENT CitationSubset (#PCDATA)>
095     * <!ELEMENT CommentsCorrectionsList (CommentsCorrections+)>
096     * <!ELEMENT GeneSymbolList (GeneSymbol+)>
097     * <!ELEMENT GeneSymbol (#PCDATA)>
098     * <!ELEMENT MeshHeadingList (MeshHeading+)>
099     * <!ELEMENT NumberOfReferences (#PCDATA)>
100     * <!ELEMENT PersonalNameSubjectList (PersonalNameSubject+)>
101     * <!ELEMENT    OtherID (#PCDATA)>
102     * <!ATTLIST    OtherID Source (NASA | KIE | PIP | POP | ARPL | CPC | 
103     *                              IND | CPFH | CLML | NRCBL | NLM) #REQUIRED>
104     * <!ELEMENT OtherAbstract (AbstractText+,CopyrightInformation?)>
105     * <!ATTLIST OtherAbstract Type (AAMC | AIDS | KIE | PIP | 
106     *                                  NASA | Publisher) #REQUIRED>
107     * <!ELEMENT KeywordList (Keyword+)>
108     * <!ATTLIST KeywordList Owner (NLM | NLM-AUTO | NASA | PIP | KIE | NOTNLM | HHS) "NLM">
109     * <!ELEMENT SpaceFlightMission (#PCDATA)>
110     * <!ELEMENT InvestigatorList (Investigator+)>
111     * <!ELEMENT GeneralNote (#PCDATA)>
112     * <!ATTLIST GeneralNote Owner (NLM | NASA | PIP | KIE | HSR | HMD) "NLM">
113     * </pre>
114     * 
115     * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
116     * 
117     */
118    @Getter
119    @ToString
120    @XStreamAlias("MedlineCitation")
121    public class MedlineCitation {
122    
123            @XStreamAlias("Owner")
124            @XStreamAsAttribute
125            private String owner;
126    
127            @XStreamAlias("Status")
128            @XStreamAsAttribute
129            private String status;
130    
131            @XStreamAlias("PMID")
132            private PubMedId pmid;
133    
134            @XStreamAlias("DateCreated")
135            private Date dateCreated;
136    
137            @XStreamAlias("DateCompleted")
138            private Date dateCompleted;
139    
140            @XStreamAlias("DateRevised")
141            private Date dateRevised;
142    
143            @XStreamAlias("Article")
144            private Article article;
145    
146            @XStreamAlias("MedlineJournalInfo")
147            private MedlineJournalInfo medlineJournalInfo;
148    
149            @XStreamAlias("ChemicalList")
150            private ChemicalList chemicalList;
151    
152            @XStreamImplicit(itemFieldName = "CitationSubset")
153            private List<String> citationSubsets;
154    
155            @XStreamAlias("MeshHeadingList")
156            private MeshHeadingList meshHeadingList;
157    
158            @XStreamAlias("CommentsCorrectionsList")
159            private CommentsCorrectionsList commentsCorrectionsList;
160    
161            @XStreamAlias("NumberOfReferences")
162            private Integer numberOfReferences;
163    
164            @XStreamImplicit
165            private List<OtherId> otherIds;
166    
167            @XStreamImplicit(itemFieldName = "OtherAbstract")
168            private List<Abstract> otherAbstractList;
169    
170            @XStreamImplicit
171            private List<KeywordList> keywordListList;
172    
173            @XStreamImplicit
174            private List<GeneralNote> generalNotes;
175    
176            @XStreamAlias("InvestigatorList")
177            private InvestigatorList investigatorList;
178    
179            @XStreamAlias("PersonalNameSubjectList")
180            private PersonalNameSubjectList personNameSubjectList;
181    
182            @XStreamImplicit(itemFieldName = "SpaceFlightMission")
183            private List<String> spaceFlightMissions;
184    
185            @XStreamAlias("SupplMeshList")
186            private SupplMeshList supplMeshList;
187    
188            @XStreamAlias("GeneSymbolList")
189            private GeneSymbolList geneSymbolList;
190    
191            /**
192             * 
193             * <pre>
194             * <!ELEMENTPMID (#PCDATA)>
195             * <!ATTLIST PMID Version CDATA #REQUIRED>
196             * </pre>
197             * 
198             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
199             */
200            @EqualsAndHashCode
201            @Setter
202            @Getter
203            @ToString
204            @XStreamConverter(PubMedIdConverter.class)
205            @XStreamAlias("PMID")
206            public static class PubMedId {
207                    @XStreamAlias("Version")
208                    @XStreamAsAttribute
209                    private String version;
210    
211                    private String pmid;
212            }
213    
214            public static class PubMedIdConverter implements Converter {
215    
216                    /*
217                     * (non-Javadoc)
218                     * 
219                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
220                     */
221                    @Override
222                    public boolean canConvert(Class clazz) {
223                            return PubMedId.class.equals(clazz);
224                    }
225    
226                    /*
227                     * (non-Javadoc)
228                     * 
229                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
230                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
231                     * com.thoughtworks.xstream.converters.MarshallingContext)
232                     */
233                    @Override
234                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
235                            PubMedId pmid = (PubMedId) object;
236                            hsw.addAttribute("Version", pmid.getVersion());
237                            hsw.setValue(pmid.getPmid());
238                    }
239    
240                    /*
241                     * (non-Javadoc)
242                     * 
243                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
244                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
245                     */
246                    @Override
247                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
248                            PubMedId pmid = new PubMedId();
249                            pmid.setVersion(hsr.getAttribute("Version"));
250                            pmid.setPmid(hsr.getValue());
251                            return pmid;
252                    }
253    
254            }
255    
256            /**
257             * 
258             * <pre>
259             * <!ELEMENT OtherID (#PCDATA)>
260             * <!ATTLIST OtherID Source (NASA | KIE | PIP | POP | ARPL | CPC | 
261             *                           IND | CPFH | CLML | NRCBL | NLM) #REQUIRED>
262             * </pre>
263             * 
264             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
265             */
266            @Setter
267            @Getter
268            @ToString
269            @XStreamAlias("OtherID")
270            @XStreamConverter(OtherIdConverter.class)
271            public static class OtherId {
272                    @XStreamAlias("Source")
273                    @XStreamAsAttribute
274                    private String source;
275    
276                    private String id;
277            }
278    
279            public static class OtherIdConverter implements Converter {
280    
281                    /*
282                     * (non-Javadoc)
283                     * 
284                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
285                     */
286                    public boolean canConvert(Class clazz) {
287                            return OtherId.class.equals(clazz);
288                    }
289    
290                    /*
291                     * (non-Javadoc)
292                     * 
293                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
294                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
295                     * com.thoughtworks.xstream.converters.MarshallingContext)
296                     */
297                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
298                            OtherId id = (OtherId) object;
299                            hsw.addAttribute("Source", id.getSource());
300                            hsw.setValue(id.getId());
301                    }
302    
303                    /*
304                     * (non-Javadoc)
305                     * 
306                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
307                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
308                     */
309                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
310                            OtherId id = new OtherId();
311                            id.setSource(hsr.getAttribute("Source"));
312                            id.setId(hsr.getValue());
313                            return id;
314                    }
315    
316            }
317    
318            /**
319             * <pre>
320             * <!ELEMENT Day (#PCDATA)>
321             * <!ELEMENT Month (#PCDATA)>
322             * <!ELEMENT Year (#PCDATA)>
323             * </pre>
324             * 
325             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
326             */
327            @Getter
328            public static class Date {
329                    @XStreamAlias("Year")
330                    private String year;
331                    @XStreamAlias("Month")
332                    private String month;
333                    @XStreamAlias("Day")
334                    private String day;
335    
336                    @Override
337                    public String toString() {
338                            String dateStr = "";
339                            if (year != null)
340                                    dateStr = year;
341                            if (month != null)
342                                    dateStr = month + "/" + year;
343                            if (day != null)
344                                    dateStr = month + "/" + day + "/" + year;
345                            return dateStr;
346                    }
347    
348            }
349    
350            /**
351             * <pre>
352             * <!ELEMENT ArticleDate (Year,Month,Day)>
353             * <!ATTLIST ArticleDate DateType CDATA  #FIXED "Electronic">
354             * </pre>
355             * 
356             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
357             * 
358             */
359            @Getter
360            @ToString
361            public static class ArticleDate extends Date {
362                    @XStreamAlias("DateType")
363                    @XStreamAsAttribute
364                    private String dateType;
365            }
366    
367            /**
368             * <pre>
369             * <!ELEMENT PubDate ((Year, ((Month, Day?) | Season)?) | MedlineDate)>
370             * <!ELEMENT MedlineDate (#PCDATA)>
371             * <!ELEMENT Season (#PCDATA)>
372             * </pre>
373             * 
374             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
375             * 
376             */
377            @Getter
378            public static class PubDate extends Date {
379                    @XStreamAlias("MedlineDate")
380                    private String medlineDate;
381    
382                    @XStreamAlias("Season")
383                    private String season;
384    
385                    /**
386                     * @return a string represenation of the publication date. If there is a "medline date" then
387                     *         it is returned. If not, then we check to see if there is a "year". If there is a
388                     *         year, then we return a string formatted to "M/D/Y" depending on the availablity
389                     *         of the month and day. If there is no year, then we check for a "season" returning
390                     *         it if it exists. If none of the previous cases pass then we return null. I don't
391                     *         think this method should ever return null however.
392                     */
393                    public String getDateStr() {
394                            if (getMedlineDate() != null && !getMedlineDate().isEmpty()) {
395                                    return getMedlineDate();
396                            } else if (getYear() != null && !getYear().isEmpty()) {
397                                    String dateStr = getYear();
398                                    if (getDay() != null && !getDay().isEmpty()) {
399                                            dateStr = getDay() + "/" + dateStr;
400                                    }
401                                    if (getMonth() != null && !getMonth().isEmpty()) {
402                                            int month = -1;
403                                            if (getMonth().equalsIgnoreCase("Jan")) {
404                                                    month = 1;
405                                            } else if (getMonth().equalsIgnoreCase("Feb")) {
406                                                    month = 2;
407                                            } else if (getMonth().equalsIgnoreCase("Mar")) {
408                                                    month = 3;
409                                            } else if (getMonth().equalsIgnoreCase("Apr")) {
410                                                    month = 4;
411                                            } else if (getMonth().equalsIgnoreCase("May")) {
412                                                    month = 5;
413                                            } else if (getMonth().equalsIgnoreCase("Jun")) {
414                                                    month = 6;
415                                            } else if (getMonth().equalsIgnoreCase("Jul")) {
416                                                    month = 7;
417                                            } else if (getMonth().equalsIgnoreCase("Aug")) {
418                                                    month = 8;
419                                            } else if (getMonth().equalsIgnoreCase("Sep")) {
420                                                    month = 9;
421                                            } else if (getMonth().equalsIgnoreCase("Oct")) {
422                                                    month = 10;
423                                            } else if (getMonth().equalsIgnoreCase("Nov")) {
424                                                    month = 11;
425                                            } else if (getMonth().equalsIgnoreCase("Dec")) {
426                                                    month = 12;
427                                            } else {
428                                                    throw new IllegalArgumentException("Unknown month: " + getMonth());
429                                            }
430                                            dateStr = month + "/" + dateStr;
431                                    }
432                                    return dateStr;
433                            } else if (getSeason() != null && !getSeason().isEmpty()) {
434                                    return getSeason();
435                            } else {
436                                    return null;
437                            }
438                    }
439            }
440    
441            /**
442             * <pre>
443             * <!ELEMENT Article (Journal,ArticleTitle,((Pagination, ELocationID*) | 
444             *                       ELocationID+),Abstract?, Affiliation?, AuthorList?, 
445             *                       Language+, DataBankList?, GrantList?,PublicationTypeList, 
446             *                       VernacularTitle?, ArticleDate*)>
447             * <!ATTLIST Article 
448             *                 PubModel (Print | Print-Electronic | Electronic | 
449             *                           Electronic-Print) #REQUIRED>
450             *                           
451             * <!ELEMENT Journal (ISSN?, JournalIssue, Title?, ISOAbbreviation?)>
452             * <!ELEMENT ArticleTitle (#PCDATA)>
453             * <!ELEMENT    Pagination ((StartPage, EndPage?, MedlinePgn?) | MedlinePgn)>
454             * <!ELEMENT ELocationID (#PCDATA)>
455             * <!ATTLIST ELocationID EIdType (doi | pii) #REQUIRED 
456             *              ValidYN  (Y | N) "Y">
457             * <!ELEMENT Abstract (AbstractText+,CopyrightInformation?)>
458             * <!ELEMENT Affiliation (#PCDATA)>
459             * <!ELEMENT AuthorList (Author+)>
460             * <!ATTLIST AuthorList CompleteYN (Y | N) "Y">
461             * <!ELEMENT Language (#PCDATA)>
462             * <!ELEMENT DataBankList (DataBank+)>
463             * <!ATTLIST DataBankList CompleteYN (Y | N) "Y">
464             * <!ELEMENT GrantList (Grant+)>
465             * <!ATTLIST GrantList CompleteYN (Y | N) "Y">
466             * <!ELEMENT PublicationTypeList (PublicationType+)>
467             * <!ELEMENT VernacularTitle (#PCDATA)>
468             * <!ELEMENT ArticleDate (Year,Month,Day)>
469             * </pre>
470             * 
471             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
472             */
473            @Getter
474            @ToString
475            public static class Article {
476    
477                    @XStreamAlias("PubModel")
478                    @XStreamAsAttribute
479                    private String pubModel;
480    
481                    @XStreamAlias("Journal")
482                    private Journal journal;
483    
484                    @XStreamAlias("ArticleTitle")
485                    private String articleTitle;
486    
487                    @XStreamAlias("Pagination")
488                    private Pagination pagination;
489    
490                    @XStreamAlias("Abstract")
491                    private Abstract theAbstract;
492    
493                    @XStreamAlias("Affiliation")
494                    private String affiliation;
495    
496                    @XStreamAlias("AuthorList")
497                    private AuthorList authorList;
498    
499                    @XStreamImplicit(itemFieldName = "Language")
500                    private List<String> languages;
501    
502                    @XStreamAlias("DataBankList")
503                    private DataBankList dataBankList;
504    
505                    @XStreamAlias("PublicationTypeList")
506                    private PublicationTypeList publicationTypeList;
507    
508                    @XStreamAlias("GrantList")
509                    private GrantList grantList;
510    
511                    @XStreamAlias("ArticleDate")
512                    private ArticleDate articleDate;
513    
514                    @XStreamAlias("VernacularTitle")
515                    private String vernacularTitle;
516    
517                    @XStreamImplicit
518                    private List<ELocationId> eLocationIds;
519    
520            }
521    
522            /**
523             * <pre>
524             * <!ELEMENT ELocationID (#PCDATA)>
525             * <!ATTLIST ELocationID EIdType (doi | pii) #REQUIRED 
526             *              ValidYN  (Y | N) "Y">
527             * </pre>
528             * 
529             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
530             */
531            @Setter
532            @Getter
533            @ToString
534            @XStreamAlias("ELocationID")
535            @XStreamConverter(ELocationIdConverter.class)
536            public static class ELocationId {
537                    @XStreamAlias("EIdType")
538                    @XStreamAsAttribute
539                    private String eIdType;
540    
541                    @XStreamAlias("ValidYN")
542                    @XStreamAsAttribute
543                    private String validYn;
544    
545                    private String eLocationId;
546            }
547    
548            public static class ELocationIdConverter implements Converter {
549    
550                    /*
551                     * (non-Javadoc)
552                     * 
553                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
554                     */
555                    @Override
556                    public boolean canConvert(Class clazz) {
557                            return ELocationId.class.equals(clazz);
558                    }
559    
560                    /*
561                     * (non-Javadoc)
562                     * 
563                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
564                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
565                     * com.thoughtworks.xstream.converters.MarshallingContext)
566                     */
567                    @Override
568                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
569                            ELocationId id = (ELocationId) object;
570                            hsw.addAttribute("EIdType", id.getEIdType());
571                            hsw.addAttribute("ValidYN", id.getValidYn());
572                            hsw.setValue(id.getELocationId());
573                    }
574    
575                    /*
576                     * (non-Javadoc)
577                     * 
578                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
579                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
580                     */
581                    @Override
582                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
583                            ELocationId id = new ELocationId();
584                            id.setEIdType(hsr.getAttribute("EIdType"));
585                            id.setValidYn(hsr.getAttribute("ValidYN"));
586                            id.setELocationId(hsr.getValue());
587                            return id;
588                    }
589    
590            }
591    
592            /**
593             * <pre>
594             * <!ELEMENT Journal (ISSN?, JournalIssue, Title?, ISOAbbreviation?)>
595             * <!ELEMENT ISSN (#PCDATA)>
596             * <!ATTLIST ISSN IssnType  (Electronic | Print) #REQUIRED>
597             * <!ELEMENT JournalIssue (Volume?, Issue?, PubDate)>
598             * <!ATTLIST JournalIssue CitedMedium (Internet | Print) #REQUIRED>
599             * <!ELEMENT Title (#PCDATA)>
600             * <!ELEMENT ISOAbbreviation (#PCDATA)>
601             * </pre>
602             * 
603             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
604             */
605            @Getter
606            @ToString
607            public static class Journal {
608                    @XStreamAlias("ISSN")
609                    private Issn issn;
610    
611                    @XStreamAlias("JournalIssue")
612                    private JournalIssue journalIssue;
613    
614                    @XStreamAlias("Title")
615                    private String title;
616    
617                    @XStreamAlias("ISOAbbreviation")
618                    private String isoAbbreviation;
619    
620            }
621    
622            /**
623             * <pre>
624             * <!ELEMENT ISSN (#PCDATA)>
625             * <!ATTLIST ISSN IssnType  (Electronic | Print) #REQUIRED>
626             * </pre>
627             * 
628             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
629             */
630            @Setter
631            @Getter
632            @ToString
633            @XStreamConverter(IssnConverter.class)
634            public static class Issn {
635                    @XStreamAlias("IssnType")
636                    @XStreamAsAttribute
637                    private String type;
638    
639                    private String issn;
640            }
641    
642            public static class IssnConverter implements Converter {
643    
644                    /*
645                     * (non-Javadoc)
646                     * 
647                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
648                     */
649                    @Override
650                    public boolean canConvert(Class clazz) {
651                            return Issn.class.equals(clazz);
652                    }
653    
654                    /*
655                     * (non-Javadoc)
656                     * 
657                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
658                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
659                     * com.thoughtworks.xstream.converters.MarshallingContext)
660                     */
661                    @Override
662                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
663                            Issn issn = (Issn) object;
664                            hsw.addAttribute("IssnType", issn.getType());
665                            hsw.setValue(issn.getIssn());
666                    }
667    
668                    /*
669                     * (non-Javadoc)
670                     * 
671                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
672                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
673                     */
674                    @Override
675                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
676                            Issn issn = new Issn();
677                            issn.setType(hsr.getAttribute("IssnType"));
678                            issn.setIssn(hsr.getValue());
679                            return issn;
680                    }
681    
682            }
683    
684            /**
685             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
686             * 
687             *         <pre>
688             * <!ELEMENT JournalIssue (Volume?, Issue?, PubDate)>
689             * <!ATTLIST JournalIssue CitedMedium (Internet | Print) #REQUIRED>
690             * <!ELEMENT Volume (#PCDATA)>
691             * <!ELEMENT Issue (#PCDATA)>
692             * <!ELEMENT PubDate ((Year, ((Month, Day?) | Season)?) | MedlineDate)>
693             * </pre>
694             */
695            @Getter
696            @ToString
697            public static class JournalIssue {
698                    @XStreamAlias("CitedMedium")
699                    @XStreamAsAttribute
700                    private String citedMedium;
701    
702                    @XStreamAlias("Volume")
703                    private String volume;
704                    @XStreamAlias("Issue")
705                    private String issue;
706                    @XStreamAlias("PubDate")
707                    private PubDate pubDate;
708            }
709    
710            /**
711             * NOTE: StartPage and EndPage in the Pagination element are not currently used; are reserved
712             * for future use.
713             * 
714             * <pre>
715             * <!ELEMENT   Pagination ((StartPage, EndPage?, MedlinePgn?) | MedlinePgn)>
716             * <!ELEMENT   StartPage (#PCDATA)>
717             * <!ELEMENT   EndPage (#PCDATA)>
718             * <!ELEMENT   MedlinePgn (#PCDATA)>
719             * </pre>
720             * 
721             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
722             */
723            @Getter
724            public static class Pagination {
725    
726                    @XStreamAlias("MedlinePgn")
727                    private String medlinePagination;
728    
729                    @XStreamAlias("StartPage")
730                    private String startPage;
731    
732                    @XStreamAlias("EndPage")
733                    private String endPage;
734    
735                    @Override
736                    public String toString() {
737                            if (medlinePagination != null)
738                                    return medlinePagination;
739                            if (startPage != null && endPage != null)
740                                    return startPage + "-" + endPage;
741                            return null;
742                    }
743    
744            }
745    
746            /**
747             * <pre>
748             * <!ELEMENT Abstract (AbstractText+,CopyrightInformation?)>
749             * <!ELEMENT CopyrightInformation (#PCDATA)>
750             * </pre>
751             * 
752             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
753             */
754            @Getter
755            public static class Abstract {
756                    @XStreamAlias("Type")
757                    @XStreamAsAttribute
758                    private String type;
759    
760                    @XStreamAlias("AbstractText")
761                    @XStreamImplicit
762                    private List<AbstractText> abstractTexts;
763    
764                    @XStreamAlias("CopyrightInformation")
765                    private String copyrightInformation;
766    
767                    @Override
768                    public String toString() {
769                            StringBuffer sb = new StringBuffer();
770                            for (AbstractText text : abstractTexts) {
771                                    sb.append(text.getAbstractText() + " ");
772                            }
773                            return StringUtil.removeLastCharacter(sb.toString());
774                    }
775            }
776    
777            /**
778             * <pre>
779             * <!ELEMENT AbstractText (#PCDATA)>
780             * <!ATTLIST       AbstractText
781             *                 Label CDATA #IMPLIED
782             *                 NlmCategory (UNLABELLED | BACKGROUND | OBJECTIVE | METHODS |
783             *                              RESULTS | CONCLUSIONS) #IMPLIED>
784             * </pre>
785             * 
786             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
787             */
788            @Setter
789            @Getter
790            @ToString
791            @XStreamConverter(AbstractTextConverter.class)
792            public static class AbstractText {
793                    @XStreamAlias("Label")
794                    @XStreamAsAttribute
795                    private String label;
796    
797                    @XStreamAlias("NlmCategory")
798                    @XStreamAsAttribute
799                    private String nlmCategory;
800    
801                    private String abstractText;
802    
803            }
804    
805            public static class AbstractTextConverter implements Converter {
806    
807                    /*
808                     * (non-Javadoc)
809                     * 
810                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
811                     */
812                    @Override
813                    public boolean canConvert(Class clazz) {
814                            return AbstractText.class.equals(clazz);
815                    }
816    
817                    /*
818                     * (non-Javadoc)
819                     * 
820                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
821                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
822                     * com.thoughtworks.xstream.converters.MarshallingContext)
823                     */
824                    @Override
825                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
826                            AbstractText abstractText = (AbstractText) object;
827                            hsw.addAttribute("Label", abstractText.getLabel());
828                            hsw.addAttribute("NlmCategory", abstractText.getNlmCategory());
829                            hsw.setValue(abstractText.getAbstractText());
830                    }
831    
832                    /*
833                     * (non-Javadoc)
834                     * 
835                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
836                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
837                     */
838                    @Override
839                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
840                            AbstractText abstractText = new AbstractText();
841                            abstractText.setLabel(hsr.getAttribute("Label"));
842                            abstractText.setLabel(hsr.getAttribute("NlmCategory"));
843                            abstractText.setAbstractText(hsr.getValue());
844                            return abstractText;
845                    }
846    
847            }
848    
849            /**
850             * <pre>
851             * <!ELEMENT AuthorList (Author+)>
852             * <!ATTLIST AuthorList CompleteYN (Y | N) "Y">
853             * </pre>
854             * 
855             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
856             */
857            @Getter
858            @ToString
859            public static class AuthorList {
860                    @XStreamImplicit
861                    private List<Author> authors;
862            }
863    
864            /**
865             * <pre>
866             * <!ELEMENT Author (((LastName, ForeName?, Initials?, Suffix?) | 
867             *                          CollectiveName),NameID*)>
868             * <!ATTLIST Author ValidYN (Y | N) "Y">
869             * <!ELEMENT LastName (#PCDATA)>
870             * <!ELEMENT ForeName (#PCDATA)>
871             * <!ELEMENT Initials (#PCDATA)>
872             * <!ELEMENT Suffix (#PCDATA)>
873             * <!ELEMENT CollectiveName (#PCDATA)>
874             * <!ELEMENT    NameID (#PCDATA)>
875             * </pre>
876             * 
877             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
878             */
879            @Getter
880            @ToString
881            @XStreamAlias("Author")
882            public static class Author {
883                    @XStreamAlias("ValidYN")
884                    @XStreamAsAttribute
885                    private String validYn;
886    
887                    @XStreamAlias("LastName")
888                    private String lastName;
889    
890                    @XStreamAlias("ForeName")
891                    private String foreName;
892    
893                    @XStreamAlias("Initials")
894                    private String initials;
895    
896                    @XStreamAlias("Suffix")
897                    private String suffix;
898    
899                    @XStreamAlias("CollectiveName")
900                    private String collectiveName;
901    
902                    @XStreamAlias("NameID")
903                    private NameId nameId;
904    
905            }
906    
907            /**
908             * <pre>
909             * <!ELEMENT InvestigatorList (Investigator+)>
910             * </pre>
911             * 
912             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
913             */
914            @Getter
915            @ToString
916            public static class InvestigatorList {
917                    @XStreamImplicit
918                    private List<Investigator> investigators;
919            }
920    
921            /**
922             * 
923             * NOTE: NameID in Investigator element is not currently used; reserved for future use.
924             * 
925             * <pre>
926             * <!ELEMENT Investigator (LastName,ForeName?, Initials?,Suffix?,NameID*,Affiliation?)>
927             * <!ATTLIST Investigator ValidYN (Y | N) "Y">
928             * <!ELEMENT LastName (#PCDATA)>
929             * <!ELEMENT ForeName (#PCDATA)>
930             * <!ELEMENT Initials (#PCDATA)>
931             * <!ELEMENT Suffix (#PCDATA)>
932             * <!ELEMENT    NameID (#PCDATA)>
933             * <!ELEMENT Affiliation (#PCDATA)>
934             * </pre>
935             * 
936             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
937             */
938            @Getter
939            @ToString
940            @XStreamAlias("Investigator")
941            public static class Investigator {
942                    @XStreamAlias("ValidYN")
943                    @XStreamAsAttribute
944                    private String validYn;
945    
946                    @XStreamAlias("LastName")
947                    private String lastName;
948    
949                    @XStreamAlias("ForeName")
950                    private String foreName;
951    
952                    @XStreamAlias("Initials")
953                    private String initials;
954    
955                    @XStreamAlias("Suffix")
956                    private String suffix;
957    
958                    @XStreamAlias("Affiliation")
959                    private String affiliation;
960    
961                    @XStreamAlias("NameID")
962                    private NameId nameId;
963    
964            }
965    
966            /**
967             * <pre>
968             * <!ELEMENT   NameID (#PCDATA)>
969             * <!ATTLIST   NameID 
970             *             Source CDATA #REQUIRED >
971             * </pre>
972             * 
973             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
974             * 
975             */
976            @Setter
977            @Getter
978            @ToString
979            @XStreamConverter(NameIdConverter.class)
980            public static class NameId {
981                    @XStreamAlias("Source")
982                    @XStreamAsAttribute
983                    private String source;
984    
985                    private String nameId;
986            }
987    
988            public static class NameIdConverter implements Converter {
989    
990                    /*
991                     * (non-Javadoc)
992                     * 
993                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
994                     */
995                    @Override
996                    public boolean canConvert(Class clazz) {
997                            return NameId.class.equals(clazz);
998                    }
999    
1000                    /*
1001                     * (non-Javadoc)
1002                     * 
1003                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
1004                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
1005                     * com.thoughtworks.xstream.converters.MarshallingContext)
1006                     */
1007                    @Override
1008                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
1009                            NameId nameId = (NameId) object;
1010                            hsw.addAttribute("Source", nameId.getSource());
1011                            hsw.setValue(nameId.getNameId());
1012                    }
1013    
1014                    /*
1015                     * (non-Javadoc)
1016                     * 
1017                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
1018                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
1019                     */
1020                    @Override
1021                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
1022                            NameId nameId = new NameId();
1023                            nameId.setSource(hsr.getAttribute("Source"));
1024                            nameId.setNameId(hsr.getValue());
1025                            return nameId;
1026                    }
1027            }
1028    
1029            /**
1030             * 
1031             * <pre>
1032             * <!ELEMENT PersonalNameSubjectList (PersonalNameSubject+)>
1033             * </pre>
1034             * 
1035             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1036             */
1037            @Getter
1038            @ToString
1039            public static class PersonalNameSubjectList {
1040                    @XStreamImplicit
1041                    private List<PersonalNameSubject> personalNameSubjects;
1042            }
1043    
1044            /**
1045             * <pre>
1046             * <!ELEMENT PersonalNameSubject (LastName,ForeName?, Initials?,Suffix?)>
1047             * <!ELEMENT LastName (#PCDATA)>
1048             * <!ELEMENT ForeName (#PCDATA)>
1049             * <!ELEMENT Initials (#PCDATA)>
1050             * <!ELEMENT Suffix (#PCDATA)>
1051             * </pre>
1052             * 
1053             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1054             */
1055            @Getter
1056            @ToString
1057            @XStreamAlias("PersonalNameSubject")
1058            public static class PersonalNameSubject {
1059                    @XStreamAlias("LastName")
1060                    private String lastName;
1061    
1062                    @XStreamAlias("ForeName")
1063                    private String foreName;
1064    
1065                    @XStreamAlias("Initials")
1066                    private String initials;
1067    
1068                    @XStreamAlias("Suffix")
1069                    private String suffix;
1070    
1071            }
1072    
1073            /**
1074             * <pre>
1075             * <!ELEMENT       SupplMeshList (SupplMeshName+)>
1076             * </pre>
1077             * 
1078             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1079             */
1080            @Getter
1081            @ToString
1082            public static class SupplMeshList {
1083                    @XStreamImplicit
1084                    private List<SupplMeshName> supplMeshNames;
1085            }
1086    
1087            /**
1088             * <pre>
1089             * <!ELEMENT       SupplMeshName (#PCDATA)>
1090             * <!ATTLIST       SupplMeshName Type (Disease | Protocol) #REQUIRED>
1091             * </pre>
1092             * 
1093             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1094             */
1095            @Setter
1096            @Getter
1097            @ToString
1098            @XStreamAlias("SupplMeshName")
1099            @XStreamConverter(SupplMeshNameConverter.class)
1100            public static class SupplMeshName {
1101                    @XStreamAlias("Type")
1102                    @XStreamAsAttribute
1103                    private String type;
1104    
1105                    private String name;
1106            }
1107    
1108            public static class SupplMeshNameConverter implements Converter {
1109    
1110                    /*
1111                     * (non-Javadoc)
1112                     * 
1113                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
1114                     */
1115                    @Override
1116                    public boolean canConvert(Class clazz) {
1117                            return SupplMeshName.class.equals(clazz);
1118                    }
1119    
1120                    /*
1121                     * (non-Javadoc)
1122                     * 
1123                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
1124                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
1125                     * com.thoughtworks.xstream.converters.MarshallingContext)
1126                     */
1127                    @Override
1128                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
1129                            SupplMeshName name = (SupplMeshName) object;
1130                            hsw.addAttribute("Type", name.getType());
1131                            hsw.setValue(name.getName());
1132                    }
1133    
1134                    /*
1135                     * (non-Javadoc)
1136                     * 
1137                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
1138                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
1139                     */
1140                    @Override
1141                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
1142                            SupplMeshName name = new SupplMeshName();
1143                            name.setType(hsr.getAttribute("Type"));
1144                            name.setName(hsr.getValue());
1145                            return name;
1146                    }
1147    
1148            }
1149    
1150            /**
1151             * <pre>
1152             * <!ELEMENT DataBankList (DataBank+)>
1153             * <!ATTLIST DataBankList CompleteYN (Y | N) "Y">
1154             * </pre>
1155             * 
1156             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1157             */
1158            @Getter
1159            @ToString
1160            public static class DataBankList {
1161                    @XStreamAlias("CompleteYN")
1162                    @XStreamAsAttribute
1163                    private String completeYn;
1164    
1165                    @XStreamImplicit
1166                    private List<DataBank> dataBanks;
1167            }
1168    
1169            /**
1170             * <pre>
1171             * <!ELEMENT DataBank (DataBankName, AccessionNumberList?)>
1172             * <!ELEMENT DataBankName (#PCDATA)>
1173             * </pre>
1174             * 
1175             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1176             */
1177            @Getter
1178            @ToString
1179            @XStreamAlias("DataBank")
1180            public static class DataBank {
1181    
1182                    @XStreamAlias("DataBankName")
1183                    private String dataBankName;
1184    
1185                    @XStreamAlias("AccessionNumberList")
1186                    private AccessionNumberList accessionNumberList;
1187            }
1188    
1189            /**
1190             * <pre>
1191             * <!ELEMENT GrantList (Grant+)>
1192             * <!ATTLIST GrantList CompleteYN (Y | N) "Y">
1193             * </pre>
1194             * 
1195             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1196             */
1197            @Getter
1198            @ToString
1199            public static class GrantList {
1200                    @XStreamAlias("CompleteYN")
1201                    @XStreamAsAttribute
1202                    private String completeYn;
1203    
1204                    @XStreamImplicit
1205                    private List<Grant> grants;
1206            }
1207    
1208            /**
1209             * <pre>
1210             * <!ELEMENT Grant (GrantID?, Acronym?, Agency, Country)>
1211             * <!ELEMENT GrantID (#PCDATA)>
1212             * <!ELEMENT Acronym (#PCDATA)>
1213             * <!ELEMENT Agency (#PCDATA)>
1214             * <!ELEMENT Country (#PCDATA)>
1215             * </pre>
1216             * 
1217             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1218             */
1219            @Getter
1220            @ToString
1221            @XStreamAlias("Grant")
1222            public static class Grant {
1223    
1224                    @XStreamAlias("GrantID")
1225                    private String grantId;
1226    
1227                    @XStreamAlias("Acronym")
1228                    private String acronym;
1229    
1230                    @XStreamAlias("Agency")
1231                    private String agency;
1232    
1233                    @XStreamAlias("Country")
1234                    private String country;
1235            }
1236    
1237            /**
1238             * <pre>
1239             * <!ELEMENT AccessionNumberList (AccessionNumber+)>
1240             * <!ELEMENT AccessionNumber (#PCDATA)>
1241             * </pre>
1242             * 
1243             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1244             */
1245            @Getter
1246            @ToString
1247            public static class AccessionNumberList {
1248                    @XStreamImplicit(itemFieldName = "AccessionNumber")
1249                    private List<String> accessionNumbers;
1250            }
1251    
1252            /**
1253             * <pre>
1254             * <!ELEMENT PublicationTypeList (PublicationType+)>
1255             * <!ELEMENT PublicationType (#PCDATA)>
1256             * </pre>
1257             * 
1258             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1259             */
1260            @Getter
1261            @ToString
1262            public static class PublicationTypeList {
1263                    @XStreamImplicit(itemFieldName = "PublicationType")
1264                    private List<String> publicationTypes;
1265            }
1266    
1267            /**
1268             * <pre>
1269             * <!ELEMENT MedlineJournalInfo (Country?, MedlineTA, NlmUniqueID?,ISSNLinking?)>
1270             * <!ELEMENT Country (#PCDATA)>
1271             * <!ELEMENT MedlineTA (#PCDATA)>
1272             * <!ELEMENT NlmUniqueID (#PCDATA)>
1273             * <!ELEMENT    ISSNLinking (#PCDATA)>
1274             * </pre>
1275             * 
1276             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1277             */
1278            @Getter
1279            @ToString
1280            public static class MedlineJournalInfo {
1281                    @XStreamAlias("Country")
1282                    private String country;
1283    
1284                    @XStreamAlias("MedlineTA")
1285                    private String medlineTa;
1286    
1287                    @XStreamAlias("NlmUniqueID")
1288                    private String nlmUniqueId;
1289    
1290                    @XStreamAlias("ISSNLinking")
1291                    private String issnLinking;
1292            }
1293    
1294            /**
1295             * <pre>
1296             * <!ELEMENT ChemicalList (Chemical+)>
1297             * </pre>
1298             * 
1299             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1300             */
1301            @Getter
1302            @ToString
1303            public static class ChemicalList {
1304                    @XStreamImplicit
1305                    private List<Chemical> chemicals;
1306            }
1307    
1308            /**
1309             * <pre>
1310             * <!ELEMENT Chemical (RegistryNumber,NameOfSubstance)>
1311             * <!ELEMENT NameOfSubstance (#PCDATA)>
1312             * <!ELEMENT RegistryNumber (#PCDATA)>
1313             * </pre>
1314             * 
1315             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1316             */
1317            @Getter
1318            @ToString
1319            @XStreamAlias("Chemical")
1320            public static class Chemical {
1321                    @XStreamAlias("RegistryNumber")
1322                    private String registryNumber;
1323    
1324                    @XStreamAlias("NameOfSubstance")
1325                    private String substanceName;
1326            }
1327    
1328            /**
1329             * <pre>
1330             * <!ELEMENT MeshHeadingList (MeshHeading+)>
1331             * </pre>
1332             * 
1333             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1334             */
1335            @Getter
1336            @ToString
1337            public static class MeshHeadingList {
1338                    @XStreamImplicit
1339                    private List<MeshHeading> meshHeadings;
1340            }
1341    
1342            /**
1343             * <pre>
1344             * <!ELEMENT MeshHeading (DescriptorName, QualifierName*)>
1345             * </pre>
1346             * 
1347             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1348             */
1349            @Getter
1350            @ToString
1351            @XStreamAlias("MeshHeading")
1352            public static class MeshHeading {
1353    
1354                    @XStreamAlias("DescriptorName")
1355                    private MeshDescriptorName descriptorName;
1356    
1357                    @XStreamImplicit
1358                    private List<MeshQualifierName> qualifierNames;
1359    
1360            }
1361    
1362            /**
1363             * <pre>
1364             * <!ELEMENT QualifierName (#PCDATA)>
1365             * <!ATTLIST QualifierName MajorTopicYN (Y | N) "N">
1366             * </pre>
1367             * 
1368             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1369             */
1370            @Setter
1371            @Getter
1372            @ToString
1373            @XStreamAlias("QualifierName")
1374            @XStreamConverter(MeshQualiferNameConverter.class)
1375            public static class MeshQualifierName {
1376                    @XStreamAlias("MajorTopicYN")
1377                    @XStreamAsAttribute
1378                    private String majorTopicYn;
1379    
1380                    private String name;
1381            }
1382    
1383            public static class MeshQualiferNameConverter implements Converter {
1384    
1385                    /*
1386                     * (non-Javadoc)
1387                     * 
1388                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
1389                     */
1390                    @Override
1391                    public boolean canConvert(Class clazz) {
1392                            return MeshQualifierName.class.equals(clazz);
1393                    }
1394    
1395                    /*
1396                     * (non-Javadoc)
1397                     * 
1398                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
1399                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
1400                     * com.thoughtworks.xstream.converters.MarshallingContext)
1401                     */
1402                    @Override
1403                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
1404                            MeshQualifierName descriptorName = (MeshQualifierName) object;
1405                            hsw.addAttribute("MajorTopicYN", descriptorName.getMajorTopicYn());
1406                            hsw.setValue(descriptorName.getName());
1407                    }
1408    
1409                    /*
1410                     * (non-Javadoc)
1411                     * 
1412                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
1413                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
1414                     */
1415                    @Override
1416                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
1417                            MeshQualifierName descriptorName = new MeshQualifierName();
1418                            descriptorName.setMajorTopicYn(hsr.getAttribute("MajorTopicYN"));
1419                            descriptorName.setName(hsr.getValue());
1420                            return descriptorName;
1421                    }
1422    
1423            }
1424    
1425            /**
1426             * <pre>
1427             * <!ELEMENT DescriptorName (#PCDATA)>
1428             * <!ATTLIST DescriptorName 
1429             *                 MajorTopicYN (Y | N) "N"
1430             *                 Type (Geographic) #IMPLIED>
1431             * </pre>
1432             * 
1433             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1434             */
1435            @Setter
1436            @Getter
1437            @ToString
1438            @XStreamAlias("DescriptorName")
1439            @XStreamConverter(MeshDescriptorNameConverter.class)
1440            public static class MeshDescriptorName {
1441                    @XStreamAlias("MajorTopicYN")
1442                    @XStreamAsAttribute
1443                    private String majorTopicYn;
1444    
1445                    @XStreamAlias("Type")
1446                    @XStreamAsAttribute
1447                    private String type;
1448    
1449                    private String name;
1450            }
1451    
1452            public static class MeshDescriptorNameConverter implements Converter {
1453    
1454                    /*
1455                     * (non-Javadoc)
1456                     * 
1457                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
1458                     */
1459                    @Override
1460                    public boolean canConvert(Class clazz) {
1461                            return MeshDescriptorName.class.equals(clazz);
1462                    }
1463    
1464                    /*
1465                     * (non-Javadoc)
1466                     * 
1467                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
1468                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
1469                     * com.thoughtworks.xstream.converters.MarshallingContext)
1470                     */
1471                    @Override
1472                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
1473                            MeshDescriptorName descriptorName = (MeshDescriptorName) object;
1474                            hsw.addAttribute("MajorTopicYN", descriptorName.getMajorTopicYn());
1475                            hsw.addAttribute("Type", descriptorName.getType());
1476                            hsw.setValue(descriptorName.getName());
1477                    }
1478    
1479                    /*
1480                     * (non-Javadoc)
1481                     * 
1482                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
1483                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
1484                     */
1485                    @Override
1486                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
1487                            MeshDescriptorName descriptorName = new MeshDescriptorName();
1488                            descriptorName.setMajorTopicYn(hsr.getAttribute("MajorTopicYN"));
1489                            descriptorName.setType(hsr.getAttribute("Type"));
1490                            descriptorName.setName(hsr.getValue());
1491                            return descriptorName;
1492                    }
1493    
1494            }
1495    
1496            /**
1497             * 
1498             * <pre>
1499             * <!ELEMENT CommentsCorrectionsList (CommentsCorrections+)>
1500             * </pre>
1501             * 
1502             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1503             */
1504            @Getter
1505            @ToString
1506            @XStreamAlias("CommentsCorrections")
1507            public static class CommentsCorrectionsList {
1508                    @XStreamImplicit
1509                    private List<CommentsCorrections> commentsCorrections;
1510            }
1511    
1512            /**
1513             * 
1514             * <pre>
1515             * <!ELEMENT CommentsCorrections (RefSource,PMID?,Note?)>
1516             * <!ATTLIST   CommentsCorrections 
1517             *                 RefType (CommentOn | CommentIn | ErratumIn | ErratumFor | 
1518             *                 PartialRetractionIn | PartialRetractionOf | RepublishedFrom |
1519             *                 RepublishedIn | RetractionOf | RetractionIn | UpdateIn |
1520             *                 UpdateOf | SummaryForPatientsIn | OriginalReportIn |
1521             *                 ReprintOf | ReprintIn | Cites) #REQUIRED >
1522             * <!ELEMENT RefSource (#PCDATA)>
1523             * <!ELEMENT Note (#PCDATA)>
1524             * </pre>
1525             * 
1526             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1527             */
1528            @Getter
1529            @ToString
1530            @XStreamAlias("CommentsCorrections")
1531            public static class CommentsCorrections {
1532                    @XStreamAlias("RefType")
1533                    @XStreamAsAttribute
1534                    private String refType;
1535    
1536                    @XStreamAlias("RefSource")
1537                    private String refSource;
1538    
1539                    @XStreamAlias("Note")
1540                    private String note;
1541    
1542                    @XStreamAlias("PMID")
1543                    private PubMedId pmid;
1544            }
1545    
1546            /**
1547             * 
1548             * <pre>
1549             * <!ELEMENT KeywordList (Keyword+)>
1550             * <!ATTLIST KeywordList Owner (NLM | NLM-AUTO | NASA | PIP | KIE | NOTNLM | HHS) "NLM">
1551             * </pre>
1552             * 
1553             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1554             */
1555            @Getter
1556            @ToString
1557            @XStreamAlias("KeywordList")
1558            public static class KeywordList {
1559                    @XStreamImplicit
1560                    private List<Keyword> keywords;
1561            }
1562    
1563            /**
1564             * 
1565             * <pre>
1566             * <!ELEMENT Keyword (#PCDATA)>
1567             * <!ATTLIST Keyword MajorTopicYN (Y | N) "N">
1568             * </pre>
1569             * 
1570             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1571             */
1572            @Setter
1573            @Getter
1574            @ToString
1575            @XStreamAlias("Keyword")
1576            @XStreamConverter(KeywordConverter.class)
1577            public static class Keyword {
1578                    @XStreamAlias("MajorTopicYN")
1579                    @XStreamAsAttribute
1580                    private String majorTopicYn;
1581    
1582                    private String keyword;
1583            }
1584    
1585            public static class KeywordConverter implements Converter {
1586    
1587                    /*
1588                     * (non-Javadoc)
1589                     * 
1590                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
1591                     */
1592                    @Override
1593                    public boolean canConvert(Class clazz) {
1594                            return Keyword.class.equals(clazz);
1595                    }
1596    
1597                    /*
1598                     * (non-Javadoc)
1599                     * 
1600                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
1601                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
1602                     * com.thoughtworks.xstream.converters.MarshallingContext)
1603                     */
1604                    @Override
1605                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
1606                            Keyword keyword = (Keyword) object;
1607                            hsw.addAttribute("MajorTopicYN", keyword.getMajorTopicYn());
1608                            hsw.setValue(keyword.getKeyword());
1609                    }
1610    
1611                    /*
1612                     * (non-Javadoc)
1613                     * 
1614                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
1615                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
1616                     */
1617                    @Override
1618                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
1619                            Keyword keyword = new Keyword();
1620                            keyword.setMajorTopicYn(hsr.getAttribute("MajorTopicYN"));
1621                            keyword.setKeyword(hsr.getValue());
1622                            return keyword;
1623                    }
1624    
1625            }
1626    
1627            /**
1628             * <pre>
1629             * <!ELEMENT GeneralNote (#PCDATA)>
1630             * <!ATTLIST GeneralNote Owner (NLM | NASA | PIP | KIE | HSR | HMD) "NLM">
1631             * </pre>
1632             * 
1633             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1634             */
1635            @Setter
1636            @Getter
1637            @ToString
1638            @XStreamAlias("GeneralNote")
1639            @XStreamConverter(GeneralNoteConverter.class)
1640            public static class GeneralNote {
1641                    @XStreamAlias("Owner")
1642                    @XStreamAsAttribute
1643                    private String owner;
1644    
1645                    private String note;
1646            }
1647    
1648            public static class GeneralNoteConverter implements Converter {
1649    
1650                    /*
1651                     * (non-Javadoc)
1652                     * 
1653                     * @see com.thoughtworks.xstream.converters.ConverterMatcher#canConvert(java.lang.Class)
1654                     */
1655                    @Override
1656                    public boolean canConvert(Class clazz) {
1657                            return GeneralNote.class.equals(clazz);
1658                    }
1659    
1660                    /*
1661                     * (non-Javadoc)
1662                     * 
1663                     * @see com.thoughtworks.xstream.converters.Converter#marshal(java.lang.Object,
1664                     * com.thoughtworks.xstream.io.HierarchicalStreamWriter,
1665                     * com.thoughtworks.xstream.converters.MarshallingContext)
1666                     */
1667                    @Override
1668                    public void marshal(Object object, HierarchicalStreamWriter hsw, MarshallingContext mc) {
1669                            GeneralNote note = (GeneralNote) object;
1670                            hsw.addAttribute("Owner", note.getOwner());
1671                            hsw.setValue(note.getNote());
1672                    }
1673    
1674                    /*
1675                     * (non-Javadoc)
1676                     * 
1677                     * @see com.thoughtworks.xstream.converters.Converter#unmarshal(com.thoughtworks.xstream.io.
1678                     * HierarchicalStreamReader, com.thoughtworks.xstream.converters.UnmarshallingContext)
1679                     */
1680                    @Override
1681                    public Object unmarshal(HierarchicalStreamReader hsr, UnmarshallingContext umc) {
1682                            GeneralNote note = new GeneralNote();
1683                            note.setOwner(hsr.getAttribute("Owner"));
1684                            note.setNote(hsr.getValue());
1685                            return note;
1686                    }
1687    
1688            }
1689    
1690            /**
1691             * <pre>
1692             * <!ELEMENT GeneSymbolList (GeneSymbol+)>
1693             * <!ELEMENT GeneSymbol (#PCDATA)>
1694             * </pre>
1695             * 
1696             * @author Center for Computational Pharmacology, UC Denver; ccpsupport@ucdenver.edu
1697             */
1698            @Getter
1699            @ToString
1700            public static class GeneSymbolList {
1701                    @XStreamImplicit(itemFieldName = "GeneSymbol")
1702                    private List<String> geneSymbols;
1703            }
1704    
1705    }