src/FHIR/R4/FHIRElement/FHIRAttachment.php

   1 <?php
   2
   3 namespace OpenEMR\FHIR\R4\FHIRElement;
   4
   5 /*!
   6  * This class was generated with the PHPFHIR library (https://github.com/dcarbone/php-fhir) using
   7  * class definitions from HL7 FHIR (https://www.hl7.org/fhir/)
   8  *
   9  * Class creation date: June 14th, 2019
  10  *
  11  * PHPFHIR Copyright:
  12  *
  13  * Copyright 2016-2017 Daniel Carbone (daniel.p.carbone@gmail.com)
  14  *
  15  * Licensed under the Apache License, Version 2.0 (the "License");
  16  * you may not use this file except in compliance with the License.
  17  * You may obtain a copy of the License at
  18  *
  19  *        http://www.apache.org/licenses/LICENSE-2.0
  20  *
  21  * Unless required by applicable law or agreed to in writing, software
  22  * distributed under the License is distributed on an "AS IS" BASIS,
  23  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  24  * See the License for the specific language governing permissions and
  25  * limitations under the License.
  26  *
  27  *
  28  * FHIR Copyright Notice:
  29  *
  30  *   Copyright (c) 2011+, HL7, Inc.
  31  *   All rights reserved.
  32  *
  33  *   Redistribution and use in source and binary forms, with or without modification,
  34  *   are permitted provided that the following conditions are met:
  35  *
  36  *    * Redistributions of source code must retain the above copyright notice, this
  37  *      list of conditions and the following disclaimer.
  38  *    * Redistributions in binary form must reproduce the above copyright notice,
  39  *      this list of conditions and the following disclaimer in the documentation
  40  *      and/or other materials provided with the distribution.
  41  *    * Neither the name of HL7 nor the names of its contributors may be used to
  42  *      endorse or promote products derived from this software without specific
  43  *      prior written permission.
  44  *
  45  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  46  *   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  47  *   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  48  *   IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  49  *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  50  *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  51  *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  52  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  53  *   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  54  *   POSSIBILITY OF SUCH DAMAGE.
  55  *
  56  *
  57  *   Generated on Thu, Dec 27, 2018 22:37+1100 for FHIR v4.0.0
  58  *
  59  *   Note: the schemas & schematrons do not contain all of the rules about what makes resources
  60  *   valid. Implementers will still need to be familiar with the content of the specification and with
  61  *   any profiles that apply to the resources in order to make a conformant implementation.
  62  *
  63  */
  64
  65 use OpenEMR\FHIR\R4\FHIRElement;
  66
  67 /**
  68  * For referring to data content defined in other formats.
  69  * If the element is present, it must have a value for at least one of the defined elements, an @id referenced from the Narrative, or extensions
  70  */
  71 class FHIRAttachment extends FHIRElement implements \JsonSerializable
  72 {
  73     /**
  74      * Identifies the type of the data in the attachment and allows a method to be chosen to interpret or render the data. Includes mime type parameters such as charset where appropriate.
  75      * @var \OpenEMR\FHIR\R4\FHIRElement\FHIRCode
  76      */
  77     public $contentType = null;
  78
  79     /**
  80      * The human language of the content. The value can be any valid value according to BCP 47.
  81      * @var \OpenEMR\FHIR\R4\FHIRElement\FHIRCode
  82      */
  83     public $language = null;
  84
  85     /**
  86      * The actual data of the attachment - a sequence of bytes, base64 encoded.
  87      * @var \OpenEMR\FHIR\R4\FHIRElement\FHIRBase64Binary
  88      */
  89     public $data = null;
  90
  91     /**
  92      * A location where the data can be accessed.
  93      * @var \OpenEMR\FHIR\R4\FHIRElement\FHIRUrl
  94      */
  95     public $url = null;
  96
  97     /**
  98      * The number of bytes of data that make up this attachment (before base64 encoding, if that is done).
  99      * @var \OpenEMR\FHIR\R4\FHIRElement\FHIRUnsignedInt
 100      */
 101     public $size = null;
 102
 103     /**
 104      * The calculated hash of the data using SHA-1. Represented using base64.
 105      * @var \OpenEMR\FHIR\R4\FHIRElement\FHIRBase64Binary
 106      */
 107     public $hash = null;
 108
 109     /**
 110      * A label or set of text to display in place of the data.
 111      * @var \OpenEMR\FHIR\R4\FHIRElement\FHIRString
 112      */
 113     public $title = null;
 114
 115     /**
 116      * The date that the attachment was first created.
 117      * @var \OpenEMR\FHIR\R4\FHIRElement\FHIRDateTime
 118      */
 119     public $creation = null;
 120
 121     /**
 122      * @var string
 123      */
 124     private $_fhirElementName = 'Attachment';
 125
 126     /**
 127      * Identifies the type of the data in the attachment and allows a method to be chosen to interpret or render the data. Includes mime type parameters such as charset where appropriate.
 128      * @return \OpenEMR\FHIR\R4\FHIRElement\FHIRCode
 129      */
 130     public function getContentType()
 131     {
 132         return $this->contentType;
 133     }
 134
 135     /**
 136      * Identifies the type of the data in the attachment and allows a method to be chosen to interpret or render the data. Includes mime type parameters such as charset where appropriate.
 137      * @param \OpenEMR\FHIR\R4\FHIRElement\FHIRCode $contentType
 138      * @return $this
 139      */
 140     public function setContentType($contentType)
 141     {
 142         $this->contentType = $contentType;
 143         return $this;
 144     }
 145
 146     /**
 147      * The human language of the content. The value can be any valid value according to BCP 47.
 148      * @return \OpenEMR\FHIR\R4\FHIRElement\FHIRCode
 149      */
 150     public function getLanguage()
 151     {
 152         return $this->language;
 153     }
 154
 155     /**
 156      * The human language of the content. The value can be any valid value according to BCP 47.
 157      * @param \OpenEMR\FHIR\R4\FHIRElement\FHIRCode $language
 158      * @return $this
 159      */
 160     public function setLanguage($language)
 161     {
 162         $this->language = $language;
 163         return $this;
 164     }
 165
 166     /**
 167      * The actual data of the attachment - a sequence of bytes, base64 encoded.
 168      * @return \OpenEMR\FHIR\R4\FHIRElement\FHIRBase64Binary
 169      */
 170     public function getData()
 171     {
 172         return $this->data;
 173     }
 174
 175     /**
 176      * The actual data of the attachment - a sequence of bytes, base64 encoded.
 177      * @param \OpenEMR\FHIR\R4\FHIRElement\FHIRBase64Binary $data
 178      * @return $this
 179      */
 180     public function setData($data)
 181     {
 182         $this->data = $data;
 183         return $this;
 184     }
 185
 186     /**
 187      * A location where the data can be accessed.
 188      * @return \OpenEMR\FHIR\R4\FHIRElement\FHIRUrl
 189      */
 190     public function getUrl()
 191     {
 192         return $this->url;
 193     }
 194
 195     /**
 196      * A location where the data can be accessed.
 197      * @param \OpenEMR\FHIR\R4\FHIRElement\FHIRUrl $url
 198      * @return $this
 199      */
 200     public function setUrl($url)
 201     {
 202         $this->url = $url;
 203         return $this;
 204     }
 205
 206     /**
 207      * The number of bytes of data that make up this attachment (before base64 encoding, if that is done).
 208      * @return \OpenEMR\FHIR\R4\FHIRElement\FHIRUnsignedInt
 209      */
 210     public function getSize()
 211     {
 212         return $this->size;
 213     }
 214
 215     /**
 216      * The number of bytes of data that make up this attachment (before base64 encoding, if that is done).
 217      * @param \OpenEMR\FHIR\R4\FHIRElement\FHIRUnsignedInt $size
 218      * @return $this
 219      */
 220     public function setSize($size)
 221     {
 222         $this->size = $size;
 223         return $this;
 224     }
 225
 226     /**
 227      * The calculated hash of the data using SHA-1. Represented using base64.
 228      * @return \OpenEMR\FHIR\R4\FHIRElement\FHIRBase64Binary
 229      */
 230     public function getHash()
 231     {
 232         return $this->hash;
 233     }
 234
 235     /**
 236      * The calculated hash of the data using SHA-1. Represented using base64.
 237      * @param \OpenEMR\FHIR\R4\FHIRElement\FHIRBase64Binary $hash
 238      * @return $this
 239      */
 240     public function setHash($hash)
 241     {
 242         $this->hash = $hash;
 243         return $this;
 244     }
 245
 246     /**
 247      * A label or set of text to display in place of the data.
 248      * @return \OpenEMR\FHIR\R4\FHIRElement\FHIRString
 249      */
 250     public function getTitle()
 251     {
 252         return $this->title;
 253     }
 254
 255     /**
 256      * A label or set of text to display in place of the data.
 257      * @param \OpenEMR\FHIR\R4\FHIRElement\FHIRString $title
 258      * @return $this
 259      */
 260     public function setTitle($title)
 261     {
 262         $this->title = $title;
 263         return $this;
 264     }
 265
 266     /**
 267      * The date that the attachment was first created.
 268      * @return \OpenEMR\FHIR\R4\FHIRElement\FHIRDateTime
 269      */
 270     public function getCreation()
 271     {
 272         return $this->creation;
 273     }
 274
 275     /**
 276      * The date that the attachment was first created.
 277      * @param \OpenEMR\FHIR\R4\FHIRElement\FHIRDateTime $creation
 278      * @return $this
 279      */
 280     public function setCreation($creation)
 281     {
 282         $this->creation = $creation;
 283         return $this;
 284     }
 285
 286     /**
 287      * @return string
 288      */
 289     public function get_fhirElementName()
 290     {
 291         return $this->_fhirElementName;
 292     }
 293
 294     /**
 295      * @param mixed $data
 296      */
 297     public function __construct($data = [])
 298     {
 299         if (is_array($data)) {
 300             if (isset($data['contentType'])) {
 301                 $this->setContentType($data['contentType']);
 302             }
 303             if (isset($data['language'])) {
 304                 $this->setLanguage($data['language']);
 305             }
 306             if (isset($data['data'])) {
 307                 $this->setData($data['data']);
 308             }
 309             if (isset($data['url'])) {
 310                 $this->setUrl($data['url']);
 311             }
 312             if (isset($data['size'])) {
 313                 $this->setSize($data['size']);
 314             }
 315             if (isset($data['hash'])) {
 316                 $this->setHash($data['hash']);
 317             }
 318             if (isset($data['title'])) {
 319                 $this->setTitle($data['title']);
 320             }
 321             if (isset($data['creation'])) {
 322                 $this->setCreation($data['creation']);
 323             }
 324         } elseif (null !== $data) {
 325             throw new \InvalidArgumentException('$data expected to be array of values, saw "' . gettype($data) . '"');
 326         }
 327         parent::__construct($data);
 328     }
 329
 330     /**
 331      * @return string
 332      */
 333     public function __toString()
 334     {
 335         return $this->get_fhirElementName();
 336     }
 337
 338     /**
 339      * @return array
 340      */
 341     public function jsonSerialize(): mixed
 342     {
 343         $json = parent::jsonSerialize();
 344         if (isset($this->contentType)) {
 345             $json['contentType'] = $this->contentType;
 346         }
 347         if (isset($this->language)) {
 348             $json['language'] = $this->language;
 349         }
 350         if (isset($this->data)) {
 351             $json['data'] = $this->data;
 352         }
 353         if (isset($this->url)) {
 354             $json['url'] = $this->url;
 355         }
 356         if (isset($this->size)) {
 357             $json['size'] = $this->size;
 358         }
 359         if (isset($this->hash)) {
 360             $json['hash'] = $this->hash;
 361         }
 362         if (isset($this->title)) {
 363             $json['title'] = $this->title;
 364         }
 365         if (isset($this->creation)) {
 366             $json['creation'] = $this->creation;
 367         }
 368         return $json;
 369     }
 370
 371     /**
 372      * @param boolean $returnSXE
 373      * @param \SimpleXMLElement $sxe
 374      * @return string|\SimpleXMLElement
 375      */
 376     public function xmlSerialize($returnSXE = false, $sxe = null)
 377     {
 378         if (null === $sxe) {
 379             $sxe = new \SimpleXMLElement('<Attachment xmlns="http://hl7.org/fhir"></Attachment>');
 380         }
 381         parent::xmlSerialize(true, $sxe);
 382         if (isset($this->contentType)) {
 383             $this->contentType->xmlSerialize(true, $sxe->addChild('contentType'));
 384         }
 385         if (isset($this->language)) {
 386             $this->language->xmlSerialize(true, $sxe->addChild('language'));
 387         }
 388         if (isset($this->data)) {
 389             $this->data->xmlSerialize(true, $sxe->addChild('data'));
 390         }
 391         if (isset($this->url)) {
 392             $this->url->xmlSerialize(true, $sxe->addChild('url'));
 393         }
 394         if (isset($this->size)) {
 395             $this->size->xmlSerialize(true, $sxe->addChild('size'));
 396         }
 397         if (isset($this->hash)) {
 398             $this->hash->xmlSerialize(true, $sxe->addChild('hash'));
 399         }
 400         if (isset($this->title)) {
 401             $this->title->xmlSerialize(true, $sxe->addChild('title'));
 402         }
 403         if (isset($this->creation)) {
 404             $this->creation->xmlSerialize(true, $sxe->addChild('creation'));
 405         }
 406         if ($returnSXE) {
 407             return $sxe;
 408         }
 409         return $sxe->saveXML();
 410     }
 411 }