001package org.hl7.fhir.dstu3.model; 002 003import java.math.BigDecimal; 004 005/*- 006 * #%L 007 * org.hl7.fhir.dstu3 008 * %% 009 * Copyright (C) 2014 - 2019 Health Level 7 010 * %% 011 * Licensed under the Apache License, Version 2.0 (the "License"); 012 * you may not use this file except in compliance with the License. 013 * You may obtain a copy of the License at 014 * 015 * http://www.apache.org/licenses/LICENSE-2.0 016 * 017 * Unless required by applicable law or agreed to in writing, software 018 * distributed under the License is distributed on an "AS IS" BASIS, 019 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 020 * See the License for the specific language governing permissions and 021 * limitations under the License. 022 * #L% 023 */ 024 025/* 026 Copyright (c) 2011+, HL7, Inc. 027 All rights reserved. 028 029 Redistribution and use in source and binary forms, with or without modification, 030 are permitted provided that the following conditions are met: 031 032 * Redistributions of source code must retain the above copyright notice, this 033 list of conditions and the following disclaimer. 034 * Redistributions in binary form must reproduce the above copyright notice, 035 this list of conditions and the following disclaimer in the documentation 036 and/or other materials provided with the distribution. 037 * Neither the name of HL7 nor the names of its contributors may be used to 038 endorse or promote products derived from this software without specific 039 prior written permission. 040 041 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 042 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 043 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 044 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 045 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 046 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 047 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 048 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 049 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 050 POSSIBILITY OF SUCH DAMAGE. 051 052*/ 053 054// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.x 055import java.util.ArrayList; 056import java.util.List; 057 058import org.hl7.fhir.exceptions.FHIRException; 059import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 060import org.hl7.fhir.utilities.Utilities; 061 062import ca.uhn.fhir.model.api.annotation.Block; 063import ca.uhn.fhir.model.api.annotation.Child; 064import ca.uhn.fhir.model.api.annotation.Description; 065import ca.uhn.fhir.model.api.annotation.ResourceDef; 066import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 067/** 068 * Raw data describing a biological sequence. 069 */ 070@ResourceDef(name="Sequence", profile="http://hl7.org/fhir/Profile/Sequence") 071public class Sequence extends DomainResource { 072 073 public enum SequenceType { 074 /** 075 * Amino acid sequence 076 */ 077 AA, 078 /** 079 * DNA Sequence 080 */ 081 DNA, 082 /** 083 * RNA Sequence 084 */ 085 RNA, 086 /** 087 * added to help the parsers with the generic types 088 */ 089 NULL; 090 public static SequenceType fromCode(String codeString) throws FHIRException { 091 if (codeString == null || "".equals(codeString)) 092 return null; 093 if ("aa".equals(codeString)) 094 return AA; 095 if ("dna".equals(codeString)) 096 return DNA; 097 if ("rna".equals(codeString)) 098 return RNA; 099 if (Configuration.isAcceptInvalidEnums()) 100 return null; 101 else 102 throw new FHIRException("Unknown SequenceType code '"+codeString+"'"); 103 } 104 public String toCode() { 105 switch (this) { 106 case AA: return "aa"; 107 case DNA: return "dna"; 108 case RNA: return "rna"; 109 default: return "?"; 110 } 111 } 112 public String getSystem() { 113 switch (this) { 114 case AA: return "http://hl7.org/fhir/sequence-type"; 115 case DNA: return "http://hl7.org/fhir/sequence-type"; 116 case RNA: return "http://hl7.org/fhir/sequence-type"; 117 default: return "?"; 118 } 119 } 120 public String getDefinition() { 121 switch (this) { 122 case AA: return "Amino acid sequence"; 123 case DNA: return "DNA Sequence"; 124 case RNA: return "RNA Sequence"; 125 default: return "?"; 126 } 127 } 128 public String getDisplay() { 129 switch (this) { 130 case AA: return "AA Sequence"; 131 case DNA: return "DNA Sequence"; 132 case RNA: return "RNA Sequence"; 133 default: return "?"; 134 } 135 } 136 } 137 138 public static class SequenceTypeEnumFactory implements EnumFactory<SequenceType> { 139 public SequenceType fromCode(String codeString) throws IllegalArgumentException { 140 if (codeString == null || "".equals(codeString)) 141 if (codeString == null || "".equals(codeString)) 142 return null; 143 if ("aa".equals(codeString)) 144 return SequenceType.AA; 145 if ("dna".equals(codeString)) 146 return SequenceType.DNA; 147 if ("rna".equals(codeString)) 148 return SequenceType.RNA; 149 throw new IllegalArgumentException("Unknown SequenceType code '"+codeString+"'"); 150 } 151 public Enumeration<SequenceType> fromType(Base code) throws FHIRException { 152 if (code == null) 153 return null; 154 if (code.isEmpty()) 155 return new Enumeration<SequenceType>(this); 156 String codeString = ((PrimitiveType) code).asStringValue(); 157 if (codeString == null || "".equals(codeString)) 158 return null; 159 if ("aa".equals(codeString)) 160 return new Enumeration<SequenceType>(this, SequenceType.AA); 161 if ("dna".equals(codeString)) 162 return new Enumeration<SequenceType>(this, SequenceType.DNA); 163 if ("rna".equals(codeString)) 164 return new Enumeration<SequenceType>(this, SequenceType.RNA); 165 throw new FHIRException("Unknown SequenceType code '"+codeString+"'"); 166 } 167 public String toCode(SequenceType code) { 168 if (code == SequenceType.AA) 169 return "aa"; 170 if (code == SequenceType.DNA) 171 return "dna"; 172 if (code == SequenceType.RNA) 173 return "rna"; 174 return "?"; 175 } 176 public String toSystem(SequenceType code) { 177 return code.getSystem(); 178 } 179 } 180 181 public enum QualityType { 182 /** 183 * INDEL Comparison 184 */ 185 INDEL, 186 /** 187 * SNP Comparison 188 */ 189 SNP, 190 /** 191 * UNKNOWN Comparison 192 */ 193 UNKNOWN, 194 /** 195 * added to help the parsers with the generic types 196 */ 197 NULL; 198 public static QualityType fromCode(String codeString) throws FHIRException { 199 if (codeString == null || "".equals(codeString)) 200 return null; 201 if ("indel".equals(codeString)) 202 return INDEL; 203 if ("snp".equals(codeString)) 204 return SNP; 205 if ("unknown".equals(codeString)) 206 return UNKNOWN; 207 if (Configuration.isAcceptInvalidEnums()) 208 return null; 209 else 210 throw new FHIRException("Unknown QualityType code '"+codeString+"'"); 211 } 212 public String toCode() { 213 switch (this) { 214 case INDEL: return "indel"; 215 case SNP: return "snp"; 216 case UNKNOWN: return "unknown"; 217 default: return "?"; 218 } 219 } 220 public String getSystem() { 221 switch (this) { 222 case INDEL: return "http://hl7.org/fhir/quality-type"; 223 case SNP: return "http://hl7.org/fhir/quality-type"; 224 case UNKNOWN: return "http://hl7.org/fhir/quality-type"; 225 default: return "?"; 226 } 227 } 228 public String getDefinition() { 229 switch (this) { 230 case INDEL: return "INDEL Comparison"; 231 case SNP: return "SNP Comparison"; 232 case UNKNOWN: return "UNKNOWN Comparison"; 233 default: return "?"; 234 } 235 } 236 public String getDisplay() { 237 switch (this) { 238 case INDEL: return "INDEL Comparison"; 239 case SNP: return "SNP Comparison"; 240 case UNKNOWN: return "UNKNOWN Comparison"; 241 default: return "?"; 242 } 243 } 244 } 245 246 public static class QualityTypeEnumFactory implements EnumFactory<QualityType> { 247 public QualityType fromCode(String codeString) throws IllegalArgumentException { 248 if (codeString == null || "".equals(codeString)) 249 if (codeString == null || "".equals(codeString)) 250 return null; 251 if ("indel".equals(codeString)) 252 return QualityType.INDEL; 253 if ("snp".equals(codeString)) 254 return QualityType.SNP; 255 if ("unknown".equals(codeString)) 256 return QualityType.UNKNOWN; 257 throw new IllegalArgumentException("Unknown QualityType code '"+codeString+"'"); 258 } 259 public Enumeration<QualityType> fromType(Base code) throws FHIRException { 260 if (code == null) 261 return null; 262 if (code.isEmpty()) 263 return new Enumeration<QualityType>(this); 264 String codeString = ((PrimitiveType) code).asStringValue(); 265 if (codeString == null || "".equals(codeString)) 266 return null; 267 if ("indel".equals(codeString)) 268 return new Enumeration<QualityType>(this, QualityType.INDEL); 269 if ("snp".equals(codeString)) 270 return new Enumeration<QualityType>(this, QualityType.SNP); 271 if ("unknown".equals(codeString)) 272 return new Enumeration<QualityType>(this, QualityType.UNKNOWN); 273 throw new FHIRException("Unknown QualityType code '"+codeString+"'"); 274 } 275 public String toCode(QualityType code) { 276 if (code == QualityType.INDEL) 277 return "indel"; 278 if (code == QualityType.SNP) 279 return "snp"; 280 if (code == QualityType.UNKNOWN) 281 return "unknown"; 282 return "?"; 283 } 284 public String toSystem(QualityType code) { 285 return code.getSystem(); 286 } 287 } 288 289 public enum RepositoryType { 290 /** 291 * When URL is clicked, the resource can be seen directly (by webpage or by download link format) 292 */ 293 DIRECTLINK, 294 /** 295 * When the API method (e.g. [base_url]/[parameter]) related with the URL of the website is executed, the resource can be seen directly (usually in JSON or XML format) 296 */ 297 OPENAPI, 298 /** 299 * When logged into the website, the resource can be seen. 300 */ 301 LOGIN, 302 /** 303 * When logged in and follow the API in the website related with URL, the resource can be seen. 304 */ 305 OAUTH, 306 /** 307 * Some other complicated or particular way to get resource from URL. 308 */ 309 OTHER, 310 /** 311 * added to help the parsers with the generic types 312 */ 313 NULL; 314 public static RepositoryType fromCode(String codeString) throws FHIRException { 315 if (codeString == null || "".equals(codeString)) 316 return null; 317 if ("directlink".equals(codeString)) 318 return DIRECTLINK; 319 if ("openapi".equals(codeString)) 320 return OPENAPI; 321 if ("login".equals(codeString)) 322 return LOGIN; 323 if ("oauth".equals(codeString)) 324 return OAUTH; 325 if ("other".equals(codeString)) 326 return OTHER; 327 if (Configuration.isAcceptInvalidEnums()) 328 return null; 329 else 330 throw new FHIRException("Unknown RepositoryType code '"+codeString+"'"); 331 } 332 public String toCode() { 333 switch (this) { 334 case DIRECTLINK: return "directlink"; 335 case OPENAPI: return "openapi"; 336 case LOGIN: return "login"; 337 case OAUTH: return "oauth"; 338 case OTHER: return "other"; 339 default: return "?"; 340 } 341 } 342 public String getSystem() { 343 switch (this) { 344 case DIRECTLINK: return "http://hl7.org/fhir/repository-type"; 345 case OPENAPI: return "http://hl7.org/fhir/repository-type"; 346 case LOGIN: return "http://hl7.org/fhir/repository-type"; 347 case OAUTH: return "http://hl7.org/fhir/repository-type"; 348 case OTHER: return "http://hl7.org/fhir/repository-type"; 349 default: return "?"; 350 } 351 } 352 public String getDefinition() { 353 switch (this) { 354 case DIRECTLINK: return "When URL is clicked, the resource can be seen directly (by webpage or by download link format)"; 355 case OPENAPI: return "When the API method (e.g. [base_url]/[parameter]) related with the URL of the website is executed, the resource can be seen directly (usually in JSON or XML format)"; 356 case LOGIN: return "When logged into the website, the resource can be seen."; 357 case OAUTH: return "When logged in and follow the API in the website related with URL, the resource can be seen."; 358 case OTHER: return "Some other complicated or particular way to get resource from URL."; 359 default: return "?"; 360 } 361 } 362 public String getDisplay() { 363 switch (this) { 364 case DIRECTLINK: return "Click and see"; 365 case OPENAPI: return "The URL is the RESTful or other kind of API that can access to the result."; 366 case LOGIN: return "Result cannot be access unless an account is logged in"; 367 case OAUTH: return "Result need to be fetched with API and need LOGIN( or cookies are required when visiting the link of resource)"; 368 case OTHER: return "Some other complicated or particular way to get resource from URL."; 369 default: return "?"; 370 } 371 } 372 } 373 374 public static class RepositoryTypeEnumFactory implements EnumFactory<RepositoryType> { 375 public RepositoryType fromCode(String codeString) throws IllegalArgumentException { 376 if (codeString == null || "".equals(codeString)) 377 if (codeString == null || "".equals(codeString)) 378 return null; 379 if ("directlink".equals(codeString)) 380 return RepositoryType.DIRECTLINK; 381 if ("openapi".equals(codeString)) 382 return RepositoryType.OPENAPI; 383 if ("login".equals(codeString)) 384 return RepositoryType.LOGIN; 385 if ("oauth".equals(codeString)) 386 return RepositoryType.OAUTH; 387 if ("other".equals(codeString)) 388 return RepositoryType.OTHER; 389 throw new IllegalArgumentException("Unknown RepositoryType code '"+codeString+"'"); 390 } 391 public Enumeration<RepositoryType> fromType(Base code) throws FHIRException { 392 if (code == null) 393 return null; 394 if (code.isEmpty()) 395 return new Enumeration<RepositoryType>(this); 396 String codeString = ((PrimitiveType) code).asStringValue(); 397 if (codeString == null || "".equals(codeString)) 398 return null; 399 if ("directlink".equals(codeString)) 400 return new Enumeration<RepositoryType>(this, RepositoryType.DIRECTLINK); 401 if ("openapi".equals(codeString)) 402 return new Enumeration<RepositoryType>(this, RepositoryType.OPENAPI); 403 if ("login".equals(codeString)) 404 return new Enumeration<RepositoryType>(this, RepositoryType.LOGIN); 405 if ("oauth".equals(codeString)) 406 return new Enumeration<RepositoryType>(this, RepositoryType.OAUTH); 407 if ("other".equals(codeString)) 408 return new Enumeration<RepositoryType>(this, RepositoryType.OTHER); 409 throw new FHIRException("Unknown RepositoryType code '"+codeString+"'"); 410 } 411 public String toCode(RepositoryType code) { 412 if (code == RepositoryType.DIRECTLINK) 413 return "directlink"; 414 if (code == RepositoryType.OPENAPI) 415 return "openapi"; 416 if (code == RepositoryType.LOGIN) 417 return "login"; 418 if (code == RepositoryType.OAUTH) 419 return "oauth"; 420 if (code == RepositoryType.OTHER) 421 return "other"; 422 return "?"; 423 } 424 public String toSystem(RepositoryType code) { 425 return code.getSystem(); 426 } 427 } 428 429 @Block() 430 public static class SequenceReferenceSeqComponent extends BackboneElement implements IBaseBackboneElement { 431 /** 432 * Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)). 433 */ 434 @Child(name = "chromosome", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=true) 435 @Description(shortDefinition="Chromosome containing genetic finding", formalDefinition="Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340))." ) 436 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/chromosome-human") 437 protected CodeableConcept chromosome; 438 439 /** 440 * The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used. 441 */ 442 @Child(name = "genomeBuild", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 443 @Description(shortDefinition="The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'", formalDefinition="The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used." ) 444 protected StringType genomeBuild; 445 446 /** 447 * Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences. 448 */ 449 @Child(name = "referenceSeqId", type = {CodeableConcept.class}, order=3, min=0, max=1, modifier=false, summary=true) 450 @Description(shortDefinition="Reference identifier", formalDefinition="Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences." ) 451 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/sequence-referenceSeq") 452 protected CodeableConcept referenceSeqId; 453 454 /** 455 * A Pointer to another Sequence entity as reference sequence. 456 */ 457 @Child(name = "referenceSeqPointer", type = {Sequence.class}, order=4, min=0, max=1, modifier=false, summary=true) 458 @Description(shortDefinition="A Pointer to another Sequence entity as reference sequence", formalDefinition="A Pointer to another Sequence entity as reference sequence." ) 459 protected Reference referenceSeqPointer; 460 461 /** 462 * The actual object that is the target of the reference (A Pointer to another Sequence entity as reference sequence.) 463 */ 464 protected Sequence referenceSeqPointerTarget; 465 466 /** 467 * A string like "ACGT". 468 */ 469 @Child(name = "referenceSeqString", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true) 470 @Description(shortDefinition="A string to represent reference sequence", formalDefinition="A string like \"ACGT\"." ) 471 protected StringType referenceSeqString; 472 473 /** 474 * Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative. 475 */ 476 @Child(name = "strand", type = {IntegerType.class}, order=6, min=0, max=1, modifier=false, summary=true) 477 @Description(shortDefinition="Directionality of DNA ( +1/-1)", formalDefinition="Directionality of DNA sequence. Available values are \"1\" for the plus strand (5' to 3')/Watson/Sense/positive and \"-1\" for the minus strand(3' to 5')/Crick/Antisense/negative." ) 478 protected IntegerType strand; 479 480 /** 481 * Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive. 482 */ 483 @Child(name = "windowStart", type = {IntegerType.class}, order=7, min=1, max=1, modifier=false, summary=true) 484 @Description(shortDefinition="Start position of the window on the reference sequence", formalDefinition="Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive." ) 485 protected IntegerType windowStart; 486 487 /** 488 * End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position. 489 */ 490 @Child(name = "windowEnd", type = {IntegerType.class}, order=8, min=1, max=1, modifier=false, summary=true) 491 @Description(shortDefinition="End position of the window on the reference sequence", formalDefinition="End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position." ) 492 protected IntegerType windowEnd; 493 494 private static final long serialVersionUID = -1675617731L; 495 496 /** 497 * Constructor 498 */ 499 public SequenceReferenceSeqComponent() { 500 super(); 501 } 502 503 /** 504 * Constructor 505 */ 506 public SequenceReferenceSeqComponent(IntegerType windowStart, IntegerType windowEnd) { 507 super(); 508 this.windowStart = windowStart; 509 this.windowEnd = windowEnd; 510 } 511 512 /** 513 * @return {@link #chromosome} (Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).) 514 */ 515 public CodeableConcept getChromosome() { 516 if (this.chromosome == null) 517 if (Configuration.errorOnAutoCreate()) 518 throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.chromosome"); 519 else if (Configuration.doAutoCreate()) 520 this.chromosome = new CodeableConcept(); // cc 521 return this.chromosome; 522 } 523 524 public boolean hasChromosome() { 525 return this.chromosome != null && !this.chromosome.isEmpty(); 526 } 527 528 /** 529 * @param value {@link #chromosome} (Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).) 530 */ 531 public SequenceReferenceSeqComponent setChromosome(CodeableConcept value) { 532 this.chromosome = value; 533 return this; 534 } 535 536 /** 537 * @return {@link #genomeBuild} (The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used.). This is the underlying object with id, value and extensions. The accessor "getGenomeBuild" gives direct access to the value 538 */ 539 public StringType getGenomeBuildElement() { 540 if (this.genomeBuild == null) 541 if (Configuration.errorOnAutoCreate()) 542 throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.genomeBuild"); 543 else if (Configuration.doAutoCreate()) 544 this.genomeBuild = new StringType(); // bb 545 return this.genomeBuild; 546 } 547 548 public boolean hasGenomeBuildElement() { 549 return this.genomeBuild != null && !this.genomeBuild.isEmpty(); 550 } 551 552 public boolean hasGenomeBuild() { 553 return this.genomeBuild != null && !this.genomeBuild.isEmpty(); 554 } 555 556 /** 557 * @param value {@link #genomeBuild} (The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used.). This is the underlying object with id, value and extensions. The accessor "getGenomeBuild" gives direct access to the value 558 */ 559 public SequenceReferenceSeqComponent setGenomeBuildElement(StringType value) { 560 this.genomeBuild = value; 561 return this; 562 } 563 564 /** 565 * @return The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used. 566 */ 567 public String getGenomeBuild() { 568 return this.genomeBuild == null ? null : this.genomeBuild.getValue(); 569 } 570 571 /** 572 * @param value The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used. 573 */ 574 public SequenceReferenceSeqComponent setGenomeBuild(String value) { 575 if (Utilities.noString(value)) 576 this.genomeBuild = null; 577 else { 578 if (this.genomeBuild == null) 579 this.genomeBuild = new StringType(); 580 this.genomeBuild.setValue(value); 581 } 582 return this; 583 } 584 585 /** 586 * @return {@link #referenceSeqId} (Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.) 587 */ 588 public CodeableConcept getReferenceSeqId() { 589 if (this.referenceSeqId == null) 590 if (Configuration.errorOnAutoCreate()) 591 throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.referenceSeqId"); 592 else if (Configuration.doAutoCreate()) 593 this.referenceSeqId = new CodeableConcept(); // cc 594 return this.referenceSeqId; 595 } 596 597 public boolean hasReferenceSeqId() { 598 return this.referenceSeqId != null && !this.referenceSeqId.isEmpty(); 599 } 600 601 /** 602 * @param value {@link #referenceSeqId} (Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.) 603 */ 604 public SequenceReferenceSeqComponent setReferenceSeqId(CodeableConcept value) { 605 this.referenceSeqId = value; 606 return this; 607 } 608 609 /** 610 * @return {@link #referenceSeqPointer} (A Pointer to another Sequence entity as reference sequence.) 611 */ 612 public Reference getReferenceSeqPointer() { 613 if (this.referenceSeqPointer == null) 614 if (Configuration.errorOnAutoCreate()) 615 throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.referenceSeqPointer"); 616 else if (Configuration.doAutoCreate()) 617 this.referenceSeqPointer = new Reference(); // cc 618 return this.referenceSeqPointer; 619 } 620 621 public boolean hasReferenceSeqPointer() { 622 return this.referenceSeqPointer != null && !this.referenceSeqPointer.isEmpty(); 623 } 624 625 /** 626 * @param value {@link #referenceSeqPointer} (A Pointer to another Sequence entity as reference sequence.) 627 */ 628 public SequenceReferenceSeqComponent setReferenceSeqPointer(Reference value) { 629 this.referenceSeqPointer = value; 630 return this; 631 } 632 633 /** 634 * @return {@link #referenceSeqPointer} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (A Pointer to another Sequence entity as reference sequence.) 635 */ 636 public Sequence getReferenceSeqPointerTarget() { 637 if (this.referenceSeqPointerTarget == null) 638 if (Configuration.errorOnAutoCreate()) 639 throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.referenceSeqPointer"); 640 else if (Configuration.doAutoCreate()) 641 this.referenceSeqPointerTarget = new Sequence(); // aa 642 return this.referenceSeqPointerTarget; 643 } 644 645 /** 646 * @param value {@link #referenceSeqPointer} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (A Pointer to another Sequence entity as reference sequence.) 647 */ 648 public SequenceReferenceSeqComponent setReferenceSeqPointerTarget(Sequence value) { 649 this.referenceSeqPointerTarget = value; 650 return this; 651 } 652 653 /** 654 * @return {@link #referenceSeqString} (A string like "ACGT".). This is the underlying object with id, value and extensions. The accessor "getReferenceSeqString" gives direct access to the value 655 */ 656 public StringType getReferenceSeqStringElement() { 657 if (this.referenceSeqString == null) 658 if (Configuration.errorOnAutoCreate()) 659 throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.referenceSeqString"); 660 else if (Configuration.doAutoCreate()) 661 this.referenceSeqString = new StringType(); // bb 662 return this.referenceSeqString; 663 } 664 665 public boolean hasReferenceSeqStringElement() { 666 return this.referenceSeqString != null && !this.referenceSeqString.isEmpty(); 667 } 668 669 public boolean hasReferenceSeqString() { 670 return this.referenceSeqString != null && !this.referenceSeqString.isEmpty(); 671 } 672 673 /** 674 * @param value {@link #referenceSeqString} (A string like "ACGT".). This is the underlying object with id, value and extensions. The accessor "getReferenceSeqString" gives direct access to the value 675 */ 676 public SequenceReferenceSeqComponent setReferenceSeqStringElement(StringType value) { 677 this.referenceSeqString = value; 678 return this; 679 } 680 681 /** 682 * @return A string like "ACGT". 683 */ 684 public String getReferenceSeqString() { 685 return this.referenceSeqString == null ? null : this.referenceSeqString.getValue(); 686 } 687 688 /** 689 * @param value A string like "ACGT". 690 */ 691 public SequenceReferenceSeqComponent setReferenceSeqString(String value) { 692 if (Utilities.noString(value)) 693 this.referenceSeqString = null; 694 else { 695 if (this.referenceSeqString == null) 696 this.referenceSeqString = new StringType(); 697 this.referenceSeqString.setValue(value); 698 } 699 return this; 700 } 701 702 /** 703 * @return {@link #strand} (Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative.). This is the underlying object with id, value and extensions. The accessor "getStrand" gives direct access to the value 704 */ 705 public IntegerType getStrandElement() { 706 if (this.strand == null) 707 if (Configuration.errorOnAutoCreate()) 708 throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.strand"); 709 else if (Configuration.doAutoCreate()) 710 this.strand = new IntegerType(); // bb 711 return this.strand; 712 } 713 714 public boolean hasStrandElement() { 715 return this.strand != null && !this.strand.isEmpty(); 716 } 717 718 public boolean hasStrand() { 719 return this.strand != null && !this.strand.isEmpty(); 720 } 721 722 /** 723 * @param value {@link #strand} (Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative.). This is the underlying object with id, value and extensions. The accessor "getStrand" gives direct access to the value 724 */ 725 public SequenceReferenceSeqComponent setStrandElement(IntegerType value) { 726 this.strand = value; 727 return this; 728 } 729 730 /** 731 * @return Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative. 732 */ 733 public int getStrand() { 734 return this.strand == null || this.strand.isEmpty() ? 0 : this.strand.getValue(); 735 } 736 737 /** 738 * @param value Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative. 739 */ 740 public SequenceReferenceSeqComponent setStrand(int value) { 741 if (this.strand == null) 742 this.strand = new IntegerType(); 743 this.strand.setValue(value); 744 return this; 745 } 746 747 /** 748 * @return {@link #windowStart} (Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getWindowStart" gives direct access to the value 749 */ 750 public IntegerType getWindowStartElement() { 751 if (this.windowStart == null) 752 if (Configuration.errorOnAutoCreate()) 753 throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.windowStart"); 754 else if (Configuration.doAutoCreate()) 755 this.windowStart = new IntegerType(); // bb 756 return this.windowStart; 757 } 758 759 public boolean hasWindowStartElement() { 760 return this.windowStart != null && !this.windowStart.isEmpty(); 761 } 762 763 public boolean hasWindowStart() { 764 return this.windowStart != null && !this.windowStart.isEmpty(); 765 } 766 767 /** 768 * @param value {@link #windowStart} (Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getWindowStart" gives direct access to the value 769 */ 770 public SequenceReferenceSeqComponent setWindowStartElement(IntegerType value) { 771 this.windowStart = value; 772 return this; 773 } 774 775 /** 776 * @return Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive. 777 */ 778 public int getWindowStart() { 779 return this.windowStart == null || this.windowStart.isEmpty() ? 0 : this.windowStart.getValue(); 780 } 781 782 /** 783 * @param value Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive. 784 */ 785 public SequenceReferenceSeqComponent setWindowStart(int value) { 786 if (this.windowStart == null) 787 this.windowStart = new IntegerType(); 788 this.windowStart.setValue(value); 789 return this; 790 } 791 792 /** 793 * @return {@link #windowEnd} (End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getWindowEnd" gives direct access to the value 794 */ 795 public IntegerType getWindowEndElement() { 796 if (this.windowEnd == null) 797 if (Configuration.errorOnAutoCreate()) 798 throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.windowEnd"); 799 else if (Configuration.doAutoCreate()) 800 this.windowEnd = new IntegerType(); // bb 801 return this.windowEnd; 802 } 803 804 public boolean hasWindowEndElement() { 805 return this.windowEnd != null && !this.windowEnd.isEmpty(); 806 } 807 808 public boolean hasWindowEnd() { 809 return this.windowEnd != null && !this.windowEnd.isEmpty(); 810 } 811 812 /** 813 * @param value {@link #windowEnd} (End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getWindowEnd" gives direct access to the value 814 */ 815 public SequenceReferenceSeqComponent setWindowEndElement(IntegerType value) { 816 this.windowEnd = value; 817 return this; 818 } 819 820 /** 821 * @return End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position. 822 */ 823 public int getWindowEnd() { 824 return this.windowEnd == null || this.windowEnd.isEmpty() ? 0 : this.windowEnd.getValue(); 825 } 826 827 /** 828 * @param value End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position. 829 */ 830 public SequenceReferenceSeqComponent setWindowEnd(int value) { 831 if (this.windowEnd == null) 832 this.windowEnd = new IntegerType(); 833 this.windowEnd.setValue(value); 834 return this; 835 } 836 837 protected void listChildren(List<Property> children) { 838 super.listChildren(children); 839 children.add(new Property("chromosome", "CodeableConcept", "Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).", 0, 1, chromosome)); 840 children.add(new Property("genomeBuild", "string", "The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used.", 0, 1, genomeBuild)); 841 children.add(new Property("referenceSeqId", "CodeableConcept", "Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.", 0, 1, referenceSeqId)); 842 children.add(new Property("referenceSeqPointer", "Reference(Sequence)", "A Pointer to another Sequence entity as reference sequence.", 0, 1, referenceSeqPointer)); 843 children.add(new Property("referenceSeqString", "string", "A string like \"ACGT\".", 0, 1, referenceSeqString)); 844 children.add(new Property("strand", "integer", "Directionality of DNA sequence. Available values are \"1\" for the plus strand (5' to 3')/Watson/Sense/positive and \"-1\" for the minus strand(3' to 5')/Crick/Antisense/negative.", 0, 1, strand)); 845 children.add(new Property("windowStart", "integer", "Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, windowStart)); 846 children.add(new Property("windowEnd", "integer", "End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, windowEnd)); 847 } 848 849 @Override 850 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 851 switch (_hash) { 852 case -1499470472: /*chromosome*/ return new Property("chromosome", "CodeableConcept", "Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).", 0, 1, chromosome); 853 case 1061239735: /*genomeBuild*/ return new Property("genomeBuild", "string", "The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used.", 0, 1, genomeBuild); 854 case -1911500465: /*referenceSeqId*/ return new Property("referenceSeqId", "CodeableConcept", "Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.", 0, 1, referenceSeqId); 855 case 1923414665: /*referenceSeqPointer*/ return new Property("referenceSeqPointer", "Reference(Sequence)", "A Pointer to another Sequence entity as reference sequence.", 0, 1, referenceSeqPointer); 856 case -1648301499: /*referenceSeqString*/ return new Property("referenceSeqString", "string", "A string like \"ACGT\".", 0, 1, referenceSeqString); 857 case -891993594: /*strand*/ return new Property("strand", "integer", "Directionality of DNA sequence. Available values are \"1\" for the plus strand (5' to 3')/Watson/Sense/positive and \"-1\" for the minus strand(3' to 5')/Crick/Antisense/negative.", 0, 1, strand); 858 case 1903685202: /*windowStart*/ return new Property("windowStart", "integer", "Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, windowStart); 859 case -217026869: /*windowEnd*/ return new Property("windowEnd", "integer", "End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, windowEnd); 860 default: return super.getNamedProperty(_hash, _name, _checkValid); 861 } 862 863 } 864 865 @Override 866 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 867 switch (hash) { 868 case -1499470472: /*chromosome*/ return this.chromosome == null ? new Base[0] : new Base[] {this.chromosome}; // CodeableConcept 869 case 1061239735: /*genomeBuild*/ return this.genomeBuild == null ? new Base[0] : new Base[] {this.genomeBuild}; // StringType 870 case -1911500465: /*referenceSeqId*/ return this.referenceSeqId == null ? new Base[0] : new Base[] {this.referenceSeqId}; // CodeableConcept 871 case 1923414665: /*referenceSeqPointer*/ return this.referenceSeqPointer == null ? new Base[0] : new Base[] {this.referenceSeqPointer}; // Reference 872 case -1648301499: /*referenceSeqString*/ return this.referenceSeqString == null ? new Base[0] : new Base[] {this.referenceSeqString}; // StringType 873 case -891993594: /*strand*/ return this.strand == null ? new Base[0] : new Base[] {this.strand}; // IntegerType 874 case 1903685202: /*windowStart*/ return this.windowStart == null ? new Base[0] : new Base[] {this.windowStart}; // IntegerType 875 case -217026869: /*windowEnd*/ return this.windowEnd == null ? new Base[0] : new Base[] {this.windowEnd}; // IntegerType 876 default: return super.getProperty(hash, name, checkValid); 877 } 878 879 } 880 881 @Override 882 public Base setProperty(int hash, String name, Base value) throws FHIRException { 883 switch (hash) { 884 case -1499470472: // chromosome 885 this.chromosome = castToCodeableConcept(value); // CodeableConcept 886 return value; 887 case 1061239735: // genomeBuild 888 this.genomeBuild = castToString(value); // StringType 889 return value; 890 case -1911500465: // referenceSeqId 891 this.referenceSeqId = castToCodeableConcept(value); // CodeableConcept 892 return value; 893 case 1923414665: // referenceSeqPointer 894 this.referenceSeqPointer = castToReference(value); // Reference 895 return value; 896 case -1648301499: // referenceSeqString 897 this.referenceSeqString = castToString(value); // StringType 898 return value; 899 case -891993594: // strand 900 this.strand = castToInteger(value); // IntegerType 901 return value; 902 case 1903685202: // windowStart 903 this.windowStart = castToInteger(value); // IntegerType 904 return value; 905 case -217026869: // windowEnd 906 this.windowEnd = castToInteger(value); // IntegerType 907 return value; 908 default: return super.setProperty(hash, name, value); 909 } 910 911 } 912 913 @Override 914 public Base setProperty(String name, Base value) throws FHIRException { 915 if (name.equals("chromosome")) { 916 this.chromosome = castToCodeableConcept(value); // CodeableConcept 917 } else if (name.equals("genomeBuild")) { 918 this.genomeBuild = castToString(value); // StringType 919 } else if (name.equals("referenceSeqId")) { 920 this.referenceSeqId = castToCodeableConcept(value); // CodeableConcept 921 } else if (name.equals("referenceSeqPointer")) { 922 this.referenceSeqPointer = castToReference(value); // Reference 923 } else if (name.equals("referenceSeqString")) { 924 this.referenceSeqString = castToString(value); // StringType 925 } else if (name.equals("strand")) { 926 this.strand = castToInteger(value); // IntegerType 927 } else if (name.equals("windowStart")) { 928 this.windowStart = castToInteger(value); // IntegerType 929 } else if (name.equals("windowEnd")) { 930 this.windowEnd = castToInteger(value); // IntegerType 931 } else 932 return super.setProperty(name, value); 933 return value; 934 } 935 936 @Override 937 public Base makeProperty(int hash, String name) throws FHIRException { 938 switch (hash) { 939 case -1499470472: return getChromosome(); 940 case 1061239735: return getGenomeBuildElement(); 941 case -1911500465: return getReferenceSeqId(); 942 case 1923414665: return getReferenceSeqPointer(); 943 case -1648301499: return getReferenceSeqStringElement(); 944 case -891993594: return getStrandElement(); 945 case 1903685202: return getWindowStartElement(); 946 case -217026869: return getWindowEndElement(); 947 default: return super.makeProperty(hash, name); 948 } 949 950 } 951 952 @Override 953 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 954 switch (hash) { 955 case -1499470472: /*chromosome*/ return new String[] {"CodeableConcept"}; 956 case 1061239735: /*genomeBuild*/ return new String[] {"string"}; 957 case -1911500465: /*referenceSeqId*/ return new String[] {"CodeableConcept"}; 958 case 1923414665: /*referenceSeqPointer*/ return new String[] {"Reference"}; 959 case -1648301499: /*referenceSeqString*/ return new String[] {"string"}; 960 case -891993594: /*strand*/ return new String[] {"integer"}; 961 case 1903685202: /*windowStart*/ return new String[] {"integer"}; 962 case -217026869: /*windowEnd*/ return new String[] {"integer"}; 963 default: return super.getTypesForProperty(hash, name); 964 } 965 966 } 967 968 @Override 969 public Base addChild(String name) throws FHIRException { 970 if (name.equals("chromosome")) { 971 this.chromosome = new CodeableConcept(); 972 return this.chromosome; 973 } 974 else if (name.equals("genomeBuild")) { 975 throw new FHIRException("Cannot call addChild on a primitive type Sequence.genomeBuild"); 976 } 977 else if (name.equals("referenceSeqId")) { 978 this.referenceSeqId = new CodeableConcept(); 979 return this.referenceSeqId; 980 } 981 else if (name.equals("referenceSeqPointer")) { 982 this.referenceSeqPointer = new Reference(); 983 return this.referenceSeqPointer; 984 } 985 else if (name.equals("referenceSeqString")) { 986 throw new FHIRException("Cannot call addChild on a primitive type Sequence.referenceSeqString"); 987 } 988 else if (name.equals("strand")) { 989 throw new FHIRException("Cannot call addChild on a primitive type Sequence.strand"); 990 } 991 else if (name.equals("windowStart")) { 992 throw new FHIRException("Cannot call addChild on a primitive type Sequence.windowStart"); 993 } 994 else if (name.equals("windowEnd")) { 995 throw new FHIRException("Cannot call addChild on a primitive type Sequence.windowEnd"); 996 } 997 else 998 return super.addChild(name); 999 } 1000 1001 public SequenceReferenceSeqComponent copy() { 1002 SequenceReferenceSeqComponent dst = new SequenceReferenceSeqComponent(); 1003 copyValues(dst); 1004 dst.chromosome = chromosome == null ? null : chromosome.copy(); 1005 dst.genomeBuild = genomeBuild == null ? null : genomeBuild.copy(); 1006 dst.referenceSeqId = referenceSeqId == null ? null : referenceSeqId.copy(); 1007 dst.referenceSeqPointer = referenceSeqPointer == null ? null : referenceSeqPointer.copy(); 1008 dst.referenceSeqString = referenceSeqString == null ? null : referenceSeqString.copy(); 1009 dst.strand = strand == null ? null : strand.copy(); 1010 dst.windowStart = windowStart == null ? null : windowStart.copy(); 1011 dst.windowEnd = windowEnd == null ? null : windowEnd.copy(); 1012 return dst; 1013 } 1014 1015 @Override 1016 public boolean equalsDeep(Base other_) { 1017 if (!super.equalsDeep(other_)) 1018 return false; 1019 if (!(other_ instanceof SequenceReferenceSeqComponent)) 1020 return false; 1021 SequenceReferenceSeqComponent o = (SequenceReferenceSeqComponent) other_; 1022 return compareDeep(chromosome, o.chromosome, true) && compareDeep(genomeBuild, o.genomeBuild, true) 1023 && compareDeep(referenceSeqId, o.referenceSeqId, true) && compareDeep(referenceSeqPointer, o.referenceSeqPointer, true) 1024 && compareDeep(referenceSeqString, o.referenceSeqString, true) && compareDeep(strand, o.strand, true) 1025 && compareDeep(windowStart, o.windowStart, true) && compareDeep(windowEnd, o.windowEnd, true); 1026 } 1027 1028 @Override 1029 public boolean equalsShallow(Base other_) { 1030 if (!super.equalsShallow(other_)) 1031 return false; 1032 if (!(other_ instanceof SequenceReferenceSeqComponent)) 1033 return false; 1034 SequenceReferenceSeqComponent o = (SequenceReferenceSeqComponent) other_; 1035 return compareValues(genomeBuild, o.genomeBuild, true) && compareValues(referenceSeqString, o.referenceSeqString, true) 1036 && compareValues(strand, o.strand, true) && compareValues(windowStart, o.windowStart, true) && compareValues(windowEnd, o.windowEnd, true) 1037 ; 1038 } 1039 1040 public boolean isEmpty() { 1041 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(chromosome, genomeBuild, referenceSeqId 1042 , referenceSeqPointer, referenceSeqString, strand, windowStart, windowEnd); 1043 } 1044 1045 public String fhirType() { 1046 return "Sequence.referenceSeq"; 1047 1048 } 1049 1050 } 1051 1052 @Block() 1053 public static class SequenceVariantComponent extends BackboneElement implements IBaseBackboneElement { 1054 /** 1055 * Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive. 1056 */ 1057 @Child(name = "start", type = {IntegerType.class}, order=1, min=0, max=1, modifier=false, summary=true) 1058 @Description(shortDefinition="Start position of the variant on the reference sequence", formalDefinition="Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive." ) 1059 protected IntegerType start; 1060 1061 /** 1062 * End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position. 1063 */ 1064 @Child(name = "end", type = {IntegerType.class}, order=2, min=0, max=1, modifier=false, summary=true) 1065 @Description(shortDefinition="End position of the variant on the reference sequence", formalDefinition="End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position." ) 1066 protected IntegerType end; 1067 1068 /** 1069 * An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end. 1070 */ 1071 @Child(name = "observedAllele", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true) 1072 @Description(shortDefinition="Allele that was observed", formalDefinition="An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end." ) 1073 protected StringType observedAllele; 1074 1075 /** 1076 * An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end. 1077 */ 1078 @Child(name = "referenceAllele", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true) 1079 @Description(shortDefinition="Allele in the reference sequence", formalDefinition="An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end." ) 1080 protected StringType referenceAllele; 1081 1082 /** 1083 * Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm). 1084 */ 1085 @Child(name = "cigar", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true) 1086 @Description(shortDefinition="Extended CIGAR string for aligning the sequence with reference bases", formalDefinition="Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm)." ) 1087 protected StringType cigar; 1088 1089 /** 1090 * A pointer to an Observation containing variant information. 1091 */ 1092 @Child(name = "variantPointer", type = {Observation.class}, order=6, min=0, max=1, modifier=false, summary=true) 1093 @Description(shortDefinition="Pointer to observed variant information", formalDefinition="A pointer to an Observation containing variant information." ) 1094 protected Reference variantPointer; 1095 1096 /** 1097 * The actual object that is the target of the reference (A pointer to an Observation containing variant information.) 1098 */ 1099 protected Observation variantPointerTarget; 1100 1101 private static final long serialVersionUID = 105611837L; 1102 1103 /** 1104 * Constructor 1105 */ 1106 public SequenceVariantComponent() { 1107 super(); 1108 } 1109 1110 /** 1111 * @return {@link #start} (Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getStart" gives direct access to the value 1112 */ 1113 public IntegerType getStartElement() { 1114 if (this.start == null) 1115 if (Configuration.errorOnAutoCreate()) 1116 throw new Error("Attempt to auto-create SequenceVariantComponent.start"); 1117 else if (Configuration.doAutoCreate()) 1118 this.start = new IntegerType(); // bb 1119 return this.start; 1120 } 1121 1122 public boolean hasStartElement() { 1123 return this.start != null && !this.start.isEmpty(); 1124 } 1125 1126 public boolean hasStart() { 1127 return this.start != null && !this.start.isEmpty(); 1128 } 1129 1130 /** 1131 * @param value {@link #start} (Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getStart" gives direct access to the value 1132 */ 1133 public SequenceVariantComponent setStartElement(IntegerType value) { 1134 this.start = value; 1135 return this; 1136 } 1137 1138 /** 1139 * @return Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive. 1140 */ 1141 public int getStart() { 1142 return this.start == null || this.start.isEmpty() ? 0 : this.start.getValue(); 1143 } 1144 1145 /** 1146 * @param value Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive. 1147 */ 1148 public SequenceVariantComponent setStart(int value) { 1149 if (this.start == null) 1150 this.start = new IntegerType(); 1151 this.start.setValue(value); 1152 return this; 1153 } 1154 1155 /** 1156 * @return {@link #end} (End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getEnd" gives direct access to the value 1157 */ 1158 public IntegerType getEndElement() { 1159 if (this.end == null) 1160 if (Configuration.errorOnAutoCreate()) 1161 throw new Error("Attempt to auto-create SequenceVariantComponent.end"); 1162 else if (Configuration.doAutoCreate()) 1163 this.end = new IntegerType(); // bb 1164 return this.end; 1165 } 1166 1167 public boolean hasEndElement() { 1168 return this.end != null && !this.end.isEmpty(); 1169 } 1170 1171 public boolean hasEnd() { 1172 return this.end != null && !this.end.isEmpty(); 1173 } 1174 1175 /** 1176 * @param value {@link #end} (End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getEnd" gives direct access to the value 1177 */ 1178 public SequenceVariantComponent setEndElement(IntegerType value) { 1179 this.end = value; 1180 return this; 1181 } 1182 1183 /** 1184 * @return End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position. 1185 */ 1186 public int getEnd() { 1187 return this.end == null || this.end.isEmpty() ? 0 : this.end.getValue(); 1188 } 1189 1190 /** 1191 * @param value End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position. 1192 */ 1193 public SequenceVariantComponent setEnd(int value) { 1194 if (this.end == null) 1195 this.end = new IntegerType(); 1196 this.end.setValue(value); 1197 return this; 1198 } 1199 1200 /** 1201 * @return {@link #observedAllele} (An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.). This is the underlying object with id, value and extensions. The accessor "getObservedAllele" gives direct access to the value 1202 */ 1203 public StringType getObservedAlleleElement() { 1204 if (this.observedAllele == null) 1205 if (Configuration.errorOnAutoCreate()) 1206 throw new Error("Attempt to auto-create SequenceVariantComponent.observedAllele"); 1207 else if (Configuration.doAutoCreate()) 1208 this.observedAllele = new StringType(); // bb 1209 return this.observedAllele; 1210 } 1211 1212 public boolean hasObservedAlleleElement() { 1213 return this.observedAllele != null && !this.observedAllele.isEmpty(); 1214 } 1215 1216 public boolean hasObservedAllele() { 1217 return this.observedAllele != null && !this.observedAllele.isEmpty(); 1218 } 1219 1220 /** 1221 * @param value {@link #observedAllele} (An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.). This is the underlying object with id, value and extensions. The accessor "getObservedAllele" gives direct access to the value 1222 */ 1223 public SequenceVariantComponent setObservedAlleleElement(StringType value) { 1224 this.observedAllele = value; 1225 return this; 1226 } 1227 1228 /** 1229 * @return An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end. 1230 */ 1231 public String getObservedAllele() { 1232 return this.observedAllele == null ? null : this.observedAllele.getValue(); 1233 } 1234 1235 /** 1236 * @param value An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end. 1237 */ 1238 public SequenceVariantComponent setObservedAllele(String value) { 1239 if (Utilities.noString(value)) 1240 this.observedAllele = null; 1241 else { 1242 if (this.observedAllele == null) 1243 this.observedAllele = new StringType(); 1244 this.observedAllele.setValue(value); 1245 } 1246 return this; 1247 } 1248 1249 /** 1250 * @return {@link #referenceAllele} (An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.). This is the underlying object with id, value and extensions. The accessor "getReferenceAllele" gives direct access to the value 1251 */ 1252 public StringType getReferenceAlleleElement() { 1253 if (this.referenceAllele == null) 1254 if (Configuration.errorOnAutoCreate()) 1255 throw new Error("Attempt to auto-create SequenceVariantComponent.referenceAllele"); 1256 else if (Configuration.doAutoCreate()) 1257 this.referenceAllele = new StringType(); // bb 1258 return this.referenceAllele; 1259 } 1260 1261 public boolean hasReferenceAlleleElement() { 1262 return this.referenceAllele != null && !this.referenceAllele.isEmpty(); 1263 } 1264 1265 public boolean hasReferenceAllele() { 1266 return this.referenceAllele != null && !this.referenceAllele.isEmpty(); 1267 } 1268 1269 /** 1270 * @param value {@link #referenceAllele} (An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.). This is the underlying object with id, value and extensions. The accessor "getReferenceAllele" gives direct access to the value 1271 */ 1272 public SequenceVariantComponent setReferenceAlleleElement(StringType value) { 1273 this.referenceAllele = value; 1274 return this; 1275 } 1276 1277 /** 1278 * @return An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end. 1279 */ 1280 public String getReferenceAllele() { 1281 return this.referenceAllele == null ? null : this.referenceAllele.getValue(); 1282 } 1283 1284 /** 1285 * @param value An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end. 1286 */ 1287 public SequenceVariantComponent setReferenceAllele(String value) { 1288 if (Utilities.noString(value)) 1289 this.referenceAllele = null; 1290 else { 1291 if (this.referenceAllele == null) 1292 this.referenceAllele = new StringType(); 1293 this.referenceAllele.setValue(value); 1294 } 1295 return this; 1296 } 1297 1298 /** 1299 * @return {@link #cigar} (Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).). This is the underlying object with id, value and extensions. The accessor "getCigar" gives direct access to the value 1300 */ 1301 public StringType getCigarElement() { 1302 if (this.cigar == null) 1303 if (Configuration.errorOnAutoCreate()) 1304 throw new Error("Attempt to auto-create SequenceVariantComponent.cigar"); 1305 else if (Configuration.doAutoCreate()) 1306 this.cigar = new StringType(); // bb 1307 return this.cigar; 1308 } 1309 1310 public boolean hasCigarElement() { 1311 return this.cigar != null && !this.cigar.isEmpty(); 1312 } 1313 1314 public boolean hasCigar() { 1315 return this.cigar != null && !this.cigar.isEmpty(); 1316 } 1317 1318 /** 1319 * @param value {@link #cigar} (Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).). This is the underlying object with id, value and extensions. The accessor "getCigar" gives direct access to the value 1320 */ 1321 public SequenceVariantComponent setCigarElement(StringType value) { 1322 this.cigar = value; 1323 return this; 1324 } 1325 1326 /** 1327 * @return Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm). 1328 */ 1329 public String getCigar() { 1330 return this.cigar == null ? null : this.cigar.getValue(); 1331 } 1332 1333 /** 1334 * @param value Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm). 1335 */ 1336 public SequenceVariantComponent setCigar(String value) { 1337 if (Utilities.noString(value)) 1338 this.cigar = null; 1339 else { 1340 if (this.cigar == null) 1341 this.cigar = new StringType(); 1342 this.cigar.setValue(value); 1343 } 1344 return this; 1345 } 1346 1347 /** 1348 * @return {@link #variantPointer} (A pointer to an Observation containing variant information.) 1349 */ 1350 public Reference getVariantPointer() { 1351 if (this.variantPointer == null) 1352 if (Configuration.errorOnAutoCreate()) 1353 throw new Error("Attempt to auto-create SequenceVariantComponent.variantPointer"); 1354 else if (Configuration.doAutoCreate()) 1355 this.variantPointer = new Reference(); // cc 1356 return this.variantPointer; 1357 } 1358 1359 public boolean hasVariantPointer() { 1360 return this.variantPointer != null && !this.variantPointer.isEmpty(); 1361 } 1362 1363 /** 1364 * @param value {@link #variantPointer} (A pointer to an Observation containing variant information.) 1365 */ 1366 public SequenceVariantComponent setVariantPointer(Reference value) { 1367 this.variantPointer = value; 1368 return this; 1369 } 1370 1371 /** 1372 * @return {@link #variantPointer} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (A pointer to an Observation containing variant information.) 1373 */ 1374 public Observation getVariantPointerTarget() { 1375 if (this.variantPointerTarget == null) 1376 if (Configuration.errorOnAutoCreate()) 1377 throw new Error("Attempt to auto-create SequenceVariantComponent.variantPointer"); 1378 else if (Configuration.doAutoCreate()) 1379 this.variantPointerTarget = new Observation(); // aa 1380 return this.variantPointerTarget; 1381 } 1382 1383 /** 1384 * @param value {@link #variantPointer} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (A pointer to an Observation containing variant information.) 1385 */ 1386 public SequenceVariantComponent setVariantPointerTarget(Observation value) { 1387 this.variantPointerTarget = value; 1388 return this; 1389 } 1390 1391 protected void listChildren(List<Property> children) { 1392 super.listChildren(children); 1393 children.add(new Property("start", "integer", "Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, start)); 1394 children.add(new Property("end", "integer", "End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, end)); 1395 children.add(new Property("observedAllele", "string", "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.", 0, 1, observedAllele)); 1396 children.add(new Property("referenceAllele", "string", "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.", 0, 1, referenceAllele)); 1397 children.add(new Property("cigar", "string", "Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).", 0, 1, cigar)); 1398 children.add(new Property("variantPointer", "Reference(Observation)", "A pointer to an Observation containing variant information.", 0, 1, variantPointer)); 1399 } 1400 1401 @Override 1402 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1403 switch (_hash) { 1404 case 109757538: /*start*/ return new Property("start", "integer", "Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, start); 1405 case 100571: /*end*/ return new Property("end", "integer", "End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, end); 1406 case -1418745787: /*observedAllele*/ return new Property("observedAllele", "string", "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.", 0, 1, observedAllele); 1407 case 364045960: /*referenceAllele*/ return new Property("referenceAllele", "string", "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.", 0, 1, referenceAllele); 1408 case 94658738: /*cigar*/ return new Property("cigar", "string", "Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).", 0, 1, cigar); 1409 case -1654319624: /*variantPointer*/ return new Property("variantPointer", "Reference(Observation)", "A pointer to an Observation containing variant information.", 0, 1, variantPointer); 1410 default: return super.getNamedProperty(_hash, _name, _checkValid); 1411 } 1412 1413 } 1414 1415 @Override 1416 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1417 switch (hash) { 1418 case 109757538: /*start*/ return this.start == null ? new Base[0] : new Base[] {this.start}; // IntegerType 1419 case 100571: /*end*/ return this.end == null ? new Base[0] : new Base[] {this.end}; // IntegerType 1420 case -1418745787: /*observedAllele*/ return this.observedAllele == null ? new Base[0] : new Base[] {this.observedAllele}; // StringType 1421 case 364045960: /*referenceAllele*/ return this.referenceAllele == null ? new Base[0] : new Base[] {this.referenceAllele}; // StringType 1422 case 94658738: /*cigar*/ return this.cigar == null ? new Base[0] : new Base[] {this.cigar}; // StringType 1423 case -1654319624: /*variantPointer*/ return this.variantPointer == null ? new Base[0] : new Base[] {this.variantPointer}; // Reference 1424 default: return super.getProperty(hash, name, checkValid); 1425 } 1426 1427 } 1428 1429 @Override 1430 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1431 switch (hash) { 1432 case 109757538: // start 1433 this.start = castToInteger(value); // IntegerType 1434 return value; 1435 case 100571: // end 1436 this.end = castToInteger(value); // IntegerType 1437 return value; 1438 case -1418745787: // observedAllele 1439 this.observedAllele = castToString(value); // StringType 1440 return value; 1441 case 364045960: // referenceAllele 1442 this.referenceAllele = castToString(value); // StringType 1443 return value; 1444 case 94658738: // cigar 1445 this.cigar = castToString(value); // StringType 1446 return value; 1447 case -1654319624: // variantPointer 1448 this.variantPointer = castToReference(value); // Reference 1449 return value; 1450 default: return super.setProperty(hash, name, value); 1451 } 1452 1453 } 1454 1455 @Override 1456 public Base setProperty(String name, Base value) throws FHIRException { 1457 if (name.equals("start")) { 1458 this.start = castToInteger(value); // IntegerType 1459 } else if (name.equals("end")) { 1460 this.end = castToInteger(value); // IntegerType 1461 } else if (name.equals("observedAllele")) { 1462 this.observedAllele = castToString(value); // StringType 1463 } else if (name.equals("referenceAllele")) { 1464 this.referenceAllele = castToString(value); // StringType 1465 } else if (name.equals("cigar")) { 1466 this.cigar = castToString(value); // StringType 1467 } else if (name.equals("variantPointer")) { 1468 this.variantPointer = castToReference(value); // Reference 1469 } else 1470 return super.setProperty(name, value); 1471 return value; 1472 } 1473 1474 @Override 1475 public Base makeProperty(int hash, String name) throws FHIRException { 1476 switch (hash) { 1477 case 109757538: return getStartElement(); 1478 case 100571: return getEndElement(); 1479 case -1418745787: return getObservedAlleleElement(); 1480 case 364045960: return getReferenceAlleleElement(); 1481 case 94658738: return getCigarElement(); 1482 case -1654319624: return getVariantPointer(); 1483 default: return super.makeProperty(hash, name); 1484 } 1485 1486 } 1487 1488 @Override 1489 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1490 switch (hash) { 1491 case 109757538: /*start*/ return new String[] {"integer"}; 1492 case 100571: /*end*/ return new String[] {"integer"}; 1493 case -1418745787: /*observedAllele*/ return new String[] {"string"}; 1494 case 364045960: /*referenceAllele*/ return new String[] {"string"}; 1495 case 94658738: /*cigar*/ return new String[] {"string"}; 1496 case -1654319624: /*variantPointer*/ return new String[] {"Reference"}; 1497 default: return super.getTypesForProperty(hash, name); 1498 } 1499 1500 } 1501 1502 @Override 1503 public Base addChild(String name) throws FHIRException { 1504 if (name.equals("start")) { 1505 throw new FHIRException("Cannot call addChild on a primitive type Sequence.start"); 1506 } 1507 else if (name.equals("end")) { 1508 throw new FHIRException("Cannot call addChild on a primitive type Sequence.end"); 1509 } 1510 else if (name.equals("observedAllele")) { 1511 throw new FHIRException("Cannot call addChild on a primitive type Sequence.observedAllele"); 1512 } 1513 else if (name.equals("referenceAllele")) { 1514 throw new FHIRException("Cannot call addChild on a primitive type Sequence.referenceAllele"); 1515 } 1516 else if (name.equals("cigar")) { 1517 throw new FHIRException("Cannot call addChild on a primitive type Sequence.cigar"); 1518 } 1519 else if (name.equals("variantPointer")) { 1520 this.variantPointer = new Reference(); 1521 return this.variantPointer; 1522 } 1523 else 1524 return super.addChild(name); 1525 } 1526 1527 public SequenceVariantComponent copy() { 1528 SequenceVariantComponent dst = new SequenceVariantComponent(); 1529 copyValues(dst); 1530 dst.start = start == null ? null : start.copy(); 1531 dst.end = end == null ? null : end.copy(); 1532 dst.observedAllele = observedAllele == null ? null : observedAllele.copy(); 1533 dst.referenceAllele = referenceAllele == null ? null : referenceAllele.copy(); 1534 dst.cigar = cigar == null ? null : cigar.copy(); 1535 dst.variantPointer = variantPointer == null ? null : variantPointer.copy(); 1536 return dst; 1537 } 1538 1539 @Override 1540 public boolean equalsDeep(Base other_) { 1541 if (!super.equalsDeep(other_)) 1542 return false; 1543 if (!(other_ instanceof SequenceVariantComponent)) 1544 return false; 1545 SequenceVariantComponent o = (SequenceVariantComponent) other_; 1546 return compareDeep(start, o.start, true) && compareDeep(end, o.end, true) && compareDeep(observedAllele, o.observedAllele, true) 1547 && compareDeep(referenceAllele, o.referenceAllele, true) && compareDeep(cigar, o.cigar, true) && compareDeep(variantPointer, o.variantPointer, true) 1548 ; 1549 } 1550 1551 @Override 1552 public boolean equalsShallow(Base other_) { 1553 if (!super.equalsShallow(other_)) 1554 return false; 1555 if (!(other_ instanceof SequenceVariantComponent)) 1556 return false; 1557 SequenceVariantComponent o = (SequenceVariantComponent) other_; 1558 return compareValues(start, o.start, true) && compareValues(end, o.end, true) && compareValues(observedAllele, o.observedAllele, true) 1559 && compareValues(referenceAllele, o.referenceAllele, true) && compareValues(cigar, o.cigar, true); 1560 } 1561 1562 public boolean isEmpty() { 1563 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(start, end, observedAllele 1564 , referenceAllele, cigar, variantPointer); 1565 } 1566 1567 public String fhirType() { 1568 return "Sequence.variant"; 1569 1570 } 1571 1572 } 1573 1574 @Block() 1575 public static class SequenceQualityComponent extends BackboneElement implements IBaseBackboneElement { 1576 /** 1577 * INDEL / SNP / Undefined variant. 1578 */ 1579 @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1580 @Description(shortDefinition="indel | snp | unknown", formalDefinition="INDEL / SNP / Undefined variant." ) 1581 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/quality-type") 1582 protected Enumeration<QualityType> type; 1583 1584 /** 1585 * Gold standard sequence used for comparing against. 1586 */ 1587 @Child(name = "standardSequence", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=true) 1588 @Description(shortDefinition="Standard sequence for comparison", formalDefinition="Gold standard sequence used for comparing against." ) 1589 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/sequence-quality-standardSequence") 1590 protected CodeableConcept standardSequence; 1591 1592 /** 1593 * Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive. 1594 */ 1595 @Child(name = "start", type = {IntegerType.class}, order=3, min=0, max=1, modifier=false, summary=true) 1596 @Description(shortDefinition="Start position of the sequence", formalDefinition="Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive." ) 1597 protected IntegerType start; 1598 1599 /** 1600 * End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position. 1601 */ 1602 @Child(name = "end", type = {IntegerType.class}, order=4, min=0, max=1, modifier=false, summary=true) 1603 @Description(shortDefinition="End position of the sequence", formalDefinition="End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position." ) 1604 protected IntegerType end; 1605 1606 /** 1607 * The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)). 1608 */ 1609 @Child(name = "score", type = {Quantity.class}, order=5, min=0, max=1, modifier=false, summary=true) 1610 @Description(shortDefinition="Quality score for the comparison", formalDefinition="The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685))." ) 1611 protected Quantity score; 1612 1613 /** 1614 * Which method is used to get sequence quality. 1615 */ 1616 @Child(name = "method", type = {CodeableConcept.class}, order=6, min=0, max=1, modifier=false, summary=true) 1617 @Description(shortDefinition="Method to get quality", formalDefinition="Which method is used to get sequence quality." ) 1618 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/sequence-quality-method") 1619 protected CodeableConcept method; 1620 1621 /** 1622 * True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 1623 */ 1624 @Child(name = "truthTP", type = {DecimalType.class}, order=7, min=0, max=1, modifier=false, summary=true) 1625 @Description(shortDefinition="True positives from the perspective of the truth data", formalDefinition="True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event." ) 1626 protected DecimalType truthTP; 1627 1628 /** 1629 * True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 1630 */ 1631 @Child(name = "queryTP", type = {DecimalType.class}, order=8, min=0, max=1, modifier=false, summary=true) 1632 @Description(shortDefinition="True positives from the perspective of the query data", formalDefinition="True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event." ) 1633 protected DecimalType queryTP; 1634 1635 /** 1636 * False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here. 1637 */ 1638 @Child(name = "truthFN", type = {DecimalType.class}, order=9, min=0, max=1, modifier=false, summary=true) 1639 @Description(shortDefinition="False negatives", formalDefinition="False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here." ) 1640 protected DecimalType truthFN; 1641 1642 /** 1643 * False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here. 1644 */ 1645 @Child(name = "queryFP", type = {DecimalType.class}, order=10, min=0, max=1, modifier=false, summary=true) 1646 @Description(shortDefinition="False positives", formalDefinition="False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here." ) 1647 protected DecimalType queryFP; 1648 1649 /** 1650 * The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar). 1651 */ 1652 @Child(name = "gtFP", type = {DecimalType.class}, order=11, min=0, max=1, modifier=false, summary=true) 1653 @Description(shortDefinition="False positives where the non-REF alleles in the Truth and Query Call Sets match", formalDefinition="The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar)." ) 1654 protected DecimalType gtFP; 1655 1656 /** 1657 * QUERY.TP / (QUERY.TP + QUERY.FP). 1658 */ 1659 @Child(name = "precision", type = {DecimalType.class}, order=12, min=0, max=1, modifier=false, summary=true) 1660 @Description(shortDefinition="Precision of comparison", formalDefinition="QUERY.TP / (QUERY.TP + QUERY.FP)." ) 1661 protected DecimalType precision; 1662 1663 /** 1664 * TRUTH.TP / (TRUTH.TP + TRUTH.FN). 1665 */ 1666 @Child(name = "recall", type = {DecimalType.class}, order=13, min=0, max=1, modifier=false, summary=true) 1667 @Description(shortDefinition="Recall of comparison", formalDefinition="TRUTH.TP / (TRUTH.TP + TRUTH.FN)." ) 1668 protected DecimalType recall; 1669 1670 /** 1671 * Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall). 1672 */ 1673 @Child(name = "fScore", type = {DecimalType.class}, order=14, min=0, max=1, modifier=false, summary=true) 1674 @Description(shortDefinition="F-score", formalDefinition="Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall)." ) 1675 protected DecimalType fScore; 1676 1677 private static final long serialVersionUID = -383644463L; 1678 1679 /** 1680 * Constructor 1681 */ 1682 public SequenceQualityComponent() { 1683 super(); 1684 } 1685 1686 /** 1687 * Constructor 1688 */ 1689 public SequenceQualityComponent(Enumeration<QualityType> type) { 1690 super(); 1691 this.type = type; 1692 } 1693 1694 /** 1695 * @return {@link #type} (INDEL / SNP / Undefined variant.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1696 */ 1697 public Enumeration<QualityType> getTypeElement() { 1698 if (this.type == null) 1699 if (Configuration.errorOnAutoCreate()) 1700 throw new Error("Attempt to auto-create SequenceQualityComponent.type"); 1701 else if (Configuration.doAutoCreate()) 1702 this.type = new Enumeration<QualityType>(new QualityTypeEnumFactory()); // bb 1703 return this.type; 1704 } 1705 1706 public boolean hasTypeElement() { 1707 return this.type != null && !this.type.isEmpty(); 1708 } 1709 1710 public boolean hasType() { 1711 return this.type != null && !this.type.isEmpty(); 1712 } 1713 1714 /** 1715 * @param value {@link #type} (INDEL / SNP / Undefined variant.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 1716 */ 1717 public SequenceQualityComponent setTypeElement(Enumeration<QualityType> value) { 1718 this.type = value; 1719 return this; 1720 } 1721 1722 /** 1723 * @return INDEL / SNP / Undefined variant. 1724 */ 1725 public QualityType getType() { 1726 return this.type == null ? null : this.type.getValue(); 1727 } 1728 1729 /** 1730 * @param value INDEL / SNP / Undefined variant. 1731 */ 1732 public SequenceQualityComponent setType(QualityType value) { 1733 if (this.type == null) 1734 this.type = new Enumeration<QualityType>(new QualityTypeEnumFactory()); 1735 this.type.setValue(value); 1736 return this; 1737 } 1738 1739 /** 1740 * @return {@link #standardSequence} (Gold standard sequence used for comparing against.) 1741 */ 1742 public CodeableConcept getStandardSequence() { 1743 if (this.standardSequence == null) 1744 if (Configuration.errorOnAutoCreate()) 1745 throw new Error("Attempt to auto-create SequenceQualityComponent.standardSequence"); 1746 else if (Configuration.doAutoCreate()) 1747 this.standardSequence = new CodeableConcept(); // cc 1748 return this.standardSequence; 1749 } 1750 1751 public boolean hasStandardSequence() { 1752 return this.standardSequence != null && !this.standardSequence.isEmpty(); 1753 } 1754 1755 /** 1756 * @param value {@link #standardSequence} (Gold standard sequence used for comparing against.) 1757 */ 1758 public SequenceQualityComponent setStandardSequence(CodeableConcept value) { 1759 this.standardSequence = value; 1760 return this; 1761 } 1762 1763 /** 1764 * @return {@link #start} (Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getStart" gives direct access to the value 1765 */ 1766 public IntegerType getStartElement() { 1767 if (this.start == null) 1768 if (Configuration.errorOnAutoCreate()) 1769 throw new Error("Attempt to auto-create SequenceQualityComponent.start"); 1770 else if (Configuration.doAutoCreate()) 1771 this.start = new IntegerType(); // bb 1772 return this.start; 1773 } 1774 1775 public boolean hasStartElement() { 1776 return this.start != null && !this.start.isEmpty(); 1777 } 1778 1779 public boolean hasStart() { 1780 return this.start != null && !this.start.isEmpty(); 1781 } 1782 1783 /** 1784 * @param value {@link #start} (Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getStart" gives direct access to the value 1785 */ 1786 public SequenceQualityComponent setStartElement(IntegerType value) { 1787 this.start = value; 1788 return this; 1789 } 1790 1791 /** 1792 * @return Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive. 1793 */ 1794 public int getStart() { 1795 return this.start == null || this.start.isEmpty() ? 0 : this.start.getValue(); 1796 } 1797 1798 /** 1799 * @param value Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive. 1800 */ 1801 public SequenceQualityComponent setStart(int value) { 1802 if (this.start == null) 1803 this.start = new IntegerType(); 1804 this.start.setValue(value); 1805 return this; 1806 } 1807 1808 /** 1809 * @return {@link #end} (End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getEnd" gives direct access to the value 1810 */ 1811 public IntegerType getEndElement() { 1812 if (this.end == null) 1813 if (Configuration.errorOnAutoCreate()) 1814 throw new Error("Attempt to auto-create SequenceQualityComponent.end"); 1815 else if (Configuration.doAutoCreate()) 1816 this.end = new IntegerType(); // bb 1817 return this.end; 1818 } 1819 1820 public boolean hasEndElement() { 1821 return this.end != null && !this.end.isEmpty(); 1822 } 1823 1824 public boolean hasEnd() { 1825 return this.end != null && !this.end.isEmpty(); 1826 } 1827 1828 /** 1829 * @param value {@link #end} (End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getEnd" gives direct access to the value 1830 */ 1831 public SequenceQualityComponent setEndElement(IntegerType value) { 1832 this.end = value; 1833 return this; 1834 } 1835 1836 /** 1837 * @return End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position. 1838 */ 1839 public int getEnd() { 1840 return this.end == null || this.end.isEmpty() ? 0 : this.end.getValue(); 1841 } 1842 1843 /** 1844 * @param value End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position. 1845 */ 1846 public SequenceQualityComponent setEnd(int value) { 1847 if (this.end == null) 1848 this.end = new IntegerType(); 1849 this.end.setValue(value); 1850 return this; 1851 } 1852 1853 /** 1854 * @return {@link #score} (The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).) 1855 */ 1856 public Quantity getScore() { 1857 if (this.score == null) 1858 if (Configuration.errorOnAutoCreate()) 1859 throw new Error("Attempt to auto-create SequenceQualityComponent.score"); 1860 else if (Configuration.doAutoCreate()) 1861 this.score = new Quantity(); // cc 1862 return this.score; 1863 } 1864 1865 public boolean hasScore() { 1866 return this.score != null && !this.score.isEmpty(); 1867 } 1868 1869 /** 1870 * @param value {@link #score} (The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).) 1871 */ 1872 public SequenceQualityComponent setScore(Quantity value) { 1873 this.score = value; 1874 return this; 1875 } 1876 1877 /** 1878 * @return {@link #method} (Which method is used to get sequence quality.) 1879 */ 1880 public CodeableConcept getMethod() { 1881 if (this.method == null) 1882 if (Configuration.errorOnAutoCreate()) 1883 throw new Error("Attempt to auto-create SequenceQualityComponent.method"); 1884 else if (Configuration.doAutoCreate()) 1885 this.method = new CodeableConcept(); // cc 1886 return this.method; 1887 } 1888 1889 public boolean hasMethod() { 1890 return this.method != null && !this.method.isEmpty(); 1891 } 1892 1893 /** 1894 * @param value {@link #method} (Which method is used to get sequence quality.) 1895 */ 1896 public SequenceQualityComponent setMethod(CodeableConcept value) { 1897 this.method = value; 1898 return this; 1899 } 1900 1901 /** 1902 * @return {@link #truthTP} (True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.). This is the underlying object with id, value and extensions. The accessor "getTruthTP" gives direct access to the value 1903 */ 1904 public DecimalType getTruthTPElement() { 1905 if (this.truthTP == null) 1906 if (Configuration.errorOnAutoCreate()) 1907 throw new Error("Attempt to auto-create SequenceQualityComponent.truthTP"); 1908 else if (Configuration.doAutoCreate()) 1909 this.truthTP = new DecimalType(); // bb 1910 return this.truthTP; 1911 } 1912 1913 public boolean hasTruthTPElement() { 1914 return this.truthTP != null && !this.truthTP.isEmpty(); 1915 } 1916 1917 public boolean hasTruthTP() { 1918 return this.truthTP != null && !this.truthTP.isEmpty(); 1919 } 1920 1921 /** 1922 * @param value {@link #truthTP} (True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.). This is the underlying object with id, value and extensions. The accessor "getTruthTP" gives direct access to the value 1923 */ 1924 public SequenceQualityComponent setTruthTPElement(DecimalType value) { 1925 this.truthTP = value; 1926 return this; 1927 } 1928 1929 /** 1930 * @return True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 1931 */ 1932 public BigDecimal getTruthTP() { 1933 return this.truthTP == null ? null : this.truthTP.getValue(); 1934 } 1935 1936 /** 1937 * @param value True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 1938 */ 1939 public SequenceQualityComponent setTruthTP(BigDecimal value) { 1940 if (value == null) 1941 this.truthTP = null; 1942 else { 1943 if (this.truthTP == null) 1944 this.truthTP = new DecimalType(); 1945 this.truthTP.setValue(value); 1946 } 1947 return this; 1948 } 1949 1950 /** 1951 * @param value True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 1952 */ 1953 public SequenceQualityComponent setTruthTP(long value) { 1954 this.truthTP = new DecimalType(); 1955 this.truthTP.setValue(value); 1956 return this; 1957 } 1958 1959 /** 1960 * @param value True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 1961 */ 1962 public SequenceQualityComponent setTruthTP(double value) { 1963 this.truthTP = new DecimalType(); 1964 this.truthTP.setValue(value); 1965 return this; 1966 } 1967 1968 /** 1969 * @return {@link #queryTP} (True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.). This is the underlying object with id, value and extensions. The accessor "getQueryTP" gives direct access to the value 1970 */ 1971 public DecimalType getQueryTPElement() { 1972 if (this.queryTP == null) 1973 if (Configuration.errorOnAutoCreate()) 1974 throw new Error("Attempt to auto-create SequenceQualityComponent.queryTP"); 1975 else if (Configuration.doAutoCreate()) 1976 this.queryTP = new DecimalType(); // bb 1977 return this.queryTP; 1978 } 1979 1980 public boolean hasQueryTPElement() { 1981 return this.queryTP != null && !this.queryTP.isEmpty(); 1982 } 1983 1984 public boolean hasQueryTP() { 1985 return this.queryTP != null && !this.queryTP.isEmpty(); 1986 } 1987 1988 /** 1989 * @param value {@link #queryTP} (True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.). This is the underlying object with id, value and extensions. The accessor "getQueryTP" gives direct access to the value 1990 */ 1991 public SequenceQualityComponent setQueryTPElement(DecimalType value) { 1992 this.queryTP = value; 1993 return this; 1994 } 1995 1996 /** 1997 * @return True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 1998 */ 1999 public BigDecimal getQueryTP() { 2000 return this.queryTP == null ? null : this.queryTP.getValue(); 2001 } 2002 2003 /** 2004 * @param value True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 2005 */ 2006 public SequenceQualityComponent setQueryTP(BigDecimal value) { 2007 if (value == null) 2008 this.queryTP = null; 2009 else { 2010 if (this.queryTP == null) 2011 this.queryTP = new DecimalType(); 2012 this.queryTP.setValue(value); 2013 } 2014 return this; 2015 } 2016 2017 /** 2018 * @param value True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 2019 */ 2020 public SequenceQualityComponent setQueryTP(long value) { 2021 this.queryTP = new DecimalType(); 2022 this.queryTP.setValue(value); 2023 return this; 2024 } 2025 2026 /** 2027 * @param value True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event. 2028 */ 2029 public SequenceQualityComponent setQueryTP(double value) { 2030 this.queryTP = new DecimalType(); 2031 this.queryTP.setValue(value); 2032 return this; 2033 } 2034 2035 /** 2036 * @return {@link #truthFN} (False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.). This is the underlying object with id, value and extensions. The accessor "getTruthFN" gives direct access to the value 2037 */ 2038 public DecimalType getTruthFNElement() { 2039 if (this.truthFN == null) 2040 if (Configuration.errorOnAutoCreate()) 2041 throw new Error("Attempt to auto-create SequenceQualityComponent.truthFN"); 2042 else if (Configuration.doAutoCreate()) 2043 this.truthFN = new DecimalType(); // bb 2044 return this.truthFN; 2045 } 2046 2047 public boolean hasTruthFNElement() { 2048 return this.truthFN != null && !this.truthFN.isEmpty(); 2049 } 2050 2051 public boolean hasTruthFN() { 2052 return this.truthFN != null && !this.truthFN.isEmpty(); 2053 } 2054 2055 /** 2056 * @param value {@link #truthFN} (False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.). This is the underlying object with id, value and extensions. The accessor "getTruthFN" gives direct access to the value 2057 */ 2058 public SequenceQualityComponent setTruthFNElement(DecimalType value) { 2059 this.truthFN = value; 2060 return this; 2061 } 2062 2063 /** 2064 * @return False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here. 2065 */ 2066 public BigDecimal getTruthFN() { 2067 return this.truthFN == null ? null : this.truthFN.getValue(); 2068 } 2069 2070 /** 2071 * @param value False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here. 2072 */ 2073 public SequenceQualityComponent setTruthFN(BigDecimal value) { 2074 if (value == null) 2075 this.truthFN = null; 2076 else { 2077 if (this.truthFN == null) 2078 this.truthFN = new DecimalType(); 2079 this.truthFN.setValue(value); 2080 } 2081 return this; 2082 } 2083 2084 /** 2085 * @param value False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here. 2086 */ 2087 public SequenceQualityComponent setTruthFN(long value) { 2088 this.truthFN = new DecimalType(); 2089 this.truthFN.setValue(value); 2090 return this; 2091 } 2092 2093 /** 2094 * @param value False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here. 2095 */ 2096 public SequenceQualityComponent setTruthFN(double value) { 2097 this.truthFN = new DecimalType(); 2098 this.truthFN.setValue(value); 2099 return this; 2100 } 2101 2102 /** 2103 * @return {@link #queryFP} (False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.). This is the underlying object with id, value and extensions. The accessor "getQueryFP" gives direct access to the value 2104 */ 2105 public DecimalType getQueryFPElement() { 2106 if (this.queryFP == null) 2107 if (Configuration.errorOnAutoCreate()) 2108 throw new Error("Attempt to auto-create SequenceQualityComponent.queryFP"); 2109 else if (Configuration.doAutoCreate()) 2110 this.queryFP = new DecimalType(); // bb 2111 return this.queryFP; 2112 } 2113 2114 public boolean hasQueryFPElement() { 2115 return this.queryFP != null && !this.queryFP.isEmpty(); 2116 } 2117 2118 public boolean hasQueryFP() { 2119 return this.queryFP != null && !this.queryFP.isEmpty(); 2120 } 2121 2122 /** 2123 * @param value {@link #queryFP} (False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.). This is the underlying object with id, value and extensions. The accessor "getQueryFP" gives direct access to the value 2124 */ 2125 public SequenceQualityComponent setQueryFPElement(DecimalType value) { 2126 this.queryFP = value; 2127 return this; 2128 } 2129 2130 /** 2131 * @return False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here. 2132 */ 2133 public BigDecimal getQueryFP() { 2134 return this.queryFP == null ? null : this.queryFP.getValue(); 2135 } 2136 2137 /** 2138 * @param value False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here. 2139 */ 2140 public SequenceQualityComponent setQueryFP(BigDecimal value) { 2141 if (value == null) 2142 this.queryFP = null; 2143 else { 2144 if (this.queryFP == null) 2145 this.queryFP = new DecimalType(); 2146 this.queryFP.setValue(value); 2147 } 2148 return this; 2149 } 2150 2151 /** 2152 * @param value False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here. 2153 */ 2154 public SequenceQualityComponent setQueryFP(long value) { 2155 this.queryFP = new DecimalType(); 2156 this.queryFP.setValue(value); 2157 return this; 2158 } 2159 2160 /** 2161 * @param value False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here. 2162 */ 2163 public SequenceQualityComponent setQueryFP(double value) { 2164 this.queryFP = new DecimalType(); 2165 this.queryFP.setValue(value); 2166 return this; 2167 } 2168 2169 /** 2170 * @return {@link #gtFP} (The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).). This is the underlying object with id, value and extensions. The accessor "getGtFP" gives direct access to the value 2171 */ 2172 public DecimalType getGtFPElement() { 2173 if (this.gtFP == null) 2174 if (Configuration.errorOnAutoCreate()) 2175 throw new Error("Attempt to auto-create SequenceQualityComponent.gtFP"); 2176 else if (Configuration.doAutoCreate()) 2177 this.gtFP = new DecimalType(); // bb 2178 return this.gtFP; 2179 } 2180 2181 public boolean hasGtFPElement() { 2182 return this.gtFP != null && !this.gtFP.isEmpty(); 2183 } 2184 2185 public boolean hasGtFP() { 2186 return this.gtFP != null && !this.gtFP.isEmpty(); 2187 } 2188 2189 /** 2190 * @param value {@link #gtFP} (The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).). This is the underlying object with id, value and extensions. The accessor "getGtFP" gives direct access to the value 2191 */ 2192 public SequenceQualityComponent setGtFPElement(DecimalType value) { 2193 this.gtFP = value; 2194 return this; 2195 } 2196 2197 /** 2198 * @return The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar). 2199 */ 2200 public BigDecimal getGtFP() { 2201 return this.gtFP == null ? null : this.gtFP.getValue(); 2202 } 2203 2204 /** 2205 * @param value The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar). 2206 */ 2207 public SequenceQualityComponent setGtFP(BigDecimal value) { 2208 if (value == null) 2209 this.gtFP = null; 2210 else { 2211 if (this.gtFP == null) 2212 this.gtFP = new DecimalType(); 2213 this.gtFP.setValue(value); 2214 } 2215 return this; 2216 } 2217 2218 /** 2219 * @param value The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar). 2220 */ 2221 public SequenceQualityComponent setGtFP(long value) { 2222 this.gtFP = new DecimalType(); 2223 this.gtFP.setValue(value); 2224 return this; 2225 } 2226 2227 /** 2228 * @param value The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar). 2229 */ 2230 public SequenceQualityComponent setGtFP(double value) { 2231 this.gtFP = new DecimalType(); 2232 this.gtFP.setValue(value); 2233 return this; 2234 } 2235 2236 /** 2237 * @return {@link #precision} (QUERY.TP / (QUERY.TP + QUERY.FP).). This is the underlying object with id, value and extensions. The accessor "getPrecision" gives direct access to the value 2238 */ 2239 public DecimalType getPrecisionElement() { 2240 if (this.precision == null) 2241 if (Configuration.errorOnAutoCreate()) 2242 throw new Error("Attempt to auto-create SequenceQualityComponent.precision"); 2243 else if (Configuration.doAutoCreate()) 2244 this.precision = new DecimalType(); // bb 2245 return this.precision; 2246 } 2247 2248 public boolean hasPrecisionElement() { 2249 return this.precision != null && !this.precision.isEmpty(); 2250 } 2251 2252 public boolean hasPrecision() { 2253 return this.precision != null && !this.precision.isEmpty(); 2254 } 2255 2256 /** 2257 * @param value {@link #precision} (QUERY.TP / (QUERY.TP + QUERY.FP).). This is the underlying object with id, value and extensions. The accessor "getPrecision" gives direct access to the value 2258 */ 2259 public SequenceQualityComponent setPrecisionElement(DecimalType value) { 2260 this.precision = value; 2261 return this; 2262 } 2263 2264 /** 2265 * @return QUERY.TP / (QUERY.TP + QUERY.FP). 2266 */ 2267 public BigDecimal getPrecision() { 2268 return this.precision == null ? null : this.precision.getValue(); 2269 } 2270 2271 /** 2272 * @param value QUERY.TP / (QUERY.TP + QUERY.FP). 2273 */ 2274 public SequenceQualityComponent setPrecision(BigDecimal value) { 2275 if (value == null) 2276 this.precision = null; 2277 else { 2278 if (this.precision == null) 2279 this.precision = new DecimalType(); 2280 this.precision.setValue(value); 2281 } 2282 return this; 2283 } 2284 2285 /** 2286 * @param value QUERY.TP / (QUERY.TP + QUERY.FP). 2287 */ 2288 public SequenceQualityComponent setPrecision(long value) { 2289 this.precision = new DecimalType(); 2290 this.precision.setValue(value); 2291 return this; 2292 } 2293 2294 /** 2295 * @param value QUERY.TP / (QUERY.TP + QUERY.FP). 2296 */ 2297 public SequenceQualityComponent setPrecision(double value) { 2298 this.precision = new DecimalType(); 2299 this.precision.setValue(value); 2300 return this; 2301 } 2302 2303 /** 2304 * @return {@link #recall} (TRUTH.TP / (TRUTH.TP + TRUTH.FN).). This is the underlying object with id, value and extensions. The accessor "getRecall" gives direct access to the value 2305 */ 2306 public DecimalType getRecallElement() { 2307 if (this.recall == null) 2308 if (Configuration.errorOnAutoCreate()) 2309 throw new Error("Attempt to auto-create SequenceQualityComponent.recall"); 2310 else if (Configuration.doAutoCreate()) 2311 this.recall = new DecimalType(); // bb 2312 return this.recall; 2313 } 2314 2315 public boolean hasRecallElement() { 2316 return this.recall != null && !this.recall.isEmpty(); 2317 } 2318 2319 public boolean hasRecall() { 2320 return this.recall != null && !this.recall.isEmpty(); 2321 } 2322 2323 /** 2324 * @param value {@link #recall} (TRUTH.TP / (TRUTH.TP + TRUTH.FN).). This is the underlying object with id, value and extensions. The accessor "getRecall" gives direct access to the value 2325 */ 2326 public SequenceQualityComponent setRecallElement(DecimalType value) { 2327 this.recall = value; 2328 return this; 2329 } 2330 2331 /** 2332 * @return TRUTH.TP / (TRUTH.TP + TRUTH.FN). 2333 */ 2334 public BigDecimal getRecall() { 2335 return this.recall == null ? null : this.recall.getValue(); 2336 } 2337 2338 /** 2339 * @param value TRUTH.TP / (TRUTH.TP + TRUTH.FN). 2340 */ 2341 public SequenceQualityComponent setRecall(BigDecimal value) { 2342 if (value == null) 2343 this.recall = null; 2344 else { 2345 if (this.recall == null) 2346 this.recall = new DecimalType(); 2347 this.recall.setValue(value); 2348 } 2349 return this; 2350 } 2351 2352 /** 2353 * @param value TRUTH.TP / (TRUTH.TP + TRUTH.FN). 2354 */ 2355 public SequenceQualityComponent setRecall(long value) { 2356 this.recall = new DecimalType(); 2357 this.recall.setValue(value); 2358 return this; 2359 } 2360 2361 /** 2362 * @param value TRUTH.TP / (TRUTH.TP + TRUTH.FN). 2363 */ 2364 public SequenceQualityComponent setRecall(double value) { 2365 this.recall = new DecimalType(); 2366 this.recall.setValue(value); 2367 return this; 2368 } 2369 2370 /** 2371 * @return {@link #fScore} (Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).). This is the underlying object with id, value and extensions. The accessor "getFScore" gives direct access to the value 2372 */ 2373 public DecimalType getFScoreElement() { 2374 if (this.fScore == null) 2375 if (Configuration.errorOnAutoCreate()) 2376 throw new Error("Attempt to auto-create SequenceQualityComponent.fScore"); 2377 else if (Configuration.doAutoCreate()) 2378 this.fScore = new DecimalType(); // bb 2379 return this.fScore; 2380 } 2381 2382 public boolean hasFScoreElement() { 2383 return this.fScore != null && !this.fScore.isEmpty(); 2384 } 2385 2386 public boolean hasFScore() { 2387 return this.fScore != null && !this.fScore.isEmpty(); 2388 } 2389 2390 /** 2391 * @param value {@link #fScore} (Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).). This is the underlying object with id, value and extensions. The accessor "getFScore" gives direct access to the value 2392 */ 2393 public SequenceQualityComponent setFScoreElement(DecimalType value) { 2394 this.fScore = value; 2395 return this; 2396 } 2397 2398 /** 2399 * @return Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall). 2400 */ 2401 public BigDecimal getFScore() { 2402 return this.fScore == null ? null : this.fScore.getValue(); 2403 } 2404 2405 /** 2406 * @param value Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall). 2407 */ 2408 public SequenceQualityComponent setFScore(BigDecimal value) { 2409 if (value == null) 2410 this.fScore = null; 2411 else { 2412 if (this.fScore == null) 2413 this.fScore = new DecimalType(); 2414 this.fScore.setValue(value); 2415 } 2416 return this; 2417 } 2418 2419 /** 2420 * @param value Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall). 2421 */ 2422 public SequenceQualityComponent setFScore(long value) { 2423 this.fScore = new DecimalType(); 2424 this.fScore.setValue(value); 2425 return this; 2426 } 2427 2428 /** 2429 * @param value Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall). 2430 */ 2431 public SequenceQualityComponent setFScore(double value) { 2432 this.fScore = new DecimalType(); 2433 this.fScore.setValue(value); 2434 return this; 2435 } 2436 2437 protected void listChildren(List<Property> children) { 2438 super.listChildren(children); 2439 children.add(new Property("type", "code", "INDEL / SNP / Undefined variant.", 0, 1, type)); 2440 children.add(new Property("standardSequence", "CodeableConcept", "Gold standard sequence used for comparing against.", 0, 1, standardSequence)); 2441 children.add(new Property("start", "integer", "Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, start)); 2442 children.add(new Property("end", "integer", "End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, end)); 2443 children.add(new Property("score", "Quantity", "The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).", 0, 1, score)); 2444 children.add(new Property("method", "CodeableConcept", "Which method is used to get sequence quality.", 0, 1, method)); 2445 children.add(new Property("truthTP", "decimal", "True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.", 0, 1, truthTP)); 2446 children.add(new Property("queryTP", "decimal", "True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.", 0, 1, queryTP)); 2447 children.add(new Property("truthFN", "decimal", "False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.", 0, 1, truthFN)); 2448 children.add(new Property("queryFP", "decimal", "False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.", 0, 1, queryFP)); 2449 children.add(new Property("gtFP", "decimal", "The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).", 0, 1, gtFP)); 2450 children.add(new Property("precision", "decimal", "QUERY.TP / (QUERY.TP + QUERY.FP).", 0, 1, precision)); 2451 children.add(new Property("recall", "decimal", "TRUTH.TP / (TRUTH.TP + TRUTH.FN).", 0, 1, recall)); 2452 children.add(new Property("fScore", "decimal", "Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).", 0, 1, fScore)); 2453 } 2454 2455 @Override 2456 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2457 switch (_hash) { 2458 case 3575610: /*type*/ return new Property("type", "code", "INDEL / SNP / Undefined variant.", 0, 1, type); 2459 case -1861227106: /*standardSequence*/ return new Property("standardSequence", "CodeableConcept", "Gold standard sequence used for comparing against.", 0, 1, standardSequence); 2460 case 109757538: /*start*/ return new Property("start", "integer", "Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, start); 2461 case 100571: /*end*/ return new Property("end", "integer", "End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, end); 2462 case 109264530: /*score*/ return new Property("score", "Quantity", "The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).", 0, 1, score); 2463 case -1077554975: /*method*/ return new Property("method", "CodeableConcept", "Which method is used to get sequence quality.", 0, 1, method); 2464 case -1048421849: /*truthTP*/ return new Property("truthTP", "decimal", "True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.", 0, 1, truthTP); 2465 case 655102276: /*queryTP*/ return new Property("queryTP", "decimal", "True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.", 0, 1, queryTP); 2466 case -1048422285: /*truthFN*/ return new Property("truthFN", "decimal", "False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.", 0, 1, truthFN); 2467 case 655101842: /*queryFP*/ return new Property("queryFP", "decimal", "False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.", 0, 1, queryFP); 2468 case 3182199: /*gtFP*/ return new Property("gtFP", "decimal", "The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).", 0, 1, gtFP); 2469 case -1376177026: /*precision*/ return new Property("precision", "decimal", "QUERY.TP / (QUERY.TP + QUERY.FP).", 0, 1, precision); 2470 case -934922479: /*recall*/ return new Property("recall", "decimal", "TRUTH.TP / (TRUTH.TP + TRUTH.FN).", 0, 1, recall); 2471 case -1295082036: /*fScore*/ return new Property("fScore", "decimal", "Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).", 0, 1, fScore); 2472 default: return super.getNamedProperty(_hash, _name, _checkValid); 2473 } 2474 2475 } 2476 2477 @Override 2478 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2479 switch (hash) { 2480 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<QualityType> 2481 case -1861227106: /*standardSequence*/ return this.standardSequence == null ? new Base[0] : new Base[] {this.standardSequence}; // CodeableConcept 2482 case 109757538: /*start*/ return this.start == null ? new Base[0] : new Base[] {this.start}; // IntegerType 2483 case 100571: /*end*/ return this.end == null ? new Base[0] : new Base[] {this.end}; // IntegerType 2484 case 109264530: /*score*/ return this.score == null ? new Base[0] : new Base[] {this.score}; // Quantity 2485 case -1077554975: /*method*/ return this.method == null ? new Base[0] : new Base[] {this.method}; // CodeableConcept 2486 case -1048421849: /*truthTP*/ return this.truthTP == null ? new Base[0] : new Base[] {this.truthTP}; // DecimalType 2487 case 655102276: /*queryTP*/ return this.queryTP == null ? new Base[0] : new Base[] {this.queryTP}; // DecimalType 2488 case -1048422285: /*truthFN*/ return this.truthFN == null ? new Base[0] : new Base[] {this.truthFN}; // DecimalType 2489 case 655101842: /*queryFP*/ return this.queryFP == null ? new Base[0] : new Base[] {this.queryFP}; // DecimalType 2490 case 3182199: /*gtFP*/ return this.gtFP == null ? new Base[0] : new Base[] {this.gtFP}; // DecimalType 2491 case -1376177026: /*precision*/ return this.precision == null ? new Base[0] : new Base[] {this.precision}; // DecimalType 2492 case -934922479: /*recall*/ return this.recall == null ? new Base[0] : new Base[] {this.recall}; // DecimalType 2493 case -1295082036: /*fScore*/ return this.fScore == null ? new Base[0] : new Base[] {this.fScore}; // DecimalType 2494 default: return super.getProperty(hash, name, checkValid); 2495 } 2496 2497 } 2498 2499 @Override 2500 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2501 switch (hash) { 2502 case 3575610: // type 2503 value = new QualityTypeEnumFactory().fromType(castToCode(value)); 2504 this.type = (Enumeration) value; // Enumeration<QualityType> 2505 return value; 2506 case -1861227106: // standardSequence 2507 this.standardSequence = castToCodeableConcept(value); // CodeableConcept 2508 return value; 2509 case 109757538: // start 2510 this.start = castToInteger(value); // IntegerType 2511 return value; 2512 case 100571: // end 2513 this.end = castToInteger(value); // IntegerType 2514 return value; 2515 case 109264530: // score 2516 this.score = castToQuantity(value); // Quantity 2517 return value; 2518 case -1077554975: // method 2519 this.method = castToCodeableConcept(value); // CodeableConcept 2520 return value; 2521 case -1048421849: // truthTP 2522 this.truthTP = castToDecimal(value); // DecimalType 2523 return value; 2524 case 655102276: // queryTP 2525 this.queryTP = castToDecimal(value); // DecimalType 2526 return value; 2527 case -1048422285: // truthFN 2528 this.truthFN = castToDecimal(value); // DecimalType 2529 return value; 2530 case 655101842: // queryFP 2531 this.queryFP = castToDecimal(value); // DecimalType 2532 return value; 2533 case 3182199: // gtFP 2534 this.gtFP = castToDecimal(value); // DecimalType 2535 return value; 2536 case -1376177026: // precision 2537 this.precision = castToDecimal(value); // DecimalType 2538 return value; 2539 case -934922479: // recall 2540 this.recall = castToDecimal(value); // DecimalType 2541 return value; 2542 case -1295082036: // fScore 2543 this.fScore = castToDecimal(value); // DecimalType 2544 return value; 2545 default: return super.setProperty(hash, name, value); 2546 } 2547 2548 } 2549 2550 @Override 2551 public Base setProperty(String name, Base value) throws FHIRException { 2552 if (name.equals("type")) { 2553 value = new QualityTypeEnumFactory().fromType(castToCode(value)); 2554 this.type = (Enumeration) value; // Enumeration<QualityType> 2555 } else if (name.equals("standardSequence")) { 2556 this.standardSequence = castToCodeableConcept(value); // CodeableConcept 2557 } else if (name.equals("start")) { 2558 this.start = castToInteger(value); // IntegerType 2559 } else if (name.equals("end")) { 2560 this.end = castToInteger(value); // IntegerType 2561 } else if (name.equals("score")) { 2562 this.score = castToQuantity(value); // Quantity 2563 } else if (name.equals("method")) { 2564 this.method = castToCodeableConcept(value); // CodeableConcept 2565 } else if (name.equals("truthTP")) { 2566 this.truthTP = castToDecimal(value); // DecimalType 2567 } else if (name.equals("queryTP")) { 2568 this.queryTP = castToDecimal(value); // DecimalType 2569 } else if (name.equals("truthFN")) { 2570 this.truthFN = castToDecimal(value); // DecimalType 2571 } else if (name.equals("queryFP")) { 2572 this.queryFP = castToDecimal(value); // DecimalType 2573 } else if (name.equals("gtFP")) { 2574 this.gtFP = castToDecimal(value); // DecimalType 2575 } else if (name.equals("precision")) { 2576 this.precision = castToDecimal(value); // DecimalType 2577 } else if (name.equals("recall")) { 2578 this.recall = castToDecimal(value); // DecimalType 2579 } else if (name.equals("fScore")) { 2580 this.fScore = castToDecimal(value); // DecimalType 2581 } else 2582 return super.setProperty(name, value); 2583 return value; 2584 } 2585 2586 @Override 2587 public Base makeProperty(int hash, String name) throws FHIRException { 2588 switch (hash) { 2589 case 3575610: return getTypeElement(); 2590 case -1861227106: return getStandardSequence(); 2591 case 109757538: return getStartElement(); 2592 case 100571: return getEndElement(); 2593 case 109264530: return getScore(); 2594 case -1077554975: return getMethod(); 2595 case -1048421849: return getTruthTPElement(); 2596 case 655102276: return getQueryTPElement(); 2597 case -1048422285: return getTruthFNElement(); 2598 case 655101842: return getQueryFPElement(); 2599 case 3182199: return getGtFPElement(); 2600 case -1376177026: return getPrecisionElement(); 2601 case -934922479: return getRecallElement(); 2602 case -1295082036: return getFScoreElement(); 2603 default: return super.makeProperty(hash, name); 2604 } 2605 2606 } 2607 2608 @Override 2609 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2610 switch (hash) { 2611 case 3575610: /*type*/ return new String[] {"code"}; 2612 case -1861227106: /*standardSequence*/ return new String[] {"CodeableConcept"}; 2613 case 109757538: /*start*/ return new String[] {"integer"}; 2614 case 100571: /*end*/ return new String[] {"integer"}; 2615 case 109264530: /*score*/ return new String[] {"Quantity"}; 2616 case -1077554975: /*method*/ return new String[] {"CodeableConcept"}; 2617 case -1048421849: /*truthTP*/ return new String[] {"decimal"}; 2618 case 655102276: /*queryTP*/ return new String[] {"decimal"}; 2619 case -1048422285: /*truthFN*/ return new String[] {"decimal"}; 2620 case 655101842: /*queryFP*/ return new String[] {"decimal"}; 2621 case 3182199: /*gtFP*/ return new String[] {"decimal"}; 2622 case -1376177026: /*precision*/ return new String[] {"decimal"}; 2623 case -934922479: /*recall*/ return new String[] {"decimal"}; 2624 case -1295082036: /*fScore*/ return new String[] {"decimal"}; 2625 default: return super.getTypesForProperty(hash, name); 2626 } 2627 2628 } 2629 2630 @Override 2631 public Base addChild(String name) throws FHIRException { 2632 if (name.equals("type")) { 2633 throw new FHIRException("Cannot call addChild on a primitive type Sequence.type"); 2634 } 2635 else if (name.equals("standardSequence")) { 2636 this.standardSequence = new CodeableConcept(); 2637 return this.standardSequence; 2638 } 2639 else if (name.equals("start")) { 2640 throw new FHIRException("Cannot call addChild on a primitive type Sequence.start"); 2641 } 2642 else if (name.equals("end")) { 2643 throw new FHIRException("Cannot call addChild on a primitive type Sequence.end"); 2644 } 2645 else if (name.equals("score")) { 2646 this.score = new Quantity(); 2647 return this.score; 2648 } 2649 else if (name.equals("method")) { 2650 this.method = new CodeableConcept(); 2651 return this.method; 2652 } 2653 else if (name.equals("truthTP")) { 2654 throw new FHIRException("Cannot call addChild on a primitive type Sequence.truthTP"); 2655 } 2656 else if (name.equals("queryTP")) { 2657 throw new FHIRException("Cannot call addChild on a primitive type Sequence.queryTP"); 2658 } 2659 else if (name.equals("truthFN")) { 2660 throw new FHIRException("Cannot call addChild on a primitive type Sequence.truthFN"); 2661 } 2662 else if (name.equals("queryFP")) { 2663 throw new FHIRException("Cannot call addChild on a primitive type Sequence.queryFP"); 2664 } 2665 else if (name.equals("gtFP")) { 2666 throw new FHIRException("Cannot call addChild on a primitive type Sequence.gtFP"); 2667 } 2668 else if (name.equals("precision")) { 2669 throw new FHIRException("Cannot call addChild on a primitive type Sequence.precision"); 2670 } 2671 else if (name.equals("recall")) { 2672 throw new FHIRException("Cannot call addChild on a primitive type Sequence.recall"); 2673 } 2674 else if (name.equals("fScore")) { 2675 throw new FHIRException("Cannot call addChild on a primitive type Sequence.fScore"); 2676 } 2677 else 2678 return super.addChild(name); 2679 } 2680 2681 public SequenceQualityComponent copy() { 2682 SequenceQualityComponent dst = new SequenceQualityComponent(); 2683 copyValues(dst); 2684 dst.type = type == null ? null : type.copy(); 2685 dst.standardSequence = standardSequence == null ? null : standardSequence.copy(); 2686 dst.start = start == null ? null : start.copy(); 2687 dst.end = end == null ? null : end.copy(); 2688 dst.score = score == null ? null : score.copy(); 2689 dst.method = method == null ? null : method.copy(); 2690 dst.truthTP = truthTP == null ? null : truthTP.copy(); 2691 dst.queryTP = queryTP == null ? null : queryTP.copy(); 2692 dst.truthFN = truthFN == null ? null : truthFN.copy(); 2693 dst.queryFP = queryFP == null ? null : queryFP.copy(); 2694 dst.gtFP = gtFP == null ? null : gtFP.copy(); 2695 dst.precision = precision == null ? null : precision.copy(); 2696 dst.recall = recall == null ? null : recall.copy(); 2697 dst.fScore = fScore == null ? null : fScore.copy(); 2698 return dst; 2699 } 2700 2701 @Override 2702 public boolean equalsDeep(Base other_) { 2703 if (!super.equalsDeep(other_)) 2704 return false; 2705 if (!(other_ instanceof SequenceQualityComponent)) 2706 return false; 2707 SequenceQualityComponent o = (SequenceQualityComponent) other_; 2708 return compareDeep(type, o.type, true) && compareDeep(standardSequence, o.standardSequence, true) 2709 && compareDeep(start, o.start, true) && compareDeep(end, o.end, true) && compareDeep(score, o.score, true) 2710 && compareDeep(method, o.method, true) && compareDeep(truthTP, o.truthTP, true) && compareDeep(queryTP, o.queryTP, true) 2711 && compareDeep(truthFN, o.truthFN, true) && compareDeep(queryFP, o.queryFP, true) && compareDeep(gtFP, o.gtFP, true) 2712 && compareDeep(precision, o.precision, true) && compareDeep(recall, o.recall, true) && compareDeep(fScore, o.fScore, true) 2713 ; 2714 } 2715 2716 @Override 2717 public boolean equalsShallow(Base other_) { 2718 if (!super.equalsShallow(other_)) 2719 return false; 2720 if (!(other_ instanceof SequenceQualityComponent)) 2721 return false; 2722 SequenceQualityComponent o = (SequenceQualityComponent) other_; 2723 return compareValues(type, o.type, true) && compareValues(start, o.start, true) && compareValues(end, o.end, true) 2724 && compareValues(truthTP, o.truthTP, true) && compareValues(queryTP, o.queryTP, true) && compareValues(truthFN, o.truthFN, true) 2725 && compareValues(queryFP, o.queryFP, true) && compareValues(gtFP, o.gtFP, true) && compareValues(precision, o.precision, true) 2726 && compareValues(recall, o.recall, true) && compareValues(fScore, o.fScore, true); 2727 } 2728 2729 public boolean isEmpty() { 2730 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, standardSequence, start 2731 , end, score, method, truthTP, queryTP, truthFN, queryFP, gtFP, precision 2732 , recall, fScore); 2733 } 2734 2735 public String fhirType() { 2736 return "Sequence.quality"; 2737 2738 } 2739 2740 } 2741 2742 @Block() 2743 public static class SequenceRepositoryComponent extends BackboneElement implements IBaseBackboneElement { 2744 /** 2745 * Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource. 2746 */ 2747 @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 2748 @Description(shortDefinition="directlink | openapi | login | oauth | other", formalDefinition="Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource." ) 2749 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/repository-type") 2750 protected Enumeration<RepositoryType> type; 2751 2752 /** 2753 * URI of an external repository which contains further details about the genetics data. 2754 */ 2755 @Child(name = "url", type = {UriType.class}, order=2, min=0, max=1, modifier=false, summary=true) 2756 @Description(shortDefinition="URI of the repository", formalDefinition="URI of an external repository which contains further details about the genetics data." ) 2757 protected UriType url; 2758 2759 /** 2760 * URI of an external repository which contains further details about the genetics data. 2761 */ 2762 @Child(name = "name", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true) 2763 @Description(shortDefinition="Repository's name", formalDefinition="URI of an external repository which contains further details about the genetics data." ) 2764 protected StringType name; 2765 2766 /** 2767 * Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository. 2768 */ 2769 @Child(name = "datasetId", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true) 2770 @Description(shortDefinition="Id of the dataset that used to call for dataset in repository", formalDefinition="Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository." ) 2771 protected StringType datasetId; 2772 2773 /** 2774 * Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository. 2775 */ 2776 @Child(name = "variantsetId", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true) 2777 @Description(shortDefinition="Id of the variantset that used to call for variantset in repository", formalDefinition="Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository." ) 2778 protected StringType variantsetId; 2779 2780 /** 2781 * Id of the read in this external repository. 2782 */ 2783 @Child(name = "readsetId", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=true) 2784 @Description(shortDefinition="Id of the read", formalDefinition="Id of the read in this external repository." ) 2785 protected StringType readsetId; 2786 2787 private static final long serialVersionUID = -899243265L; 2788 2789 /** 2790 * Constructor 2791 */ 2792 public SequenceRepositoryComponent() { 2793 super(); 2794 } 2795 2796 /** 2797 * Constructor 2798 */ 2799 public SequenceRepositoryComponent(Enumeration<RepositoryType> type) { 2800 super(); 2801 this.type = type; 2802 } 2803 2804 /** 2805 * @return {@link #type} (Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 2806 */ 2807 public Enumeration<RepositoryType> getTypeElement() { 2808 if (this.type == null) 2809 if (Configuration.errorOnAutoCreate()) 2810 throw new Error("Attempt to auto-create SequenceRepositoryComponent.type"); 2811 else if (Configuration.doAutoCreate()) 2812 this.type = new Enumeration<RepositoryType>(new RepositoryTypeEnumFactory()); // bb 2813 return this.type; 2814 } 2815 2816 public boolean hasTypeElement() { 2817 return this.type != null && !this.type.isEmpty(); 2818 } 2819 2820 public boolean hasType() { 2821 return this.type != null && !this.type.isEmpty(); 2822 } 2823 2824 /** 2825 * @param value {@link #type} (Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 2826 */ 2827 public SequenceRepositoryComponent setTypeElement(Enumeration<RepositoryType> value) { 2828 this.type = value; 2829 return this; 2830 } 2831 2832 /** 2833 * @return Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource. 2834 */ 2835 public RepositoryType getType() { 2836 return this.type == null ? null : this.type.getValue(); 2837 } 2838 2839 /** 2840 * @param value Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource. 2841 */ 2842 public SequenceRepositoryComponent setType(RepositoryType value) { 2843 if (this.type == null) 2844 this.type = new Enumeration<RepositoryType>(new RepositoryTypeEnumFactory()); 2845 this.type.setValue(value); 2846 return this; 2847 } 2848 2849 /** 2850 * @return {@link #url} (URI of an external repository which contains further details about the genetics data.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 2851 */ 2852 public UriType getUrlElement() { 2853 if (this.url == null) 2854 if (Configuration.errorOnAutoCreate()) 2855 throw new Error("Attempt to auto-create SequenceRepositoryComponent.url"); 2856 else if (Configuration.doAutoCreate()) 2857 this.url = new UriType(); // bb 2858 return this.url; 2859 } 2860 2861 public boolean hasUrlElement() { 2862 return this.url != null && !this.url.isEmpty(); 2863 } 2864 2865 public boolean hasUrl() { 2866 return this.url != null && !this.url.isEmpty(); 2867 } 2868 2869 /** 2870 * @param value {@link #url} (URI of an external repository which contains further details about the genetics data.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 2871 */ 2872 public SequenceRepositoryComponent setUrlElement(UriType value) { 2873 this.url = value; 2874 return this; 2875 } 2876 2877 /** 2878 * @return URI of an external repository which contains further details about the genetics data. 2879 */ 2880 public String getUrl() { 2881 return this.url == null ? null : this.url.getValue(); 2882 } 2883 2884 /** 2885 * @param value URI of an external repository which contains further details about the genetics data. 2886 */ 2887 public SequenceRepositoryComponent setUrl(String value) { 2888 if (Utilities.noString(value)) 2889 this.url = null; 2890 else { 2891 if (this.url == null) 2892 this.url = new UriType(); 2893 this.url.setValue(value); 2894 } 2895 return this; 2896 } 2897 2898 /** 2899 * @return {@link #name} (URI of an external repository which contains further details about the genetics data.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 2900 */ 2901 public StringType getNameElement() { 2902 if (this.name == null) 2903 if (Configuration.errorOnAutoCreate()) 2904 throw new Error("Attempt to auto-create SequenceRepositoryComponent.name"); 2905 else if (Configuration.doAutoCreate()) 2906 this.name = new StringType(); // bb 2907 return this.name; 2908 } 2909 2910 public boolean hasNameElement() { 2911 return this.name != null && !this.name.isEmpty(); 2912 } 2913 2914 public boolean hasName() { 2915 return this.name != null && !this.name.isEmpty(); 2916 } 2917 2918 /** 2919 * @param value {@link #name} (URI of an external repository which contains further details about the genetics data.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 2920 */ 2921 public SequenceRepositoryComponent setNameElement(StringType value) { 2922 this.name = value; 2923 return this; 2924 } 2925 2926 /** 2927 * @return URI of an external repository which contains further details about the genetics data. 2928 */ 2929 public String getName() { 2930 return this.name == null ? null : this.name.getValue(); 2931 } 2932 2933 /** 2934 * @param value URI of an external repository which contains further details about the genetics data. 2935 */ 2936 public SequenceRepositoryComponent setName(String value) { 2937 if (Utilities.noString(value)) 2938 this.name = null; 2939 else { 2940 if (this.name == null) 2941 this.name = new StringType(); 2942 this.name.setValue(value); 2943 } 2944 return this; 2945 } 2946 2947 /** 2948 * @return {@link #datasetId} (Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.). This is the underlying object with id, value and extensions. The accessor "getDatasetId" gives direct access to the value 2949 */ 2950 public StringType getDatasetIdElement() { 2951 if (this.datasetId == null) 2952 if (Configuration.errorOnAutoCreate()) 2953 throw new Error("Attempt to auto-create SequenceRepositoryComponent.datasetId"); 2954 else if (Configuration.doAutoCreate()) 2955 this.datasetId = new StringType(); // bb 2956 return this.datasetId; 2957 } 2958 2959 public boolean hasDatasetIdElement() { 2960 return this.datasetId != null && !this.datasetId.isEmpty(); 2961 } 2962 2963 public boolean hasDatasetId() { 2964 return this.datasetId != null && !this.datasetId.isEmpty(); 2965 } 2966 2967 /** 2968 * @param value {@link #datasetId} (Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.). This is the underlying object with id, value and extensions. The accessor "getDatasetId" gives direct access to the value 2969 */ 2970 public SequenceRepositoryComponent setDatasetIdElement(StringType value) { 2971 this.datasetId = value; 2972 return this; 2973 } 2974 2975 /** 2976 * @return Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository. 2977 */ 2978 public String getDatasetId() { 2979 return this.datasetId == null ? null : this.datasetId.getValue(); 2980 } 2981 2982 /** 2983 * @param value Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository. 2984 */ 2985 public SequenceRepositoryComponent setDatasetId(String value) { 2986 if (Utilities.noString(value)) 2987 this.datasetId = null; 2988 else { 2989 if (this.datasetId == null) 2990 this.datasetId = new StringType(); 2991 this.datasetId.setValue(value); 2992 } 2993 return this; 2994 } 2995 2996 /** 2997 * @return {@link #variantsetId} (Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.). This is the underlying object with id, value and extensions. The accessor "getVariantsetId" gives direct access to the value 2998 */ 2999 public StringType getVariantsetIdElement() { 3000 if (this.variantsetId == null) 3001 if (Configuration.errorOnAutoCreate()) 3002 throw new Error("Attempt to auto-create SequenceRepositoryComponent.variantsetId"); 3003 else if (Configuration.doAutoCreate()) 3004 this.variantsetId = new StringType(); // bb 3005 return this.variantsetId; 3006 } 3007 3008 public boolean hasVariantsetIdElement() { 3009 return this.variantsetId != null && !this.variantsetId.isEmpty(); 3010 } 3011 3012 public boolean hasVariantsetId() { 3013 return this.variantsetId != null && !this.variantsetId.isEmpty(); 3014 } 3015 3016 /** 3017 * @param value {@link #variantsetId} (Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.). This is the underlying object with id, value and extensions. The accessor "getVariantsetId" gives direct access to the value 3018 */ 3019 public SequenceRepositoryComponent setVariantsetIdElement(StringType value) { 3020 this.variantsetId = value; 3021 return this; 3022 } 3023 3024 /** 3025 * @return Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository. 3026 */ 3027 public String getVariantsetId() { 3028 return this.variantsetId == null ? null : this.variantsetId.getValue(); 3029 } 3030 3031 /** 3032 * @param value Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository. 3033 */ 3034 public SequenceRepositoryComponent setVariantsetId(String value) { 3035 if (Utilities.noString(value)) 3036 this.variantsetId = null; 3037 else { 3038 if (this.variantsetId == null) 3039 this.variantsetId = new StringType(); 3040 this.variantsetId.setValue(value); 3041 } 3042 return this; 3043 } 3044 3045 /** 3046 * @return {@link #readsetId} (Id of the read in this external repository.). This is the underlying object with id, value and extensions. The accessor "getReadsetId" gives direct access to the value 3047 */ 3048 public StringType getReadsetIdElement() { 3049 if (this.readsetId == null) 3050 if (Configuration.errorOnAutoCreate()) 3051 throw new Error("Attempt to auto-create SequenceRepositoryComponent.readsetId"); 3052 else if (Configuration.doAutoCreate()) 3053 this.readsetId = new StringType(); // bb 3054 return this.readsetId; 3055 } 3056 3057 public boolean hasReadsetIdElement() { 3058 return this.readsetId != null && !this.readsetId.isEmpty(); 3059 } 3060 3061 public boolean hasReadsetId() { 3062 return this.readsetId != null && !this.readsetId.isEmpty(); 3063 } 3064 3065 /** 3066 * @param value {@link #readsetId} (Id of the read in this external repository.). This is the underlying object with id, value and extensions. The accessor "getReadsetId" gives direct access to the value 3067 */ 3068 public SequenceRepositoryComponent setReadsetIdElement(StringType value) { 3069 this.readsetId = value; 3070 return this; 3071 } 3072 3073 /** 3074 * @return Id of the read in this external repository. 3075 */ 3076 public String getReadsetId() { 3077 return this.readsetId == null ? null : this.readsetId.getValue(); 3078 } 3079 3080 /** 3081 * @param value Id of the read in this external repository. 3082 */ 3083 public SequenceRepositoryComponent setReadsetId(String value) { 3084 if (Utilities.noString(value)) 3085 this.readsetId = null; 3086 else { 3087 if (this.readsetId == null) 3088 this.readsetId = new StringType(); 3089 this.readsetId.setValue(value); 3090 } 3091 return this; 3092 } 3093 3094 protected void listChildren(List<Property> children) { 3095 super.listChildren(children); 3096 children.add(new Property("type", "code", "Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.", 0, 1, type)); 3097 children.add(new Property("url", "uri", "URI of an external repository which contains further details about the genetics data.", 0, 1, url)); 3098 children.add(new Property("name", "string", "URI of an external repository which contains further details about the genetics data.", 0, 1, name)); 3099 children.add(new Property("datasetId", "string", "Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.", 0, 1, datasetId)); 3100 children.add(new Property("variantsetId", "string", "Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.", 0, 1, variantsetId)); 3101 children.add(new Property("readsetId", "string", "Id of the read in this external repository.", 0, 1, readsetId)); 3102 } 3103 3104 @Override 3105 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3106 switch (_hash) { 3107 case 3575610: /*type*/ return new Property("type", "code", "Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.", 0, 1, type); 3108 case 116079: /*url*/ return new Property("url", "uri", "URI of an external repository which contains further details about the genetics data.", 0, 1, url); 3109 case 3373707: /*name*/ return new Property("name", "string", "URI of an external repository which contains further details about the genetics data.", 0, 1, name); 3110 case -345342029: /*datasetId*/ return new Property("datasetId", "string", "Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.", 0, 1, datasetId); 3111 case 1929752504: /*variantsetId*/ return new Property("variantsetId", "string", "Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.", 0, 1, variantsetId); 3112 case -1095407289: /*readsetId*/ return new Property("readsetId", "string", "Id of the read in this external repository.", 0, 1, readsetId); 3113 default: return super.getNamedProperty(_hash, _name, _checkValid); 3114 } 3115 3116 } 3117 3118 @Override 3119 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3120 switch (hash) { 3121 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<RepositoryType> 3122 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType 3123 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 3124 case -345342029: /*datasetId*/ return this.datasetId == null ? new Base[0] : new Base[] {this.datasetId}; // StringType 3125 case 1929752504: /*variantsetId*/ return this.variantsetId == null ? new Base[0] : new Base[] {this.variantsetId}; // StringType 3126 case -1095407289: /*readsetId*/ return this.readsetId == null ? new Base[0] : new Base[] {this.readsetId}; // StringType 3127 default: return super.getProperty(hash, name, checkValid); 3128 } 3129 3130 } 3131 3132 @Override 3133 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3134 switch (hash) { 3135 case 3575610: // type 3136 value = new RepositoryTypeEnumFactory().fromType(castToCode(value)); 3137 this.type = (Enumeration) value; // Enumeration<RepositoryType> 3138 return value; 3139 case 116079: // url 3140 this.url = castToUri(value); // UriType 3141 return value; 3142 case 3373707: // name 3143 this.name = castToString(value); // StringType 3144 return value; 3145 case -345342029: // datasetId 3146 this.datasetId = castToString(value); // StringType 3147 return value; 3148 case 1929752504: // variantsetId 3149 this.variantsetId = castToString(value); // StringType 3150 return value; 3151 case -1095407289: // readsetId 3152 this.readsetId = castToString(value); // StringType 3153 return value; 3154 default: return super.setProperty(hash, name, value); 3155 } 3156 3157 } 3158 3159 @Override 3160 public Base setProperty(String name, Base value) throws FHIRException { 3161 if (name.equals("type")) { 3162 value = new RepositoryTypeEnumFactory().fromType(castToCode(value)); 3163 this.type = (Enumeration) value; // Enumeration<RepositoryType> 3164 } else if (name.equals("url")) { 3165 this.url = castToUri(value); // UriType 3166 } else if (name.equals("name")) { 3167 this.name = castToString(value); // StringType 3168 } else if (name.equals("datasetId")) { 3169 this.datasetId = castToString(value); // StringType 3170 } else if (name.equals("variantsetId")) { 3171 this.variantsetId = castToString(value); // StringType 3172 } else if (name.equals("readsetId")) { 3173 this.readsetId = castToString(value); // StringType 3174 } else 3175 return super.setProperty(name, value); 3176 return value; 3177 } 3178 3179 @Override 3180 public Base makeProperty(int hash, String name) throws FHIRException { 3181 switch (hash) { 3182 case 3575610: return getTypeElement(); 3183 case 116079: return getUrlElement(); 3184 case 3373707: return getNameElement(); 3185 case -345342029: return getDatasetIdElement(); 3186 case 1929752504: return getVariantsetIdElement(); 3187 case -1095407289: return getReadsetIdElement(); 3188 default: return super.makeProperty(hash, name); 3189 } 3190 3191 } 3192 3193 @Override 3194 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3195 switch (hash) { 3196 case 3575610: /*type*/ return new String[] {"code"}; 3197 case 116079: /*url*/ return new String[] {"uri"}; 3198 case 3373707: /*name*/ return new String[] {"string"}; 3199 case -345342029: /*datasetId*/ return new String[] {"string"}; 3200 case 1929752504: /*variantsetId*/ return new String[] {"string"}; 3201 case -1095407289: /*readsetId*/ return new String[] {"string"}; 3202 default: return super.getTypesForProperty(hash, name); 3203 } 3204 3205 } 3206 3207 @Override 3208 public Base addChild(String name) throws FHIRException { 3209 if (name.equals("type")) { 3210 throw new FHIRException("Cannot call addChild on a primitive type Sequence.type"); 3211 } 3212 else if (name.equals("url")) { 3213 throw new FHIRException("Cannot call addChild on a primitive type Sequence.url"); 3214 } 3215 else if (name.equals("name")) { 3216 throw new FHIRException("Cannot call addChild on a primitive type Sequence.name"); 3217 } 3218 else if (name.equals("datasetId")) { 3219 throw new FHIRException("Cannot call addChild on a primitive type Sequence.datasetId"); 3220 } 3221 else if (name.equals("variantsetId")) { 3222 throw new FHIRException("Cannot call addChild on a primitive type Sequence.variantsetId"); 3223 } 3224 else if (name.equals("readsetId")) { 3225 throw new FHIRException("Cannot call addChild on a primitive type Sequence.readsetId"); 3226 } 3227 else 3228 return super.addChild(name); 3229 } 3230 3231 public SequenceRepositoryComponent copy() { 3232 SequenceRepositoryComponent dst = new SequenceRepositoryComponent(); 3233 copyValues(dst); 3234 dst.type = type == null ? null : type.copy(); 3235 dst.url = url == null ? null : url.copy(); 3236 dst.name = name == null ? null : name.copy(); 3237 dst.datasetId = datasetId == null ? null : datasetId.copy(); 3238 dst.variantsetId = variantsetId == null ? null : variantsetId.copy(); 3239 dst.readsetId = readsetId == null ? null : readsetId.copy(); 3240 return dst; 3241 } 3242 3243 @Override 3244 public boolean equalsDeep(Base other_) { 3245 if (!super.equalsDeep(other_)) 3246 return false; 3247 if (!(other_ instanceof SequenceRepositoryComponent)) 3248 return false; 3249 SequenceRepositoryComponent o = (SequenceRepositoryComponent) other_; 3250 return compareDeep(type, o.type, true) && compareDeep(url, o.url, true) && compareDeep(name, o.name, true) 3251 && compareDeep(datasetId, o.datasetId, true) && compareDeep(variantsetId, o.variantsetId, true) 3252 && compareDeep(readsetId, o.readsetId, true); 3253 } 3254 3255 @Override 3256 public boolean equalsShallow(Base other_) { 3257 if (!super.equalsShallow(other_)) 3258 return false; 3259 if (!(other_ instanceof SequenceRepositoryComponent)) 3260 return false; 3261 SequenceRepositoryComponent o = (SequenceRepositoryComponent) other_; 3262 return compareValues(type, o.type, true) && compareValues(url, o.url, true) && compareValues(name, o.name, true) 3263 && compareValues(datasetId, o.datasetId, true) && compareValues(variantsetId, o.variantsetId, true) 3264 && compareValues(readsetId, o.readsetId, true); 3265 } 3266 3267 public boolean isEmpty() { 3268 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, url, name, datasetId 3269 , variantsetId, readsetId); 3270 } 3271 3272 public String fhirType() { 3273 return "Sequence.repository"; 3274 3275 } 3276 3277 } 3278 3279 /** 3280 * A unique identifier for this particular sequence instance. This is a FHIR-defined id. 3281 */ 3282 @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 3283 @Description(shortDefinition="Unique ID for this particular sequence. This is a FHIR-defined id", formalDefinition="A unique identifier for this particular sequence instance. This is a FHIR-defined id." ) 3284 protected List<Identifier> identifier; 3285 3286 /** 3287 * Amino Acid Sequence/ DNA Sequence / RNA Sequence. 3288 */ 3289 @Child(name = "type", type = {CodeType.class}, order=1, min=0, max=1, modifier=false, summary=true) 3290 @Description(shortDefinition="aa | dna | rna", formalDefinition="Amino Acid Sequence/ DNA Sequence / RNA Sequence." ) 3291 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/sequence-type") 3292 protected Enumeration<SequenceType> type; 3293 3294 /** 3295 * Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end). 3296 */ 3297 @Child(name = "coordinateSystem", type = {IntegerType.class}, order=2, min=1, max=1, modifier=false, summary=true) 3298 @Description(shortDefinition="Base number of coordinate system (0 for 0-based numbering or coordinates, inclusive start, exclusive end, 1 for 1-based numbering, inclusive start, inclusive end)", formalDefinition="Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end)." ) 3299 protected IntegerType coordinateSystem; 3300 3301 /** 3302 * The patient whose sequencing results are described by this resource. 3303 */ 3304 @Child(name = "patient", type = {Patient.class}, order=3, min=0, max=1, modifier=false, summary=true) 3305 @Description(shortDefinition="Who and/or what this is about", formalDefinition="The patient whose sequencing results are described by this resource." ) 3306 protected Reference patient; 3307 3308 /** 3309 * The actual object that is the target of the reference (The patient whose sequencing results are described by this resource.) 3310 */ 3311 protected Patient patientTarget; 3312 3313 /** 3314 * Specimen used for sequencing. 3315 */ 3316 @Child(name = "specimen", type = {Specimen.class}, order=4, min=0, max=1, modifier=false, summary=true) 3317 @Description(shortDefinition="Specimen used for sequencing", formalDefinition="Specimen used for sequencing." ) 3318 protected Reference specimen; 3319 3320 /** 3321 * The actual object that is the target of the reference (Specimen used for sequencing.) 3322 */ 3323 protected Specimen specimenTarget; 3324 3325 /** 3326 * The method for sequencing, for example, chip information. 3327 */ 3328 @Child(name = "device", type = {Device.class}, order=5, min=0, max=1, modifier=false, summary=true) 3329 @Description(shortDefinition="The method for sequencing", formalDefinition="The method for sequencing, for example, chip information." ) 3330 protected Reference device; 3331 3332 /** 3333 * The actual object that is the target of the reference (The method for sequencing, for example, chip information.) 3334 */ 3335 protected Device deviceTarget; 3336 3337 /** 3338 * The organization or lab that should be responsible for this result. 3339 */ 3340 @Child(name = "performer", type = {Organization.class}, order=6, min=0, max=1, modifier=false, summary=true) 3341 @Description(shortDefinition="Who should be responsible for test result", formalDefinition="The organization or lab that should be responsible for this result." ) 3342 protected Reference performer; 3343 3344 /** 3345 * The actual object that is the target of the reference (The organization or lab that should be responsible for this result.) 3346 */ 3347 protected Organization performerTarget; 3348 3349 /** 3350 * The number of copies of the seqeunce of interest. (RNASeq). 3351 */ 3352 @Child(name = "quantity", type = {Quantity.class}, order=7, min=0, max=1, modifier=false, summary=true) 3353 @Description(shortDefinition="The number of copies of the seqeunce of interest. (RNASeq)", formalDefinition="The number of copies of the seqeunce of interest. (RNASeq)." ) 3354 protected Quantity quantity; 3355 3356 /** 3357 * A sequence that is used as a reference to describe variants that are present in a sequence analyzed. 3358 */ 3359 @Child(name = "referenceSeq", type = {}, order=8, min=0, max=1, modifier=false, summary=true) 3360 @Description(shortDefinition="A sequence used as reference", formalDefinition="A sequence that is used as a reference to describe variants that are present in a sequence analyzed." ) 3361 protected SequenceReferenceSeqComponent referenceSeq; 3362 3363 /** 3364 * The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.) It can represent some complex mutation or segment variation with the assist of CIGAR string. 3365 */ 3366 @Child(name = "variant", type = {}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 3367 @Description(shortDefinition="Variant in sequence", formalDefinition="The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.) It can represent some complex mutation or segment variation with the assist of CIGAR string." ) 3368 protected List<SequenceVariantComponent> variant; 3369 3370 /** 3371 * Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd. 3372 */ 3373 @Child(name = "observedSeq", type = {StringType.class}, order=10, min=0, max=1, modifier=false, summary=true) 3374 @Description(shortDefinition="Sequence that was observed", formalDefinition="Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd." ) 3375 protected StringType observedSeq; 3376 3377 /** 3378 * An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)). 3379 */ 3380 @Child(name = "quality", type = {}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 3381 @Description(shortDefinition="An set of value as quality of sequence", formalDefinition="An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686))." ) 3382 protected List<SequenceQualityComponent> quality; 3383 3384 /** 3385 * Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence. 3386 */ 3387 @Child(name = "readCoverage", type = {IntegerType.class}, order=12, min=0, max=1, modifier=false, summary=true) 3388 @Description(shortDefinition="Average number of reads representing a given nucleotide in the reconstructed sequence", formalDefinition="Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence." ) 3389 protected IntegerType readCoverage; 3390 3391 /** 3392 * Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq. 3393 */ 3394 @Child(name = "repository", type = {}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 3395 @Description(shortDefinition="External repository which contains detailed report related with observedSeq in this resource", formalDefinition="Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq." ) 3396 protected List<SequenceRepositoryComponent> repository; 3397 3398 /** 3399 * Pointer to next atomic sequence which at most contains one variant. 3400 */ 3401 @Child(name = "pointer", type = {Sequence.class}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 3402 @Description(shortDefinition="Pointer to next atomic sequence", formalDefinition="Pointer to next atomic sequence which at most contains one variant." ) 3403 protected List<Reference> pointer; 3404 /** 3405 * The actual objects that are the target of the reference (Pointer to next atomic sequence which at most contains one variant.) 3406 */ 3407 protected List<Sequence> pointerTarget; 3408 3409 3410 private static final long serialVersionUID = -2101352712L; 3411 3412 /** 3413 * Constructor 3414 */ 3415 public Sequence() { 3416 super(); 3417 } 3418 3419 /** 3420 * Constructor 3421 */ 3422 public Sequence(IntegerType coordinateSystem) { 3423 super(); 3424 this.coordinateSystem = coordinateSystem; 3425 } 3426 3427 /** 3428 * @return {@link #identifier} (A unique identifier for this particular sequence instance. This is a FHIR-defined id.) 3429 */ 3430 public List<Identifier> getIdentifier() { 3431 if (this.identifier == null) 3432 this.identifier = new ArrayList<Identifier>(); 3433 return this.identifier; 3434 } 3435 3436 /** 3437 * @return Returns a reference to <code>this</code> for easy method chaining 3438 */ 3439 public Sequence setIdentifier(List<Identifier> theIdentifier) { 3440 this.identifier = theIdentifier; 3441 return this; 3442 } 3443 3444 public boolean hasIdentifier() { 3445 if (this.identifier == null) 3446 return false; 3447 for (Identifier item : this.identifier) 3448 if (!item.isEmpty()) 3449 return true; 3450 return false; 3451 } 3452 3453 public Identifier addIdentifier() { //3 3454 Identifier t = new Identifier(); 3455 if (this.identifier == null) 3456 this.identifier = new ArrayList<Identifier>(); 3457 this.identifier.add(t); 3458 return t; 3459 } 3460 3461 public Sequence addIdentifier(Identifier t) { //3 3462 if (t == null) 3463 return this; 3464 if (this.identifier == null) 3465 this.identifier = new ArrayList<Identifier>(); 3466 this.identifier.add(t); 3467 return this; 3468 } 3469 3470 /** 3471 * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist 3472 */ 3473 public Identifier getIdentifierFirstRep() { 3474 if (getIdentifier().isEmpty()) { 3475 addIdentifier(); 3476 } 3477 return getIdentifier().get(0); 3478 } 3479 3480 /** 3481 * @return {@link #type} (Amino Acid Sequence/ DNA Sequence / RNA Sequence.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 3482 */ 3483 public Enumeration<SequenceType> getTypeElement() { 3484 if (this.type == null) 3485 if (Configuration.errorOnAutoCreate()) 3486 throw new Error("Attempt to auto-create Sequence.type"); 3487 else if (Configuration.doAutoCreate()) 3488 this.type = new Enumeration<SequenceType>(new SequenceTypeEnumFactory()); // bb 3489 return this.type; 3490 } 3491 3492 public boolean hasTypeElement() { 3493 return this.type != null && !this.type.isEmpty(); 3494 } 3495 3496 public boolean hasType() { 3497 return this.type != null && !this.type.isEmpty(); 3498 } 3499 3500 /** 3501 * @param value {@link #type} (Amino Acid Sequence/ DNA Sequence / RNA Sequence.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 3502 */ 3503 public Sequence setTypeElement(Enumeration<SequenceType> value) { 3504 this.type = value; 3505 return this; 3506 } 3507 3508 /** 3509 * @return Amino Acid Sequence/ DNA Sequence / RNA Sequence. 3510 */ 3511 public SequenceType getType() { 3512 return this.type == null ? null : this.type.getValue(); 3513 } 3514 3515 /** 3516 * @param value Amino Acid Sequence/ DNA Sequence / RNA Sequence. 3517 */ 3518 public Sequence setType(SequenceType value) { 3519 if (value == null) 3520 this.type = null; 3521 else { 3522 if (this.type == null) 3523 this.type = new Enumeration<SequenceType>(new SequenceTypeEnumFactory()); 3524 this.type.setValue(value); 3525 } 3526 return this; 3527 } 3528 3529 /** 3530 * @return {@link #coordinateSystem} (Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).). This is the underlying object with id, value and extensions. The accessor "getCoordinateSystem" gives direct access to the value 3531 */ 3532 public IntegerType getCoordinateSystemElement() { 3533 if (this.coordinateSystem == null) 3534 if (Configuration.errorOnAutoCreate()) 3535 throw new Error("Attempt to auto-create Sequence.coordinateSystem"); 3536 else if (Configuration.doAutoCreate()) 3537 this.coordinateSystem = new IntegerType(); // bb 3538 return this.coordinateSystem; 3539 } 3540 3541 public boolean hasCoordinateSystemElement() { 3542 return this.coordinateSystem != null && !this.coordinateSystem.isEmpty(); 3543 } 3544 3545 public boolean hasCoordinateSystem() { 3546 return this.coordinateSystem != null && !this.coordinateSystem.isEmpty(); 3547 } 3548 3549 /** 3550 * @param value {@link #coordinateSystem} (Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).). This is the underlying object with id, value and extensions. The accessor "getCoordinateSystem" gives direct access to the value 3551 */ 3552 public Sequence setCoordinateSystemElement(IntegerType value) { 3553 this.coordinateSystem = value; 3554 return this; 3555 } 3556 3557 /** 3558 * @return Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end). 3559 */ 3560 public int getCoordinateSystem() { 3561 return this.coordinateSystem == null || this.coordinateSystem.isEmpty() ? 0 : this.coordinateSystem.getValue(); 3562 } 3563 3564 /** 3565 * @param value Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end). 3566 */ 3567 public Sequence setCoordinateSystem(int value) { 3568 if (this.coordinateSystem == null) 3569 this.coordinateSystem = new IntegerType(); 3570 this.coordinateSystem.setValue(value); 3571 return this; 3572 } 3573 3574 /** 3575 * @return {@link #patient} (The patient whose sequencing results are described by this resource.) 3576 */ 3577 public Reference getPatient() { 3578 if (this.patient == null) 3579 if (Configuration.errorOnAutoCreate()) 3580 throw new Error("Attempt to auto-create Sequence.patient"); 3581 else if (Configuration.doAutoCreate()) 3582 this.patient = new Reference(); // cc 3583 return this.patient; 3584 } 3585 3586 public boolean hasPatient() { 3587 return this.patient != null && !this.patient.isEmpty(); 3588 } 3589 3590 /** 3591 * @param value {@link #patient} (The patient whose sequencing results are described by this resource.) 3592 */ 3593 public Sequence setPatient(Reference value) { 3594 this.patient = value; 3595 return this; 3596 } 3597 3598 /** 3599 * @return {@link #patient} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The patient whose sequencing results are described by this resource.) 3600 */ 3601 public Patient getPatientTarget() { 3602 if (this.patientTarget == null) 3603 if (Configuration.errorOnAutoCreate()) 3604 throw new Error("Attempt to auto-create Sequence.patient"); 3605 else if (Configuration.doAutoCreate()) 3606 this.patientTarget = new Patient(); // aa 3607 return this.patientTarget; 3608 } 3609 3610 /** 3611 * @param value {@link #patient} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The patient whose sequencing results are described by this resource.) 3612 */ 3613 public Sequence setPatientTarget(Patient value) { 3614 this.patientTarget = value; 3615 return this; 3616 } 3617 3618 /** 3619 * @return {@link #specimen} (Specimen used for sequencing.) 3620 */ 3621 public Reference getSpecimen() { 3622 if (this.specimen == null) 3623 if (Configuration.errorOnAutoCreate()) 3624 throw new Error("Attempt to auto-create Sequence.specimen"); 3625 else if (Configuration.doAutoCreate()) 3626 this.specimen = new Reference(); // cc 3627 return this.specimen; 3628 } 3629 3630 public boolean hasSpecimen() { 3631 return this.specimen != null && !this.specimen.isEmpty(); 3632 } 3633 3634 /** 3635 * @param value {@link #specimen} (Specimen used for sequencing.) 3636 */ 3637 public Sequence setSpecimen(Reference value) { 3638 this.specimen = value; 3639 return this; 3640 } 3641 3642 /** 3643 * @return {@link #specimen} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Specimen used for sequencing.) 3644 */ 3645 public Specimen getSpecimenTarget() { 3646 if (this.specimenTarget == null) 3647 if (Configuration.errorOnAutoCreate()) 3648 throw new Error("Attempt to auto-create Sequence.specimen"); 3649 else if (Configuration.doAutoCreate()) 3650 this.specimenTarget = new Specimen(); // aa 3651 return this.specimenTarget; 3652 } 3653 3654 /** 3655 * @param value {@link #specimen} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Specimen used for sequencing.) 3656 */ 3657 public Sequence setSpecimenTarget(Specimen value) { 3658 this.specimenTarget = value; 3659 return this; 3660 } 3661 3662 /** 3663 * @return {@link #device} (The method for sequencing, for example, chip information.) 3664 */ 3665 public Reference getDevice() { 3666 if (this.device == null) 3667 if (Configuration.errorOnAutoCreate()) 3668 throw new Error("Attempt to auto-create Sequence.device"); 3669 else if (Configuration.doAutoCreate()) 3670 this.device = new Reference(); // cc 3671 return this.device; 3672 } 3673 3674 public boolean hasDevice() { 3675 return this.device != null && !this.device.isEmpty(); 3676 } 3677 3678 /** 3679 * @param value {@link #device} (The method for sequencing, for example, chip information.) 3680 */ 3681 public Sequence setDevice(Reference value) { 3682 this.device = value; 3683 return this; 3684 } 3685 3686 /** 3687 * @return {@link #device} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The method for sequencing, for example, chip information.) 3688 */ 3689 public Device getDeviceTarget() { 3690 if (this.deviceTarget == null) 3691 if (Configuration.errorOnAutoCreate()) 3692 throw new Error("Attempt to auto-create Sequence.device"); 3693 else if (Configuration.doAutoCreate()) 3694 this.deviceTarget = new Device(); // aa 3695 return this.deviceTarget; 3696 } 3697 3698 /** 3699 * @param value {@link #device} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The method for sequencing, for example, chip information.) 3700 */ 3701 public Sequence setDeviceTarget(Device value) { 3702 this.deviceTarget = value; 3703 return this; 3704 } 3705 3706 /** 3707 * @return {@link #performer} (The organization or lab that should be responsible for this result.) 3708 */ 3709 public Reference getPerformer() { 3710 if (this.performer == null) 3711 if (Configuration.errorOnAutoCreate()) 3712 throw new Error("Attempt to auto-create Sequence.performer"); 3713 else if (Configuration.doAutoCreate()) 3714 this.performer = new Reference(); // cc 3715 return this.performer; 3716 } 3717 3718 public boolean hasPerformer() { 3719 return this.performer != null && !this.performer.isEmpty(); 3720 } 3721 3722 /** 3723 * @param value {@link #performer} (The organization or lab that should be responsible for this result.) 3724 */ 3725 public Sequence setPerformer(Reference value) { 3726 this.performer = value; 3727 return this; 3728 } 3729 3730 /** 3731 * @return {@link #performer} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The organization or lab that should be responsible for this result.) 3732 */ 3733 public Organization getPerformerTarget() { 3734 if (this.performerTarget == null) 3735 if (Configuration.errorOnAutoCreate()) 3736 throw new Error("Attempt to auto-create Sequence.performer"); 3737 else if (Configuration.doAutoCreate()) 3738 this.performerTarget = new Organization(); // aa 3739 return this.performerTarget; 3740 } 3741 3742 /** 3743 * @param value {@link #performer} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The organization or lab that should be responsible for this result.) 3744 */ 3745 public Sequence setPerformerTarget(Organization value) { 3746 this.performerTarget = value; 3747 return this; 3748 } 3749 3750 /** 3751 * @return {@link #quantity} (The number of copies of the seqeunce of interest. (RNASeq).) 3752 */ 3753 public Quantity getQuantity() { 3754 if (this.quantity == null) 3755 if (Configuration.errorOnAutoCreate()) 3756 throw new Error("Attempt to auto-create Sequence.quantity"); 3757 else if (Configuration.doAutoCreate()) 3758 this.quantity = new Quantity(); // cc 3759 return this.quantity; 3760 } 3761 3762 public boolean hasQuantity() { 3763 return this.quantity != null && !this.quantity.isEmpty(); 3764 } 3765 3766 /** 3767 * @param value {@link #quantity} (The number of copies of the seqeunce of interest. (RNASeq).) 3768 */ 3769 public Sequence setQuantity(Quantity value) { 3770 this.quantity = value; 3771 return this; 3772 } 3773 3774 /** 3775 * @return {@link #referenceSeq} (A sequence that is used as a reference to describe variants that are present in a sequence analyzed.) 3776 */ 3777 public SequenceReferenceSeqComponent getReferenceSeq() { 3778 if (this.referenceSeq == null) 3779 if (Configuration.errorOnAutoCreate()) 3780 throw new Error("Attempt to auto-create Sequence.referenceSeq"); 3781 else if (Configuration.doAutoCreate()) 3782 this.referenceSeq = new SequenceReferenceSeqComponent(); // cc 3783 return this.referenceSeq; 3784 } 3785 3786 public boolean hasReferenceSeq() { 3787 return this.referenceSeq != null && !this.referenceSeq.isEmpty(); 3788 } 3789 3790 /** 3791 * @param value {@link #referenceSeq} (A sequence that is used as a reference to describe variants that are present in a sequence analyzed.) 3792 */ 3793 public Sequence setReferenceSeq(SequenceReferenceSeqComponent value) { 3794 this.referenceSeq = value; 3795 return this; 3796 } 3797 3798 /** 3799 * @return {@link #variant} (The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.) It can represent some complex mutation or segment variation with the assist of CIGAR string.) 3800 */ 3801 public List<SequenceVariantComponent> getVariant() { 3802 if (this.variant == null) 3803 this.variant = new ArrayList<SequenceVariantComponent>(); 3804 return this.variant; 3805 } 3806 3807 /** 3808 * @return Returns a reference to <code>this</code> for easy method chaining 3809 */ 3810 public Sequence setVariant(List<SequenceVariantComponent> theVariant) { 3811 this.variant = theVariant; 3812 return this; 3813 } 3814 3815 public boolean hasVariant() { 3816 if (this.variant == null) 3817 return false; 3818 for (SequenceVariantComponent item : this.variant) 3819 if (!item.isEmpty()) 3820 return true; 3821 return false; 3822 } 3823 3824 public SequenceVariantComponent addVariant() { //3 3825 SequenceVariantComponent t = new SequenceVariantComponent(); 3826 if (this.variant == null) 3827 this.variant = new ArrayList<SequenceVariantComponent>(); 3828 this.variant.add(t); 3829 return t; 3830 } 3831 3832 public Sequence addVariant(SequenceVariantComponent t) { //3 3833 if (t == null) 3834 return this; 3835 if (this.variant == null) 3836 this.variant = new ArrayList<SequenceVariantComponent>(); 3837 this.variant.add(t); 3838 return this; 3839 } 3840 3841 /** 3842 * @return The first repetition of repeating field {@link #variant}, creating it if it does not already exist 3843 */ 3844 public SequenceVariantComponent getVariantFirstRep() { 3845 if (getVariant().isEmpty()) { 3846 addVariant(); 3847 } 3848 return getVariant().get(0); 3849 } 3850 3851 /** 3852 * @return {@link #observedSeq} (Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.). This is the underlying object with id, value and extensions. The accessor "getObservedSeq" gives direct access to the value 3853 */ 3854 public StringType getObservedSeqElement() { 3855 if (this.observedSeq == null) 3856 if (Configuration.errorOnAutoCreate()) 3857 throw new Error("Attempt to auto-create Sequence.observedSeq"); 3858 else if (Configuration.doAutoCreate()) 3859 this.observedSeq = new StringType(); // bb 3860 return this.observedSeq; 3861 } 3862 3863 public boolean hasObservedSeqElement() { 3864 return this.observedSeq != null && !this.observedSeq.isEmpty(); 3865 } 3866 3867 public boolean hasObservedSeq() { 3868 return this.observedSeq != null && !this.observedSeq.isEmpty(); 3869 } 3870 3871 /** 3872 * @param value {@link #observedSeq} (Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.). This is the underlying object with id, value and extensions. The accessor "getObservedSeq" gives direct access to the value 3873 */ 3874 public Sequence setObservedSeqElement(StringType value) { 3875 this.observedSeq = value; 3876 return this; 3877 } 3878 3879 /** 3880 * @return Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd. 3881 */ 3882 public String getObservedSeq() { 3883 return this.observedSeq == null ? null : this.observedSeq.getValue(); 3884 } 3885 3886 /** 3887 * @param value Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd. 3888 */ 3889 public Sequence setObservedSeq(String value) { 3890 if (Utilities.noString(value)) 3891 this.observedSeq = null; 3892 else { 3893 if (this.observedSeq == null) 3894 this.observedSeq = new StringType(); 3895 this.observedSeq.setValue(value); 3896 } 3897 return this; 3898 } 3899 3900 /** 3901 * @return {@link #quality} (An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)).) 3902 */ 3903 public List<SequenceQualityComponent> getQuality() { 3904 if (this.quality == null) 3905 this.quality = new ArrayList<SequenceQualityComponent>(); 3906 return this.quality; 3907 } 3908 3909 /** 3910 * @return Returns a reference to <code>this</code> for easy method chaining 3911 */ 3912 public Sequence setQuality(List<SequenceQualityComponent> theQuality) { 3913 this.quality = theQuality; 3914 return this; 3915 } 3916 3917 public boolean hasQuality() { 3918 if (this.quality == null) 3919 return false; 3920 for (SequenceQualityComponent item : this.quality) 3921 if (!item.isEmpty()) 3922 return true; 3923 return false; 3924 } 3925 3926 public SequenceQualityComponent addQuality() { //3 3927 SequenceQualityComponent t = new SequenceQualityComponent(); 3928 if (this.quality == null) 3929 this.quality = new ArrayList<SequenceQualityComponent>(); 3930 this.quality.add(t); 3931 return t; 3932 } 3933 3934 public Sequence addQuality(SequenceQualityComponent t) { //3 3935 if (t == null) 3936 return this; 3937 if (this.quality == null) 3938 this.quality = new ArrayList<SequenceQualityComponent>(); 3939 this.quality.add(t); 3940 return this; 3941 } 3942 3943 /** 3944 * @return The first repetition of repeating field {@link #quality}, creating it if it does not already exist 3945 */ 3946 public SequenceQualityComponent getQualityFirstRep() { 3947 if (getQuality().isEmpty()) { 3948 addQuality(); 3949 } 3950 return getQuality().get(0); 3951 } 3952 3953 /** 3954 * @return {@link #readCoverage} (Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.). This is the underlying object with id, value and extensions. The accessor "getReadCoverage" gives direct access to the value 3955 */ 3956 public IntegerType getReadCoverageElement() { 3957 if (this.readCoverage == null) 3958 if (Configuration.errorOnAutoCreate()) 3959 throw new Error("Attempt to auto-create Sequence.readCoverage"); 3960 else if (Configuration.doAutoCreate()) 3961 this.readCoverage = new IntegerType(); // bb 3962 return this.readCoverage; 3963 } 3964 3965 public boolean hasReadCoverageElement() { 3966 return this.readCoverage != null && !this.readCoverage.isEmpty(); 3967 } 3968 3969 public boolean hasReadCoverage() { 3970 return this.readCoverage != null && !this.readCoverage.isEmpty(); 3971 } 3972 3973 /** 3974 * @param value {@link #readCoverage} (Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.). This is the underlying object with id, value and extensions. The accessor "getReadCoverage" gives direct access to the value 3975 */ 3976 public Sequence setReadCoverageElement(IntegerType value) { 3977 this.readCoverage = value; 3978 return this; 3979 } 3980 3981 /** 3982 * @return Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence. 3983 */ 3984 public int getReadCoverage() { 3985 return this.readCoverage == null || this.readCoverage.isEmpty() ? 0 : this.readCoverage.getValue(); 3986 } 3987 3988 /** 3989 * @param value Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence. 3990 */ 3991 public Sequence setReadCoverage(int value) { 3992 if (this.readCoverage == null) 3993 this.readCoverage = new IntegerType(); 3994 this.readCoverage.setValue(value); 3995 return this; 3996 } 3997 3998 /** 3999 * @return {@link #repository} (Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq.) 4000 */ 4001 public List<SequenceRepositoryComponent> getRepository() { 4002 if (this.repository == null) 4003 this.repository = new ArrayList<SequenceRepositoryComponent>(); 4004 return this.repository; 4005 } 4006 4007 /** 4008 * @return Returns a reference to <code>this</code> for easy method chaining 4009 */ 4010 public Sequence setRepository(List<SequenceRepositoryComponent> theRepository) { 4011 this.repository = theRepository; 4012 return this; 4013 } 4014 4015 public boolean hasRepository() { 4016 if (this.repository == null) 4017 return false; 4018 for (SequenceRepositoryComponent item : this.repository) 4019 if (!item.isEmpty()) 4020 return true; 4021 return false; 4022 } 4023 4024 public SequenceRepositoryComponent addRepository() { //3 4025 SequenceRepositoryComponent t = new SequenceRepositoryComponent(); 4026 if (this.repository == null) 4027 this.repository = new ArrayList<SequenceRepositoryComponent>(); 4028 this.repository.add(t); 4029 return t; 4030 } 4031 4032 public Sequence addRepository(SequenceRepositoryComponent t) { //3 4033 if (t == null) 4034 return this; 4035 if (this.repository == null) 4036 this.repository = new ArrayList<SequenceRepositoryComponent>(); 4037 this.repository.add(t); 4038 return this; 4039 } 4040 4041 /** 4042 * @return The first repetition of repeating field {@link #repository}, creating it if it does not already exist 4043 */ 4044 public SequenceRepositoryComponent getRepositoryFirstRep() { 4045 if (getRepository().isEmpty()) { 4046 addRepository(); 4047 } 4048 return getRepository().get(0); 4049 } 4050 4051 /** 4052 * @return {@link #pointer} (Pointer to next atomic sequence which at most contains one variant.) 4053 */ 4054 public List<Reference> getPointer() { 4055 if (this.pointer == null) 4056 this.pointer = new ArrayList<Reference>(); 4057 return this.pointer; 4058 } 4059 4060 /** 4061 * @return Returns a reference to <code>this</code> for easy method chaining 4062 */ 4063 public Sequence setPointer(List<Reference> thePointer) { 4064 this.pointer = thePointer; 4065 return this; 4066 } 4067 4068 public boolean hasPointer() { 4069 if (this.pointer == null) 4070 return false; 4071 for (Reference item : this.pointer) 4072 if (!item.isEmpty()) 4073 return true; 4074 return false; 4075 } 4076 4077 public Reference addPointer() { //3 4078 Reference t = new Reference(); 4079 if (this.pointer == null) 4080 this.pointer = new ArrayList<Reference>(); 4081 this.pointer.add(t); 4082 return t; 4083 } 4084 4085 public Sequence addPointer(Reference t) { //3 4086 if (t == null) 4087 return this; 4088 if (this.pointer == null) 4089 this.pointer = new ArrayList<Reference>(); 4090 this.pointer.add(t); 4091 return this; 4092 } 4093 4094 /** 4095 * @return The first repetition of repeating field {@link #pointer}, creating it if it does not already exist 4096 */ 4097 public Reference getPointerFirstRep() { 4098 if (getPointer().isEmpty()) { 4099 addPointer(); 4100 } 4101 return getPointer().get(0); 4102 } 4103 4104 /** 4105 * @deprecated Use Reference#setResource(IBaseResource) instead 4106 */ 4107 @Deprecated 4108 public List<Sequence> getPointerTarget() { 4109 if (this.pointerTarget == null) 4110 this.pointerTarget = new ArrayList<Sequence>(); 4111 return this.pointerTarget; 4112 } 4113 4114 /** 4115 * @deprecated Use Reference#setResource(IBaseResource) instead 4116 */ 4117 @Deprecated 4118 public Sequence addPointerTarget() { 4119 Sequence r = new Sequence(); 4120 if (this.pointerTarget == null) 4121 this.pointerTarget = new ArrayList<Sequence>(); 4122 this.pointerTarget.add(r); 4123 return r; 4124 } 4125 4126 protected void listChildren(List<Property> children) { 4127 super.listChildren(children); 4128 children.add(new Property("identifier", "Identifier", "A unique identifier for this particular sequence instance. This is a FHIR-defined id.", 0, java.lang.Integer.MAX_VALUE, identifier)); 4129 children.add(new Property("type", "code", "Amino Acid Sequence/ DNA Sequence / RNA Sequence.", 0, 1, type)); 4130 children.add(new Property("coordinateSystem", "integer", "Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).", 0, 1, coordinateSystem)); 4131 children.add(new Property("patient", "Reference(Patient)", "The patient whose sequencing results are described by this resource.", 0, 1, patient)); 4132 children.add(new Property("specimen", "Reference(Specimen)", "Specimen used for sequencing.", 0, 1, specimen)); 4133 children.add(new Property("device", "Reference(Device)", "The method for sequencing, for example, chip information.", 0, 1, device)); 4134 children.add(new Property("performer", "Reference(Organization)", "The organization or lab that should be responsible for this result.", 0, 1, performer)); 4135 children.add(new Property("quantity", "Quantity", "The number of copies of the seqeunce of interest. (RNASeq).", 0, 1, quantity)); 4136 children.add(new Property("referenceSeq", "", "A sequence that is used as a reference to describe variants that are present in a sequence analyzed.", 0, 1, referenceSeq)); 4137 children.add(new Property("variant", "", "The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.) It can represent some complex mutation or segment variation with the assist of CIGAR string.", 0, java.lang.Integer.MAX_VALUE, variant)); 4138 children.add(new Property("observedSeq", "string", "Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.", 0, 1, observedSeq)); 4139 children.add(new Property("quality", "", "An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)).", 0, java.lang.Integer.MAX_VALUE, quality)); 4140 children.add(new Property("readCoverage", "integer", "Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.", 0, 1, readCoverage)); 4141 children.add(new Property("repository", "", "Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq.", 0, java.lang.Integer.MAX_VALUE, repository)); 4142 children.add(new Property("pointer", "Reference(Sequence)", "Pointer to next atomic sequence which at most contains one variant.", 0, java.lang.Integer.MAX_VALUE, pointer)); 4143 } 4144 4145 @Override 4146 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4147 switch (_hash) { 4148 case -1618432855: /*identifier*/ return new Property("identifier", "Identifier", "A unique identifier for this particular sequence instance. This is a FHIR-defined id.", 0, java.lang.Integer.MAX_VALUE, identifier); 4149 case 3575610: /*type*/ return new Property("type", "code", "Amino Acid Sequence/ DNA Sequence / RNA Sequence.", 0, 1, type); 4150 case 354212295: /*coordinateSystem*/ return new Property("coordinateSystem", "integer", "Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).", 0, 1, coordinateSystem); 4151 case -791418107: /*patient*/ return new Property("patient", "Reference(Patient)", "The patient whose sequencing results are described by this resource.", 0, 1, patient); 4152 case -2132868344: /*specimen*/ return new Property("specimen", "Reference(Specimen)", "Specimen used for sequencing.", 0, 1, specimen); 4153 case -1335157162: /*device*/ return new Property("device", "Reference(Device)", "The method for sequencing, for example, chip information.", 0, 1, device); 4154 case 481140686: /*performer*/ return new Property("performer", "Reference(Organization)", "The organization or lab that should be responsible for this result.", 0, 1, performer); 4155 case -1285004149: /*quantity*/ return new Property("quantity", "Quantity", "The number of copies of the seqeunce of interest. (RNASeq).", 0, 1, quantity); 4156 case -502547180: /*referenceSeq*/ return new Property("referenceSeq", "", "A sequence that is used as a reference to describe variants that are present in a sequence analyzed.", 0, 1, referenceSeq); 4157 case 236785797: /*variant*/ return new Property("variant", "", "The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.) It can represent some complex mutation or segment variation with the assist of CIGAR string.", 0, java.lang.Integer.MAX_VALUE, variant); 4158 case 125541495: /*observedSeq*/ return new Property("observedSeq", "string", "Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.", 0, 1, observedSeq); 4159 case 651215103: /*quality*/ return new Property("quality", "", "An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)).", 0, java.lang.Integer.MAX_VALUE, quality); 4160 case -1798816354: /*readCoverage*/ return new Property("readCoverage", "integer", "Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.", 0, 1, readCoverage); 4161 case 1950800714: /*repository*/ return new Property("repository", "", "Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq.", 0, java.lang.Integer.MAX_VALUE, repository); 4162 case -400605635: /*pointer*/ return new Property("pointer", "Reference(Sequence)", "Pointer to next atomic sequence which at most contains one variant.", 0, java.lang.Integer.MAX_VALUE, pointer); 4163 default: return super.getNamedProperty(_hash, _name, _checkValid); 4164 } 4165 4166 } 4167 4168 @Override 4169 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4170 switch (hash) { 4171 case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 4172 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<SequenceType> 4173 case 354212295: /*coordinateSystem*/ return this.coordinateSystem == null ? new Base[0] : new Base[] {this.coordinateSystem}; // IntegerType 4174 case -791418107: /*patient*/ return this.patient == null ? new Base[0] : new Base[] {this.patient}; // Reference 4175 case -2132868344: /*specimen*/ return this.specimen == null ? new Base[0] : new Base[] {this.specimen}; // Reference 4176 case -1335157162: /*device*/ return this.device == null ? new Base[0] : new Base[] {this.device}; // Reference 4177 case 481140686: /*performer*/ return this.performer == null ? new Base[0] : new Base[] {this.performer}; // Reference 4178 case -1285004149: /*quantity*/ return this.quantity == null ? new Base[0] : new Base[] {this.quantity}; // Quantity 4179 case -502547180: /*referenceSeq*/ return this.referenceSeq == null ? new Base[0] : new Base[] {this.referenceSeq}; // SequenceReferenceSeqComponent 4180 case 236785797: /*variant*/ return this.variant == null ? new Base[0] : this.variant.toArray(new Base[this.variant.size()]); // SequenceVariantComponent 4181 case 125541495: /*observedSeq*/ return this.observedSeq == null ? new Base[0] : new Base[] {this.observedSeq}; // StringType 4182 case 651215103: /*quality*/ return this.quality == null ? new Base[0] : this.quality.toArray(new Base[this.quality.size()]); // SequenceQualityComponent 4183 case -1798816354: /*readCoverage*/ return this.readCoverage == null ? new Base[0] : new Base[] {this.readCoverage}; // IntegerType 4184 case 1950800714: /*repository*/ return this.repository == null ? new Base[0] : this.repository.toArray(new Base[this.repository.size()]); // SequenceRepositoryComponent 4185 case -400605635: /*pointer*/ return this.pointer == null ? new Base[0] : this.pointer.toArray(new Base[this.pointer.size()]); // Reference 4186 default: return super.getProperty(hash, name, checkValid); 4187 } 4188 4189 } 4190 4191 @Override 4192 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4193 switch (hash) { 4194 case -1618432855: // identifier 4195 this.getIdentifier().add(castToIdentifier(value)); // Identifier 4196 return value; 4197 case 3575610: // type 4198 value = new SequenceTypeEnumFactory().fromType(castToCode(value)); 4199 this.type = (Enumeration) value; // Enumeration<SequenceType> 4200 return value; 4201 case 354212295: // coordinateSystem 4202 this.coordinateSystem = castToInteger(value); // IntegerType 4203 return value; 4204 case -791418107: // patient 4205 this.patient = castToReference(value); // Reference 4206 return value; 4207 case -2132868344: // specimen 4208 this.specimen = castToReference(value); // Reference 4209 return value; 4210 case -1335157162: // device 4211 this.device = castToReference(value); // Reference 4212 return value; 4213 case 481140686: // performer 4214 this.performer = castToReference(value); // Reference 4215 return value; 4216 case -1285004149: // quantity 4217 this.quantity = castToQuantity(value); // Quantity 4218 return value; 4219 case -502547180: // referenceSeq 4220 this.referenceSeq = (SequenceReferenceSeqComponent) value; // SequenceReferenceSeqComponent 4221 return value; 4222 case 236785797: // variant 4223 this.getVariant().add((SequenceVariantComponent) value); // SequenceVariantComponent 4224 return value; 4225 case 125541495: // observedSeq 4226 this.observedSeq = castToString(value); // StringType 4227 return value; 4228 case 651215103: // quality 4229 this.getQuality().add((SequenceQualityComponent) value); // SequenceQualityComponent 4230 return value; 4231 case -1798816354: // readCoverage 4232 this.readCoverage = castToInteger(value); // IntegerType 4233 return value; 4234 case 1950800714: // repository 4235 this.getRepository().add((SequenceRepositoryComponent) value); // SequenceRepositoryComponent 4236 return value; 4237 case -400605635: // pointer 4238 this.getPointer().add(castToReference(value)); // Reference 4239 return value; 4240 default: return super.setProperty(hash, name, value); 4241 } 4242 4243 } 4244 4245 @Override 4246 public Base setProperty(String name, Base value) throws FHIRException { 4247 if (name.equals("identifier")) { 4248 this.getIdentifier().add(castToIdentifier(value)); 4249 } else if (name.equals("type")) { 4250 value = new SequenceTypeEnumFactory().fromType(castToCode(value)); 4251 this.type = (Enumeration) value; // Enumeration<SequenceType> 4252 } else if (name.equals("coordinateSystem")) { 4253 this.coordinateSystem = castToInteger(value); // IntegerType 4254 } else if (name.equals("patient")) { 4255 this.patient = castToReference(value); // Reference 4256 } else if (name.equals("specimen")) { 4257 this.specimen = castToReference(value); // Reference 4258 } else if (name.equals("device")) { 4259 this.device = castToReference(value); // Reference 4260 } else if (name.equals("performer")) { 4261 this.performer = castToReference(value); // Reference 4262 } else if (name.equals("quantity")) { 4263 this.quantity = castToQuantity(value); // Quantity 4264 } else if (name.equals("referenceSeq")) { 4265 this.referenceSeq = (SequenceReferenceSeqComponent) value; // SequenceReferenceSeqComponent 4266 } else if (name.equals("variant")) { 4267 this.getVariant().add((SequenceVariantComponent) value); 4268 } else if (name.equals("observedSeq")) { 4269 this.observedSeq = castToString(value); // StringType 4270 } else if (name.equals("quality")) { 4271 this.getQuality().add((SequenceQualityComponent) value); 4272 } else if (name.equals("readCoverage")) { 4273 this.readCoverage = castToInteger(value); // IntegerType 4274 } else if (name.equals("repository")) { 4275 this.getRepository().add((SequenceRepositoryComponent) value); 4276 } else if (name.equals("pointer")) { 4277 this.getPointer().add(castToReference(value)); 4278 } else 4279 return super.setProperty(name, value); 4280 return value; 4281 } 4282 4283 @Override 4284 public Base makeProperty(int hash, String name) throws FHIRException { 4285 switch (hash) { 4286 case -1618432855: return addIdentifier(); 4287 case 3575610: return getTypeElement(); 4288 case 354212295: return getCoordinateSystemElement(); 4289 case -791418107: return getPatient(); 4290 case -2132868344: return getSpecimen(); 4291 case -1335157162: return getDevice(); 4292 case 481140686: return getPerformer(); 4293 case -1285004149: return getQuantity(); 4294 case -502547180: return getReferenceSeq(); 4295 case 236785797: return addVariant(); 4296 case 125541495: return getObservedSeqElement(); 4297 case 651215103: return addQuality(); 4298 case -1798816354: return getReadCoverageElement(); 4299 case 1950800714: return addRepository(); 4300 case -400605635: return addPointer(); 4301 default: return super.makeProperty(hash, name); 4302 } 4303 4304 } 4305 4306 @Override 4307 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4308 switch (hash) { 4309 case -1618432855: /*identifier*/ return new String[] {"Identifier"}; 4310 case 3575610: /*type*/ return new String[] {"code"}; 4311 case 354212295: /*coordinateSystem*/ return new String[] {"integer"}; 4312 case -791418107: /*patient*/ return new String[] {"Reference"}; 4313 case -2132868344: /*specimen*/ return new String[] {"Reference"}; 4314 case -1335157162: /*device*/ return new String[] {"Reference"}; 4315 case 481140686: /*performer*/ return new String[] {"Reference"}; 4316 case -1285004149: /*quantity*/ return new String[] {"Quantity"}; 4317 case -502547180: /*referenceSeq*/ return new String[] {}; 4318 case 236785797: /*variant*/ return new String[] {}; 4319 case 125541495: /*observedSeq*/ return new String[] {"string"}; 4320 case 651215103: /*quality*/ return new String[] {}; 4321 case -1798816354: /*readCoverage*/ return new String[] {"integer"}; 4322 case 1950800714: /*repository*/ return new String[] {}; 4323 case -400605635: /*pointer*/ return new String[] {"Reference"}; 4324 default: return super.getTypesForProperty(hash, name); 4325 } 4326 4327 } 4328 4329 @Override 4330 public Base addChild(String name) throws FHIRException { 4331 if (name.equals("identifier")) { 4332 return addIdentifier(); 4333 } 4334 else if (name.equals("type")) { 4335 throw new FHIRException("Cannot call addChild on a primitive type Sequence.type"); 4336 } 4337 else if (name.equals("coordinateSystem")) { 4338 throw new FHIRException("Cannot call addChild on a primitive type Sequence.coordinateSystem"); 4339 } 4340 else if (name.equals("patient")) { 4341 this.patient = new Reference(); 4342 return this.patient; 4343 } 4344 else if (name.equals("specimen")) { 4345 this.specimen = new Reference(); 4346 return this.specimen; 4347 } 4348 else if (name.equals("device")) { 4349 this.device = new Reference(); 4350 return this.device; 4351 } 4352 else if (name.equals("performer")) { 4353 this.performer = new Reference(); 4354 return this.performer; 4355 } 4356 else if (name.equals("quantity")) { 4357 this.quantity = new Quantity(); 4358 return this.quantity; 4359 } 4360 else if (name.equals("referenceSeq")) { 4361 this.referenceSeq = new SequenceReferenceSeqComponent(); 4362 return this.referenceSeq; 4363 } 4364 else if (name.equals("variant")) { 4365 return addVariant(); 4366 } 4367 else if (name.equals("observedSeq")) { 4368 throw new FHIRException("Cannot call addChild on a primitive type Sequence.observedSeq"); 4369 } 4370 else if (name.equals("quality")) { 4371 return addQuality(); 4372 } 4373 else if (name.equals("readCoverage")) { 4374 throw new FHIRException("Cannot call addChild on a primitive type Sequence.readCoverage"); 4375 } 4376 else if (name.equals("repository")) { 4377 return addRepository(); 4378 } 4379 else if (name.equals("pointer")) { 4380 return addPointer(); 4381 } 4382 else 4383 return super.addChild(name); 4384 } 4385 4386 public String fhirType() { 4387 return "Sequence"; 4388 4389 } 4390 4391 public Sequence copy() { 4392 Sequence dst = new Sequence(); 4393 copyValues(dst); 4394 if (identifier != null) { 4395 dst.identifier = new ArrayList<Identifier>(); 4396 for (Identifier i : identifier) 4397 dst.identifier.add(i.copy()); 4398 }; 4399 dst.type = type == null ? null : type.copy(); 4400 dst.coordinateSystem = coordinateSystem == null ? null : coordinateSystem.copy(); 4401 dst.patient = patient == null ? null : patient.copy(); 4402 dst.specimen = specimen == null ? null : specimen.copy(); 4403 dst.device = device == null ? null : device.copy(); 4404 dst.performer = performer == null ? null : performer.copy(); 4405 dst.quantity = quantity == null ? null : quantity.copy(); 4406 dst.referenceSeq = referenceSeq == null ? null : referenceSeq.copy(); 4407 if (variant != null) { 4408 dst.variant = new ArrayList<SequenceVariantComponent>(); 4409 for (SequenceVariantComponent i : variant) 4410 dst.variant.add(i.copy()); 4411 }; 4412 dst.observedSeq = observedSeq == null ? null : observedSeq.copy(); 4413 if (quality != null) { 4414 dst.quality = new ArrayList<SequenceQualityComponent>(); 4415 for (SequenceQualityComponent i : quality) 4416 dst.quality.add(i.copy()); 4417 }; 4418 dst.readCoverage = readCoverage == null ? null : readCoverage.copy(); 4419 if (repository != null) { 4420 dst.repository = new ArrayList<SequenceRepositoryComponent>(); 4421 for (SequenceRepositoryComponent i : repository) 4422 dst.repository.add(i.copy()); 4423 }; 4424 if (pointer != null) { 4425 dst.pointer = new ArrayList<Reference>(); 4426 for (Reference i : pointer) 4427 dst.pointer.add(i.copy()); 4428 }; 4429 return dst; 4430 } 4431 4432 protected Sequence typedCopy() { 4433 return copy(); 4434 } 4435 4436 @Override 4437 public boolean equalsDeep(Base other_) { 4438 if (!super.equalsDeep(other_)) 4439 return false; 4440 if (!(other_ instanceof Sequence)) 4441 return false; 4442 Sequence o = (Sequence) other_; 4443 return compareDeep(identifier, o.identifier, true) && compareDeep(type, o.type, true) && compareDeep(coordinateSystem, o.coordinateSystem, true) 4444 && compareDeep(patient, o.patient, true) && compareDeep(specimen, o.specimen, true) && compareDeep(device, o.device, true) 4445 && compareDeep(performer, o.performer, true) && compareDeep(quantity, o.quantity, true) && compareDeep(referenceSeq, o.referenceSeq, true) 4446 && compareDeep(variant, o.variant, true) && compareDeep(observedSeq, o.observedSeq, true) && compareDeep(quality, o.quality, true) 4447 && compareDeep(readCoverage, o.readCoverage, true) && compareDeep(repository, o.repository, true) 4448 && compareDeep(pointer, o.pointer, true); 4449 } 4450 4451 @Override 4452 public boolean equalsShallow(Base other_) { 4453 if (!super.equalsShallow(other_)) 4454 return false; 4455 if (!(other_ instanceof Sequence)) 4456 return false; 4457 Sequence o = (Sequence) other_; 4458 return compareValues(type, o.type, true) && compareValues(coordinateSystem, o.coordinateSystem, true) 4459 && compareValues(observedSeq, o.observedSeq, true) && compareValues(readCoverage, o.readCoverage, true) 4460 ; 4461 } 4462 4463 public boolean isEmpty() { 4464 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, type, coordinateSystem 4465 , patient, specimen, device, performer, quantity, referenceSeq, variant, observedSeq 4466 , quality, readCoverage, repository, pointer); 4467 } 4468 4469 @Override 4470 public ResourceType getResourceType() { 4471 return ResourceType.Sequence; 4472 } 4473 4474 /** 4475 * Search parameter: <b>identifier</b> 4476 * <p> 4477 * Description: <b>The unique identity for a particular sequence</b><br> 4478 * Type: <b>token</b><br> 4479 * Path: <b>Sequence.identifier</b><br> 4480 * </p> 4481 */ 4482 @SearchParamDefinition(name="identifier", path="Sequence.identifier", description="The unique identity for a particular sequence", type="token" ) 4483 public static final String SP_IDENTIFIER = "identifier"; 4484 /** 4485 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 4486 * <p> 4487 * Description: <b>The unique identity for a particular sequence</b><br> 4488 * Type: <b>token</b><br> 4489 * Path: <b>Sequence.identifier</b><br> 4490 * </p> 4491 */ 4492 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER); 4493 4494 /** 4495 * Search parameter: <b>coordinate</b> 4496 * <p> 4497 * Description: <b>Search parameter for region of the reference DNA sequence string. This will refer to part of a locus or part of a gene where search region will be represented in 1-based system. Since the coordinateSystem can either be 0-based or 1-based, this search query will include the result of both coordinateSystem that contains the equivalent segment of the gene or whole genome sequence. For example, a search for sequence can be represented as `coordinate=1$lt345$gt123`, this means it will search for the Sequence resource on chromosome 1 and with position >123 and <345, where in 1-based system resource, all strings within region 1:124-344 will be revealed, while in 0-based system resource, all strings within region 1:123-344 will be revealed. You may want to check detail about 0-based v.s. 1-based above.</b><br> 4498 * Type: <b>composite</b><br> 4499 * Path: <b></b><br> 4500 * </p> 4501 */ 4502 @SearchParamDefinition(name="coordinate", path="Sequence.variant", description="Search parameter for region of the reference DNA sequence string. This will refer to part of a locus or part of a gene where search region will be represented in 1-based system. Since the coordinateSystem can either be 0-based or 1-based, this search query will include the result of both coordinateSystem that contains the equivalent segment of the gene or whole genome sequence. For example, a search for sequence can be represented as `coordinate=1$lt345$gt123`, this means it will search for the Sequence resource on chromosome 1 and with position >123 and <345, where in 1-based system resource, all strings within region 1:124-344 will be revealed, while in 0-based system resource, all strings within region 1:123-344 will be revealed. You may want to check detail about 0-based v.s. 1-based above.", type="composite", compositeOf={"chromosome", "start"} ) 4503 public static final String SP_COORDINATE = "coordinate"; 4504 /** 4505 * <b>Fluent Client</b> search parameter constant for <b>coordinate</b> 4506 * <p> 4507 * Description: <b>Search parameter for region of the reference DNA sequence string. This will refer to part of a locus or part of a gene where search region will be represented in 1-based system. Since the coordinateSystem can either be 0-based or 1-based, this search query will include the result of both coordinateSystem that contains the equivalent segment of the gene or whole genome sequence. For example, a search for sequence can be represented as `coordinate=1$lt345$gt123`, this means it will search for the Sequence resource on chromosome 1 and with position >123 and <345, where in 1-based system resource, all strings within region 1:124-344 will be revealed, while in 0-based system resource, all strings within region 1:123-344 will be revealed. You may want to check detail about 0-based v.s. 1-based above.</b><br> 4508 * Type: <b>composite</b><br> 4509 * Path: <b></b><br> 4510 * </p> 4511 */ 4512 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.NumberClientParam> COORDINATE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.NumberClientParam>(SP_COORDINATE); 4513 4514 /** 4515 * Search parameter: <b>patient</b> 4516 * <p> 4517 * Description: <b>The subject that the observation is about</b><br> 4518 * Type: <b>reference</b><br> 4519 * Path: <b>Sequence.patient</b><br> 4520 * </p> 4521 */ 4522 @SearchParamDefinition(name="patient", path="Sequence.patient", description="The subject that the observation is about", type="reference", target={Patient.class } ) 4523 public static final String SP_PATIENT = "patient"; 4524 /** 4525 * <b>Fluent Client</b> search parameter constant for <b>patient</b> 4526 * <p> 4527 * Description: <b>The subject that the observation is about</b><br> 4528 * Type: <b>reference</b><br> 4529 * Path: <b>Sequence.patient</b><br> 4530 * </p> 4531 */ 4532 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PATIENT); 4533 4534/** 4535 * Constant for fluent queries to be used to add include statements. Specifies 4536 * the path value of "<b>Sequence:patient</b>". 4537 */ 4538 public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include("Sequence:patient").toLocked(); 4539 4540 /** 4541 * Search parameter: <b>chromosome</b> 4542 * <p> 4543 * Description: <b>Chromosome number of the reference sequence</b><br> 4544 * Type: <b>token</b><br> 4545 * Path: <b>Sequence.referenceSeq.chromosome</b><br> 4546 * </p> 4547 */ 4548 @SearchParamDefinition(name="chromosome", path="Sequence.referenceSeq.chromosome", description="Chromosome number of the reference sequence", type="token" ) 4549 public static final String SP_CHROMOSOME = "chromosome"; 4550 /** 4551 * <b>Fluent Client</b> search parameter constant for <b>chromosome</b> 4552 * <p> 4553 * Description: <b>Chromosome number of the reference sequence</b><br> 4554 * Type: <b>token</b><br> 4555 * Path: <b>Sequence.referenceSeq.chromosome</b><br> 4556 * </p> 4557 */ 4558 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CHROMOSOME = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CHROMOSOME); 4559 4560 /** 4561 * Search parameter: <b>start</b> 4562 * <p> 4563 * Description: <b>Start position (0-based inclusive, 1-based inclusive, that means the nucleic acid or amino acid at this position will be included) of the reference sequence.</b><br> 4564 * Type: <b>number</b><br> 4565 * Path: <b>Sequence.referenceSeq.windowStart</b><br> 4566 * </p> 4567 */ 4568 @SearchParamDefinition(name="start", path="Sequence.referenceSeq.windowStart", description="Start position (0-based inclusive, 1-based inclusive, that means the nucleic acid or amino acid at this position will be included) of the reference sequence.", type="number" ) 4569 public static final String SP_START = "start"; 4570 /** 4571 * <b>Fluent Client</b> search parameter constant for <b>start</b> 4572 * <p> 4573 * Description: <b>Start position (0-based inclusive, 1-based inclusive, that means the nucleic acid or amino acid at this position will be included) of the reference sequence.</b><br> 4574 * Type: <b>number</b><br> 4575 * Path: <b>Sequence.referenceSeq.windowStart</b><br> 4576 * </p> 4577 */ 4578 public static final ca.uhn.fhir.rest.gclient.NumberClientParam START = new ca.uhn.fhir.rest.gclient.NumberClientParam(SP_START); 4579 4580 /** 4581 * Search parameter: <b>end</b> 4582 * <p> 4583 * Description: <b>End position (0-based exclusive, which menas the acid at this position will not be included, 1-based inclusive, which means the acid at this position will be included) of the reference sequence.</b><br> 4584 * Type: <b>number</b><br> 4585 * Path: <b>Sequence.referenceSeq.windowEnd</b><br> 4586 * </p> 4587 */ 4588 @SearchParamDefinition(name="end", path="Sequence.referenceSeq.windowEnd", description="End position (0-based exclusive, which menas the acid at this position will not be included, 1-based inclusive, which means the acid at this position will be included) of the reference sequence.", type="number" ) 4589 public static final String SP_END = "end"; 4590 /** 4591 * <b>Fluent Client</b> search parameter constant for <b>end</b> 4592 * <p> 4593 * Description: <b>End position (0-based exclusive, which menas the acid at this position will not be included, 1-based inclusive, which means the acid at this position will be included) of the reference sequence.</b><br> 4594 * Type: <b>number</b><br> 4595 * Path: <b>Sequence.referenceSeq.windowEnd</b><br> 4596 * </p> 4597 */ 4598 public static final ca.uhn.fhir.rest.gclient.NumberClientParam END = new ca.uhn.fhir.rest.gclient.NumberClientParam(SP_END); 4599 4600 /** 4601 * Search parameter: <b>type</b> 4602 * <p> 4603 * Description: <b>Amino Acid Sequence/ DNA Sequence / RNA Sequence</b><br> 4604 * Type: <b>token</b><br> 4605 * Path: <b>Sequence.type</b><br> 4606 * </p> 4607 */ 4608 @SearchParamDefinition(name="type", path="Sequence.type", description="Amino Acid Sequence/ DNA Sequence / RNA Sequence", type="token" ) 4609 public static final String SP_TYPE = "type"; 4610 /** 4611 * <b>Fluent Client</b> search parameter constant for <b>type</b> 4612 * <p> 4613 * Description: <b>Amino Acid Sequence/ DNA Sequence / RNA Sequence</b><br> 4614 * Type: <b>token</b><br> 4615 * Path: <b>Sequence.type</b><br> 4616 * </p> 4617 */ 4618 public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE); 4619 4620 4621} 4622