[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * This file is part of the ramsey/uuid library
   4   *
   5   * For the full copyright and license information, please view the LICENSE
   6   * file that was distributed with this source code.
   7   *
   8   * @copyright Copyright (c) Ben Ramsey <[email protected]>
   9   * @license http://opensource.org/licenses/MIT MIT
  10   * @link https://benramsey.com/projects/ramsey-uuid/ Documentation
  11   * @link https://packagist.org/packages/ramsey/uuid Packagist
  12   * @link https://github.com/ramsey/uuid GitHub
  13   */
  14  
  15  namespace Ramsey\Uuid;
  16  
  17  use Ramsey\Uuid\Converter\TimeConverterInterface;
  18  use Ramsey\Uuid\Generator\PeclUuidTimeGenerator;
  19  use Ramsey\Uuid\Provider\Node\FallbackNodeProvider;
  20  use Ramsey\Uuid\Provider\Node\RandomNodeProvider;
  21  use Ramsey\Uuid\Provider\Node\SystemNodeProvider;
  22  use Ramsey\Uuid\Converter\NumberConverterInterface;
  23  use Ramsey\Uuid\Converter\Number\BigNumberConverter;
  24  use Ramsey\Uuid\Converter\Number\DegradedNumberConverter;
  25  use Ramsey\Uuid\Converter\Time\BigNumberTimeConverter;
  26  use Ramsey\Uuid\Converter\Time\DegradedTimeConverter;
  27  use Ramsey\Uuid\Converter\Time\PhpTimeConverter;
  28  use Ramsey\Uuid\Provider\Time\SystemTimeProvider;
  29  use Ramsey\Uuid\Builder\UuidBuilderInterface;
  30  use Ramsey\Uuid\Builder\DefaultUuidBuilder;
  31  use Ramsey\Uuid\Codec\CodecInterface;
  32  use Ramsey\Uuid\Codec\StringCodec;
  33  use Ramsey\Uuid\Codec\GuidStringCodec;
  34  use Ramsey\Uuid\Builder\DegradedUuidBuilder;
  35  use Ramsey\Uuid\Generator\RandomGeneratorFactory;
  36  use Ramsey\Uuid\Generator\RandomGeneratorInterface;
  37  use Ramsey\Uuid\Generator\TimeGeneratorFactory;
  38  use Ramsey\Uuid\Generator\TimeGeneratorInterface;
  39  use Ramsey\Uuid\Provider\TimeProviderInterface;
  40  use Ramsey\Uuid\Provider\NodeProviderInterface;
  41  
  42  /**
  43   * FeatureSet detects and exposes available features in the current environment
  44   * (32- or 64-bit, available dependencies, etc.)
  45   */
  46  class FeatureSet
  47  {
  48      /**
  49       * @var bool
  50       */
  51      private $disableBigNumber = false;
  52  
  53      /**
  54       * @var bool
  55       */
  56      private $disable64Bit = false;
  57  
  58      /**
  59       * @var bool
  60       */
  61      private $ignoreSystemNode = false;
  62  
  63      /**
  64       * @var bool
  65       */
  66      private $enablePecl = false;
  67  
  68      /**
  69       * @var UuidBuilderInterface
  70       */
  71      private $builder;
  72  
  73      /**
  74       * @var CodecInterface
  75       */
  76      private $codec;
  77  
  78      /**
  79       * @var NodeProviderInterface
  80       */
  81      private $nodeProvider;
  82  
  83      /**
  84       * @var NumberConverterInterface
  85       */
  86      private $numberConverter;
  87  
  88      /**
  89       * @var RandomGeneratorInterface
  90       */
  91      private $randomGenerator;
  92  
  93      /**
  94       * @var TimeGeneratorInterface
  95       */
  96      private $timeGenerator;
  97  
  98      /**
  99       * Constructs a `FeatureSet` for use by a `UuidFactory` to determine or set
 100       * features available to the environment
 101       *
 102       * @param bool $useGuids Whether to build UUIDs using the `GuidStringCodec`
 103       * @param bool $force32Bit Whether to force the use of 32-bit functionality
 104       *     (primarily for testing purposes)
 105       * @param bool $forceNoBigNumber Whether to disable the use of moontoast/math
 106       *     `BigNumber` (primarily for testing purposes)
 107       * @param bool $ignoreSystemNode Whether to disable attempts to check for
 108       *     the system host ID (primarily for testing purposes)
 109       * @param bool $enablePecl Whether to enable the use of the `PeclUuidTimeGenerator`
 110       *     to generate version 1 UUIDs
 111       */
 112      public function __construct(
 113          $useGuids = false,
 114          $force32Bit = false,
 115          $forceNoBigNumber = false,
 116          $ignoreSystemNode = false,
 117          $enablePecl = false
 118      ) {
 119          $this->disableBigNumber = $forceNoBigNumber;
 120          $this->disable64Bit = $force32Bit;
 121          $this->ignoreSystemNode = $ignoreSystemNode;
 122          $this->enablePecl = $enablePecl;
 123  
 124          $this->numberConverter = $this->buildNumberConverter();
 125          $this->builder = $this->buildUuidBuilder();
 126          $this->codec = $this->buildCodec($useGuids);
 127          $this->nodeProvider = $this->buildNodeProvider();
 128          $this->randomGenerator = $this->buildRandomGenerator();
 129          $this->setTimeProvider(new SystemTimeProvider());
 130      }
 131  
 132      /**
 133       * Returns the builder configured for this environment
 134       *
 135       * @return UuidBuilderInterface
 136       */
 137      public function getBuilder()
 138      {
 139          return $this->builder;
 140      }
 141  
 142      /**
 143       * Returns the UUID UUID coder-decoder configured for this environment
 144       *
 145       * @return CodecInterface
 146       */
 147      public function getCodec()
 148      {
 149          return $this->codec;
 150      }
 151  
 152      /**
 153       * Returns the system node ID provider configured for this environment
 154       *
 155       * @return NodeProviderInterface
 156       */
 157      public function getNodeProvider()
 158      {
 159          return $this->nodeProvider;
 160      }
 161  
 162      /**
 163       * Returns the number converter configured for this environment
 164       *
 165       * @return NumberConverterInterface
 166       */
 167      public function getNumberConverter()
 168      {
 169          return $this->numberConverter;
 170      }
 171  
 172      /**
 173       * Returns the random UUID generator configured for this environment
 174       *
 175       * @return RandomGeneratorInterface
 176       */
 177      public function getRandomGenerator()
 178      {
 179          return $this->randomGenerator;
 180      }
 181  
 182      /**
 183       * Returns the time-based UUID generator configured for this environment
 184       *
 185       * @return TimeGeneratorInterface
 186       */
 187      public function getTimeGenerator()
 188      {
 189          return $this->timeGenerator;
 190      }
 191  
 192      /**
 193       * Sets the time provider for use in this environment
 194       *
 195       * @param TimeProviderInterface $timeProvider
 196       */
 197      public function setTimeProvider(TimeProviderInterface $timeProvider)
 198      {
 199          $this->timeGenerator = $this->buildTimeGenerator($timeProvider);
 200      }
 201  
 202      /**
 203       * Determines which UUID coder-decoder to use and returns the configured
 204       * codec for this environment
 205       *
 206       * @param bool $useGuids Whether to build UUIDs using the `GuidStringCodec`
 207       * @return CodecInterface
 208       */
 209      protected function buildCodec($useGuids = false)
 210      {
 211          if ($useGuids) {
 212              return new GuidStringCodec($this->builder);
 213          }
 214  
 215          return new StringCodec($this->builder);
 216      }
 217  
 218      /**
 219       * Determines which system node ID provider to use and returns the configured
 220       * system node ID provider for this environment
 221       *
 222       * @return NodeProviderInterface
 223       */
 224      protected function buildNodeProvider()
 225      {
 226          if ($this->ignoreSystemNode) {
 227              return new RandomNodeProvider();
 228          }
 229  
 230          return new FallbackNodeProvider([
 231              new SystemNodeProvider(),
 232              new RandomNodeProvider()
 233          ]);
 234      }
 235  
 236      /**
 237       * Determines which number converter to use and returns the configured
 238       * number converter for this environment
 239       *
 240       * @return NumberConverterInterface
 241       */
 242      protected function buildNumberConverter()
 243      {
 244          if ($this->hasBigNumber()) {
 245              return new BigNumberConverter();
 246          }
 247  
 248          return new DegradedNumberConverter();
 249      }
 250  
 251      /**
 252       * Determines which random UUID generator to use and returns the configured
 253       * random UUID generator for this environment
 254       *
 255       * @return RandomGeneratorInterface
 256       */
 257      protected function buildRandomGenerator()
 258      {
 259          return (new RandomGeneratorFactory())->getGenerator();
 260      }
 261  
 262      /**
 263       * Determines which time-based UUID generator to use and returns the configured
 264       * time-based UUID generator for this environment
 265       *
 266       * @param TimeProviderInterface $timeProvider
 267       * @return TimeGeneratorInterface
 268       */
 269      protected function buildTimeGenerator(TimeProviderInterface $timeProvider)
 270      {
 271          if ($this->enablePecl) {
 272              return new PeclUuidTimeGenerator();
 273          }
 274  
 275          return (new TimeGeneratorFactory(
 276              $this->nodeProvider,
 277              $this->buildTimeConverter(),
 278              $timeProvider
 279          ))->getGenerator();
 280      }
 281  
 282      /**
 283       * Determines which time converter to use and returns the configured
 284       * time converter for this environment
 285       *
 286       * @return TimeConverterInterface
 287       */
 288      protected function buildTimeConverter()
 289      {
 290          if ($this->is64BitSystem()) {
 291              return new PhpTimeConverter();
 292          }
 293  
 294          if ($this->hasBigNumber()) {
 295              return new BigNumberTimeConverter();
 296          }
 297  
 298          return new DegradedTimeConverter();
 299      }
 300  
 301      /**
 302       * Determines which UUID builder to use and returns the configured UUID
 303       * builder for this environment
 304       *
 305       * @return UuidBuilderInterface
 306       */
 307      protected function buildUuidBuilder()
 308      {
 309          if ($this->is64BitSystem()) {
 310              return new DefaultUuidBuilder($this->numberConverter);
 311          }
 312  
 313          return new DegradedUuidBuilder($this->numberConverter);
 314      }
 315  
 316      /**
 317       * Returns true if the system has `Moontoast\Math\BigNumber`
 318       *
 319       * @return bool
 320       */
 321      protected function hasBigNumber()
 322      {
 323          return class_exists('Moontoast\Math\BigNumber') && !$this->disableBigNumber;
 324      }
 325  
 326      /**
 327       * Returns true if the system is 64-bit, false otherwise
 328       *
 329       * @return bool
 330       */
 331      protected function is64BitSystem()
 332      {
 333          return PHP_INT_SIZE == 8 && !$this->disable64Bit;
 334      }
 335  }