sop / asn1

lib/ASN1/Type/UnspecifiedType.php

Indentation +678 added lines, -678 removed lines

@@ -16,682 +16,682 @@
  */
 class UnspecifiedType implements ElementBase
 {
-    /**
-     * The wrapped element.
-     *
-     * @var Element
-     */
-    private $_element;
-    
-    /**
-     * Constructor.
-     *
-     * @param Element $el
-     */
-    public function __construct(Element $el)
-    {
-        $this->_element = $el;
-    }
-    
-    /**
-     * Initialize from DER data.
-     *
-     * @param string $data DER encoded data
-     * @return self
-     */
-    public static function fromDER(string $data): self
-    {
-        return Element::fromDER($data)->asUnspecified();
-    }
-    
-    /**
-     * Initialize from ElementBase interface.
-     *
-     * @param ElementBase $el
-     * @return self
-     */
-    public static function fromElementBase(ElementBase $el): self
-    {
-        // if element is already wrapped
-        if ($el instanceof self) {
-            return $el;
-        }
-        return new self($el->asElement());
-    }
-    
-    /**
-     * Compatibility method to dispatch calls to the wrapped element.
-     *
-     * @deprecated Use <code>as*</code> accessor methods to ensure strict type
-     * @param string $mtd Method name
-     * @param array $args Arguments
-     * @return mixed
-     */
-    public function __call($mtd, array $args)
-    {
-        return call_user_func_array([$this->_element, $mtd], $args);
-    }
-    
-    /**
-     * Get the wrapped element as a context specific tagged type.
-     *
-     * @throws \UnexpectedValueException If the element is not tagged
-     * @return TaggedType
-     */
-    public function asTagged(): TaggedType
-    {
-        if (!$this->_element instanceof TaggedType) {
-            throw new \UnexpectedValueException(
-                "Tagged element expected, got " . $this->_typeDescriptorString());
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as an application specific type.
-     *
-     * @throws \UnexpectedValueException If element is not application specific
-     * @return \ASN1\Type\Tagged\ApplicationType
-     */
-    public function asApplication(): Tagged\ApplicationType
-    {
-        if (!$this->_element instanceof Tagged\ApplicationType) {
-            throw new \UnexpectedValueException(
-                "Application type expected, got " .
-                $this->_typeDescriptorString());
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a private tagged type.
-     *
-     * @throws \UnexpectedValueException If element is not using private tagging
-     * @return \ASN1\Type\Tagged\PrivateType
-     */
-    public function asPrivate(): Tagged\PrivateType
-    {
-        if (!$this->_element instanceof Tagged\PrivateType) {
-            throw new \UnexpectedValueException(
-                "Private type expected, got " . $this->_typeDescriptorString());
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a boolean type.
-     *
-     * @throws \UnexpectedValueException If the element is not a boolean
-     * @return \ASN1\Type\Primitive\Boolean
-     */
-    public function asBoolean(): Primitive\Boolean
-    {
-        if (!$this->_element instanceof Primitive\Boolean) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_BOOLEAN));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as an integer type.
-     *
-     * @throws \UnexpectedValueException If the element is not an integer
-     * @return \ASN1\Type\Primitive\Integer
-     */
-    public function asInteger(): Primitive\Integer
-    {
-        if (!$this->_element instanceof Primitive\Integer) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_INTEGER));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a bit string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a bit string
-     * @return \ASN1\Type\Primitive\BitString
-     */
-    public function asBitString(): Primitive\BitString
-    {
-        if (!$this->_element instanceof Primitive\BitString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_BIT_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as an octet string type.
-     *
-     * @throws \UnexpectedValueException If the element is not an octet string
-     * @return \ASN1\Type\Primitive\OctetString
-     */
-    public function asOctetString(): Primitive\OctetString
-    {
-        if (!$this->_element instanceof Primitive\OctetString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_OCTET_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a null type.
-     *
-     * @throws \UnexpectedValueException If the element is not a null
-     * @return \ASN1\Type\Primitive\NullType
-     */
-    public function asNull(): Primitive\NullType
-    {
-        if (!$this->_element instanceof Primitive\NullType) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_NULL));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as an object identifier type.
-     *
-     * @throws \UnexpectedValueException If the element is not an object
-     *         identifier
-     * @return \ASN1\Type\Primitive\ObjectIdentifier
-     */
-    public function asObjectIdentifier(): Primitive\ObjectIdentifier
-    {
-        if (!$this->_element instanceof Primitive\ObjectIdentifier) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(
-                    Element::TYPE_OBJECT_IDENTIFIER));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as an object descriptor type.
-     *
-     * @throws \UnexpectedValueException If the element is not an object
-     *         descriptor
-     * @return \ASN1\Type\Primitive\ObjectDescriptor
-     */
-    public function asObjectDescriptor(): Primitive\ObjectDescriptor
-    {
-        if (!$this->_element instanceof Primitive\ObjectDescriptor) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(
-                    Element::TYPE_OBJECT_DESCRIPTOR));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a real type.
-     *
-     * @throws \UnexpectedValueException If the element is not a real
-     * @return \ASN1\Type\Primitive\Real
-     */
-    public function asReal(): Primitive\Real
-    {
-        if (!$this->_element instanceof Primitive\Real) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_REAL));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as an enumerated type.
-     *
-     * @throws \UnexpectedValueException If the element is not an enumerated
-     * @return \ASN1\Type\Primitive\Enumerated
-     */
-    public function asEnumerated(): Primitive\Enumerated
-    {
-        if (!$this->_element instanceof Primitive\Enumerated) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_ENUMERATED));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a UTF8 string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a UTF8 string
-     * @return \ASN1\Type\Primitive\UTF8String
-     */
-    public function asUTF8String(): Primitive\UTF8String
-    {
-        if (!$this->_element instanceof Primitive\UTF8String) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_UTF8_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a relative OID type.
-     *
-     * @throws \UnexpectedValueException If the element is not a relative OID
-     * @return \ASN1\Type\Primitive\RelativeOID
-     */
-    public function asRelativeOID(): Primitive\RelativeOID
-    {
-        if (!$this->_element instanceof Primitive\RelativeOID) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_RELATIVE_OID));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a sequence type.
-     *
-     * @throws \UnexpectedValueException If the element is not a sequence
-     * @return \ASN1\Type\Constructed\Sequence
-     */
-    public function asSequence(): Constructed\Sequence
-    {
-        if (!$this->_element instanceof Constructed\Sequence) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_SEQUENCE));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a set type.
-     *
-     * @throws \UnexpectedValueException If the element is not a set
-     * @return \ASN1\Type\Constructed\Set
-     */
-    public function asSet(): Constructed\Set
-    {
-        if (!$this->_element instanceof Constructed\Set) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_SET));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a numeric string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a numeric string
-     * @return \ASN1\Type\Primitive\NumericString
-     */
-    public function asNumericString(): Primitive\NumericString
-    {
-        if (!$this->_element instanceof Primitive\NumericString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_NUMERIC_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a printable string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a printable
-     *         string
-     * @return \ASN1\Type\Primitive\PrintableString
-     */
-    public function asPrintableString(): Primitive\PrintableString
-    {
-        if (!$this->_element instanceof Primitive\PrintableString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_PRINTABLE_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a T61 string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a T61 string
-     * @return \ASN1\Type\Primitive\T61String
-     */
-    public function asT61String(): Primitive\T61String
-    {
-        if (!$this->_element instanceof Primitive\T61String) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_T61_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a videotex string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a videotex string
-     * @return \ASN1\Type\Primitive\VideotexString
-     */
-    public function asVideotexString(): Primitive\VideotexString
-    {
-        if (!$this->_element instanceof Primitive\VideotexString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_VIDEOTEX_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a IA5 string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a IA5 string
-     * @return \ASN1\Type\Primitive\IA5String
-     */
-    public function asIA5String(): Primitive\IA5String
-    {
-        if (!$this->_element instanceof Primitive\IA5String) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_IA5_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as an UTC time type.
-     *
-     * @throws \UnexpectedValueException If the element is not a UTC time
-     * @return \ASN1\Type\Primitive\UTCTime
-     */
-    public function asUTCTime(): Primitive\UTCTime
-    {
-        if (!$this->_element instanceof Primitive\UTCTime) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_UTC_TIME));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a generalized time type.
-     *
-     * @throws \UnexpectedValueException If the element is not a generalized
-     *         time
-     * @return \ASN1\Type\Primitive\GeneralizedTime
-     */
-    public function asGeneralizedTime(): Primitive\GeneralizedTime
-    {
-        if (!$this->_element instanceof Primitive\GeneralizedTime) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_GENERALIZED_TIME));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a graphic string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a graphic string
-     * @return \ASN1\Type\Primitive\GraphicString
-     */
-    public function asGraphicString(): Primitive\GraphicString
-    {
-        if (!$this->_element instanceof Primitive\GraphicString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_GRAPHIC_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a visible string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a visible string
-     * @return \ASN1\Type\Primitive\VisibleString
-     */
-    public function asVisibleString(): Primitive\VisibleString
-    {
-        if (!$this->_element instanceof Primitive\VisibleString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_VISIBLE_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a general string type.
-     *
-     * @throws \UnexpectedValueException If the element is not general string
-     * @return \ASN1\Type\Primitive\GeneralString
-     */
-    public function asGeneralString(): Primitive\GeneralString
-    {
-        if (!$this->_element instanceof Primitive\GeneralString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_GENERAL_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a universal string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a universal
-     *         string
-     * @return \ASN1\Type\Primitive\UniversalString
-     */
-    public function asUniversalString(): Primitive\UniversalString
-    {
-        if (!$this->_element instanceof Primitive\UniversalString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_UNIVERSAL_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a character string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a character
-     *         string
-     * @return \ASN1\Type\Primitive\CharacterString
-     */
-    public function asCharacterString(): Primitive\CharacterString
-    {
-        if (!$this->_element instanceof Primitive\CharacterString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_CHARACTER_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a BMP string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a bmp string
-     * @return \ASN1\Type\Primitive\BMPString
-     */
-    public function asBMPString(): Primitive\BMPString
-    {
-        if (!$this->_element instanceof Primitive\BMPString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_BMP_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as a constructed string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a constructed
-     *         string
-     * @return Constructed\ConstructedString
-     */
-    public function asConstructedString(): Constructed\ConstructedString
-    {
-        if (!$this->_element instanceof Constructed\ConstructedString) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(
-                    Element::TYPE_CONSTRUCTED_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as any string type.
-     *
-     * @throws \UnexpectedValueException If the element is not a string
-     * @return StringType
-     */
-    public function asString(): StringType
-    {
-        if (!$this->_element instanceof StringType) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_STRING));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Get the wrapped element as any time type.
-     *
-     * @throws \UnexpectedValueException If the element is not a time
-     * @return TimeType
-     */
-    public function asTime(): TimeType
-    {
-        if (!$this->_element instanceof TimeType) {
-            throw new \UnexpectedValueException(
-                $this->_generateExceptionMessage(Element::TYPE_TIME));
-        }
-        return $this->_element;
-    }
-    
-    /**
-     * Generate message for exceptions thrown by <code>as*</code> methods.
-     *
-     * @param int $tag Type tag of the expected element
-     * @return string
-     */
-    private function _generateExceptionMessage(int $tag): string
-    {
-        return sprintf("%s expected, got %s.", Element::tagToName($tag),
-            $this->_typeDescriptorString());
-    }
-    
-    /**
-     * Get textual description of the wrapped element for debugging purposes.
-     *
-     * @return string
-     */
-    private function _typeDescriptorString(): string
-    {
-        $type_cls = $this->_element->typeClass();
-        $tag = $this->_element->tag();
-        if ($type_cls == Identifier::CLASS_UNIVERSAL) {
-            return Element::tagToName($tag);
-        }
-        return Identifier::classToName($type_cls) . " TAG $tag";
-    }
-    
-    /**
-     *
-     * @see \ASN1\Feature\Encodable::toDER()
-     * @return string
-     */
-    public function toDER(): string
-    {
-        return $this->_element->toDER();
-    }
-    
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::typeClass()
-     * @return int
-     */
-    public function typeClass(): int
-    {
-        return $this->_element->typeClass();
-    }
-    
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::isConstructed()
-     * @return bool
-     */
-    public function isConstructed(): bool
-    {
-        return $this->_element->isConstructed();
-    }
-    
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::tag()
-     * @return int
-     */
-    public function tag(): int
-    {
-        return $this->_element->tag();
-    }
-    
-    /**
-     *
-     * {@inheritdoc}
-     * @see \ASN1\Feature\ElementBase::isType()
-     * @return bool
-     */
-    public function isType(int $tag): bool
-    {
-        return $this->_element->isType($tag);
-    }
-    
-    /**
-     *
-     * @deprecated Use any <code>as*</code> accessor method first to ensure
-     *             type strictness.
-     * @see \ASN1\Feature\ElementBase::expectType()
-     * @return ElementBase
-     */
-    public function expectType(int $tag): ElementBase
-    {
-        return $this->_element->expectType($tag);
-    }
-    
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::isTagged()
-     * @return bool
-     */
-    public function isTagged(): bool
-    {
-        return $this->_element->isTagged();
-    }
-    
-    /**
-     *
-     * @deprecated Use any <code>as*</code> accessor method first to ensure
-     *             type strictness.
-     * @see \ASN1\Feature\ElementBase::expectTagged()
-     * @return TaggedType
-     */
-    public function expectTagged($tag = null): TaggedType
-    {
-        return $this->_element->expectTagged($tag);
-    }
-    
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::asElement()
-     * @return Element
-     */
-    public function asElement(): Element
-    {
-        return $this->_element;
-    }
-    
-    /**
-     *
-     * {@inheritdoc}
-     * @return UnspecifiedType
-     */
-    public function asUnspecified(): UnspecifiedType
-    {
-        return $this;
-    }
+	/**
+	 * The wrapped element.
+	 *
+	 * @var Element
+	 */
+	private $_element;
+    
+	/**
+	 * Constructor.
+	 *
+	 * @param Element $el
+	 */
+	public function __construct(Element $el)
+	{
+		$this->_element = $el;
+	}
+    
+	/**
+	 * Initialize from DER data.
+	 *
+	 * @param string $data DER encoded data
+	 * @return self
+	 */
+	public static function fromDER(string $data): self
+	{
+		return Element::fromDER($data)->asUnspecified();
+	}
+    
+	/**
+	 * Initialize from ElementBase interface.
+	 *
+	 * @param ElementBase $el
+	 * @return self
+	 */
+	public static function fromElementBase(ElementBase $el): self
+	{
+		// if element is already wrapped
+		if ($el instanceof self) {
+			return $el;
+		}
+		return new self($el->asElement());
+	}
+    
+	/**
+	 * Compatibility method to dispatch calls to the wrapped element.
+	 *
+	 * @deprecated Use <code>as*</code> accessor methods to ensure strict type
+	 * @param string $mtd Method name
+	 * @param array $args Arguments
+	 * @return mixed
+	 */
+	public function __call($mtd, array $args)
+	{
+		return call_user_func_array([$this->_element, $mtd], $args);
+	}
+    
+	/**
+	 * Get the wrapped element as a context specific tagged type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not tagged
+	 * @return TaggedType
+	 */
+	public function asTagged(): TaggedType
+	{
+		if (!$this->_element instanceof TaggedType) {
+			throw new \UnexpectedValueException(
+				"Tagged element expected, got " . $this->_typeDescriptorString());
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as an application specific type.
+	 *
+	 * @throws \UnexpectedValueException If element is not application specific
+	 * @return \ASN1\Type\Tagged\ApplicationType
+	 */
+	public function asApplication(): Tagged\ApplicationType
+	{
+		if (!$this->_element instanceof Tagged\ApplicationType) {
+			throw new \UnexpectedValueException(
+				"Application type expected, got " .
+				$this->_typeDescriptorString());
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a private tagged type.
+	 *
+	 * @throws \UnexpectedValueException If element is not using private tagging
+	 * @return \ASN1\Type\Tagged\PrivateType
+	 */
+	public function asPrivate(): Tagged\PrivateType
+	{
+		if (!$this->_element instanceof Tagged\PrivateType) {
+			throw new \UnexpectedValueException(
+				"Private type expected, got " . $this->_typeDescriptorString());
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a boolean type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a boolean
+	 * @return \ASN1\Type\Primitive\Boolean
+	 */
+	public function asBoolean(): Primitive\Boolean
+	{
+		if (!$this->_element instanceof Primitive\Boolean) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_BOOLEAN));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as an integer type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not an integer
+	 * @return \ASN1\Type\Primitive\Integer
+	 */
+	public function asInteger(): Primitive\Integer
+	{
+		if (!$this->_element instanceof Primitive\Integer) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_INTEGER));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a bit string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a bit string
+	 * @return \ASN1\Type\Primitive\BitString
+	 */
+	public function asBitString(): Primitive\BitString
+	{
+		if (!$this->_element instanceof Primitive\BitString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_BIT_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as an octet string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not an octet string
+	 * @return \ASN1\Type\Primitive\OctetString
+	 */
+	public function asOctetString(): Primitive\OctetString
+	{
+		if (!$this->_element instanceof Primitive\OctetString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_OCTET_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a null type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a null
+	 * @return \ASN1\Type\Primitive\NullType
+	 */
+	public function asNull(): Primitive\NullType
+	{
+		if (!$this->_element instanceof Primitive\NullType) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_NULL));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as an object identifier type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not an object
+	 *         identifier
+	 * @return \ASN1\Type\Primitive\ObjectIdentifier
+	 */
+	public function asObjectIdentifier(): Primitive\ObjectIdentifier
+	{
+		if (!$this->_element instanceof Primitive\ObjectIdentifier) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(
+					Element::TYPE_OBJECT_IDENTIFIER));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as an object descriptor type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not an object
+	 *         descriptor
+	 * @return \ASN1\Type\Primitive\ObjectDescriptor
+	 */
+	public function asObjectDescriptor(): Primitive\ObjectDescriptor
+	{
+		if (!$this->_element instanceof Primitive\ObjectDescriptor) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(
+					Element::TYPE_OBJECT_DESCRIPTOR));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a real type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a real
+	 * @return \ASN1\Type\Primitive\Real
+	 */
+	public function asReal(): Primitive\Real
+	{
+		if (!$this->_element instanceof Primitive\Real) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_REAL));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as an enumerated type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not an enumerated
+	 * @return \ASN1\Type\Primitive\Enumerated
+	 */
+	public function asEnumerated(): Primitive\Enumerated
+	{
+		if (!$this->_element instanceof Primitive\Enumerated) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_ENUMERATED));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a UTF8 string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a UTF8 string
+	 * @return \ASN1\Type\Primitive\UTF8String
+	 */
+	public function asUTF8String(): Primitive\UTF8String
+	{
+		if (!$this->_element instanceof Primitive\UTF8String) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_UTF8_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a relative OID type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a relative OID
+	 * @return \ASN1\Type\Primitive\RelativeOID
+	 */
+	public function asRelativeOID(): Primitive\RelativeOID
+	{
+		if (!$this->_element instanceof Primitive\RelativeOID) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_RELATIVE_OID));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a sequence type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a sequence
+	 * @return \ASN1\Type\Constructed\Sequence
+	 */
+	public function asSequence(): Constructed\Sequence
+	{
+		if (!$this->_element instanceof Constructed\Sequence) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_SEQUENCE));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a set type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a set
+	 * @return \ASN1\Type\Constructed\Set
+	 */
+	public function asSet(): Constructed\Set
+	{
+		if (!$this->_element instanceof Constructed\Set) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_SET));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a numeric string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a numeric string
+	 * @return \ASN1\Type\Primitive\NumericString
+	 */
+	public function asNumericString(): Primitive\NumericString
+	{
+		if (!$this->_element instanceof Primitive\NumericString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_NUMERIC_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a printable string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a printable
+	 *         string
+	 * @return \ASN1\Type\Primitive\PrintableString
+	 */
+	public function asPrintableString(): Primitive\PrintableString
+	{
+		if (!$this->_element instanceof Primitive\PrintableString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_PRINTABLE_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a T61 string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a T61 string
+	 * @return \ASN1\Type\Primitive\T61String
+	 */
+	public function asT61String(): Primitive\T61String
+	{
+		if (!$this->_element instanceof Primitive\T61String) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_T61_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a videotex string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a videotex string
+	 * @return \ASN1\Type\Primitive\VideotexString
+	 */
+	public function asVideotexString(): Primitive\VideotexString
+	{
+		if (!$this->_element instanceof Primitive\VideotexString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_VIDEOTEX_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a IA5 string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a IA5 string
+	 * @return \ASN1\Type\Primitive\IA5String
+	 */
+	public function asIA5String(): Primitive\IA5String
+	{
+		if (!$this->_element instanceof Primitive\IA5String) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_IA5_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as an UTC time type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a UTC time
+	 * @return \ASN1\Type\Primitive\UTCTime
+	 */
+	public function asUTCTime(): Primitive\UTCTime
+	{
+		if (!$this->_element instanceof Primitive\UTCTime) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_UTC_TIME));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a generalized time type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a generalized
+	 *         time
+	 * @return \ASN1\Type\Primitive\GeneralizedTime
+	 */
+	public function asGeneralizedTime(): Primitive\GeneralizedTime
+	{
+		if (!$this->_element instanceof Primitive\GeneralizedTime) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_GENERALIZED_TIME));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a graphic string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a graphic string
+	 * @return \ASN1\Type\Primitive\GraphicString
+	 */
+	public function asGraphicString(): Primitive\GraphicString
+	{
+		if (!$this->_element instanceof Primitive\GraphicString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_GRAPHIC_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a visible string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a visible string
+	 * @return \ASN1\Type\Primitive\VisibleString
+	 */
+	public function asVisibleString(): Primitive\VisibleString
+	{
+		if (!$this->_element instanceof Primitive\VisibleString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_VISIBLE_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a general string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not general string
+	 * @return \ASN1\Type\Primitive\GeneralString
+	 */
+	public function asGeneralString(): Primitive\GeneralString
+	{
+		if (!$this->_element instanceof Primitive\GeneralString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_GENERAL_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a universal string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a universal
+	 *         string
+	 * @return \ASN1\Type\Primitive\UniversalString
+	 */
+	public function asUniversalString(): Primitive\UniversalString
+	{
+		if (!$this->_element instanceof Primitive\UniversalString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_UNIVERSAL_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a character string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a character
+	 *         string
+	 * @return \ASN1\Type\Primitive\CharacterString
+	 */
+	public function asCharacterString(): Primitive\CharacterString
+	{
+		if (!$this->_element instanceof Primitive\CharacterString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_CHARACTER_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a BMP string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a bmp string
+	 * @return \ASN1\Type\Primitive\BMPString
+	 */
+	public function asBMPString(): Primitive\BMPString
+	{
+		if (!$this->_element instanceof Primitive\BMPString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_BMP_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as a constructed string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a constructed
+	 *         string
+	 * @return Constructed\ConstructedString
+	 */
+	public function asConstructedString(): Constructed\ConstructedString
+	{
+		if (!$this->_element instanceof Constructed\ConstructedString) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(
+					Element::TYPE_CONSTRUCTED_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as any string type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a string
+	 * @return StringType
+	 */
+	public function asString(): StringType
+	{
+		if (!$this->_element instanceof StringType) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_STRING));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Get the wrapped element as any time type.
+	 *
+	 * @throws \UnexpectedValueException If the element is not a time
+	 * @return TimeType
+	 */
+	public function asTime(): TimeType
+	{
+		if (!$this->_element instanceof TimeType) {
+			throw new \UnexpectedValueException(
+				$this->_generateExceptionMessage(Element::TYPE_TIME));
+		}
+		return $this->_element;
+	}
+    
+	/**
+	 * Generate message for exceptions thrown by <code>as*</code> methods.
+	 *
+	 * @param int $tag Type tag of the expected element
+	 * @return string
+	 */
+	private function _generateExceptionMessage(int $tag): string
+	{
+		return sprintf("%s expected, got %s.", Element::tagToName($tag),
+			$this->_typeDescriptorString());
+	}
+    
+	/**
+	 * Get textual description of the wrapped element for debugging purposes.
+	 *
+	 * @return string
+	 */
+	private function _typeDescriptorString(): string
+	{
+		$type_cls = $this->_element->typeClass();
+		$tag = $this->_element->tag();
+		if ($type_cls == Identifier::CLASS_UNIVERSAL) {
+			return Element::tagToName($tag);
+		}
+		return Identifier::classToName($type_cls) . " TAG $tag";
+	}
+    
+	/**
+	 *
+	 * @see \ASN1\Feature\Encodable::toDER()
+	 * @return string
+	 */
+	public function toDER(): string
+	{
+		return $this->_element->toDER();
+	}
+    
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::typeClass()
+	 * @return int
+	 */
+	public function typeClass(): int
+	{
+		return $this->_element->typeClass();
+	}
+    
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::isConstructed()
+	 * @return bool
+	 */
+	public function isConstructed(): bool
+	{
+		return $this->_element->isConstructed();
+	}
+    
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::tag()
+	 * @return int
+	 */
+	public function tag(): int
+	{
+		return $this->_element->tag();
+	}
+    
+	/**
+	 *
+	 * {@inheritdoc}
+	 * @see \ASN1\Feature\ElementBase::isType()
+	 * @return bool
+	 */
+	public function isType(int $tag): bool
+	{
+		return $this->_element->isType($tag);
+	}
+    
+	/**
+	 *
+	 * @deprecated Use any <code>as*</code> accessor method first to ensure
+	 *             type strictness.
+	 * @see \ASN1\Feature\ElementBase::expectType()
+	 * @return ElementBase
+	 */
+	public function expectType(int $tag): ElementBase
+	{
+		return $this->_element->expectType($tag);
+	}
+    
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::isTagged()
+	 * @return bool
+	 */
+	public function isTagged(): bool
+	{
+		return $this->_element->isTagged();
+	}
+    
+	/**
+	 *
+	 * @deprecated Use any <code>as*</code> accessor method first to ensure
+	 *             type strictness.
+	 * @see \ASN1\Feature\ElementBase::expectTagged()
+	 * @return TaggedType
+	 */
+	public function expectTagged($tag = null): TaggedType
+	{
+		return $this->_element->expectTagged($tag);
+	}
+    
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::asElement()
+	 * @return Element
+	 */
+	public function asElement(): Element
+	{
+		return $this->_element;
+	}
+    
+	/**
+	 *
+	 * {@inheritdoc}
+	 * @return UnspecifiedType
+	 */
+	public function asUnspecified(): UnspecifiedType
+	{
+		return $this;
+	}
 }

lib/ASN1/Type/Constructed/ConstructedString.php

Indentation +101 added lines, -101 removed lines

@@ -15,112 +15,112 @@
  */
 class ConstructedString extends Structure implements Stringable
 {
-    /**
-     * Constructor.
-     *
-     * @internal Use create()
-     *          
-     * @param Element ...$elements Any number of elements
-     */
-    public function __construct(Element ...$elements)
-    {
-        parent::__construct(...$elements);
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @internal Use create()
+	 *          
+	 * @param Element ...$elements Any number of elements
+	 */
+	public function __construct(Element ...$elements)
+	{
+		parent::__construct(...$elements);
+	}
     
-    /**
-     * Create from a list of string type elements
-     *
-     * All strings must have the same type.
-     *
-     * @param StringType ...$elements
-     * @throws \LogicException
-     * @return self
-     */
-    public static function create(StringType ...$elements): self
-    {
-        if (!count($elements)) {
-            throw new \LogicException(
-                'No elements, unable to determine type tag.');
-        }
-        $tag = $elements[0]->tag();
-        foreach ($elements as $el) {
-            if ($el->tag() !== $tag) {
-                throw new \LogicException(
-                    'All elements in constructed string must have the same type.');
-            }
-        }
-        return self::createWithTag($tag, ...$elements);
-    }
+	/**
+	 * Create from a list of string type elements
+	 *
+	 * All strings must have the same type.
+	 *
+	 * @param StringType ...$elements
+	 * @throws \LogicException
+	 * @return self
+	 */
+	public static function create(StringType ...$elements): self
+	{
+		if (!count($elements)) {
+			throw new \LogicException(
+				'No elements, unable to determine type tag.');
+		}
+		$tag = $elements[0]->tag();
+		foreach ($elements as $el) {
+			if ($el->tag() !== $tag) {
+				throw new \LogicException(
+					'All elements in constructed string must have the same type.');
+			}
+		}
+		return self::createWithTag($tag, ...$elements);
+	}
     
-    /**
-     * Create from strings with a given type tag.
-     *
-     * @param int $tag Type tag for the constructed string element
-     * @param StringType ...$elements Any number of elements
-     * @return self
-     */
-    public static function createWithTag(int $tag, StringType ...$elements)
-    {
-        $el = new self(...$elements);
-        $el->_typeTag = $tag;
-        return $el;
-    }
+	/**
+	 * Create from strings with a given type tag.
+	 *
+	 * @param int $tag Type tag for the constructed string element
+	 * @param StringType ...$elements Any number of elements
+	 * @return self
+	 */
+	public static function createWithTag(int $tag, StringType ...$elements)
+	{
+		$el = new self(...$elements);
+		$el->_typeTag = $tag;
+		return $el;
+	}
     
-    /**
-     * Get a list of strings in this structure.
-     *
-     * @return string[]
-     */
-    public function strings(): array
-    {
-        return array_map(function (StringType $el) {
-            return $el->string();
-        }, $this->_elements);
-    }
+	/**
+	 * Get a list of strings in this structure.
+	 *
+	 * @return string[]
+	 */
+	public function strings(): array
+	{
+		return array_map(function (StringType $el) {
+			return $el->string();
+		}, $this->_elements);
+	}
     
-    /**
-     * Get the contained strings concatenated together.
-     *
-     * @return string
-     */
-    public function concatenated(): string
-    {
-        return implode('', $this->strings());
-    }
+	/**
+	 * Get the contained strings concatenated together.
+	 *
+	 * @return string
+	 */
+	public function concatenated(): string
+	{
+		return implode('', $this->strings());
+	}
     
-    /**
-     * Get the contained strings concatenated together.
-     *
-     * @return string
-     */
-    public function string(): string
-    {
-        return $this->concatenated();
-    }
+	/**
+	 * Get the contained strings concatenated together.
+	 *
+	 * @return string
+	 */
+	public function string(): string
+	{
+		return $this->concatenated();
+	}
     
-    /**
-     *
-     * @inheritdoc
-     * @return string
-     */
-    public function __toString(): string
-    {
-        return $this->concatenated();
-    }
+	/**
+	 *
+	 * @inheritdoc
+	 * @return string
+	 */
+	public function __toString(): string
+	{
+		return $this->concatenated();
+	}
     
-    /**
-     *
-     * {@inheritdoc}
-     *
-     * @return self
-     */
-    protected static function _decodeFromDER(Identifier $identifier,
-        string $data, int &$offset): ElementBase
-    {
-        /** @var ConstructedString $type */
-        $type = forward_static_call_array([parent::class, __FUNCTION__],
-            [$identifier, $data, &$offset]);
-        $type->_typeTag = $identifier->intTag();
-        return $type;
-    }
+	/**
+	 *
+	 * {@inheritdoc}
+	 *
+	 * @return self
+	 */
+	protected static function _decodeFromDER(Identifier $identifier,
+		string $data, int &$offset): ElementBase
+	{
+		/** @var ConstructedString $type */
+		$type = forward_static_call_array([parent::class, __FUNCTION__],
+			[$identifier, $data, &$offset]);
+		$type->_typeTag = $identifier->intTag();
+		return $type;
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -1,5 +1,5 @@ 
 <?php
-declare(strict_types = 1);
+declare(strict_types=1);
 
 namespace ASN1\Type\Constructed;
 
@@ -73,7 +73,7 @@ 
      */
     public function strings(): array
     {
-        return array_map(function (StringType $el) {
+        return array_map(function(StringType $el) {
             return $el->string();
         }, $this->_elements);
     }

lib/ASN1/Type/StringType.php

Indentation +50 added lines, -50 removed lines

@@ -11,58 +11,58 @@
  */
 abstract class StringType extends Element implements Stringable
 {
-    /**
-     * String value.
-     *
-     * @var string $_string
-     */
-    protected $_string;
+	/**
+	 * String value.
+	 *
+	 * @var string $_string
+	 */
+	protected $_string;
     
-    /**
-     * Constructor.
-     *
-     * @param string $string
-     * @throws \InvalidArgumentException
-     */
-    public function __construct(string $string)
-    {
-        if (!$this->_validateString($string)) {
-            throw new \InvalidArgumentException(
-                sprintf("Not a valid %s string.",
-                    self::tagToName($this->_typeTag)));
-        }
-        $this->_string = $string;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param string $string
+	 * @throws \InvalidArgumentException
+	 */
+	public function __construct(string $string)
+	{
+		if (!$this->_validateString($string)) {
+			throw new \InvalidArgumentException(
+				sprintf("Not a valid %s string.",
+					self::tagToName($this->_typeTag)));
+		}
+		$this->_string = $string;
+	}
     
-    /**
-     * Get the string value.
-     *
-     * @return string
-     */
-    public function string(): string
-    {
-        return $this->_string;
-    }
+	/**
+	 * Get the string value.
+	 *
+	 * @return string
+	 */
+	public function string(): string
+	{
+		return $this->_string;
+	}
     
-    /**
-     *
-     * @inheritdoc
-     * @return string
-     */
-    public function __toString(): string
-    {
-        return $this->_string;
-    }
+	/**
+	 *
+	 * @inheritdoc
+	 * @return string
+	 */
+	public function __toString(): string
+	{
+		return $this->_string;
+	}
     
-    /**
-     * Check whether string is valid for the concrete type.
-     *
-     * @param string $string
-     * @return bool
-     */
-    protected function _validateString(string $string): bool
-    {
-        // Override in derived classes
-        return true;
-    }
+	/**
+	 * Check whether string is valid for the concrete type.
+	 *
+	 * @param string $string
+	 * @return bool
+	 */
+	protected function _validateString(string $string): bool
+	{
+		// Override in derived classes
+		return true;
+	}
 }

lib/ASN1/Element.php

Indentation +463 added lines, -463 removed lines

@@ -24,495 +24,495 @@
  */
 abstract class Element implements ElementBase
 {
-    // Universal type tags
-    const TYPE_EOC = 0x00;
-    const TYPE_BOOLEAN = 0x01;
-    const TYPE_INTEGER = 0x02;
-    const TYPE_BIT_STRING = 0x03;
-    const TYPE_OCTET_STRING = 0x04;
-    const TYPE_NULL = 0x05;
-    const TYPE_OBJECT_IDENTIFIER = 0x06;
-    const TYPE_OBJECT_DESCRIPTOR = 0x07;
-    const TYPE_EXTERNAL = 0x08;
-    const TYPE_REAL = 0x09;
-    const TYPE_ENUMERATED = 0x0a;
-    const TYPE_EMBEDDED_PDV = 0x0b;
-    const TYPE_UTF8_STRING = 0x0c;
-    const TYPE_RELATIVE_OID = 0x0d;
-    const TYPE_SEQUENCE = 0x10;
-    const TYPE_SET = 0x11;
-    const TYPE_NUMERIC_STRING = 0x12;
-    const TYPE_PRINTABLE_STRING = 0x13;
-    const TYPE_T61_STRING = 0x14;
-    const TYPE_VIDEOTEX_STRING = 0x15;
-    const TYPE_IA5_STRING = 0x16;
-    const TYPE_UTC_TIME = 0x17;
-    const TYPE_GENERALIZED_TIME = 0x18;
-    const TYPE_GRAPHIC_STRING = 0x19;
-    const TYPE_VISIBLE_STRING = 0x1a;
-    const TYPE_GENERAL_STRING = 0x1b;
-    const TYPE_UNIVERSAL_STRING = 0x1c;
-    const TYPE_CHARACTER_STRING = 0x1d;
-    const TYPE_BMP_STRING = 0x1e;
+	// Universal type tags
+	const TYPE_EOC = 0x00;
+	const TYPE_BOOLEAN = 0x01;
+	const TYPE_INTEGER = 0x02;
+	const TYPE_BIT_STRING = 0x03;
+	const TYPE_OCTET_STRING = 0x04;
+	const TYPE_NULL = 0x05;
+	const TYPE_OBJECT_IDENTIFIER = 0x06;
+	const TYPE_OBJECT_DESCRIPTOR = 0x07;
+	const TYPE_EXTERNAL = 0x08;
+	const TYPE_REAL = 0x09;
+	const TYPE_ENUMERATED = 0x0a;
+	const TYPE_EMBEDDED_PDV = 0x0b;
+	const TYPE_UTF8_STRING = 0x0c;
+	const TYPE_RELATIVE_OID = 0x0d;
+	const TYPE_SEQUENCE = 0x10;
+	const TYPE_SET = 0x11;
+	const TYPE_NUMERIC_STRING = 0x12;
+	const TYPE_PRINTABLE_STRING = 0x13;
+	const TYPE_T61_STRING = 0x14;
+	const TYPE_VIDEOTEX_STRING = 0x15;
+	const TYPE_IA5_STRING = 0x16;
+	const TYPE_UTC_TIME = 0x17;
+	const TYPE_GENERALIZED_TIME = 0x18;
+	const TYPE_GRAPHIC_STRING = 0x19;
+	const TYPE_VISIBLE_STRING = 0x1a;
+	const TYPE_GENERAL_STRING = 0x1b;
+	const TYPE_UNIVERSAL_STRING = 0x1c;
+	const TYPE_CHARACTER_STRING = 0x1d;
+	const TYPE_BMP_STRING = 0x1e;
     
-    /**
-     * Mapping from universal type tag to implementation class name.
-     *
-     * @internal
-     *
-     * @var array
-     */
-    const MAP_TAG_TO_CLASS = [ /* @formatter:off */
-        self::TYPE_EOC => Primitive\EOC::class,
-        self::TYPE_BOOLEAN => Primitive\Boolean::class,
-        self::TYPE_INTEGER => Primitive\Integer::class,
-        self::TYPE_BIT_STRING => Primitive\BitString::class,
-        self::TYPE_OCTET_STRING => Primitive\OctetString::class,
-        self::TYPE_NULL => Primitive\NullType::class,
-        self::TYPE_OBJECT_IDENTIFIER => Primitive\ObjectIdentifier::class,
-        self::TYPE_OBJECT_DESCRIPTOR => Primitive\ObjectDescriptor::class,
-        self::TYPE_REAL => Primitive\Real::class,
-        self::TYPE_ENUMERATED => Primitive\Enumerated::class,
-        self::TYPE_UTF8_STRING => Primitive\UTF8String::class,
-        self::TYPE_RELATIVE_OID => Primitive\RelativeOID::class,
-        self::TYPE_SEQUENCE => Constructed\Sequence::class,
-        self::TYPE_SET => Constructed\Set::class,
-        self::TYPE_NUMERIC_STRING => Primitive\NumericString::class,
-        self::TYPE_PRINTABLE_STRING => Primitive\PrintableString::class,
-        self::TYPE_T61_STRING => Primitive\T61String::class,
-        self::TYPE_VIDEOTEX_STRING => Primitive\VideotexString::class,
-        self::TYPE_IA5_STRING => Primitive\IA5String::class,
-        self::TYPE_UTC_TIME => Primitive\UTCTime::class,
-        self::TYPE_GENERALIZED_TIME => Primitive\GeneralizedTime::class,
-        self::TYPE_GRAPHIC_STRING => Primitive\GraphicString::class,
-        self::TYPE_VISIBLE_STRING => Primitive\VisibleString::class,
-        self::TYPE_GENERAL_STRING => Primitive\GeneralString::class,
-        self::TYPE_UNIVERSAL_STRING => Primitive\UniversalString::class,
-        self::TYPE_CHARACTER_STRING => Primitive\CharacterString::class,
-        self::TYPE_BMP_STRING => Primitive\BMPString::class
-        /* @formatter:on */
-    ];
+	/**
+	 * Mapping from universal type tag to implementation class name.
+	 *
+	 * @internal
+	 *
+	 * @var array
+	 */
+	const MAP_TAG_TO_CLASS = [ /* @formatter:off */
+		self::TYPE_EOC => Primitive\EOC::class,
+		self::TYPE_BOOLEAN => Primitive\Boolean::class,
+		self::TYPE_INTEGER => Primitive\Integer::class,
+		self::TYPE_BIT_STRING => Primitive\BitString::class,
+		self::TYPE_OCTET_STRING => Primitive\OctetString::class,
+		self::TYPE_NULL => Primitive\NullType::class,
+		self::TYPE_OBJECT_IDENTIFIER => Primitive\ObjectIdentifier::class,
+		self::TYPE_OBJECT_DESCRIPTOR => Primitive\ObjectDescriptor::class,
+		self::TYPE_REAL => Primitive\Real::class,
+		self::TYPE_ENUMERATED => Primitive\Enumerated::class,
+		self::TYPE_UTF8_STRING => Primitive\UTF8String::class,
+		self::TYPE_RELATIVE_OID => Primitive\RelativeOID::class,
+		self::TYPE_SEQUENCE => Constructed\Sequence::class,
+		self::TYPE_SET => Constructed\Set::class,
+		self::TYPE_NUMERIC_STRING => Primitive\NumericString::class,
+		self::TYPE_PRINTABLE_STRING => Primitive\PrintableString::class,
+		self::TYPE_T61_STRING => Primitive\T61String::class,
+		self::TYPE_VIDEOTEX_STRING => Primitive\VideotexString::class,
+		self::TYPE_IA5_STRING => Primitive\IA5String::class,
+		self::TYPE_UTC_TIME => Primitive\UTCTime::class,
+		self::TYPE_GENERALIZED_TIME => Primitive\GeneralizedTime::class,
+		self::TYPE_GRAPHIC_STRING => Primitive\GraphicString::class,
+		self::TYPE_VISIBLE_STRING => Primitive\VisibleString::class,
+		self::TYPE_GENERAL_STRING => Primitive\GeneralString::class,
+		self::TYPE_UNIVERSAL_STRING => Primitive\UniversalString::class,
+		self::TYPE_CHARACTER_STRING => Primitive\CharacterString::class,
+		self::TYPE_BMP_STRING => Primitive\BMPString::class
+		/* @formatter:on */
+	];
     
-    /**
-     * Pseudotype for all string types.
-     *
-     * May be used as an expectation parameter.
-     *
-     * @var int
-     */
-    const TYPE_STRING = -1;
+	/**
+	 * Pseudotype for all string types.
+	 *
+	 * May be used as an expectation parameter.
+	 *
+	 * @var int
+	 */
+	const TYPE_STRING = -1;
     
-    /**
-     * Pseudotype for all time types.
-     *
-     * May be used as an expectation parameter.
-     *
-     * @var int
-     */
-    const TYPE_TIME = -2;
+	/**
+	 * Pseudotype for all time types.
+	 *
+	 * May be used as an expectation parameter.
+	 *
+	 * @var int
+	 */
+	const TYPE_TIME = -2;
     
-    /**
-     * Pseudotype for constructed strings.
-     *
-     * May be used as an expectation parameter.
-     *
-     * @var int
-     */
-    const TYPE_CONSTRUCTED_STRING = -3;
+	/**
+	 * Pseudotype for constructed strings.
+	 *
+	 * May be used as an expectation parameter.
+	 *
+	 * @var int
+	 */
+	const TYPE_CONSTRUCTED_STRING = -3;
     
-    /**
-     * Mapping from universal type tag to human readable name.
-     *
-     * @internal
-     *
-     * @var array
-     */
-    const MAP_TYPE_TO_NAME = [ /* @formatter:off */
-        self::TYPE_EOC => "EOC",
-        self::TYPE_BOOLEAN => "BOOLEAN",
-        self::TYPE_INTEGER => "INTEGER",
-        self::TYPE_BIT_STRING => "BIT STRING",
-        self::TYPE_OCTET_STRING => "OCTET STRING",
-        self::TYPE_NULL => "NULL",
-        self::TYPE_OBJECT_IDENTIFIER => "OBJECT IDENTIFIER",
-        self::TYPE_OBJECT_DESCRIPTOR => "ObjectDescriptor",
-        self::TYPE_EXTERNAL => "EXTERNAL",
-        self::TYPE_REAL => "REAL",
-        self::TYPE_ENUMERATED => "ENUMERATED",
-        self::TYPE_EMBEDDED_PDV => "EMBEDDED PDV",
-        self::TYPE_UTF8_STRING => "UTF8String",
-        self::TYPE_RELATIVE_OID => "RELATIVE-OID",
-        self::TYPE_SEQUENCE => "SEQUENCE",
-        self::TYPE_SET => "SET",
-        self::TYPE_NUMERIC_STRING => "NumericString",
-        self::TYPE_PRINTABLE_STRING => "PrintableString",
-        self::TYPE_T61_STRING => "T61String",
-        self::TYPE_VIDEOTEX_STRING => "VideotexString",
-        self::TYPE_IA5_STRING => "IA5String",
-        self::TYPE_UTC_TIME => "UTCTime",
-        self::TYPE_GENERALIZED_TIME => "GeneralizedTime",
-        self::TYPE_GRAPHIC_STRING => "GraphicString",
-        self::TYPE_VISIBLE_STRING => "VisibleString",
-        self::TYPE_GENERAL_STRING => "GeneralString",
-        self::TYPE_UNIVERSAL_STRING => "UniversalString",
-        self::TYPE_CHARACTER_STRING => "CHARACTER STRING",
-        self::TYPE_BMP_STRING => "BMPString",
-        self::TYPE_STRING => "Any String",
-        self::TYPE_TIME => "Any Time",
-        self::TYPE_CONSTRUCTED_STRING => "Constructed String"
-        /* @formatter:on */
-    ];
+	/**
+	 * Mapping from universal type tag to human readable name.
+	 *
+	 * @internal
+	 *
+	 * @var array
+	 */
+	const MAP_TYPE_TO_NAME = [ /* @formatter:off */
+		self::TYPE_EOC => "EOC",
+		self::TYPE_BOOLEAN => "BOOLEAN",
+		self::TYPE_INTEGER => "INTEGER",
+		self::TYPE_BIT_STRING => "BIT STRING",
+		self::TYPE_OCTET_STRING => "OCTET STRING",
+		self::TYPE_NULL => "NULL",
+		self::TYPE_OBJECT_IDENTIFIER => "OBJECT IDENTIFIER",
+		self::TYPE_OBJECT_DESCRIPTOR => "ObjectDescriptor",
+		self::TYPE_EXTERNAL => "EXTERNAL",
+		self::TYPE_REAL => "REAL",
+		self::TYPE_ENUMERATED => "ENUMERATED",
+		self::TYPE_EMBEDDED_PDV => "EMBEDDED PDV",
+		self::TYPE_UTF8_STRING => "UTF8String",
+		self::TYPE_RELATIVE_OID => "RELATIVE-OID",
+		self::TYPE_SEQUENCE => "SEQUENCE",
+		self::TYPE_SET => "SET",
+		self::TYPE_NUMERIC_STRING => "NumericString",
+		self::TYPE_PRINTABLE_STRING => "PrintableString",
+		self::TYPE_T61_STRING => "T61String",
+		self::TYPE_VIDEOTEX_STRING => "VideotexString",
+		self::TYPE_IA5_STRING => "IA5String",
+		self::TYPE_UTC_TIME => "UTCTime",
+		self::TYPE_GENERALIZED_TIME => "GeneralizedTime",
+		self::TYPE_GRAPHIC_STRING => "GraphicString",
+		self::TYPE_VISIBLE_STRING => "VisibleString",
+		self::TYPE_GENERAL_STRING => "GeneralString",
+		self::TYPE_UNIVERSAL_STRING => "UniversalString",
+		self::TYPE_CHARACTER_STRING => "CHARACTER STRING",
+		self::TYPE_BMP_STRING => "BMPString",
+		self::TYPE_STRING => "Any String",
+		self::TYPE_TIME => "Any Time",
+		self::TYPE_CONSTRUCTED_STRING => "Constructed String"
+		/* @formatter:on */
+	];
     
-    /**
-     * Element's type tag.
-     *
-     * @var int
-     */
-    protected $_typeTag;
+	/**
+	 * Element's type tag.
+	 *
+	 * @var int
+	 */
+	protected $_typeTag;
     
-    /**
-     * Whether type shall be encoded with indefinite length.
-     *
-     * @var bool
-     */
-    protected $_indefiniteLength = false;
+	/**
+	 * Whether type shall be encoded with indefinite length.
+	 *
+	 * @var bool
+	 */
+	protected $_indefiniteLength = false;
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::typeClass()
-     * @return int
-     */
-    abstract public function typeClass(): int;
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::typeClass()
+	 * @return int
+	 */
+	abstract public function typeClass(): int;
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::isConstructed()
-     * @return bool
-     */
-    abstract public function isConstructed(): bool;
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::isConstructed()
+	 * @return bool
+	 */
+	abstract public function isConstructed(): bool;
     
-    /**
-     * Get the content encoded in DER.
-     *
-     * Returns the DER encoded content without identifier and length header
-     * octets.
-     *
-     * @return string
-     */
-    abstract protected function _encodedContentDER(): string;
+	/**
+	 * Get the content encoded in DER.
+	 *
+	 * Returns the DER encoded content without identifier and length header
+	 * octets.
+	 *
+	 * @return string
+	 */
+	abstract protected function _encodedContentDER(): string;
     
-    /**
-     * Decode type-specific element from DER.
-     *
-     * @param Identifier $identifier Pre-parsed identifier
-     * @param string $data DER data
-     * @param int $offset Offset in data to the next byte after identifier
-     * @throws DecodeException If decoding fails
-     * @return ElementBase
-     */
-    protected static function _decodeFromDER(Identifier $identifier,
-        string $data, int &$offset): ElementBase
-    {
-        throw new \BadMethodCallException(
-            __METHOD__ . " must be implemented in derived class.");
-    }
+	/**
+	 * Decode type-specific element from DER.
+	 *
+	 * @param Identifier $identifier Pre-parsed identifier
+	 * @param string $data DER data
+	 * @param int $offset Offset in data to the next byte after identifier
+	 * @throws DecodeException If decoding fails
+	 * @return ElementBase
+	 */
+	protected static function _decodeFromDER(Identifier $identifier,
+		string $data, int &$offset): ElementBase
+	{
+		throw new \BadMethodCallException(
+			__METHOD__ . " must be implemented in derived class.");
+	}
     
-    /**
-     * Decode element from DER data.
-     *
-     * @param string $data DER encoded data
-     * @param int|null $offset Reference to the variable that contains offset
-     *        into the data where to start parsing. Variable is updated to
-     *        the offset next to the parsed element. If null, start from offset
-     *        0.
-     * @throws DecodeException If decoding fails
-     * @throws \UnexpectedValueException If called in the context of an expected
-     *         type, but decoding yields another type
-     * @return ElementBase
-     */
-    public static function fromDER(string $data, int &$offset = null): ElementBase
-    {
-        $idx = $offset ?? 0;
-        // decode identifier
-        $identifier = Identifier::fromDER($data, $idx);
-        // determine class that implements type specific decoding
-        $cls = self::_determineImplClass($identifier);
-        try {
-            // decode remaining element
-            $element = $cls::_decodeFromDER($identifier, $data, $idx);
-        } catch (\LogicException $e) {
-            // rethrow as a RuntimeException for unified exception handling
-            throw new DecodeException(
-                sprintf("Error while decoding %s.",
-                    self::tagToName($identifier->intTag())), 0, $e);
-        }
-        // if called in the context of a concrete class, check
-        // that decoded type matches the type of a calling class
-        $called_class = get_called_class();
-        if (self::class != $called_class) {
-            if (!$element instanceof $called_class) {
-                throw new \UnexpectedValueException(
-                    sprintf("%s expected, got %s.", $called_class,
-                        get_class($element)));
-            }
-        }
-        // update offset for the caller
-        if (isset($offset)) {
-            $offset = $idx;
-        }
-        return $element;
-    }
+	/**
+	 * Decode element from DER data.
+	 *
+	 * @param string $data DER encoded data
+	 * @param int|null $offset Reference to the variable that contains offset
+	 *        into the data where to start parsing. Variable is updated to
+	 *        the offset next to the parsed element. If null, start from offset
+	 *        0.
+	 * @throws DecodeException If decoding fails
+	 * @throws \UnexpectedValueException If called in the context of an expected
+	 *         type, but decoding yields another type
+	 * @return ElementBase
+	 */
+	public static function fromDER(string $data, int &$offset = null): ElementBase
+	{
+		$idx = $offset ?? 0;
+		// decode identifier
+		$identifier = Identifier::fromDER($data, $idx);
+		// determine class that implements type specific decoding
+		$cls = self::_determineImplClass($identifier);
+		try {
+			// decode remaining element
+			$element = $cls::_decodeFromDER($identifier, $data, $idx);
+		} catch (\LogicException $e) {
+			// rethrow as a RuntimeException for unified exception handling
+			throw new DecodeException(
+				sprintf("Error while decoding %s.",
+					self::tagToName($identifier->intTag())), 0, $e);
+		}
+		// if called in the context of a concrete class, check
+		// that decoded type matches the type of a calling class
+		$called_class = get_called_class();
+		if (self::class != $called_class) {
+			if (!$element instanceof $called_class) {
+				throw new \UnexpectedValueException(
+					sprintf("%s expected, got %s.", $called_class,
+						get_class($element)));
+			}
+		}
+		// update offset for the caller
+		if (isset($offset)) {
+			$offset = $idx;
+		}
+		return $element;
+	}
     
-    /**
-     *
-     * @see \ASN1\Feature\Encodable::toDER()
-     * @return string
-     */
-    public function toDER(): string
-    {
-        $identifier = new Identifier($this->typeClass(),
-            $this->isConstructed() ? Identifier::CONSTRUCTED : Identifier::PRIMITIVE,
-            $this->_typeTag);
-        $content = $this->_encodedContentDER();
-        if ($this->_indefiniteLength) {
-            $length = new Length(0, true);
-            $eoc = new Primitive\EOC();
-            return $identifier->toDER() . $length->toDER() . $content .
-                $eoc->toDER();
-        } else {
-            $length = new Length(strlen($content));
-            return $identifier->toDER() . $length->toDER() . $content;
-        }
-    }
+	/**
+	 *
+	 * @see \ASN1\Feature\Encodable::toDER()
+	 * @return string
+	 */
+	public function toDER(): string
+	{
+		$identifier = new Identifier($this->typeClass(),
+			$this->isConstructed() ? Identifier::CONSTRUCTED : Identifier::PRIMITIVE,
+			$this->_typeTag);
+		$content = $this->_encodedContentDER();
+		if ($this->_indefiniteLength) {
+			$length = new Length(0, true);
+			$eoc = new Primitive\EOC();
+			return $identifier->toDER() . $length->toDER() . $content .
+				$eoc->toDER();
+		} else {
+			$length = new Length(strlen($content));
+			return $identifier->toDER() . $length->toDER() . $content;
+		}
+	}
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::tag()
-     * @return int
-     */
-    public function tag(): int
-    {
-        return $this->_typeTag;
-    }
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::tag()
+	 * @return int
+	 */
+	public function tag(): int
+	{
+		return $this->_typeTag;
+	}
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::isType()
-     * @return bool
-     */
-    public function isType(int $tag): bool
-    {
-        // if element is context specific
-        if ($this->typeClass() == Identifier::CLASS_CONTEXT_SPECIFIC) {
-            return false;
-        }
-        // negative tags identify an abstract pseudotype
-        if ($tag < 0) {
-            return $this->_isPseudoType($tag);
-        }
-        return $this->_isConcreteType($tag);
-    }
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::isType()
+	 * @return bool
+	 */
+	public function isType(int $tag): bool
+	{
+		// if element is context specific
+		if ($this->typeClass() == Identifier::CLASS_CONTEXT_SPECIFIC) {
+			return false;
+		}
+		// negative tags identify an abstract pseudotype
+		if ($tag < 0) {
+			return $this->_isPseudoType($tag);
+		}
+		return $this->_isConcreteType($tag);
+	}
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::expectType()
-     * @return ElementBase
-     */
-    public function expectType(int $tag): ElementBase
-    {
-        if (!$this->isType($tag)) {
-            throw new \UnexpectedValueException(
-                sprintf("%s expected, got %s.", self::tagToName($tag),
-                    $this->_typeDescriptorString()));
-        }
-        return $this;
-    }
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::expectType()
+	 * @return ElementBase
+	 */
+	public function expectType(int $tag): ElementBase
+	{
+		if (!$this->isType($tag)) {
+			throw new \UnexpectedValueException(
+				sprintf("%s expected, got %s.", self::tagToName($tag),
+					$this->_typeDescriptorString()));
+		}
+		return $this;
+	}
     
-    /**
-     * Check whether the element is a concrete type of a given tag.
-     *
-     * @param int $tag
-     * @return bool
-     */
-    private function _isConcreteType(int $tag): bool
-    {
-        // if tag doesn't match
-        if ($this->tag() != $tag) {
-            return false;
-        }
-        // if type is universal check that instance is of a correct class
-        if ($this->typeClass() == Identifier::CLASS_UNIVERSAL) {
-            $cls = self::_determineUniversalImplClass($tag);
-            if (!$this instanceof $cls) {
-                return false;
-            }
-        }
-        return true;
-    }
+	/**
+	 * Check whether the element is a concrete type of a given tag.
+	 *
+	 * @param int $tag
+	 * @return bool
+	 */
+	private function _isConcreteType(int $tag): bool
+	{
+		// if tag doesn't match
+		if ($this->tag() != $tag) {
+			return false;
+		}
+		// if type is universal check that instance is of a correct class
+		if ($this->typeClass() == Identifier::CLASS_UNIVERSAL) {
+			$cls = self::_determineUniversalImplClass($tag);
+			if (!$this instanceof $cls) {
+				return false;
+			}
+		}
+		return true;
+	}
     
-    /**
-     * Check whether the element is a pseudotype.
-     *
-     * @param int $tag
-     * @return bool
-     */
-    private function _isPseudoType(int $tag): bool
-    {
-        switch ($tag) {
-            case self::TYPE_STRING:
-                return $this instanceof StringType;
-            case self::TYPE_TIME:
-                return $this instanceof TimeType;
-            case self::TYPE_CONSTRUCTED_STRING:
-                return $this instanceof ConstructedString;
-        }
-        return false;
-    }
+	/**
+	 * Check whether the element is a pseudotype.
+	 *
+	 * @param int $tag
+	 * @return bool
+	 */
+	private function _isPseudoType(int $tag): bool
+	{
+		switch ($tag) {
+			case self::TYPE_STRING:
+				return $this instanceof StringType;
+			case self::TYPE_TIME:
+				return $this instanceof TimeType;
+			case self::TYPE_CONSTRUCTED_STRING:
+				return $this instanceof ConstructedString;
+		}
+		return false;
+	}
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::isTagged()
-     * @return bool
-     */
-    public function isTagged(): bool
-    {
-        return $this instanceof TaggedType;
-    }
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::isTagged()
+	 * @return bool
+	 */
+	public function isTagged(): bool
+	{
+		return $this instanceof TaggedType;
+	}
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::expectTagged()
-     * @return TaggedType
-     */
-    public function expectTagged($tag = null): TaggedType
-    {
-        if (!$this->isTagged()) {
-            throw new \UnexpectedValueException(
-                sprintf("Context specific element expected, got %s.",
-                    Identifier::classToName($this->typeClass())));
-        }
-        if (isset($tag) && $this->tag() != $tag) {
-            throw new \UnexpectedValueException(
-                sprintf("Tag %d expected, got %d.", $tag, $this->tag()));
-        }
-        return $this;
-    }
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::expectTagged()
+	 * @return TaggedType
+	 */
+	public function expectTagged($tag = null): TaggedType
+	{
+		if (!$this->isTagged()) {
+			throw new \UnexpectedValueException(
+				sprintf("Context specific element expected, got %s.",
+					Identifier::classToName($this->typeClass())));
+		}
+		if (isset($tag) && $this->tag() != $tag) {
+			throw new \UnexpectedValueException(
+				sprintf("Tag %d expected, got %d.", $tag, $this->tag()));
+		}
+		return $this;
+	}
     
-    /**
-     * Whether element has indefinite length.
-     *
-     * @return bool
-     */
-    public function hasIndefiniteLength(): bool
-    {
-        return $this->_indefiniteLength;
-    }
+	/**
+	 * Whether element has indefinite length.
+	 *
+	 * @return bool
+	 */
+	public function hasIndefiniteLength(): bool
+	{
+		return $this->_indefiniteLength;
+	}
     
-    /**
-     * Get self with indefinite length encoding set.
-     *
-     * @param bool $indefinite True for indefinite length, false for definite
-     *        length
-     * @return self
-     */
-    public function withIndefiniteLength(bool $indefinite = true): self
-    {
-        $obj = clone $this;
-        $obj->_indefiniteLength = $indefinite;
-        return $obj;
-    }
+	/**
+	 * Get self with indefinite length encoding set.
+	 *
+	 * @param bool $indefinite True for indefinite length, false for definite
+	 *        length
+	 * @return self
+	 */
+	public function withIndefiniteLength(bool $indefinite = true): self
+	{
+		$obj = clone $this;
+		$obj->_indefiniteLength = $indefinite;
+		return $obj;
+	}
     
-    /**
-     *
-     * @see \ASN1\Feature\ElementBase::asElement()
-     * @return Element
-     */
-    final public function asElement(): Element
-    {
-        return $this;
-    }
+	/**
+	 *
+	 * @see \ASN1\Feature\ElementBase::asElement()
+	 * @return Element
+	 */
+	final public function asElement(): Element
+	{
+		return $this;
+	}
     
-    /**
-     * Get element decorated with UnspecifiedType object.
-     *
-     * @return UnspecifiedType
-     */
-    public function asUnspecified(): UnspecifiedType
-    {
-        return new UnspecifiedType($this);
-    }
+	/**
+	 * Get element decorated with UnspecifiedType object.
+	 *
+	 * @return UnspecifiedType
+	 */
+	public function asUnspecified(): UnspecifiedType
+	{
+		return new UnspecifiedType($this);
+	}
     
-    /**
-     * Determine the class that implements the type.
-     *
-     * @param Identifier $identifier
-     * @return string Class name
-     */
-    protected static function _determineImplClass(Identifier $identifier): string
-    {
-        switch ($identifier->typeClass()) {
-            case Identifier::CLASS_UNIVERSAL:
-                $cls = self::_determineUniversalImplClass($identifier->intTag());
-                // constructed strings may be present in BER
-                if ($identifier->isConstructed() &&
-                    is_subclass_of($cls, PrimitiveString::class)) {
-                    $cls = ConstructedString::class;
-                }
-                return $cls;
-            case Identifier::CLASS_CONTEXT_SPECIFIC:
-                return ContextSpecificType::class;
-            case Identifier::CLASS_APPLICATION:
-                return ApplicationType::class;
-            case Identifier::CLASS_PRIVATE:
-                return PrivateType::class;
-        }
-        throw new \UnexpectedValueException(
-            sprintf("%s %d not implemented.",
-                Identifier::classToName($identifier->typeClass()),
-                $identifier->tag()));
-    }
+	/**
+	 * Determine the class that implements the type.
+	 *
+	 * @param Identifier $identifier
+	 * @return string Class name
+	 */
+	protected static function _determineImplClass(Identifier $identifier): string
+	{
+		switch ($identifier->typeClass()) {
+			case Identifier::CLASS_UNIVERSAL:
+				$cls = self::_determineUniversalImplClass($identifier->intTag());
+				// constructed strings may be present in BER
+				if ($identifier->isConstructed() &&
+					is_subclass_of($cls, PrimitiveString::class)) {
+					$cls = ConstructedString::class;
+				}
+				return $cls;
+			case Identifier::CLASS_CONTEXT_SPECIFIC:
+				return ContextSpecificType::class;
+			case Identifier::CLASS_APPLICATION:
+				return ApplicationType::class;
+			case Identifier::CLASS_PRIVATE:
+				return PrivateType::class;
+		}
+		throw new \UnexpectedValueException(
+			sprintf("%s %d not implemented.",
+				Identifier::classToName($identifier->typeClass()),
+				$identifier->tag()));
+	}
     
-    /**
-     * Determine the class that implements an universal type of the given tag.
-     *
-     * @param int $tag
-     * @throws \UnexpectedValueException
-     * @return string Class name
-     */
-    protected static function _determineUniversalImplClass(int $tag): string
-    {
-        if (!array_key_exists($tag, self::MAP_TAG_TO_CLASS)) {
-            throw new \UnexpectedValueException(
-                "Universal tag $tag not implemented.");
-        }
-        return self::MAP_TAG_TO_CLASS[$tag];
-    }
+	/**
+	 * Determine the class that implements an universal type of the given tag.
+	 *
+	 * @param int $tag
+	 * @throws \UnexpectedValueException
+	 * @return string Class name
+	 */
+	protected static function _determineUniversalImplClass(int $tag): string
+	{
+		if (!array_key_exists($tag, self::MAP_TAG_TO_CLASS)) {
+			throw new \UnexpectedValueException(
+				"Universal tag $tag not implemented.");
+		}
+		return self::MAP_TAG_TO_CLASS[$tag];
+	}
     
-    /**
-     * Get textual description of the type for debugging purposes.
-     *
-     * @return string
-     */
-    protected function _typeDescriptorString(): string
-    {
-        if ($this->typeClass() == Identifier::CLASS_UNIVERSAL) {
-            return self::tagToName($this->_typeTag);
-        }
-        return sprintf("%s TAG %d", Identifier::classToName($this->typeClass()),
-            $this->_typeTag);
-    }
+	/**
+	 * Get textual description of the type for debugging purposes.
+	 *
+	 * @return string
+	 */
+	protected function _typeDescriptorString(): string
+	{
+		if ($this->typeClass() == Identifier::CLASS_UNIVERSAL) {
+			return self::tagToName($this->_typeTag);
+		}
+		return sprintf("%s TAG %d", Identifier::classToName($this->typeClass()),
+			$this->_typeTag);
+	}
     
-    /**
-     * Get human readable name for an universal tag.
-     *
-     * @param int $tag
-     * @return string
-     */
-    public static function tagToName(int $tag): string
-    {
-        if (!array_key_exists($tag, self::MAP_TYPE_TO_NAME)) {
-            return "TAG $tag";
-        }
-        return self::MAP_TYPE_TO_NAME[$tag];
-    }
+	/**
+	 * Get human readable name for an universal tag.
+	 *
+	 * @param int $tag
+	 * @return string
+	 */
+	public static function tagToName(int $tag): string
+	{
+		if (!array_key_exists($tag, self::MAP_TYPE_TO_NAME)) {
+			return "TAG $tag";
+		}
+		return self::MAP_TYPE_TO_NAME[$tag];
+	}
 }

Switch Indentation +20 added lines, -20 removed lines

@@ -359,12 +359,12 @@ 
     private function _isPseudoType(int $tag): bool
     {
         switch ($tag) {
-            case self::TYPE_STRING:
-                return $this instanceof StringType;
-            case self::TYPE_TIME:
-                return $this instanceof TimeType;
-            case self::TYPE_CONSTRUCTED_STRING:
-                return $this instanceof ConstructedString;
+        case self::TYPE_STRING:
+            return $this instanceof StringType;
+        case self::TYPE_TIME:
+            return $this instanceof TimeType;
+        case self::TYPE_CONSTRUCTED_STRING:
+            return $this instanceof ConstructedString;
         }
         return false;
     }
@@ -451,20 +451,20 @@ 
     protected static function _determineImplClass(Identifier $identifier): string
     {
         switch ($identifier->typeClass()) {
-            case Identifier::CLASS_UNIVERSAL:
-                $cls = self::_determineUniversalImplClass($identifier->intTag());
-                // constructed strings may be present in BER
-                if ($identifier->isConstructed() &&
-                    is_subclass_of($cls, PrimitiveString::class)) {
-                    $cls = ConstructedString::class;
-                }
-                return $cls;
-            case Identifier::CLASS_CONTEXT_SPECIFIC:
-                return ContextSpecificType::class;
-            case Identifier::CLASS_APPLICATION:
-                return ApplicationType::class;
-            case Identifier::CLASS_PRIVATE:
-                return PrivateType::class;
+        case Identifier::CLASS_UNIVERSAL:
+            $cls = self::_determineUniversalImplClass($identifier->intTag());
+            // constructed strings may be present in BER
+            if ($identifier->isConstructed() &&
+                is_subclass_of($cls, PrimitiveString::class)) {
+                $cls = ConstructedString::class;
+            }
+            return $cls;
+        case Identifier::CLASS_CONTEXT_SPECIFIC:
+            return ContextSpecificType::class;
+        case Identifier::CLASS_APPLICATION:
+            return ApplicationType::class;
+        case Identifier::CLASS_PRIVATE:
+            return PrivateType::class;
         }
         throw new \UnexpectedValueException(
             sprintf("%s %d not implemented.",

lib/ASN1/Feature/Stringable.php

Indentation +12 added lines, -12 removed lines

@@ -8,17 +8,17 @@
  */
 interface Stringable
 {
-    /**
-     * Get the string representation of the type.
-     *
-     * @return string
-     */
-    public function string(): string;
+	/**
+	 * Get the string representation of the type.
+	 *
+	 * @return string
+	 */
+	public function string(): string;
     
-    /**
-     *
-     * @inheritdoc
-     * @return string
-     */
-    public function __toString(): string;
+	/**
+	 *
+	 * @inheritdoc
+	 * @return string
+	 */
+	public function __toString(): string;
 }

Spacing +1 added lines, -1 removed lines

@@ -1,6 +1,6 @@
 <?php
 
-declare(strict_types = 1);
+declare(strict_types=1);
 
 namespace ASN1\Feature;