PHP Assertion::isInstanceOf方法代码示例

 /**
  * @param $partId
  * @return \Modules\Parts\ReadModel\PartsThatWereManufactured
  */
 public function getReadModel($partId)
 {
     $partId = (string) $partId;
     $readModel = $this->repository->find($partId);
     Assertion::isInstanceOf($readModel, PartsThatWereManufactured::class);
     return $readModel;
 }

 /**
  * @param ServiceLocatorInterface $serviceLocator
  *
  * @return CommonReport
  * @throws \Zend\ServiceManager\Exception\ServiceNotFoundException
  * @throws \Assert\AssertionFailedException
  */
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     $appServiceLocator = $serviceLocator instanceof AbstractPluginManager ? $serviceLocator->getServiceLocator() : $serviceLocator;
     /** @var ModuleOptionsPluginManagerInterface $moduleOptionsManager */
     $moduleOptionsManager = $appServiceLocator->get(ModuleOptionsPluginManagerInterface::class);
     Assertion::isInstanceOf($moduleOptionsManager, ModuleOptionsPluginManagerInterface::class, sprintf('Module options manager not implement %s', ModuleOptionsPluginManagerInterface::class));
     /** @var ModuleOptions $moduleOptions */
     $moduleOptions = $moduleOptionsManager->get(ModuleOptions::class);
     Assertion::isInstanceOf($moduleOptions, ModuleOptions::class, sprintf('Module options not implement %s', ModuleOptions::class));
     /** @var GoogleSheetsStorageBuilder $googleSheetsStorageBuilder */
     $googleSheetsStorageBuilder = $appServiceLocator->get(GoogleSheetsStorageBuilder::class);
     Assertion::isInstanceOf($googleSheetsStorageBuilder, GoogleSheetsStorageBuilder::class, sprintf('GoogleSheetsStorageBuilder not implement %s', GoogleSheetsStorageBuilder::class));
     /** @var GitLabDataStorageBuilder $gitLabDataStorageBuilder */
     $gitLabDataStorageBuilder = $appServiceLocator->get(GitLabDataStorageBuilder::class);
     Assertion::isInstanceOf($gitLabDataStorageBuilder, GitLabDataStorageBuilder::class, sprintf('GitLabDataStorageBuilder not implement %s', GitLabDataStorageBuilder::class));
     $report = new CommonReport($googleSheetsStorageBuilder, $gitLabDataStorageBuilder);
     if ($report instanceof LoggerAwareInterface) {
         $loggerName = $moduleOptions->getLogger();
         if (null !== $loggerName) {
             /** @var LoggerInterface  $logger */
             $logger = $appServiceLocator->get($loggerName);
             Assertion::isInstanceOf($logger, LoggerInterface::class, sprintf('Log  not implement %s', LoggerInterface::class));
             $report->setLogger($logger);
         }
     }
     return $report;
 }

 /**
  * {@inheritdoc}
  */
 public function authenticate($subject, Caller $caller)
 {
     Assertion::isArray($subject);
     Assertion::choicesNotEmpty($subject, ['password']);
     Assertion::isInstanceOf($caller, 'Guardian\\User\\Caller', sprintf('The caller was expected to be an instance of "%s"', 'Indigo\\Guardian\\Caller\\User'));
     return $this->hasher->verify($subject['password'], $caller->getPassword());
 }

 /**
  * @Given /^I have some generated config at "([^"]*)"$/
  */
 public function iHaveSomeGeneratedConfigAt($arg1)
 {
     $this->configFilePath = getcwd() . "/{$arg1}/";
     Assertion::file($this->configFilePath . 'configured.json');
     $this->config = json_decode(file_get_contents($this->configFilePath . 'configured.json'));
     Assertion::isInstanceOf($this->config, 'stdClass');
 }

 /**
  * @param LegDto[] $legs
  */
 public function setLegs(array $legs) : array
 {
     foreach ($legs as $leg) {
         Assertion::isInstanceOf($leg, LegDto::class);
     }
     $this->legs = $legs;
 }

 /**
  * FilesCollection constructor.
  *
  * @param File[] $files
  */
 public function __construct(array $files)
 {
     foreach ($files as $file) {
         Assertion::isInstanceOf($file, File::class);
     }
     $this->files = $files;
 }

 /**
  * @param CreateCoupon $createCoupon
  */
 public function validate(DtoInterface $createCoupon)
 {
     Assertion::isInstanceOf($createCoupon, 'Matthias\\LeanpubApi\\Dto\\CreateCoupon');
     if (count($createCoupon->getPackageDiscounts()) === 0) {
         throw new BadRequestException('Coupon should have at least one package discount, one of which can be for the "book" package');
     }
 }

 protected function _validateIpnListeners()
 {
     Assertion::notEmpty($this->ipnListeners);
     foreach ($this->ipnListeners as $ipn_listener) {
         Assertion::isInstanceOf($ipn_listener, PaymentListener::class);
     }
 }

 public function fromFileMakerValue($value)
 {
     if (null === $value) {
         return null;
     }
     Assertion::isInstanceOf($value, StreamInterface::class);
     return $value;
 }

 /**
  * @param TaskListId $taskListId
  * @param TaskListEntry[] $taskListEntries
  */
 private function __construct(TaskListId $taskListId, array $taskListEntries)
 {
     foreach ($taskListEntries as $taskListEntry) {
         Assertion::isInstanceOf($taskListEntry, 'Prooph\\Processing\\Processor\\Task\\TaskListEntry');
     }
     $this->taskListEntries = $taskListEntries;
     $this->taskListId = $taskListId;
 }

 public function toFileMakerValue($value)
 {
     if (null === $value) {
         return null;
     }
     Assertion::isInstanceOf($value, Decimal::class);
     return $value;
 }

 /**
  * @param Adapter $snapshotAdapter
  */
 public function __construct(Adapter $snapshotAdapter, array $aggregateRepositories)
 {
     foreach ($aggregateRepositories as $aggregateRepository) {
         Assertion::isInstanceOf($aggregateRepository, AggregateRepository::class);
     }
     $this->snapshotAdapter = $snapshotAdapter;
     $this->aggregateRepositories = $aggregateRepositories;
 }

 /**
  * @param StreamName $streamName
  * @param Message[] $streamEvents
  */
 public function __construct(StreamName $streamName, array $streamEvents)
 {
     foreach ($streamEvents as $streamEvent) {
         Assertion::isInstanceOf($streamEvent, Message::class);
     }
     $this->streamName = $streamName;
     $this->streamEvents = $streamEvents;
 }

 public function fromFileMakerValue($value)
 {
     if (null === $value) {
         return null;
     }
     Assertion::isInstanceOf($value, Decimal::class);
     return $value->asInteger();
 }

 public function delete($identifier, SettingsInterface $settings = null)
 {
     $arguments = $settings->get('arguments');
     Assertion::isInstanceOf($arguments, SettingsInterface::CLASS);
     $exchange = $this->getConfig()->get('exchange');
     $channel = $this->connector->getConnection()->channel();
     $channel->exchange_unbind($exchange, $exchange, $identifier, false, $arguments->toArray());
 }