AbstractElement::createElement() - Code Metrics - Inspection of "trying to publish to packagist, with no access to..." - pgee70/cda - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 26e0e4...4a85b9 )

by Peter
created 2018-08-31 11:09 UTC
AbstractElement::createElement() F

↳ Parent: AbstractElement
Complexity

Conditions	26
Paths	4097
Size

Total Lines	79
Code Lines	46
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	46
dl	0
loc	79
rs	0
c	0
b	0
f	0
cc	26
nc	4097
nop	2
How to fix Long Method Complexity

<?php

/**
 * The MIT License
 *
 * Copyright 2016 Julien Fastré <[email protected]>.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

namespace i3Soft\CDA\Elements;

use i3Soft\CDA\ClinicalDocument as CDA;
use i3Soft\CDA\DataType\Boolean\Boolean;
use i3Soft\CDA\Interfaces\ClassCodeInterface;
use i3Soft\CDA\Interfaces\ContextConductionIndInterface;
use i3Soft\CDA\Interfaces\ContextControlCodeInterface;
use i3Soft\CDA\Interfaces\DeterminerCodeInterface;
use i3Soft\CDA\Interfaces\ElementInterface;
use i3Soft\CDA\Interfaces\InversionIndInterface;
use i3Soft\CDA\Interfaces\MediaTypeInterface;
use i3Soft\CDA\Interfaces\MoodCodeInterface;
use i3Soft\CDA\Interfaces\NegationInterface;
use i3Soft\CDA\Interfaces\NullFlavourInterface;
use i3Soft\CDA\Interfaces\TypeCodeInterface;
use i3Soft\CDA\Interfaces\UseAttributeInterface;
use i3Soft\CDA\Interfaces\XSITypeInterface;
use i3Soft\CDA\RIM\Act\Observation;
use i3Soft\CDA\RIM\Act\SubstanceAdministration;
use i3Soft\CDA\RIM\Act\Supply;
use i3Soft\CDA\RIM\Entity\AssignedPerson;
use i3Soft\CDA\RIM\Entity\SpecimenPlayingEntity;
use i3Soft\CDA\RIM\Extensions\ExtParticipantRole;
use i3Soft\CDA\RIM\Participation\Consumable;
use i3Soft\CDA\RIM\Participation\Performer;
use i3Soft\CDA\RIM\Role\ManufacturedProduct;
use i3Soft\CDA\RIM\Role\SpecimenRole;
use i3Soft\CDA\Traits\NullFlavourTrait;
use i3Soft\CDA\Traits\RealmCodesTrait;
use i3Soft\CDA\Traits\TemplateIdsTrait;
use i3Soft\CDA\Traits\TypeIdTrait;

/**
 * @author Julien Fastré <[email protected]>
 */
abstract class AbstractElement implements ElementInterface, NullFlavourInterface
{
    use NullFlavourTrait;
    use RealmCodesTrait;
    use TypeIdTrait;
    use TemplateIdsTrait;

    /**
     * @var array
     */
    protected $attributes = array();

    /**
     * this is a total hack to add non-commonly used attributes.
     * don't use it lazy bones!
     *
     * @param $attribute
     * @param $value
     *
     * @return AbstractElement
     * @deprecated
     */
    public function addAttribute($attribute, $value): self
    {
        $this->attributes[$attribute] = $value;
        return $this;
    }

    /**
     * @return TargetSiteCode
     */
    public function returnTargetSiteCode(): TargetSiteCode
    {
        if ($this instanceof TargetSiteCode) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of TargetSiteCode');
    }

    /**
     * @return Observation
     */
    public function returnObservation(): Observation
    {
        if ($this instanceof Observation) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of Observation');
    }

    /**
     * @return SubstanceAdministration
     */
    public function returnSubstanceAdministration(): SubstanceAdministration
    {
        if ($this instanceof SubstanceAdministration) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of SubstanceAdministration');
    }

    /**
     * @return SpecimenRole
     */
    public function returnSpecimenRole(): SpecimenRole
    {
        if ($this instanceof SpecimenRole) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of SpecimenRole');
    }

    /**
     * @return ManufacturedProduct
     */
    public function returnManufacturedProduct(): ManufacturedProduct
    {
        if ($this instanceof ManufacturedProduct) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of ManufacturedProduct');
    }

    /**
     * @return SpecimenPlayingEntity
     */
    public function returnSpecimenPlayingEntity(): SpecimenPlayingEntity
    {
        if ($this instanceof SpecimenPlayingEntity) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of SpecimenPlayingEntity');
    }

    /**
     * @return Consumable
     */
    public function returnConsumable(): Consumable
    {
        if ($this instanceof Consumable) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of Consumable');
    }

    /**
     * @return Performer
     */
    public function returnPerformer(): Performer
    {
        if ($this instanceof Performer) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of Performer');
    }

    /**
     * @return AssignedPerson
     */
    public function returnAssignedPerson(): AssignedPerson
    {
        if ($this instanceof AssignedPerson) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of AssignedPerson');
    }

    /**
     * @return ExtParticipantRole
     */
    public function returnExtParticipantRole(): ExtParticipantRole
    {
        if ($this instanceof ExtParticipantRole) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of ExtParticipantRole');
    }

    /**
     * @return Supply
     */
    public function returnSupply(): Supply
    {
        if ($this instanceof Supply) {
            return $this;
        }
        throw new \RuntimeException('The method must be an instance of Supply');
    }

    /**
     * @param \DOMDocument $doc
     * @param array        $properties
     *
     * @return \DOMElement
     */
    protected function createElement(\DOMDocument $doc, array $properties = array()): \DOMElement
    {
        /* @var $el \DOMElement */
        $el = $doc->createElement(CDA::NS_CDA . $this->getElementTag());
        if ($this->hasNullFlavour()) {
            $el->setAttribute(CDA::NS_CDA . 'nullFlavor', $this->getNullFlavour());
            return $el;
        }

        // tag can have class code or type code, but not both.
        // can have a class code and a mood code, but not type code and mood code
        /** @noinspection PhpUndefinedMethodInspection */
        if ($this instanceof ClassCodeInterface
            && $this->hasClassCode()) {
            && $this->/** @scrutinizer ignore-call */ hasClassCode()) {
            $el->setAttribute(CDA::NS_CDA . 'classCode', $this->getClassCode());
            /** @noinspection PhpUndefinedMethodInspection */
            if ($this instanceof MoodCodeInterface
                && $this->hasMoodCode()) {
                && $this->/** @scrutinizer ignore-call */ hasMoodCode()) {
                $el->setAttribute(CDA::NS_CDA . 'moodCode', $this->getMoodCode());
            }
        } /** @noinspection PhpUndefinedMethodInspection */
        elseif ($this instanceof TypeCodeInterface && $this->hasTypeCode()) {
        elseif ($this instanceof TypeCodeInterface && $this->/** @scrutinizer ignore-call */ hasTypeCode()) {
            $el->setAttribute(CDA::NS_CDA . 'typeCode', $this->getTypeCode());
        }

        if ($this instanceof DeterminerCodeInterface
            && false === empty($this->getDeterminerCode())) {
            $el->setAttribute(CDA::NS_CDA . 'determinerCode', $this->getDeterminerCode());
        }

        if ($this instanceof MediaTypeInterface && $this->getMediaType()) {
            $el->setAttribute(CDA::NS_CDA . 'mediaType', $this->getMediaType());
        }

        if ($this instanceof InversionIndInterface
            && $this->hasInversionInd()) {
            $negationInd = new Boolean('inversionInd', $this->getInversionInd());
            $negationInd->setValueToElement($el, $doc);
        }

        if ($this instanceof ContextConductionIndInterface
            && $this->hasContextConductionInd()) {
            $negationInd = new Boolean('contextConductionInd', $this->getContextConductionInd());
            $negationInd->setValueToElement($el, $doc);
        }

        if ($this instanceof NegationInterface
            && $this->hasNegationInd()) {
            $negationInd = new Boolean('negationInd', $this->getNegationInd());
            $negationInd->setValueToElement($el, $doc);
        }
        if ($this instanceof UseAttributeInterface
            && false === empty($this->getUseAttribute())) {
            $el->setAttribute(CDA::NS_CDA . 'use', $this->getUseAttribute());
        }

        if ($this instanceof ContextControlCodeInterface
            && false === empty($this->getContextControlCode())) {

            $el->setAttribute(CDA::NS_CDA . 'contextControlCode', $this->getContextControlCode());
        }
        if ($this instanceof XSITypeInterface
            && false === empty($this->getXSIType())) {
            $el->setAttribute(CDA::NS_CDA . 'xsi:type', $this->getXSIType());
        }

        foreach ($properties as $property) {
            $this->{$property}->setValueToElement($el, $doc);
        }

        foreach ($this->attributes as $attribute => $value) {
            $el->setAttribute($attribute, $value);
        }
        // attributes have finished, now start adding the elements.
        // realm codes are used to store data like the organisation/country etc this tag conforms to.
        $this->renderRealmCodes($el, $doc)
          ->renderTypeId($el, $doc)
          ->/** @scrutinizer ignore-call */ renderTypeId($el, $doc)
          ->renderTemplateIds($el, $doc);
        return $el;
    }

    /**
     * get the element tag name
     *
     * @return string
     */
    abstract protected function getElementTag(): string;

}

pgee70 / cda

Push — master ( 26e0e4...4a85b9 )

AbstractElement::createElement() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
