first commit

modules/x13allegro/tools/DeepCopy/DeepCopy.php

@@ -0,0 +1,287 @@
+<?php
+
+namespace DeepCopy;
+
+use DateTimeInterface;
+use DateTimeZone;
+use DeepCopy\Exception\CloneException;
+use DeepCopy\Filter\Filter;
+use DeepCopy\Matcher\Matcher;
+use DeepCopy\TypeFilter\Date\DateIntervalFilter;
+use DeepCopy\TypeFilter\Spl\SplDoublyLinkedListFilter;
+use DeepCopy\TypeFilter\TypeFilter;
+use DeepCopy\TypeMatcher\TypeMatcher;
+use ReflectionObject;
+use ReflectionProperty;
+use DeepCopy\Reflection\ReflectionHelper;
+
+/**
+ * @final
+ */
+class DeepCopy
+{
+    /**
+     * @var object[] List of objects copied.
+     */
+    private $hashMap = [];
+
+    /**
+     * Filters to apply.
+     *
+     * @var array Array of ['filter' => Filter, 'matcher' => Matcher] pairs.
+     */
+    private $filters = [];
+
+    /**
+     * Type Filters to apply.
+     *
+     * @var array Array of ['filter' => Filter, 'matcher' => Matcher] pairs.
+     */
+    private $typeFilters = [];
+
+    /**
+     * @var bool
+     */
+    private $skipUncloneable = false;
+
+    /**
+     * @var bool
+     */
+    private $useCloneMethod;
+
+    /**
+     * @param bool $useCloneMethod   If set to true, when an object implements the __clone() function, it will be used
+     *                               instead of the regular deep cloning.
+     */
+    public function __construct($useCloneMethod = false)
+    {
+        $this->useCloneMethod = $useCloneMethod;
+
+        $this->addTypeFilter(new DateIntervalFilter(), new TypeMatcher('DateInterval'));
+        $this->addTypeFilter(new SplDoublyLinkedListFilter($this), new TypeMatcher('SplDoublyLinkedList'));
+    }
+
+    /**
+     * If enabled, will not throw an exception when coming across an uncloneable property.
+     *
+     * @param $skipUncloneable
+     *
+     * @return $this
+     */
+    public function skipUncloneable($skipUncloneable = true)
+    {
+        $this->skipUncloneable = $skipUncloneable;
+
+        return $this;
+    }
+
+    /**
+     * Deep copies the given object.
+     *
+     * @param mixed $object
+     *
+     * @return mixed
+     */
+    public function copy($object)
+    {
+        $this->hashMap = [];
+
+        return $this->recursiveCopy($object);
+    }
+
+    public function addFilter(Filter $filter, Matcher $matcher)
+    {
+        $this->filters[] = [
+            'matcher' => $matcher,
+            'filter'  => $filter,
+        ];
+    }
+
+    public function prependFilter(Filter $filter, Matcher $matcher)
+    {
+        array_unshift($this->filters, [
+            'matcher' => $matcher,
+            'filter'  => $filter,
+        ]);
+    }
+
+    public function addTypeFilter(TypeFilter $filter, TypeMatcher $matcher)
+    {
+        $this->typeFilters[] = [
+            'matcher' => $matcher,
+            'filter'  => $filter,
+        ];
+    }
+
+    public function recursiveCopy($var)
+    {
+        // Matches Type Filter
+        if ($filter = $this->getFirstMatchedTypeFilter($this->typeFilters, $var)) {
+            return $filter->apply($var);
+        }
+
+        // Resource
+        if (is_resource($var)) {
+            return $var;
+        }
+
+        // Array
+        if (is_array($var)) {
+            return $this->copyArray($var);
+        }
+
+        // Scalar
+        if (! is_object($var)) {
+            return $var;
+        }
+
+        // Object
+        return $this->copyObject($var);
+    }
+
+    /**
+     * Copy an array
+     * @param array $array
+     * @return array
+     */
+    private function copyArray(array $array)
+    {
+        foreach ($array as $key => $value) {
+            $array[$key] = $this->recursiveCopy($value);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Copies an object.
+     *
+     * @param object $object
+     *
+     * @throws CloneException
+     *
+     * @return object
+     */
+    private function copyObject($object)
+    {
+        $objectHash = spl_object_hash($object);
+
+        if (isset($this->hashMap[$objectHash])) {
+            return $this->hashMap[$objectHash];
+        }
+
+        $reflectedObject = new ReflectionObject($object);
+        $isCloneable = $reflectedObject->isCloneable();
+
+        if (false === $isCloneable) {
+            if ($this->skipUncloneable) {
+                $this->hashMap[$objectHash] = $object;
+
+                return $object;
+            }
+
+            throw new CloneException(
+                sprintf(
+                    'The class "%s" is not cloneable.',
+                    $reflectedObject->getName()
+                )
+            );
+        }
+
+        $newObject = clone $object;
+        $this->hashMap[$objectHash] = $newObject;
+
+        if ($this->useCloneMethod && $reflectedObject->hasMethod('__clone')) {
+            return $newObject;
+        }
+
+        if ($newObject instanceof DateTimeInterface || $newObject instanceof DateTimeZone) {
+            return $newObject;
+        }
+
+        foreach (ReflectionHelper::getProperties($reflectedObject) as $property) {
+            $this->copyObjectProperty($newObject, $property);
+        }
+
+        return $newObject;
+    }
+
+    private function copyObjectProperty($object, ReflectionProperty $property)
+    {
+        // Ignore static properties
+        if ($property->isStatic()) {
+            return;
+        }
+
+        // Apply the filters
+        foreach ($this->filters as $item) {
+            /** @var Matcher $matcher */
+            $matcher = $item['matcher'];
+            /** @var Filter $filter */
+            $filter = $item['filter'];
+
+            if ($matcher->matches($object, $property->getName())) {
+                $filter->apply(
+                    $object,
+                    $property->getName(),
+                    function ($object) {
+                        return $this->recursiveCopy($object);
+                    }
+                );
+
+                // If a filter matches, we stop processing this property
+                return;
+            }
+        }
+
+        $property->setAccessible(true);
+        $propertyValue = $property->getValue($object);
+
+        // Copy the property
+        $property->setValue($object, $this->recursiveCopy($propertyValue));
+    }
+
+    /**
+     * Returns first filter that matches variable, `null` if no such filter found.
+     *
+     * @param array $filterRecords Associative array with 2 members: 'filter' with value of type {@see TypeFilter} and
+     *                             'matcher' with value of type {@see TypeMatcher}
+     * @param mixed $var
+     *
+     * @return TypeFilter|null
+     */
+    private function getFirstMatchedTypeFilter(array $filterRecords, $var)
+    {
+        $matched = $this->first(
+            $filterRecords,
+            function (array $record) use ($var) {
+                /* @var TypeMatcher $matcher */
+                $matcher = $record['matcher'];
+
+                return $matcher->matches($var);
+            }
+        );
+
+        return isset($matched) ? $matched['filter'] : null;
+    }
+
+    /**
+     * Returns first element that matches predicate, `null` if no such element found.
+     *
+     * @param array    $elements Array of ['filter' => Filter, 'matcher' => Matcher] pairs.
+     * @param callable $predicate Predicate arguments are: element.
+     *
+     * @return array|null Associative array with 2 members: 'filter' with value of type {@see TypeFilter} and 'matcher'
+     *                    with value of type {@see TypeMatcher} or `null`.
+     */
+    private function first(array $elements, callable $predicate)
+    {
+        foreach ($elements as $element) {
+            if (call_user_func($predicate, $element)) {
+                return $element;
+            }
+        }
+
+        return null;
+    }
+}

modules/x13allegro/tools/DeepCopy/Exception/CloneException.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace DeepCopy\Exception;
+
+use UnexpectedValueException;
+
+class CloneException extends UnexpectedValueException
+{
+} 

modules/x13allegro/tools/DeepCopy/Exception/PropertyException.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace DeepCopy\Exception;
+
+use ReflectionException;
+
+class PropertyException extends ReflectionException
+{
+}

modules/x13allegro/tools/DeepCopy/Filter/Doctrine/DoctrineCollectionFilter.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace DeepCopy\Filter\Doctrine;
+
+use DeepCopy\Filter\Filter;
+use DeepCopy\Reflection\ReflectionHelper;
+
+/**
+ * @final
+ */
+class DoctrineCollectionFilter implements Filter
+{
+    /**
+     * Copies the object property doctrine collection.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+
+        $reflectionProperty->setAccessible(true);
+        $oldCollection = $reflectionProperty->getValue($object);
+
+        $newCollection = $oldCollection->map(
+            function ($item) use ($objectCopier) {
+                return $objectCopier($item);
+            }
+        );
+
+        $reflectionProperty->setValue($object, $newCollection);
+    }
+}

modules/x13allegro/tools/DeepCopy/Filter/Doctrine/DoctrineEmptyCollectionFilter.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DeepCopy\Filter\Doctrine;
+
+use DeepCopy\Filter\Filter;
+use DeepCopy\Reflection\ReflectionHelper;
+use Doctrine\Common\Collections\ArrayCollection;
+
+/**
+ * @final
+ */
+class DoctrineEmptyCollectionFilter implements Filter
+{
+    /**
+     * Sets the object property to an empty doctrine collection.
+     *
+     * @param object   $object
+     * @param string   $property
+     * @param callable $objectCopier
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+        $reflectionProperty->setAccessible(true);
+
+        $reflectionProperty->setValue($object, new ArrayCollection());
+    }
+} 

modules/x13allegro/tools/DeepCopy/Filter/Doctrine/DoctrineProxyFilter.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace DeepCopy\Filter\Doctrine;
+
+use DeepCopy\Filter\Filter;
+
+/**
+ * @final
+ */
+class DoctrineProxyFilter implements Filter
+{
+    /**
+     * Triggers the magic method __load() on a Doctrine Proxy class to load the
+     * actual entity from the database.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $object->__load();
+    }
+}

modules/x13allegro/tools/DeepCopy/Filter/Filter.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace DeepCopy\Filter;
+
+/**
+ * Filter to apply to a property while copying an object
+ */
+interface Filter
+{
+    /**
+     * Applies the filter to the object.
+     *
+     * @param object   $object
+     * @param string   $property
+     * @param callable $objectCopier
+     */
+    public function apply($object, $property, $objectCopier);
+}

modules/x13allegro/tools/DeepCopy/Filter/KeepFilter.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace DeepCopy\Filter;
+
+class KeepFilter implements Filter
+{
+    /**
+     * Keeps the value of the object property.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        // Nothing to do
+    }
+}

modules/x13allegro/tools/DeepCopy/Filter/ReplaceFilter.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace DeepCopy\Filter;
+
+use DeepCopy\Reflection\ReflectionHelper;
+
+/**
+ * @final
+ */
+class ReplaceFilter implements Filter
+{
+    /**
+     * @var callable
+     */
+    protected $callback;
+
+    /**
+     * @param callable $callable Will be called to get the new value for each property to replace
+     */
+    public function __construct(callable $callable)
+    {
+        $this->callback = $callable;
+    }
+
+    /**
+     * Replaces the object property by the result of the callback called with the object property.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+        $reflectionProperty->setAccessible(true);
+
+        $value = call_user_func($this->callback, $reflectionProperty->getValue($object));
+
+        $reflectionProperty->setValue($object, $value);
+    }
+}

modules/x13allegro/tools/DeepCopy/Filter/SetNullFilter.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace DeepCopy\Filter;
+
+use DeepCopy\Reflection\ReflectionHelper;
+
+/**
+ * @final
+ */
+class SetNullFilter implements Filter
+{
+    /**
+     * Sets the object property to null.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+
+        $reflectionProperty->setAccessible(true);
+        $reflectionProperty->setValue($object, null);
+    }
+}

modules/x13allegro/tools/DeepCopy/Matcher/Doctrine/DoctrineProxyMatcher.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace DeepCopy\Matcher\Doctrine;
+
+use DeepCopy\Matcher\Matcher;
+use Doctrine\Common\Persistence\Proxy;
+
+/**
+ * @final
+ */
+class DoctrineProxyMatcher implements Matcher
+{
+    /**
+     * Matches a Doctrine Proxy class.
+     *
+     * {@inheritdoc}
+     */
+    public function matches($object, $property)
+    {
+        return $object instanceof Proxy;
+    }
+}

modules/x13allegro/tools/DeepCopy/Matcher/Matcher.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace DeepCopy\Matcher;
+
+interface Matcher
+{
+    /**
+     * @param object $object
+     * @param string $property
+     *
+     * @return boolean
+     */
+    public function matches($object, $property);
+}

modules/x13allegro/tools/DeepCopy/Matcher/PropertyMatcher.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace DeepCopy\Matcher;
+
+/**
+ * @final
+ */
+class PropertyMatcher implements Matcher
+{
+    /**
+     * @var string
+     */
+    private $class;
+
+    /**
+     * @var string
+     */
+    private $property;
+
+    /**
+     * @param string $class    Class name
+     * @param string $property Property name
+     */
+    public function __construct($class, $property)
+    {
+        $this->class = $class;
+        $this->property = $property;
+    }
+
+    /**
+     * Matches a specific property of a specific class.
+     *
+     * {@inheritdoc}
+     */
+    public function matches($object, $property)
+    {
+        return ($object instanceof $this->class) && $property == $this->property;
+    }
+}

modules/x13allegro/tools/DeepCopy/Matcher/PropertyNameMatcher.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace DeepCopy\Matcher;
+
+/**
+ * @final
+ */
+class PropertyNameMatcher implements Matcher
+{
+    /**
+     * @var string
+     */
+    private $property;
+
+    /**
+     * @param string $property Property name
+     */
+    public function __construct($property)
+    {
+        $this->property = $property;
+    }
+
+    /**
+     * Matches a property by its name.
+     *
+     * {@inheritdoc}
+     */
+    public function matches($object, $property)
+    {
+        return $property == $this->property;
+    }
+}

modules/x13allegro/tools/DeepCopy/Matcher/PropertyTypeMatcher.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace DeepCopy\Matcher;
+
+use DeepCopy\Reflection\ReflectionHelper;
+use ReflectionException;
+
+/**
+ * Matches a property by its type.
+ *
+ * It is recommended to use {@see DeepCopy\TypeFilter\TypeFilter} instead, as it applies on all occurrences
+ * of given type in copied context (eg. array elements), not just on object properties.
+ *
+ * @final
+ */
+class PropertyTypeMatcher implements Matcher
+{
+    /**
+     * @var string
+     */
+    private $propertyType;
+
+    /**
+     * @param string $propertyType Property type
+     */
+    public function __construct($propertyType)
+    {
+        $this->propertyType = $propertyType;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function matches($object, $property)
+    {
+        try {
+            $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+        } catch (ReflectionException $exception) {
+            return false;
+        }
+
+        $reflectionProperty->setAccessible(true);
+
+        return $reflectionProperty->getValue($object) instanceof $this->propertyType;
+    }
+}

modules/x13allegro/tools/DeepCopy/Reflection/ReflectionHelper.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace DeepCopy\Reflection;
+
+use DeepCopy\Exception\PropertyException;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionObject;
+use ReflectionProperty;
+
+class ReflectionHelper
+{
+    /**
+     * Retrieves all properties (including private ones), from object and all its ancestors.
+     *
+     * Standard \ReflectionClass->getProperties() does not return private properties from ancestor classes.
+     *
+     * @author muratyaman@gmail.com
+     * @see http://php.net/manual/en/reflectionclass.getproperties.php
+     *
+     * @param ReflectionClass $ref
+     *
+     * @return ReflectionProperty[]
+     */
+    public static function getProperties(ReflectionClass $ref)
+    {
+        $props = $ref->getProperties();
+        $propsArr = array();
+
+        foreach ($props as $prop) {
+            $propertyName = $prop->getName();
+            $propsArr[$propertyName] = $prop;
+        }
+
+        if ($parentClass = $ref->getParentClass()) {
+            $parentPropsArr = self::getProperties($parentClass);
+            foreach ($propsArr as $key => $property) {
+                $parentPropsArr[$key] = $property;
+            }
+
+            return $parentPropsArr;
+        }
+
+        return $propsArr;
+    }
+
+    /**
+     * Retrieves property by name from object and all its ancestors.
+     *
+     * @param object|string $object
+     * @param string $name
+     *
+     * @throws PropertyException
+     * @throws ReflectionException
+     *
+     * @return ReflectionProperty
+     */
+    public static function getProperty($object, $name)
+    {
+        $reflection = is_object($object) ? new ReflectionObject($object) : new ReflectionClass($object);
+
+        if ($reflection->hasProperty($name)) {
+            return $reflection->getProperty($name);
+        }
+
+        if ($parentClass = $reflection->getParentClass()) {
+            return self::getProperty($parentClass->getName(), $name);
+        }
+
+        throw new PropertyException(
+            sprintf(
+                'The class "%s" doesn\'t have a property with the given name: "%s".',
+                is_object($object) ? get_class($object) : $object,
+                $name
+            )
+        );
+    }
+}

modules/x13allegro/tools/DeepCopy/TypeFilter/Date/DateIntervalFilter.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace DeepCopy\TypeFilter\Date;
+
+use DateInterval;
+use DeepCopy\TypeFilter\TypeFilter;
+
+/**
+ * @final
+ *
+ * @deprecated Will be removed in 2.0. This filter will no longer be necessary in PHP 7.1+.
+ */
+class DateIntervalFilter implements TypeFilter
+{
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param DateInterval $element
+     *
+     * @see http://news.php.net/php.bugs/205076
+     */
+    public function apply($element)
+    {
+        $copy = new DateInterval('P0D');
+
+        foreach ($element as $propertyName => $propertyValue) {
+            $copy->{$propertyName} = $propertyValue;
+        }
+
+        return $copy;
+    }
+}

modules/x13allegro/tools/DeepCopy/TypeFilter/ReplaceFilter.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace DeepCopy\TypeFilter;
+
+/**
+ * @final
+ */
+class ReplaceFilter implements TypeFilter
+{
+    /**
+     * @var callable
+     */
+    protected $callback;
+
+    /**
+     * @param callable $callable Will be called to get the new value for each element to replace
+     */
+    public function __construct(callable $callable)
+    {
+        $this->callback = $callable;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function apply($element)
+    {
+        return call_user_func($this->callback, $element);
+    }
+}

modules/x13allegro/tools/DeepCopy/TypeFilter/ShallowCopyFilter.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace DeepCopy\TypeFilter;
+
+/**
+ * @final
+ */
+class ShallowCopyFilter implements TypeFilter
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function apply($element)
+    {
+        return clone $element;
+    }
+}

modules/x13allegro/tools/DeepCopy/TypeFilter/Spl/SplDoublyLinkedList.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace DeepCopy\TypeFilter\Spl;
+
+/**
+ * @deprecated Use {@see SplDoublyLinkedListFilter} instead.
+ */
+class SplDoublyLinkedList extends SplDoublyLinkedListFilter
+{
+}

modules/x13allegro/tools/DeepCopy/TypeFilter/Spl/SplDoublyLinkedListFilter.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace DeepCopy\TypeFilter\Spl;
+
+use Closure;
+use DeepCopy\DeepCopy;
+use DeepCopy\TypeFilter\TypeFilter;
+use SplDoublyLinkedList;
+
+/**
+ * @final
+ */
+class SplDoublyLinkedListFilter implements TypeFilter
+{
+    private $copier;
+
+    public function __construct(DeepCopy $copier)
+    {
+        $this->copier = $copier;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function apply($element)
+    {
+        $newElement = clone $element;
+
+        $copy = $this->createCopyClosure();
+
+        return $copy($newElement);
+    }
+
+    private function createCopyClosure()
+    {
+        $copier = $this->copier;
+
+        $copy = function (SplDoublyLinkedList $list) use ($copier) {
+            // Replace each element in the list with a deep copy of itself
+            for ($i = 1; $i <= $list->count(); $i++) {
+                $copy = $copier->recursiveCopy($list->shift());
+
+                $list->push($copy);
+            }
+
+            return $list;
+        };
+
+        return Closure::bind($copy, null, 'DeepCopy\DeepCopy');
+    }
+}

modules/x13allegro/tools/DeepCopy/TypeFilter/TypeFilter.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace DeepCopy\TypeFilter;
+
+interface TypeFilter
+{
+    /**
+     * Applies the filter to the object.
+     *
+     * @param mixed $element
+     */
+    public function apply($element);
+}

modules/x13allegro/tools/DeepCopy/TypeMatcher/TypeMatcher.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DeepCopy\TypeMatcher;
+
+class TypeMatcher
+{
+    /**
+     * @var string
+     */
+    private $type;
+
+    /**
+     * @param string $type
+     */
+    public function __construct($type)
+    {
+        $this->type = $type;
+    }
+
+    /**
+     * @param mixed $element
+     *
+     * @return boolean
+     */
+    public function matches($element)
+    {
+        return is_object($element) ? is_a($element, $this->type) : gettype($element) === $this->type;
+    }
+}

modules/x13allegro/tools/Firebase/JWT/BeforeValidException.php

@@ -0,0 +1,7 @@
+<?php
+namespace Firebase\JWT;
+
+class BeforeValidException extends \UnexpectedValueException
+{
+
+}

modules/x13allegro/tools/Firebase/JWT/ExpiredException.php

@@ -0,0 +1,7 @@
+<?php
+namespace Firebase\JWT;
+
+class ExpiredException extends \UnexpectedValueException
+{
+
+}

modules/x13allegro/tools/Firebase/JWT/JWT.php

@@ -0,0 +1,382 @@
+<?php
+
+namespace MyFirebase\JWT;
+use \DomainException;
+use \InvalidArgumentException;
+use \UnexpectedValueException;
+use \DateTime;
+
+/**
+ * JSON Web Token implementation, based on this spec:
+ * https://tools.ietf.org/html/rfc7519
+ *
+ * PHP version 5
+ *
+ * @category Authentication
+ * @package  Authentication_JWT
+ * @author   Neuman Vong <neuman@twilio.com>
+ * @author   Anant Narayanan <anant@php.net>
+ * @license  http://opensource.org/licenses/BSD-3-Clause 3-clause BSD
+ * @link     https://github.com/firebase/php-jwt
+ */
+class JWT
+{
+    /**
+     * When checking nbf, iat or expiration times,
+     * we want to provide some extra leeway time to
+     * account for clock skew.
+     */
+    public static $leeway = 0;
+
+    /**
+     * Allow the current timestamp to be specified.
+     * Useful for fixing a value within unit testing.
+     *
+     * Will default to PHP time() value if null.
+     */
+    public static $timestamp = null;
+
+    public static $supported_algs = array(
+        'HS256' => array('hash_hmac', 'SHA256'),
+        'HS512' => array('hash_hmac', 'SHA512'),
+        'HS384' => array('hash_hmac', 'SHA384'),
+        'RS256' => array('openssl', 'SHA256'),
+        'RS384' => array('openssl', 'SHA384'),
+        'RS512' => array('openssl', 'SHA512'),
+    );
+
+    /**
+     * Decodes a JWT string into a PHP object.
+     *
+     * @param string        $jwt            The JWT
+     * @param string|array  $key            The key, or map of keys.
+     *                                      If the algorithm used is asymmetric, this is the public key
+     * @param array         $allowed_algs   List of supported verification algorithms
+     *                                      Supported algorithms are 'HS256', 'HS384', 'HS512' and 'RS256'
+     *
+     * @return object The JWT's payload as a PHP object
+     *
+     * @throws UnexpectedValueException     Provided JWT was invalid
+     * @throws SignatureInvalidException    Provided JWT was invalid because the signature verification failed
+     * @throws BeforeValidException         Provided JWT is trying to be used before it's eligible as defined by 'nbf'
+     * @throws BeforeValidException         Provided JWT is trying to be used before it's been created as defined by 'iat'
+     * @throws ExpiredException             Provided JWT has since expired, as defined by the 'exp' claim
+     *
+     * @uses jsonDecode
+     * @uses urlsafeB64Decode
+     */
+    public static function decode($jwt, $key = '', array $allowed_algs = array('RS256'))
+    {
+        $timestamp = is_null(static::$timestamp) ? time() : static::$timestamp;
+
+        if (empty($jwt)) {
+            throw new InvalidArgumentException('JWT token cannot be empty');
+        }
+
+        /*if (empty($key)) {
+            throw new InvalidArgumentException('Key may not be empty');
+        }*/
+        $tks = explode('.', $jwt);
+        if (count($tks) != 3) {
+            throw new UnexpectedValueException('Wrong number of segments');
+        }
+        list($headb64, $bodyb64, $cryptob64) = $tks;
+        if (null === ($header = static::jsonDecode(static::urlsafeB64Decode($headb64)))) {
+            throw new UnexpectedValueException('Invalid header encoding');
+        }
+        if (null === $payload = static::jsonDecode(static::urlsafeB64Decode($bodyb64))) {
+            throw new UnexpectedValueException('Invalid claims encoding');
+        }
+        if (false === ($sig = static::urlsafeB64Decode($cryptob64))) {
+            throw new UnexpectedValueException('Invalid signature encoding');
+        }
+        if (empty($header->alg)) {
+            throw new UnexpectedValueException('Empty algorithm');
+        }
+        if (empty(static::$supported_algs[$header->alg])) {
+            throw new UnexpectedValueException('Algorithm not supported');
+        }
+        if (!in_array($header->alg, $allowed_algs)) {
+            throw new UnexpectedValueException('Algorithm not allowed');
+        }
+        /*if (is_array($key) || $key instanceof \ArrayAccess) {
+            if (isset($header->kid)) {
+                if (!isset($key[$header->kid])) {
+                    throw new UnexpectedValueException('"kid" invalid, unable to lookup correct key');
+                }
+                $key = $key[$header->kid];
+            } else {
+                throw new UnexpectedValueException('"kid" empty, unable to lookup correct key');
+            }
+        }*/
+
+        // Check the signature
+        /*if (!static::verify("$headb64.$bodyb64", $sig, $key, $header->alg)) {
+            throw new SignatureInvalidException('Signature verification failed');
+        }*/
+
+        // Check if the nbf if it is defined. This is the time that the
+        // token can actually be used. If it's not yet that time, abort.
+        if (isset($payload->nbf) && $payload->nbf > ($timestamp + static::$leeway)) {
+            throw new BeforeValidException(
+                'Cannot handle token prior to ' . date(DateTime::ISO8601, $payload->nbf)
+            );
+        }
+
+        // Check that this token has been created before 'now'. This prevents
+        // using tokens that have been created for later use (and haven't
+        // correctly used the nbf claim).
+        if (isset($payload->iat) && $payload->iat > ($timestamp + static::$leeway)) {
+            throw new BeforeValidException(
+                'Cannot handle token prior to ' . date(DateTime::ISO8601, $payload->iat)
+            );
+        }
+
+        // Check if this token has expired.
+        //if (isset($payload->exp) && ($timestamp - static::$leeway) >= $payload->exp) {
+        //    throw new ExpiredException('Expired token');
+        //}
+
+        return $payload;
+    }
+
+    /**
+     * Converts and signs a PHP object or array into a JWT string.
+     *
+     * @param object|array  $payload    PHP object or array
+     * @param string        $key        The secret key.
+     *                                  If the algorithm used is asymmetric, this is the private key
+     * @param string        $alg        The signing algorithm.
+     *                                  Supported algorithms are 'HS256', 'HS384', 'HS512' and 'RS256'
+     * @param mixed         $keyId
+     * @param array         $head       An array with header elements to attach
+     *
+     * @return string A signed JWT
+     *
+     * @uses jsonEncode
+     * @uses urlsafeB64Encode
+     */
+    public static function encode($payload, $key, $alg = 'HS256', $keyId = null, $head = null)
+    {
+        $header = array('typ' => 'JWT', 'alg' => $alg);
+        if ($keyId !== null) {
+            $header['kid'] = $keyId;
+        }
+        if ( isset($head) && is_array($head) ) {
+            $header = array_merge($head, $header);
+        }
+        $segments = array();
+        $segments[] = static::urlsafeB64Encode(static::jsonEncode($header));
+        $segments[] = static::urlsafeB64Encode(static::jsonEncode($payload));
+        $signing_input = implode('.', $segments);
+
+        $signature = static::sign($signing_input, $key, $alg);
+        $segments[] = static::urlsafeB64Encode($signature);
+
+        return implode('.', $segments);
+    }
+
+    /**
+     * Sign a string with a given key and algorithm.
+     *
+     * @param string            $msg    The message to sign
+     * @param string|resource   $key    The secret key
+     * @param string            $alg    The signing algorithm.
+     *                                  Supported algorithms are 'HS256', 'HS384', 'HS512' and 'RS256'
+     *
+     * @return string An encrypted message
+     *
+     * @throws DomainException Unsupported algorithm was specified
+     */
+    public static function sign($msg, $key, $alg = 'HS256')
+    {
+        if (empty(static::$supported_algs[$alg])) {
+            throw new DomainException('Algorithm not supported');
+        }
+        list($function, $algorithm) = static::$supported_algs[$alg];
+        switch($function) {
+            case 'hash_hmac':
+                return hash_hmac($algorithm, $msg, $key, true);
+            case 'openssl':
+                $signature = '';
+                $success = openssl_sign($msg, $signature, $key, $algorithm);
+                if (!$success) {
+                    throw new DomainException("OpenSSL unable to sign data");
+                } else {
+                    return $signature;
+                }
+        }
+    }
+
+    /**
+     * Verify a signature with the message, key and method. Not all methods
+     * are symmetric, so we must have a separate verify and sign method.
+     *
+     * @param string            $msg        The original message (header and body)
+     * @param string            $signature  The original signature
+     * @param string|resource   $key        For HS*, a string key works. for RS*, must be a resource of an openssl public key
+     * @param string            $alg        The algorithm
+     *
+     * @return bool
+     *
+     * @throws DomainException Invalid Algorithm or OpenSSL failure
+     */
+    private static function verify($msg, $signature, $key, $alg)
+    {
+        if (empty(static::$supported_algs[$alg])) {
+            throw new DomainException('Algorithm not supported');
+        }
+
+        list($function, $algorithm) = static::$supported_algs[$alg];
+        switch($function) {
+            case 'openssl':
+                $success = openssl_verify($msg, $signature, $key, $algorithm);
+                if ($success === 1) {
+                    return true;
+                } elseif ($success === 0) {
+                    return false;
+                }
+                // returns 1 on success, 0 on failure, -1 on error.
+                throw new DomainException(
+                    'OpenSSL error: ' . openssl_error_string()
+                );
+            case 'hash_hmac':
+            default:
+                $hash = hash_hmac($algorithm, $msg, $key, true);
+                if (function_exists('hash_equals')) {
+                    return hash_equals($signature, $hash);
+                }
+                $len = min(static::safeStrlen($signature), static::safeStrlen($hash));
+
+                $status = 0;
+                for ($i = 0; $i < $len; $i++) {
+                    $status |= (ord($signature[$i]) ^ ord($hash[$i]));
+                }
+                $status |= (static::safeStrlen($signature) ^ static::safeStrlen($hash));
+
+                return ($status === 0);
+        }
+    }
+
+    /**
+     * Decode a JSON string into a PHP object.
+     *
+     * @param string $input JSON string
+     *
+     * @return object Object representation of JSON string
+     *
+     * @throws DomainException Provided string was invalid JSON
+     */
+    public static function jsonDecode($input)
+    {
+        if (version_compare(PHP_VERSION, '5.4.0', '>=') && !(defined('JSON_C_VERSION') && PHP_INT_SIZE > 4)) {
+            /** In PHP >=5.4.0, json_decode() accepts an options parameter, that allows you
+             * to specify that large ints (like Steam Transaction IDs) should be treated as
+             * strings, rather than the PHP default behaviour of converting them to floats.
+             */
+            $obj = json_decode($input, false, 512, JSON_BIGINT_AS_STRING);
+        } else {
+            /** Not all servers will support that, however, so for older versions we must
+             * manually detect large ints in the JSON string and quote them (thus converting
+             *them to strings) before decoding, hence the preg_replace() call.
+             */
+            $max_int_length = strlen((string) PHP_INT_MAX) - 1;
+            $json_without_bigints = preg_replace('/:\s*(-?\d{'.$max_int_length.',})/', ': "$1"', $input);
+            $obj = json_decode($json_without_bigints);
+        }
+
+        if (function_exists('json_last_error') && $errno = json_last_error()) {
+            static::handleJsonError($errno);
+        } elseif ($obj === null && $input !== 'null') {
+            throw new DomainException('Null result with non-null input');
+        }
+        return $obj;
+    }
+
+    /**
+     * Encode a PHP object into a JSON string.
+     *
+     * @param object|array $input A PHP object or array
+     *
+     * @return string JSON representation of the PHP object or array
+     *
+     * @throws DomainException Provided object could not be encoded to valid JSON
+     */
+    public static function jsonEncode($input)
+    {
+        $json = json_encode($input);
+        if (function_exists('json_last_error') && $errno = json_last_error()) {
+            static::handleJsonError($errno);
+        } elseif ($json === 'null' && $input !== null) {
+            throw new DomainException('Null result with non-null input');
+        }
+        return $json;
+    }
+
+    /**
+     * Decode a string with URL-safe Base64.
+     *
+     * @param string $input A Base64 encoded string
+     *
+     * @return string A decoded string
+     */
+    public static function urlsafeB64Decode($input)
+    {
+        $remainder = strlen($input) % 4;
+        if ($remainder) {
+            $padlen = 4 - $remainder;
+            $input .= str_repeat('=', $padlen);
+        }
+        return base64_decode(strtr($input, '-_', '+/'));
+    }
+
+    /**
+     * Encode a string with URL-safe Base64.
+     *
+     * @param string $input The string you want encoded
+     *
+     * @return string The base64 encode of what you passed in
+     */
+    public static function urlsafeB64Encode($input)
+    {
+        return str_replace('=', '', strtr(base64_encode($input), '+/', '-_'));
+    }
+
+    /**
+     * Helper method to create a JSON error.
+     *
+     * @param int $errno An error number from json_last_error()
+     *
+     * @return void
+     */
+    private static function handleJsonError($errno)
+    {
+        $messages = array(
+            JSON_ERROR_DEPTH => 'Maximum stack depth exceeded',
+            JSON_ERROR_STATE_MISMATCH => 'Invalid or malformed JSON',
+            JSON_ERROR_CTRL_CHAR => 'Unexpected control character found',
+            JSON_ERROR_SYNTAX => 'Syntax error, malformed JSON',
+            JSON_ERROR_UTF8 => 'Malformed UTF-8 characters' //PHP >= 5.3.3
+        );
+        throw new DomainException(
+            isset($messages[$errno])
+            ? $messages[$errno]
+            : 'Unknown JSON error: ' . $errno
+        );
+    }
+
+    /**
+     * Get the number of bytes in cryptographic strings.
+     *
+     * @param string
+     *
+     * @return int
+     */
+    private static function safeStrlen($str)
+    {
+        if (function_exists('mb_strlen')) {
+            return mb_strlen($str, '8bit');
+        }
+        return strlen($str);
+    }
+}

modules/x13allegro/tools/Firebase/JWT/SignatureInvalidException.php

@@ -0,0 +1,7 @@
+<?php
+namespace Firebase\JWT;
+
+class SignatureInvalidException extends \UnexpectedValueException
+{
+
+}

modules/x13allegro/tools/JsonMapper/JsonMapper.php

@@ -0,0 +1,687 @@
+<?php
+
+namespace JsonMapper;
+
+use ReflectionClass;
+use ReflectionProperty;
+use InvalidArgumentException;
+
+/**
+ * Automatically map JSON structures into objects.
+ *
+ * @category Netresearch
+ * @package  JsonMapper
+ * @author   Christian Weiske <cweiske@cweiske.de>
+ * @license  OSL-3.0 http://opensource.org/licenses/osl-3.0
+ * @link     http://cweiske.de/
+ */
+final class JsonMapper
+{
+    /**
+     * Throw an exception when JSON data contain a property
+     * that is not defined in the PHP class
+     *
+     * @var boolean
+     */
+    public $bExceptionOnUndefinedProperty = false;
+
+    /**
+     * Throw an exception if the JSON data miss a property
+     * that is marked with @required in the PHP class
+     *
+     * @var boolean
+     */
+    public $bExceptionOnMissingData = false;
+
+    /**
+     * If the types of map() parameters shall be checked.
+     *
+     * You have to disable it if you're using the json_decode "assoc" parameter.
+     *
+     *     json_decode($str, false)
+     *
+     * @var boolean
+     */
+    public $bEnforceMapType = true;
+
+    /**
+     * Throw an exception when an object is expected but the JSON contains
+     * a non-object type.
+     *
+     * @var boolean
+     */
+    public $bStrictObjectTypeChecking = false;
+
+    /**
+     * Throw an exception, if null value is found
+     * but the type of attribute does not allow nulls.
+     *
+     * @var bool
+     */
+    public $bStrictNullTypes = true;
+
+    /**
+     * Allow mapping of private and proteted properties.
+     *
+     * @var boolean
+     */
+    public $bIgnoreVisibility = false;
+
+    /**
+     * Override class names that JsonMapper uses to create objects.
+     * Useful when your setter methods accept abstract classes or interfaces.
+     *
+     * @var array
+     */
+    public $classMap = array();
+
+    /**
+     * Callback used when an undefined property is found.
+     *
+     * Works only when $bExceptionOnUndefinedProperty is disabled.
+     *
+     * Parameters to this function are:
+     * 1. Object that is being filled
+     * 2. Name of the unknown JSON property
+     * 3. JSON value of the property
+     *
+     * @var callable
+     */
+    public $undefinedPropertyHandler = null;
+
+    /**
+     * Runtime cache for inspected classes. This is particularly effective if
+     * mapArray() is called with a large number of objects
+     *
+     * @var array property inspection result cache
+     */
+    protected $arInspectedClasses = array();
+
+    /**
+     * Map data all data in $json into the given $object instance.
+     *
+     * @param object $json   JSON object structure from json_decode()
+     * @param object $object Object to map $json data into
+     *
+     * @return object Mapped object is returned.
+     * @see    mapArray()
+     */
+    public function map($json, $object)
+    {
+        if ($this->bEnforceMapType && !is_object($json)) {
+            throw new InvalidArgumentException(
+                'JsonMapper::map() requires first argument to be an object'
+                . ', ' . gettype($json) . ' given.'
+            );
+        }
+        if (!is_object($object)) {
+            throw new InvalidArgumentException(
+                'JsonMapper::map() requires second argument to be an object'
+                . ', ' . gettype($object) . ' given.'
+            );
+        }
+
+        $strClassName = get_class($object);
+        $rc = new ReflectionClass($object);
+        $strNs = $rc->getNamespaceName();
+        $providedProperties = array();
+        foreach ($json as $key => $jvalue) {
+            $key = $this->getSafeName($key);
+            $providedProperties[$key] = true;
+
+            // Store the property inspection results so we don't have to do it
+            // again for subsequent objects of the same type
+            if (!isset($this->arInspectedClasses[$strClassName][$key])) {
+                $this->arInspectedClasses[$strClassName][$key]
+                    = $this->inspectProperty($rc, $key);
+            }
+
+            list($hasProperty, $accessor, $type)
+                = $this->arInspectedClasses[$strClassName][$key];
+
+            if (!$hasProperty) {
+                if ($this->bExceptionOnUndefinedProperty) {
+                    throw new JsonMapperException(
+                        'JSON property "' . $key . '" does not exist'
+                        . ' in object of type ' . $strClassName
+                    );
+                } else if ($this->undefinedPropertyHandler !== null) {
+                    call_user_func(
+                        $this->undefinedPropertyHandler,
+                        $object, $key, $jvalue
+                    );
+                }
+                continue;
+            }
+
+            if ($accessor === null) {
+                if ($this->bExceptionOnUndefinedProperty) {
+                    throw new JsonMapperException(
+                        'JSON property "' . $key . '" has no public setter method'
+                        . ' in object of type ' . $strClassName
+                    );
+                }
+                continue;
+            }
+
+            if ($this->isNullable($type) || !$this->bStrictNullTypes) {
+                if ($jvalue === null) {
+                    $this->setProperty($object, $accessor, null);
+                    continue;
+                }
+                $type = $this->removeNullable($type);
+            } else if ($jvalue === null) {
+                throw new JsonMapperException(
+                    'JSON property "' . $key . '" in class "'
+                    . $strClassName . '" must not be NULL'
+                );
+            }
+
+            if ($type === null || $type === 'mixed') {
+                //no given type - simply set the json data
+                $this->setProperty($object, $accessor, $jvalue);
+                continue;
+            } else if ($this->isObjectOfSameType($type, $jvalue)) {
+                $this->setProperty($object, $accessor, $jvalue);
+                continue;
+            } else if ($this->isSimpleType($type)) {
+                if ($type === 'string' && is_object($jvalue)) {
+                    throw new JsonMapperException(
+                        'JSON property "' . $key . '" in class "'
+                        . $strClassName . '" is an object and'
+                        . ' cannot be converted to a string'
+                    );
+                }
+                settype($jvalue, $type);
+                $this->setProperty($object, $accessor, $jvalue);
+                continue;
+            }
+
+            //FIXME: check if type exists, give detailed error message if not
+            if ($type === '') {
+                throw new JsonMapperException(
+                    'Empty type at property "'
+                    . $strClassName . '::$' . $key . '"'
+                );
+            }
+
+            $array = null;
+            $subtype = null;
+            if ($this->isArrayOfType($type)) {
+                //array
+                $array = array();
+                $subtype = substr($type, 0, -2);
+            } else if (substr($type, -1) == ']') {
+                list($proptype, $subtype) = explode('[', substr($type, 0, -1));
+                if (!$this->isSimpleType($proptype)) {
+                    $proptype = $this->getFullNamespace($proptype, $strNs);
+                }
+                if ($proptype == 'array') {
+                    $array = array();
+                } else {
+                    $array = $this->createInstance($proptype, false, $jvalue);
+                }
+            } else {
+                $type = $this->getFullNamespace($type, $strNs);
+                if (is_a($type, 'ArrayObject', true)) {
+                    $array = $this->createInstance($type, false, $jvalue);
+                }
+            }
+
+            if ($array !== null) {
+                if (!is_array($jvalue) && $this->isFlatType(gettype($jvalue))) {
+                    throw new JsonMapperException(
+                        'JSON property "' . $key . '" must be an array, '
+                        . gettype($jvalue) . ' given'
+                    );
+                }
+
+                $cleanSubtype = $this->removeNullable($subtype);
+                if (!$this->isSimpleType($cleanSubtype)
+                    && $cleanSubtype !== null
+                ) {
+                    $subtype = $this->getFullNamespace($cleanSubtype, $strNs);
+                }
+                $child = $this->mapArray($jvalue, $array, $subtype, $key);
+            } else if ($this->isFlatType(gettype($jvalue))) {
+                //use constructor parameter if we have a class
+                // but only a flat type (i.e. string, int)
+                if ($this->bStrictObjectTypeChecking) {
+                    throw new JsonMapperException(
+                        'JSON property "' . $key . '" must be an object, '
+                        . gettype($jvalue) . ' given'
+                    );
+                }
+                $type = $this->getFullNamespace($type, $strNs);
+                $child = $this->createInstance($type, true, $jvalue);
+            } else {
+                $type = $this->getFullNamespace($type, $strNs);
+                $child = $this->createInstance($type, false, $jvalue);
+                $this->map($jvalue, $child);
+            }
+            $this->setProperty($object, $accessor, $child);
+        }
+
+        if ($this->bExceptionOnMissingData) {
+            $this->checkMissingData($providedProperties, $rc);
+        }
+
+        return $object;
+    }
+
+    /**
+     * Convert a type name to a fully namespaced type name.
+     *
+     * @param string $type  Type name (simple type or class name)
+     * @param string $strNs Base namespace that gets prepended to the type name
+     *
+     * @return string Fully-qualified type name with namespace
+     */
+    protected function getFullNamespace($type, $strNs)
+    {
+        if ($type !== '' && $type[0] != '\\') {
+            //create a full qualified namespace
+            if ($strNs != '') {
+                $type = '\\' . $strNs . '\\' . $type;
+            }
+        }
+        return $type;
+    }
+
+    /**
+     * Check required properties exist in json
+     *
+     * @param array  $providedProperties array with json properties
+     * @param ReflectionClass $rc Reflection class to check
+     *
+     * @return void
+     * @throws JsonMapperException
+     *
+     */
+    protected function checkMissingData($providedProperties, ReflectionClass $rc)
+    {
+        foreach ($rc->getProperties() as $property) {
+            $rprop = $rc->getProperty($property->name);
+            $docblock = $rprop->getDocComment();
+            $annotations = $this->parseAnnotations($docblock);
+            if (isset($annotations['required'])
+                && !isset($providedProperties[$property->name])
+            ) {
+                throw new JsonMapperException(
+                    'Required property "' . $property->name . '" of class '
+                    . $rc->getName()
+                    . ' is missing in JSON data'
+                );
+            }
+        }
+    }
+
+    /**
+     * Map an array
+     *
+     * @param array  $json       JSON array structure from json_decode()
+     * @param mixed  $array      Array or ArrayObject that gets filled with
+     *                           data from $json
+     * @param string $class      Class name for children objects.
+     *                           All children will get mapped onto this type.
+     *                           Supports class names and simple types
+     *                           like "string" and nullability "string|null".
+     *                           Pass "null" to not convert any values
+     * @param string $parent_key Defines the key this array belongs to
+     *                           in order to aid debugging.
+     *
+     * @return mixed Mapped $array is returned
+     */
+    public function mapArray($json, $array, $class = null, $parent_key = '')
+    {
+        foreach ($json as $key => $jvalue) {
+            if ($class === null) {
+                $array[$key] = $jvalue;
+            } else if ($this->isArrayOfType($class)) {
+                $array[$key] = $this->mapArray(
+                    $jvalue,
+                    array(),
+                    substr($class, 0, -2)
+                );
+            } else if ($this->isFlatType(gettype($jvalue))) {
+                //use constructor parameter if we have a class
+                // but only a flat type (i.e. string, int)
+                if ($jvalue === null) {
+                    $array[$key] = null;
+                } else {
+                    if ($this->isSimpleType($class)) {
+                        settype($jvalue, $class);
+                        $array[$key] = $jvalue;
+                    } else {
+                        $array[$key] = $this->createInstance(
+                            $class, true, $jvalue
+                        );
+                    }
+                }
+            } else if ($this->isFlatType($class)) {
+                throw new JsonMapperException(
+                    'JSON property "' . ($parent_key ? $parent_key : '?') . '"'
+                    . ' is an array of type "' . $class . '"'
+                    . ' but contained a value of type'
+                    . ' "' . gettype($jvalue) . '"'
+                );
+            } else if (is_a($class, 'ArrayObject', true)) {
+                $array[$key] = $this->mapArray(
+                    $jvalue,
+                    $this->createInstance($class)
+                );
+            } else {
+                $array[$key] = $this->map(
+                    $jvalue, $this->createInstance($class, false, $jvalue)
+                );
+            }
+        }
+        return $array;
+    }
+
+    /**
+     * Try to find out if a property exists in a given class.
+     * Checks property first, falls back to setter method.
+     *
+     * @param ReflectionClass $rc Reflection class to check
+     * @param string $name Property name
+     *
+     * @return array First value: if the property exists
+     *               Second value: the accessor to use (
+     *               ReflectionMethod or ReflectionProperty, or null)
+     *               Third value: type of the property
+     */
+    protected function inspectProperty(ReflectionClass $rc, $name)
+    {
+        //try setter method first
+        $setter = 'set' . $this->getCamelCaseName($name);
+
+        if ($rc->hasMethod($setter)) {
+            $rmeth = $rc->getMethod($setter);
+            if ($rmeth->isPublic() || $this->bIgnoreVisibility) {
+                $rparams = $rmeth->getParameters();
+                if (count($rparams) > 0) {
+                    $pclass = $rparams[0]->getClass();
+                    $nullability = '';
+                    if ($rparams[0]->allowsNull()) {
+                        $nullability = '|null';
+                    }
+                    if ($pclass !== null) {
+                        return array(
+                            true, $rmeth,
+                            '\\' . $pclass->getName() . $nullability
+                        );
+                    }
+                }
+
+                $docblock    = $rmeth->getDocComment();
+                $annotations = $this->parseAnnotations($docblock);
+
+                if (!isset($annotations['param'][0])) {
+                    // If there is no annotations (higher priority) inspect
+                    // if there's a scalar type being defined
+                    if (PHP_MAJOR_VERSION >= 7) {
+                        $ptype = $rparams[0]->getType();
+                        if ($ptype !== null) {
+                            return array(true, $rmeth, $ptype . $nullability);
+                        }
+                    }
+                    return array(true, $rmeth, null);
+                }
+                list($type) = explode(' ', trim($annotations['param'][0]));
+                return array(true, $rmeth, $type);
+            }
+        }
+
+        //now try to set the property directly
+        //we have to look it up in the class hierarchy
+        $class = $rc;
+        $rprop = null;
+        do {
+            if ($class->hasProperty($name)) {
+                $rprop = $class->getProperty($name);
+            }
+        } while ($rprop === null && $class = $class->getParentClass());
+
+        if ($rprop === null) {
+            //case-insensitive property matching
+            foreach ($rc->getProperties() as $p) {
+                if ((strcasecmp($p->name, $name) === 0)) {
+                    $rprop = $p;
+                    break;
+                }
+            }
+        }
+        if ($rprop !== null) {
+            if ($rprop->isPublic() || $this->bIgnoreVisibility) {
+                $docblock    = $rprop->getDocComment();
+                $annotations = $this->parseAnnotations($docblock);
+
+                if (!isset($annotations['var'][0])) {
+                    return array(true, $rprop, null);
+                }
+
+                //support "@var type description"
+                list($type) = explode(' ', $annotations['var'][0]);
+
+                return array(true, $rprop, $type);
+            } else {
+                //no setter, private property
+                return array(true, null, null);
+            }
+        }
+
+        //no setter, no property
+        return array(false, null, null);
+    }
+
+    /**
+     * Removes - and _ and makes the next letter uppercase
+     *
+     * @param string $name Property name
+     *
+     * @return string CamelCasedVariableName
+     */
+    protected function getCamelCaseName($name)
+    {
+        return str_replace(
+            ' ', '', ucwords(str_replace(array('_', '-'), ' ', $name))
+        );
+    }
+
+    /**
+     * Since hyphens cannot be used in variables we have to uppercase them.
+     *
+     * Technically you may use them, but they are awkward to access.
+     *
+     * @param string $name Property name
+     *
+     * @return string Name without hyphen
+     */
+    protected function getSafeName($name)
+    {
+        if (strpos($name, '-') !== false) {
+            $name = $this->getCamelCaseName($name);
+        }
+
+        return $name;
+    }
+
+    /**
+     * Set a property on a given object to a given value.
+     *
+     * Checks if the setter or the property are public are made before
+     * calling this method.
+     *
+     * @param object $object   Object to set property on
+     * @param object $accessor ReflectionMethod or ReflectionProperty
+     * @param mixed  $value    Value of property
+     *
+     * @return void
+     */
+    protected function setProperty(
+        $object, $accessor, $value
+    ) {
+        if (!$accessor->isPublic() && $this->bIgnoreVisibility) {
+            $accessor->setAccessible(true);
+        }
+        if ($accessor instanceof ReflectionProperty) {
+            $accessor->setValue($object, $value);
+        } else {
+            //setter method
+            $accessor->invoke($object, $value);
+        }
+    }
+
+    /**
+     * Create a new object of the given type.
+     *
+     * This method exists to be overwritten in child classes,
+     * so you can do dependency injection or so.
+     *
+     * @param string  $class        Class name to instantiate
+     * @param boolean $useParameter Pass $parameter to the constructor or not
+     * @param mixed   $jvalue       Constructor parameter (the json value)
+     *
+     * @return object Freshly created object
+     */
+    public function createInstance(
+        $class, $useParameter = false, $jvalue = null
+    ) {
+        if (isset($this->classMap[$class])) {
+            if (is_callable($mapper = $this->classMap[$class])) {
+                $class = $mapper($class, $jvalue);
+            } else {
+                $class = $this->classMap[$class];
+            }
+        }
+        if ($useParameter) {
+            return new $class($jvalue);
+        } else {
+            return (new ReflectionClass($class))->newInstanceWithoutConstructor();
+        }
+    }
+
+    /**
+     * Checks if the given type is a "simple type"
+     *
+     * @param string $type type name from gettype()
+     *
+     * @return boolean True if it is a simple PHP type
+     *
+     * @see isFlatType()
+     */
+    protected function isSimpleType($type)
+    {
+        return $type == 'string'
+            || $type == 'boolean' || $type == 'bool'
+            || $type == 'integer' || $type == 'int'
+            || $type == 'double' || $type == 'float'
+            || $type == 'array' || $type == 'object';
+    }
+
+    /**
+     * Checks if the object is of this type or has this type as one of its parents
+     *
+     * @param string $type  class name of type being required
+     * @param mixed  $value Some PHP value to be tested
+     *
+     * @return boolean True if $object has type of $type
+     */
+    protected function isObjectOfSameType($type, $value)
+    {
+        if (false === is_object($value)) {
+            return false;
+        }
+
+        return is_a($value, $type);
+    }
+
+    /**
+     * Checks if the given type is a type that is not nested
+     * (simple type except array and object)
+     *
+     * @param string $type type name from gettype()
+     *
+     * @return boolean True if it is a non-nested PHP type
+     *
+     * @see isSimpleType()
+     */
+    protected function isFlatType($type)
+    {
+        return $type == 'NULL'
+            || $type == 'string'
+            || $type == 'boolean' || $type == 'bool'
+            || $type == 'integer' || $type == 'int'
+            || $type == 'double' || $type == 'float';
+    }
+
+    /**
+     * Returns true if type is an array of elements
+     * (bracket notation)
+     *
+     * @param string $strType type to be matched
+     *
+     * @return bool
+     */
+    protected function isArrayOfType($strType)
+    {
+        return substr($strType, -2) === '[]';
+    }
+
+    /**
+     * Checks if the given type is nullable
+     *
+     * @param string $type type name from the phpdoc param
+     *
+     * @return boolean True if it is nullable
+     */
+    protected function isNullable($type)
+    {
+        return stripos('|' . $type . '|', '|null|') !== false;
+    }
+
+    /**
+     * Remove the 'null' section of a type
+     *
+     * @param string $type type name from the phpdoc param
+     *
+     * @return string The new type value
+     */
+    protected function removeNullable($type)
+    {
+        if ($type === null) {
+            return null;
+        }
+        return substr(
+            str_ireplace('|null|', '|', '|' . $type . '|'),
+            1, -1
+        );
+    }
+
+    /**
+     * Copied from PHPUnit 3.7.29, Util/Test.php
+     *
+     * @param string $docblock Full method docblock
+     *
+     * @return array
+     */
+    protected static function parseAnnotations($docblock)
+    {
+        $annotations = array();
+        // Strip away the docblock header and footer
+        // to ease parsing of one line annotations
+        $docblock = substr($docblock, 3, -2);
+
+        $re = '/@(?P<name>[A-Za-z_-]+)(?:[ \t]+(?P<value>.*?))?[ \t]*\r?$/m';
+        if (preg_match_all($re, $docblock, $matches)) {
+            $numMatches = count($matches[0]);
+
+            for ($i = 0; $i < $numMatches; ++$i) {
+                $annotations[$matches['name'][$i]][] = $matches['value'][$i];
+            }
+        }
+
+        return $annotations;
+    }
+}

modules/x13allegro/tools/JsonMapper/JsonMapperException.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace JsonMapper;
+
+use Exception;
+
+/**
+ * Simple exception
+ *
+ * @category Netresearch
+ * @package  JsonMapper
+ * @author   Christian Weiske <cweiske@cweiske.de>
+ * @license  OSL-3.0 http://opensource.org/licenses/osl-3.0
+ * @link     http://cweiske.de/
+ */
+class JsonMapperException extends Exception
+{
+}

modules/x13allegro/tools/MyCLabs/Enum.php

@@ -0,0 +1,321 @@
+<?php
+/**
+ * @link    http://github.com/myclabs/php-enum
+ * @license http://www.opensource.org/licenses/mit-license.php MIT (see the LICENSE file)
+ */
+
+namespace MyCLabs;
+
+/**
+ * Base Enum class
+ *
+ * Create an enum by implementing this class and adding class constants.
+ *
+ * @author Matthieu Napoli <matthieu@mnapoli.fr>
+ * @author Daniel Costa <danielcosta@gmail.com>
+ * @author Mirosław Filip <mirfilip@gmail.com>
+ *
+ * @psalm-template T
+ * @psalm-immutable
+ * @psalm-consistent-constructor
+ */
+abstract class Enum implements \JsonSerializable
+{
+    /**
+     * Enum value
+     *
+     * @var mixed
+     * @psalm-var T
+     */
+    protected $value;
+
+    /**
+     * Enum key, the constant name
+     *
+     * @var string
+     */
+    private $key;
+
+    /**
+     * Store existing constants in a static cache per object.
+     *
+     *
+     * @var array
+     * @psalm-var array<class-string, array<string, mixed>>
+     */
+    protected static $cache = [];
+
+    /**
+     * Cache of instances of the Enum class
+     *
+     * @var array
+     * @psalm-var array<class-string, array<string, static>>
+     */
+    protected static $instances = [];
+
+    /**
+     * Creates a new value of some type
+     *
+     * @psalm-pure
+     * @param mixed $value
+     *
+     * @psalm-param T $value
+     * @throws \UnexpectedValueException if incompatible type is given.
+     */
+    public function __construct($value)
+    {
+        if ($value instanceof static) {
+            /** @psalm-var T */
+            $value = $value->getValue();
+        }
+
+        /** @psalm-suppress ImplicitToStringCast assertValidValueReturningKey returns always a string but psalm has currently an issue here */
+        $this->key = static::assertValidValueReturningKey($value);
+
+        /** @psalm-var T */
+        $this->value = $value;
+    }
+
+    /**
+     * This method exists only for the compatibility reason when deserializing a previously serialized version
+     * that didn't had the key property
+     */
+    public function __wakeup()
+    {
+        /** @psalm-suppress DocblockTypeContradiction key can be null when deserializing an enum without the key */
+        if ($this->key === null) {
+            /**
+             * @psalm-suppress InaccessibleProperty key is not readonly as marked by psalm
+             * @psalm-suppress PossiblyFalsePropertyAssignmentValue deserializing a case that was removed
+             */
+            $this->key = static::search($this->value);
+        }
+    }
+
+    /**
+     * @param mixed $value
+     * @return static
+     */
+    public static function from($value)
+    {
+        $key = static::assertValidValueReturningKey($value);
+
+        return self::__callStatic($key, []);
+    }
+
+    /**
+     * @psalm-pure
+     * @return mixed
+     * @psalm-return T
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    /**
+     * Returns the enum key (i.e. the constant name).
+     *
+     * @psalm-pure
+     * @return string
+     */
+    public function getKey()
+    {
+        return $this->key;
+    }
+
+    /**
+     * @psalm-pure
+     * @psalm-suppress InvalidCast
+     * @return string
+     */
+    public function __toString()
+    {
+        return (string)$this->value;
+    }
+
+    /**
+     * Determines if Enum should be considered equal with the variable passed as a parameter.
+     * Returns false if an argument is an object of different class or not an object.
+     *
+     * This method is final, for more information read https://github.com/myclabs/php-enum/issues/4
+     *
+     * @psalm-pure
+     * @psalm-param mixed $variable
+     * @return bool
+     */
+    final public function equals($variable = null)
+    {
+        return $variable instanceof self
+            && $this->getValue() === $variable->getValue()
+            && static::class === \get_class($variable);
+    }
+
+    /**
+     * Returns the names (keys) of all constants in the Enum class
+     *
+     * @psalm-pure
+     * @psalm-return list<string>
+     * @return array
+     */
+    public static function keys()
+    {
+        return \array_keys(static::toArray());
+    }
+
+    /**
+     * Returns instances of the Enum class of all Enum constants
+     *
+     * @psalm-pure
+     * @psalm-return array<string, static>
+     * @return static[] Constant name in key, Enum instance in value
+     */
+    public static function values()
+    {
+        $values = array();
+
+        /** @psalm-var T $value */
+        foreach (static::toArray() as $key => $value) {
+            $values[$key] = new static($value);
+        }
+
+        return $values;
+    }
+
+    /**
+     * Returns all possible values as an array
+     *
+     * @psalm-pure
+     * @psalm-suppress ImpureStaticProperty
+     *
+     * @psalm-return array<string, mixed>
+     * @return array Constant name in key, constant value in value
+     */
+    public static function toArray()
+    {
+        $class = static::class;
+
+        if (!isset(static::$cache[$class])) {
+            /** @psalm-suppress ImpureMethodCall this reflection API usage has no side-effects here */
+            $reflection            = new \ReflectionClass($class);
+            /** @psalm-suppress ImpureMethodCall this reflection API usage has no side-effects here */
+            static::$cache[$class] = $reflection->getConstants();
+        }
+
+        return static::$cache[$class];
+    }
+
+    /**
+     * Check if is valid enum value
+     *
+     * @param $value
+     * @psalm-param mixed $value
+     * @psalm-pure
+     * @psalm-assert-if-true T $value
+     * @return bool
+     */
+    public static function isValid($value)
+    {
+        return \in_array($value, static::toArray(), true);
+    }
+
+    /**
+     * Asserts valid enum value
+     *
+     * @psalm-pure
+     * @psalm-assert T $value
+     * @param mixed $value
+     */
+    public static function assertValidValue($value)
+    {
+        self::assertValidValueReturningKey($value);
+    }
+
+    /**
+     * Asserts valid enum value
+     *
+     * @psalm-pure
+     * @psalm-assert T $value
+     * @param mixed $value
+     * @return string
+     */
+    private static function assertValidValueReturningKey($value)
+    {
+        if (false === ($key = static::search($value))) {
+            throw new \UnexpectedValueException("Value '$value' is not part of the enum " . static::class);
+        }
+
+        return $key;
+    }
+
+    /**
+     * Check if is valid enum key
+     *
+     * @param $key
+     * @psalm-param string $key
+     * @psalm-pure
+     * @return bool
+     */
+    public static function isValidKey($key)
+    {
+        $array = static::toArray();
+
+        return isset($array[$key]) || \array_key_exists($key, $array);
+    }
+
+    /**
+     * Return key for value
+     *
+     * @param mixed $value
+     *
+     * @psalm-param mixed $value
+     * @psalm-pure
+     * @return string|false
+     */
+    public static function search($value)
+    {
+        return \array_search($value, static::toArray(), true);
+    }
+
+    /**
+     * Returns a value when called statically like so: MyEnum::SOME_VALUE() given SOME_VALUE is a class constant
+     *
+     * @param string $name
+     * @param array  $arguments
+     *
+     * @return static
+     * @throws \BadMethodCallException
+     *
+     * @psalm-pure
+     */
+    public static function __callStatic($name, $arguments)
+    {
+        // fix ionCube lowercase error
+        $name = strtoupper($name);
+
+        $class = static::class;
+        if (!isset(self::$instances[$class][$name])) {
+            $array = static::toArray();
+            if (!isset($array[$name]) && !\array_key_exists($name, $array)) {
+                $message = "No static method or enum constant '$name' in class " . static::class;
+                throw new \BadMethodCallException($message);
+            }
+            return self::$instances[$class][$name] = new static($array[$name]);
+        }
+        return clone self::$instances[$class][$name];
+    }
+
+    /**
+     * Specify data which should be serialized to JSON. This method returns data that can be serialized by json_encode()
+     * natively.
+     *
+     * @return mixed
+     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
+     * @psalm-pure
+     */
+    #[\ReturnTypeWillChange]
+    public function jsonSerialize()
+    {
+        return $this->getValue();
+    }
+}

modules/x13allegro/tools/Psr/Autoloader/Psr4Autoloader.php

@@ -0,0 +1,146 @@
+<?php
+
+/**
+ * Class Psr4Autoloader
+ * @see https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader-examples.md#class-example
+ */
+class Psr4Autoloader
+{
+    /**
+     * An associative array where the key is a namespace prefix and the value
+     * is an array of base directories for classes in that namespace.
+     *
+     * @var array
+     */
+    protected $prefixes = array();
+
+    /**
+     * Register loader with SPL autoloader stack.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        spl_autoload_register(array($this, 'loadClass'));
+    }
+
+    /**
+     * Adds a base directory for a namespace prefix.
+     *
+     * @param string $prefix The namespace prefix.
+     * @param string $baseDir A base directory for class files in the
+     * namespace.
+     * @param bool $prepend If true, prepend the base directory to the stack
+     * instead of appending it; this causes it to be searched first rather
+     * than last.
+     * @return void
+     */
+    public function addNamespace($prefix, $baseDir, $prepend = false)
+    {
+        // normalize namespace prefix
+        $prefix = trim($prefix, '\\') . '\\';
+
+        // normalize the base directory with a trailing separator
+        $baseDir = rtrim($baseDir, DIRECTORY_SEPARATOR) . '/';
+
+        // initialize the namespace prefix array
+        if (isset($this->prefixes[$prefix]) === false) {
+            $this->prefixes[$prefix] = array();
+        }
+
+        // retain the base directory for the namespace prefix
+        if ($prepend) {
+            array_unshift($this->prefixes[$prefix], $baseDir);
+        } else {
+            array_push($this->prefixes[$prefix], $baseDir);
+        }
+    }
+
+    /**
+     * Loads the class file for a given class name.
+     *
+     * @param string $class The fully-qualified class name.
+     * @return mixed The mapped file name on success, or boolean false on
+     * failure.
+     */
+    public function loadClass($class)
+    {
+        // the current namespace prefix
+        $prefix = $class;
+
+        // work backwards through the namespace names of the fully-qualified
+        // class name to find a mapped file name
+        while (false !== $pos = strrpos($prefix, '\\')) {
+
+            // retain the trailing namespace separator in the prefix
+            $prefix = substr($class, 0, $pos + 1);
+
+            // the rest is the relative class name
+            $relativeClass = substr($class, $pos + 1);
+
+            // try to load a mapped file for the prefix and relative class
+            $mappedFile = $this->loadMappedFile($prefix, $relativeClass);
+            if ($mappedFile !== false) {
+                return $mappedFile;
+            }
+
+            // remove the trailing namespace separator for the next iteration
+            // of strrpos()
+            $prefix = rtrim($prefix, '\\');
+        }
+
+        // never found a mapped file
+        return false;
+    }
+
+    /**
+     * Load the mapped file for a namespace prefix and relative class.
+     *
+     * @param string $prefix The namespace prefix.
+     * @param string $relativeClass The relative class name.
+     * @return mixed Boolean false if no mapped file can be loaded, or the
+     * name of the mapped file that was loaded.
+     */
+    protected function loadMappedFile($prefix, $relativeClass)
+    {
+        // are there any base directories for this namespace prefix?
+        if (isset($this->prefixes[$prefix]) === false) {
+            return false;
+        }
+
+        // look through base directories for this namespace prefix
+        foreach ($this->prefixes[$prefix] as $baseDir) {
+
+            // replace the namespace prefix with the base directory,
+            // replace namespace separators with directory separators
+            // in the relative class name, append with .php
+            $file = $baseDir
+                . str_replace('\\', '/', $relativeClass)
+                . '.php';
+
+            // if the mapped file exists, require it
+            if ($this->requireFile($file)) {
+                // yes, we're done
+                return $file;
+            }
+        }
+
+        // never found it
+        return false;
+    }
+
+    /**
+     * If a file exists, require it from the file system.
+     *
+     * @param string $file The file to require.
+     * @return bool True if the file exists, false if not.
+     */
+    protected function requireFile($file)
+    {
+        if (file_exists($file)) {
+            require $file;
+            return true;
+        }
+        return false;
+    }
+}

modules/x13allegro/tools/UUID/UUID.php

@@ -0,0 +1,152 @@
+<?php
+
+namespace UUID;
+
+use http\Exception\InvalidArgumentException;
+
+/**
+ * Represents a universally unique identifier (UUID), according to RFC 4122.
+ *
+ * This class provides the static methods `uuid3()`, `uuid4()`, and
+ * `uuid5()` for generating version 3, 4, and 5 UUIDs as specified in RFC 4122.
+ *
+ * If all you want is a unique ID, you should call `uuid4()`.
+ *
+ * @link http://tools.ietf.org/html/rfc4122
+ * @link http://en.wikipedia.org/wiki/Universally_unique_identifier
+ * @link http://www.php.net/manual/en/function.uniqid.php#94959
+ */
+class UUID
+{
+    /**
+     * When this namespace is specified, the name string is a fully-qualified domain name.
+     * @link http://tools.ietf.org/html/rfc4122#appendix-C
+     */
+    const NAMESPACE_DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+    /**
+     * When this namespace is specified, the name string is a URL.
+     * @link http://tools.ietf.org/html/rfc4122#appendix-C
+     */
+    const NAMESPACE_URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+    /**
+     * When this namespace is specified, the name string is an ISO OID.
+     * @link http://tools.ietf.org/html/rfc4122#appendix-C
+     */
+    const NAMESPACE_OID = '6ba7b812-9dad-11d1-80b4-00c04fd430c8';
+    /**
+     * When this namespace is specified, the name string is an X.500 DN in DER or a text output format.
+     * @link http://tools.ietf.org/html/rfc4122#appendix-C
+     */
+    const NAMESPACE_X500 = '6ba7b814-9dad-11d1-80b4-00c04fd430c8';
+    /**
+     * The nil UUID is special form of UUID that is specified to have all 128 bits set to zero.
+     * @link http://tools.ietf.org/html/rfc4122#section-4.1.7
+     */
+    const NIL = '00000000-0000-0000-0000-000000000000';
+
+    private static function getBytes($uuid) {
+        if (!self::isValid($uuid)) {
+            throw new InvalidArgumentException('Invalid UUID string: ' . $uuid);
+        }
+        // Get hexadecimal components of UUID
+        $uhex = str_replace(array(
+            'urn:',
+            'uuid:',
+            '-',
+            '{',
+            '}'
+        ), '', $uuid);
+
+        // Binary Value
+        $ustr = '';
+
+        // Convert UUID to bits
+        for ($i = 0; $i < strlen($uhex); $i += 2) {
+            $ustr .= chr(hexdec($uhex[$i] . $uhex[$i + 1]));
+        }
+        return $ustr;
+    }
+
+    private static function uuidFromHash($hash, $version) {
+        return sprintf('%08s-%04s-%04x-%04x-%12s',
+            // 32 bits for "time_low"
+            substr($hash, 0, 8),
+            // 16 bits for "time_mid"
+            substr($hash, 8, 4),
+            // 16 bits for "time_hi_and_version",
+            // four most significant bits holds version number
+            (hexdec(substr($hash, 12, 4)) & 0x0fff) | $version << 12,
+            // 16 bits, 8 bits for "clk_seq_hi_res",
+            // 8 bits for "clk_seq_low",
+            // two most significant bits holds zero and one for variant DCE1.1
+            (hexdec(substr($hash, 16, 4)) & 0x3fff) | 0x8000,
+            // 48 bits for "node"
+            substr($hash, 20, 12));
+    }
+
+    /**
+     * Generate a version 3 UUID based on the MD5 hash of a namespace identifier
+     * (which is a UUID) and a name (which is a string).
+     *
+     * @param string $namespace The UUID namespace in which to create the named UUID
+     * @param string $name The name to create a UUID for
+     * @return string
+     */
+    public static function uuid3($namespace, $name) {
+        $nbytes = self::getBytes($namespace);
+
+        // Calculate hash value
+        $hash = md5($nbytes . $name);
+
+        return self::uuidFromHash($hash, 3);
+    }
+
+    /**
+     * Generate a version 4 (random) UUID.
+     *
+     * @return string
+     */
+    public static function uuid4() {
+        $bytes = function_exists('random_bytes') ? random_bytes(16) : openssl_random_pseudo_bytes(16);
+        $hash = bin2hex($bytes);
+        return self::uuidFromHash($hash, 4);
+    }
+
+    /**
+     * Generate a version 5 UUID based on the SHA-1 hash of a namespace
+     * identifier (which is a UUID) and a name (which is a string).
+     *
+     * @param string $namespace The UUID namespace in which to create the named UUID
+     * @param string $name The name to create a UUID for
+     * @return string
+     */
+    public static function uuid5($namespace, $name) {
+        $nbytes = self::getBytes($namespace);
+
+        // Calculate hash value
+        $hash = sha1($nbytes . $name);
+
+        return self::uuidFromHash($hash, 5);
+    }
+
+    /**
+     * Check if a string is a valid UUID.
+     *
+     * @param string $uuid The string UUID to test
+     * @return boolean
+     */
+    public static function isValid($uuid) {
+        return preg_match('/^(urn:)?(uuid:)?(\{)?[0-9a-f]{8}\-?[0-9a-f]{4}\-?[0-9a-f]{4}\-?[0-9a-f]{4}\-?[0-9a-f]{12}(?(3)\}|)$/i', $uuid) === 1;
+    }
+
+    /**
+     * Check if two UUIDs are equal.
+     *
+     * @param string $uuid1 The first UUID to test
+     * @param string $uuid2 The second UUID to test
+     * @return boolean
+     */
+    public static function equals($uuid1, $uuid2) {
+        return self::getBytes($uuid1) === self::getBytes($uuid2);
+    }
+}