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 }