PHP Validate::isA方法代码示例

 /**
  * Constructor
  *
  * @param string                                         $content Http response
  * as string
  *
  * @param WindowsAzure\Common\Internal\Http\BatchRequest $request Source batch
  * request object
  */
 public function __construct($content, $request = null)
 {
     $params['include_bodies'] = true;
     $params['input'] = $content;
     $mimeDecoder = new \Mail_mimeDecode($content);
     $structure = $mimeDecoder->decode($params);
     $parts = $structure->parts;
     $this->_contexts = array();
     $requestContexts = null;
     if ($request != null) {
         Validate::isA($request, 'WindowsAzure\\Common\\Internal\\Http\\BatchRequest', 'request');
         $requestContexts = $request->getContexts();
     }
     $i = 0;
     foreach ($parts as $part) {
         if (!empty($part->body)) {
             $headerEndPos = strpos($part->body, "\r\n\r\n");
             $header = substr($part->body, 0, $headerEndPos);
             $body = substr($part->body, $headerEndPos + 4);
             $headerStrings = explode("\r\n", $header);
             $response = new \HTTP_Request2_Response(array_shift($headerStrings));
             foreach ($headerStrings as $headerString) {
                 $response->parseHeaderLine($headerString);
             }
             $response->appendBody($body);
             $this->_contexts[] = $response;
             if (is_array($requestContexts)) {
                 $expectedCodes = $requestContexts[$i]->getStatusCodes();
                 $statusCode = $response->getStatus();
                 if (!in_array($statusCode, $expectedCodes)) {
                     $reason = $response->getReasonPhrase();
                     throw new ServiceException($statusCode, $reason, $body);
                 }
             }
             $i++;
         }
     }
 }

 /**
  * Update encoding reserved units settings.
  *
  * @param Models\EncodingReservedUnit $encodingReservedUnit Update data
  * valid idli
  *
  * @return void
  */
 public function updateEncodingReservedUnit($encodingReservedUnit)
 {
     Validate::isA($encodingReservedUnit, 'WindowsAzure\\MediaServices\\Models\\EncodingReservedUnit', 'encodingReservedUnit');
     $accountID = $encodingReservedUnit->getAccountId();
     $encodingReservedUnit->setAccountId(null);
     // never send account Id
     $this->_updateEntity($encodingReservedUnit, "EncodingReservedUnitTypes(guid'{$accountID}')");
     $encodingReservedUnit->setAccountId($accountID);
 }

 /**
  * Creates an ATOM ENTRY instance with specified simpleXML object
  *
  * @param \SimpleXMLElement $entryXml xml element of ATOM ENTRY
  *
  * @return none
  */
 public function fromXml($entryXml)
 {
     Validate::notNull($entryXml, 'entryXml');
     Validate::isA($entryXml, '\\SimpleXMLElement', 'entryXml');
     $this->attributes = (array) $entryXml->attributes();
     $entryArray = (array) $entryXml;
     if (array_key_exists(Resources::AUTHOR, $entryArray)) {
         $this->author = $this->processAuthorNode($entryArray);
     }
     if (array_key_exists(Resources::CATEGORY, $entryArray)) {
         $this->category = $this->processCategoryNode($entryArray);
     }
     if (array_key_exists('content', $entryArray)) {
         $content = new Content();
         $content->fromXml($entryArray['content']);
         $this->content = $content;
     }
     if (array_key_exists(Resources::CONTRIBUTOR, $entryArray)) {
         $this->contributor = $this->processContributorNode($entryArray);
     }
     if (array_key_exists('id', $entryArray)) {
         $this->id = (string) $entryArray['id'];
     }
     if (array_key_exists(Resources::LINK, $entryArray)) {
         $this->link = $this->processLinkNode($entryArray);
     }
     if (array_key_exists('published', $entryArray)) {
         $this->published = $entryArray['published'];
     }
     if (array_key_exists('rights', $entryArray)) {
         $this->rights = $entryArray['rights'];
     }
     if (array_key_exists('source', $entryArray)) {
         $source = new Source();
         $source->parseXml($entryArray['source']->asXML());
         $this->source = $source;
     }
     if (array_key_exists('title', $entryArray)) {
         $this->title = $entryArray['title'];
     }
     if (array_key_exists('updated', $entryArray)) {
         $this->updated = \DateTime::createFromFormat(\DateTime::ATOM, (string) $entryArray['updated']);
     }
 }

 /**
  * Send Update Program operation
  *
  * @param Models\Programs $program Programs data
  *
  * @return Models\Operation The operation to track the program update.
  */
 public function sendUpdateProgramOperation($program)
 {
     Validate::isA($program, 'WindowsAzure\\MediaServices\\Models\\Program', 'program');
     $programId = $program->getId();
     Validate::notNull($programId, "programId");
     return $this->_sendOperation($program, "Programs('{$programId}')", Resources::HTTP_MERGE, [Resources::STATUS_ACCEPTED, Resources::STATUS_NO_CONTENT]);
 }

 /**
  * Creates an ATOM CONTENT instance with specified simpleXML object
  *
  * @param \SimpleXMLElement $contentXml xml element of ATOM CONTENT
  *
  * @return none
  */
 public function fromXml($contentXml)
 {
     Validate::notNull($contentXml, 'contentXml');
     Validate::isA($contentXml, '\\SimpleXMLElement', 'contentXml');
     $attributes = $contentXml->attributes();
     if (!empty($attributes['type'])) {
         $this->content = (string) $attributes['type'];
     }
     $text = '';
     foreach ($contentXml->children() as $child) {
         $text .= $child->asXML();
     }
     $this->text = $text;
     $this->xml = $contentXml;
 }

 /**
  * Builds a media services object.
  *
  * @param WindowsAzure\Common\Internal\MediaServicesSettings $settings The media
  * services configuration settings.
  *
  * @return WindowsAzure\MediaServices\Internal\IMediaServices
  */
 public function createMediaServicesService($settings)
 {
     Validate::isA($settings, 'WindowsAzure\\Common\\Internal\\MediaServicesSettings', 'settings');
     $httpClient = new HttpClient();
     $serializer = $this->serializer();
     $uri = Utilities::tryAddUrlScheme($settings->getEndpointUri(), Resources::HTTPS_SCHEME);
     $mediaServicesWrapper = new MediaServicesRestProxy($httpClient, $uri, $settings->getAccountName(), $serializer);
     // Adding headers filter
     $xMSVersion = Resources::MEDIA_SERVICES_API_LATEST_VERSION;
     $dataVersion = Resources::MEDIA_SERVICES_DATA_SERVICE_VERSION_VALUE;
     $dataMaxVersion = Resources::MEDIA_SERVICES_MAX_DATA_SERVICE_VERSION_VALUE;
     $accept = Resources::ACCEPT_HEADER_VALUE;
     $contentType = Resources::ATOM_ENTRY_CONTENT_TYPE;
     $userAgent = Resources::SDK_USER_AGENT;
     $headers = array(Resources::X_MS_VERSION => $xMSVersion, Resources::DATA_SERVICE_VERSION => $dataVersion, Resources::MAX_DATA_SERVICE_VERSION => $dataMaxVersion, Resources::ACCEPT_HEADER => $accept, Resources::CONTENT_TYPE => $contentType, Resources::USER_AGENT => $userAgent);
     $headersFilter = new HeadersFilter($headers);
     $mediaServicesWrapper = $mediaServicesWrapper->withFilter($headersFilter);
     // Adding OAuth filter
     $oauthService = new OAuthRestProxy(new HttpClient(), $settings->getOAuthEndpointUri());
     $authentification = new OAuthScheme($settings->getAccountName(), $settings->getAccessKey(), Resources::OAUTH_GT_CLIENT_CREDENTIALS, Resources::MEDIA_SERVICES_OAUTH_SCOPE, $oauthService);
     $authentificationFilter = new AuthenticationFilter($authentification);
     $mediaServicesWrapper = $mediaServicesWrapper->withFilter($authentificationFilter);
     return $mediaServicesWrapper;
 }

 public static function generateTestToken($template, $verificationKey, $contentKeyUUID, $tokenExpiration = null, $notBefore = null)
 {
     Validate::notNull($template, 'template');
     Validate::isA($template, 'WindowsAzure\\MediaServices\\Templates\\TokenRestrictionTemplate', 'template');
     if ($verificationKey == null) {
         $verificationKey = $template->getPrimaryVerificationKey();
     }
     Validate::notNull($verificationKey, 'verificationKey');
     Validate::isA($verificationKey, 'WindowsAzure\\MediaServices\\Templates\\SymmetricVerificationKey', 'verificationKey');
     if ($tokenExpiration == null) {
         $tokenExpiration = time() + 60 * 10;
     }
     if ($notBefore == null) {
         $notBefore = time() - 60 * 5;
     }
     if ($template->getTokenType() == TokenType::SWT) {
         return TokenRestrictionTemplateSerializer::generateTestTokenSWT($template, $verificationKey, $contentKeyUUID, $tokenExpiration);
     } else {
         return TokenRestrictionTemplateSerializer::generateTestTokenJWT($template, $verificationKey, $contentKeyUUID, $tokenExpiration, $notBefore);
     }
 }

 /**
  * Serialize a WidevineMessage as JSON
  * @param WidevineMessage $template 
  * @return string
  */
 public static function serialize($template)
 {
     Validate::isA($template, 'WindowsAzure\\MediaServices\\Templates\\WidevineMessage', 'template');
     return json_encode($template);
 }

 /**
  * @covers WindowsAzure\Common\Internal\Validate::isA
  */
 public function testIsANotAClass()
 {
     // Setup
     $this->setExpectedException(get_class(new InvalidArgumentTypeException('')));
     $value = 'test string';
     $type = 'WindowsAzure\\Common\\Internal\\Resources';
     // Test
     $result = Validate::isA($value, $type, 'value');
     // Assert
 }

 /**
  * Create a job.
  *
  * @param WindowsAzure\MediaServices\Models\JobTemplate $jobTemplate   Job
  * template data
  *
  * @param array                                         $taskTemplates Performed
  * tasks template array
  *
  * @return array
  */
 public function createJobTemplate($jobTemplate, $taskTemplates)
 {
     Validate::isA($jobTemplate, 'WindowsAzure\\MediaServices\\Models\\JobTemplate', 'jobTemplate');
     Validate::isArray($taskTemplates, 'taskTemplates');
     $batch = new BatchRequest();
     $batch->appendContext($this->_getCreateEmptyJobTemplateContext($jobTemplate));
     if ($taskTemplates != null) {
         foreach ($taskTemplates as $taskTemplate) {
             $batch->appendContext($this->_getCreateTaskTemplateContext($taskTemplate));
         }
     }
     $batch->encode();
     $method = Resources::HTTP_POST;
     $headers = $batch->getHeaders();
     $postParams = array();
     $queryParams = array();
     $path = '$batch';
     $statusCode = Resources::STATUS_ACCEPTED;
     $body = $batch->getBody();
     $response = $this->send($method, $headers, $postParams, $queryParams, $path, $statusCode, $body);
     $batchResponse = new BatchResponse($response->getBody(), $batch);
     $responses = $batchResponse->getContexts();
     $jobTemplateResponse = $responses[0];
     $entry = new Entry();
     $entry->parseXml($jobTemplateResponse->getBody());
     $properties = $this->getPropertiesFromAtomEntry($entry);
     return JobTemplate::createFromOptions($properties);
 }

 /**
  * Update asset delivery policy
  *
  * @param Models\AssetDeliveryPolicy $assetDeliveryPolicy New asset delivery policy data with
  * valid id
  *
  * @return void
  */
 public function updateAssetDeliveryPolicy($assetDeliveryPolicy)
 {
     Validate::isA($assetDeliveryPolicy, 'WindowsAzure\\MediaServices\\Models\\AssetDeliveryPolicy', 'assetDeliveryPolicy');
     $this->_updateEntity($assetDeliveryPolicy, "AssetDeliveryPolicies('{$assetDeliveryPolicy->getId()}')");
 }

 /**
  * Create new ContentKey
  *
  * @param Models\ContentKey $contentKey ContentKey data
  *
  * @return Models\ContentKey Created ContentKey
  */
 public function createContentKey($contentKey)
 {
     Validate::isA($contentKey, 'WindowsAzure\\Mediaservices\\Models\\ContentKey', 'contentKey');
     return ContentKey::createFromOptions($this->_createEntity($contentKey, 'ContentKeys'));
 }