Ejemplo n.º 1
0
 /**
  * Create a reader instance from a stream-wrapped source
  *
  * @param string $src Stream-wrapped source
  * @param string $resourceClass Resource class name
  * @param array $parameters Reader parameters
  * @return AbstractResource Resource instance
  * @throws InvalidReaderArgumentException If an invalid reader stream wrapper is given
  */
 protected static function fromSource($src, $resourceClass, ...$parameters)
 {
     $reader = Tools::reader($src, $parameters);
     if ($reader instanceof ReaderInterface) {
         return Kernel::create($resourceClass, [$reader]);
     }
     throw new InvalidArgumentException('Invalid reader stream wrapper', InvalidReaderArgumentException::INVALID_READER_STREAM_WRAPPER);
 }
Ejemplo n.º 2
0
 /**
  * String serialization
  *
  * @return string String value (file content)
  */
 public function __toString()
 {
     /** @var InMemoryWriter $writer */
     $writer = Kernel::create(InMemoryWriter::class);
     /** @var AbstractResource $this */
     $this->dump($writer);
     return $writer->getData();
 }
Ejemplo n.º 3
0
 /**
  * Create and return a FrontMark resource instance from an object
  *
  * @param ObjectInterface $object Object
  * @return ResourceInterface Object resource
  */
 public static function createFromObject(ObjectInterface $object)
 {
     /** @var ResourceInterface $resource */
     $resource = Kernel::create(Resource::class, [null]);
     $resource->setPropertyData($object->getPropertyData());
     $resource->setPayload($object->getPayload());
     return $resource;
 }
Ejemplo n.º 4
0
 /**
  * Instantiate and return an object
  *
  * @param string $url Object URL (relative or absolute including the apparat base URL)
  * @param int $visibility Object visibility
  * @return ObjectInterface Object
  */
 public static function load($url, $visibility = ObjectTypes::VISIBILITY_ALL)
 {
     // Instantiate the object URL
     /** @var ObjectUrl $objectUrl */
     $objectUrl = Kernel::create(ObjectUrl::class, [$url, true]);
     // Instantiate the local object repository, load and return the object
     return Repository::instance($objectUrl->getRepositoryUrl())->loadObject($objectUrl, $visibility);
 }
Ejemplo n.º 5
0
 /**
  * Match a value against this datatype
  *
  * @param mixed $value Value
  * @return mixed Matched and processed value
  * @throws DomainException If the value is not a valid Geo URI
  */
 public function match($value)
 {
     try {
         $geo = Kernel::create(GeoUri::class, [$value]);
     } catch (\Exception $e) {
         throw new DomainException();
     }
     return $geo;
 }
Ejemplo n.º 6
0
 /**
  * Match a value against this datatype
  *
  * @param mixed $value Value
  * @return mixed Matched and processed value
  * @throws DomainException If the value is not a valid URL
  */
 public function match($value)
 {
     try {
         $url = Kernel::create(\Apparat\Object\Domain\Model\Uri\Url::class, [$value, true]);
     } catch (\Exception $e) {
         throw new DomainException();
     }
     return $url;
 }
Ejemplo n.º 7
0
 /**
  * Create and return an apparat object decorator
  *
  * @param ObjectInterface $object Object
  * @return ApparatObjectInterface Apparat object
  */
 public static function create(ObjectInterface $object)
 {
     $objectType = $object->getObjectType()->getType();
     // If the object type doesn't map to known apparat object class
     if (!array_key_exists($objectType, static::$typeClasses) || !static::$typeClasses[$objectType]) {
         throw new PortsInvalidArgumentException(sprintf('Unknown apparat object type "%s"', $objectType), PortsInvalidArgumentException::UNKNOWN_APPARAT_OBJECT_TYPE);
     }
     /** @var ApparatObjectInterface $apparatObject */
     $apparatObject = Kernel::create(self::$typeClasses[$objectType], [$object]);
     return $apparatObject;
 }
Ejemplo n.º 8
0
 /**
  * Auto-connect a repository with URL default settings
  *
  * @param string $url Repository URL
  * @return boolean Success
  */
 public function connect($url)
 {
     // If it's an absolute URL
     /** @var Url $url */
     $url = Kernel::create(Url::class, [$url]);
     $config = $url->isAbsolute() ? $this->getAbsoluteUrlConfig() : $this->getRelativeUrlConfig($url);
     // If a repository configuration has been created
     if ($config !== null) {
         $repository = Repository::register(strval($url), $config);
         return $repository instanceof DomainRepository;
     }
     return true;
 }
Ejemplo n.º 9
0
 /**
  * Match a value against this datatype
  *
  * @param mixed $value Value
  * @return mixed Matched and processed value
  * @throws DomainException If the value is not a valid URL
  */
 public function match($value)
 {
     try {
         /** @var \Apparat\Object\Domain\Model\Uri\ApparatUrl $apparatUrl */
         $apparatUrl = Kernel::create(\Apparat\Object\Domain\Model\Uri\ApparatUrl::class, [$value, true, $this->object->getRepositoryLocator()->getRepository()]);
         // If the apparat URL needs to be filtered
         if (count($this->filter) && !in_array($apparatUrl->getObjectType()->getType(), $this->filter)) {
             throw new DomainException();
         }
     } catch (DomainException $e) {
         throw new \InvalidArgumentException();
     } catch (\Exception $e) {
         throw new DomainException();
     }
     return $apparatUrl;
 }
Ejemplo n.º 10
0
 /**
  * Create and return a new object
  *
  * @param RepositoryInterface $repository Repository to create the object in
  * @param Type $type Object type
  * @param string $payload Object payload
  * @param array $propertyData Object property data
  * @param \DateTimeInterface $creationDate Object creation date
  * @return ObjectInterface Object
  */
 public function createObject(RepositoryInterface $repository, Type $type, $payload = '', array $propertyData = [], \DateTimeInterface $creationDate = null)
 {
     // Set the creation date to now if empty
     if ($creationDate === null) {
         $creationDate = new \DateTimeImmutable('now');
     }
     // Construct a creation closure
     $creationClosure = function (Id $uid) use($repository, $type, $payload, $propertyData, $creationDate) {
         /** @var Revision $revision */
         $revision = Kernel::create(Revision::class, [1, true]);
         /** @var RepositoryLocator $repositoryLocator */
         $repositoryLocator = Kernel::create(RepositoryLocator::class, [$repository]);
         $repositoryLocator = $repositoryLocator->setId($uid);
         $repositoryLocator = $repositoryLocator->setRevision($revision);
         $repositoryLocator = $repositoryLocator->setObjectType($type);
         $repositoryLocator = $repositoryLocator->setCreationDate($creationDate);
         return ObjectFactory::createFromParams($repositoryLocator, $payload, $propertyData);
     };
     // Wrap the object creation in an ID allocation transaction
     return $repository->getAdapterStrategy()->createObjectResource($creationClosure);
 }
Ejemplo n.º 11
0
 /**
  * Use a specific object revision
  *
  * @param Revision $revision Revision to be used
  * @return ObjectInterface Object
  * @throws OutOfBoundsException If a revision beyond the latest one is requested
  */
 public function useRevision(Revision $revision)
 {
     // If a revision beyond the latest one is requested
     if (!$revision->isCurrent() && $revision->getRevision() > $this->latestRevision->getRevision()) {
         throw new OutOfBoundsException(sprintf('Invalid object revision "%s"', $revision->getRevision()), OutOfBoundsException::INVALID_OBJECT_REVISION);
     }
     // Determine whether the current revision was requested
     $currentRevision = $this->getCurrentRevision();
     $isCurrentRevision = $revision->isCurrent() || $currentRevision->equals($revision);
     if ($isCurrentRevision) {
         $revision = $currentRevision;
     }
     // If the requested revision is not already used
     if (!$this->getRevision()->equals($revision)) {
         /** @var ManagerInterface $objectManager */
         $objectManager = Kernel::create(Service::class)->getObjectManager();
         /** @var Revision $newRevision */
         $newRevision = $isCurrentRevision ? Revision::current() : $revision;
         /** @var RepositoryLocator $newRevisionLocator */
         $newRevisionLocator = $this->locator->setRevision($newRevision);
         // Instantiate the requested revision resource
         $revisionResource = $objectManager->loadObjectResource($newRevisionLocator, SelectorInterface::ALL);
         // Load the revision resource data
         $this->loadRevisionData($revisionResource->getPayload(), $revisionResource->getPropertyData());
         // Update the object locator
         $this->updateLocator();
     }
     return $this;
 }
Ejemplo n.º 12
0
 /**
  * Load an object from this repository
  *
  * @param string $locator Object locator
  * @param int $visibility Object visibility
  * @return ApparatObjectInterface Object
  */
 public function loadObject($locator, $visibility = SelectorInterface::ALL)
 {
     /** @var LocatorInterface $objectLocator */
     $objectLocator = Kernel::create(RepositoryLocator::class, [$this->repository, $locator]);
     return ApparatObjectFactory::create($this->repository->loadObject($objectLocator, $visibility));
 }
Ejemplo n.º 13
0
 /**
  * Create and return a new object
  *
  * @param RepositoryLocatorInterface $locator Repository object locator
  * @param string $payload Object payload
  * @param array $propertyData Object property data
  * @return ObjectInterface Object
  */
 public static function createFromParams(RepositoryLocatorInterface $locator, $payload = '', array $propertyData = [])
 {
     // Determine the object class
     $objectClass = self::objectClassFromType($locator->getObjectType());
     // Prepare the system properties collection
     $systemPropertyData = empty($propertyData[SystemProperties::COLLECTION]) || !is_array($propertyData[SystemProperties::COLLECTION]) ? [] : $propertyData[SystemProperties::COLLECTION];
     $systemPropertyData[SystemProperties::PROPERTY_ID] = $locator->getId()->getId();
     $systemPropertyData[SystemProperties::PROPERTY_TYPE] = $locator->getObjectType()->getType();
     $systemPropertyData[SystemProperties::PROPERTY_REVISION] = $locator->getRevision()->getRevision();
     $systemPropertyData[SystemProperties::PROPERTY_CREATED] = $systemPropertyData[SystemProperties::PROPERTY_MODIFIED] = $locator->getCreationDate();
     if (empty($systemPropertyData[SystemProperties::PROPERTY_LANGUAGE])) {
         $systemPropertyData[SystemProperties::PROPERTY_LANGUAGE] = getenv('OBJECT_DEFAULT_LANGUAGE');
     }
     $propertyData[SystemProperties::COLLECTION] = $systemPropertyData;
     // Prepare the meta properties collection
     $metaPropertyData = empty($propertyData[MetaProperties::COLLECTION]) || !is_array($propertyData[MetaProperties::COLLECTION]) ? [] : $propertyData[MetaProperties::COLLECTION];
     $metaPropertyData[MetaProperties::PROPERTY_PRIVACY] = getenv('OBJECT_DEFAULT_PRIVACY');
     $propertyData[MetaProperties::COLLECTION] = $metaPropertyData;
     // Instantiate the object
     /** @var ObjectInterface $object */
     $object = Kernel::create($objectClass, [$locator, '', $propertyData]);
     return $object->setPayload($payload);
 }
Ejemplo n.º 14
0
 /**
  * Instantiate an object selector from a list of parameters
  *
  * @param array $params Object selector parameters
  * @return SelectorInterface Object selector
  */
 public static function createFromParams(array $params)
 {
     $datePrecision = intval(getenv('OBJECT_DATE_PRECISION'));
     // Object visibility
     $visibility = empty($params['visibility']) ? SelectorInterface::VISIBLE : ($params['visibility'] == SelectorInterface::INDICATOR_HIDDEN ? SelectorInterface::HIDDEN : SelectorInterface::ALL);
     // Object draft
     $draft = empty($params['draft']) ? SelectorInterface::PUBLISHED : ($params['draft'] == SelectorInterface::INDICATOR_DRAFT ? SelectorInterface::DRAFT : SelectorInterface::ALL);
     $year = $month = $day = $hour = $minute = $second = null;
     if ($datePrecision > 0) {
         $year = isset($params['year']) ? self::castInt($params['year']) : SelectorInterface::WILDCARD;
     }
     if ($datePrecision > 1) {
         $month = isset($params['month']) ? self::castInt($params['month']) : SelectorInterface::WILDCARD;
     }
     if ($datePrecision > 2) {
         $day = isset($params['day']) ? self::castInt($params['day']) : SelectorInterface::WILDCARD;
     }
     if ($datePrecision > 3) {
         $hour = isset($params['hour']) ? self::castInt($params['hour']) : SelectorInterface::WILDCARD;
     }
     if ($datePrecision > 4) {
         $minute = isset($params['minute']) ? self::castInt($params['minute']) : SelectorInterface::WILDCARD;
     }
     if ($datePrecision > 5) {
         $second = isset($params['second']) ? self::castInt($params['second']) : SelectorInterface::WILDCARD;
     }
     $uid = isset($params['id']) ? self::castInt($params['id']) : SelectorInterface::WILDCARD;
     $type = empty($params['type']) ? SelectorInterface::WILDCARD : trim($params['type']);
     $revision = empty($params['revision']) ? Revision::CURRENT : self::castInt($params['revision']);
     return Kernel::create(Selector::class, [$year, $month, $day, $hour, $minute, $second, $uid, $type, $revision, $visibility, $draft]);
 }
Ejemplo n.º 15
0
 /**
  * Process the payload of an object
  *
  * @param string $payload Payload
  * @return string Processed payload
  */
 public function processPayload($payload)
 {
     // Reset all relevant relations
     $this->resetRefersToRelations();
     $this->resetEmbedsRelations();
     $env = Environment::createCommonMarkEnvironment();
     $env->addDocumentProcessor($this);
     // Parse and process the object payload
     /** @var DocParser $docParser */
     $docParser = Kernel::create(DocParser::class, [$env]);
     $docParser->parse($payload);
     return $payload;
 }
Ejemplo n.º 16
0
 /**
  * Instantiate and return an adapter strategy
  *
  * @param array $config Adapter strategy config
  * @return AdapterStrategyInterface Repository adapter
  * @throws InvalidArgumentException If the adapter strategy config is empty
  * @throws InvalidArgumentException If the adapter strategy type is missing or invalid
  */
 public function createFromConfig(array $config)
 {
     // If the adapter strategy config is empty
     if (!count($config)) {
         throw new InvalidArgumentException('Empty adapter strategy configuration', InvalidArgumentException::EMPTY_ADAPTER_STRATEGY_CONFIG);
     }
     // If the adapter strategy type is missing or invalid
     if (empty($config['type']) || !array_key_exists($config['type'], self::$types)) {
         throw new InvalidArgumentException(sprintf('Invalid adapter strategy type "%s"', empty($config['type']) ? '(empty)' : $config['type']), InvalidArgumentException::INVALID_ADAPTER_STRATEGY_TYPE);
     }
     // Instantiate the adapter strategy
     return Kernel::create(self::$types[$config['type']], [$config]);
 }
Ejemplo n.º 17
0
 /**
  * Return the enclosed remote object
  *
  * @return ObjectInterface Remote object
  */
 protected function object()
 {
     // Lazy-load the remote object if necessary
     if (!$this->object instanceof ObjectInterface) {
         // Instantiate the local object repository, load and return the object
         $this->object = Kernel::create(Service::class)->get($this->getUrl())->loadObject($this->getUrl()->getLocator());
     }
     return $this->object;
 }
Ejemplo n.º 18
0
 /**
  * Extract the title and abstract out of the payload
  *
  * @param string $markdownPayload Markdown payload
  * @return array Titel and abstract
  */
 protected function extractTitleAndAbstract($markdownPayload)
 {
     $abstract = trim($markdownPayload);
     if (preg_match('%^(.+?)\\R%', $markdownPayload, $firstParagraph)) {
         $abstract = trim($firstParagraph[1]);
     }
     // Strip formatting
     if (strlen($abstract)) {
         $environment = Environment::createCommonMarkEnvironment();
         /** @var CommonMarkConverter $converter */
         $converter = Kernel::create(CommonMarkConverter::class, [[], $environment]);
         $abstract = trim(strip_tags($converter->convertToHtml($abstract)));
     }
     $title = $abstract;
     return [$title, $abstract];
 }
Ejemplo n.º 19
0
 /**
  * Load an object from this repository
  *
  * @param LocatorInterface $locator Object locator
  * @param int $visibility Object visibility
  * @return ObjectInterface Object
  */
 public function loadObject(LocatorInterface $locator, $visibility = SelectorInterface::ALL)
 {
     /** @var ManagerInterface $objectManager */
     $objectManager = Kernel::create(Service::class)->getObjectManager();
     /** @var RepositoryLocatorInterface $repositoryLocator */
     $repositoryLocator = Kernel::create(RepositoryLocator::class, [$this, $locator]);
     // Load and return the object
     return $objectManager->loadObject($repositoryLocator, $visibility);
 }
Ejemplo n.º 20
0
 /**
  * Rewind to the first revision
  */
 public function rewind()
 {
     $this->nextRevision = $this->latestRevision->getRevision() > 1 ? Kernel::create(Revision::class, [1]) : $this->latestRevision;
     $this->useRevision($this->nextRevision);
 }
Ejemplo n.º 21
0
 /**
  * Traverse the property tree and return a node
  *
  * @param array $propertyPath Property name path
  * @param array $propertyTree Copy of the current property tree
  * @param boolean $created Property has been created
  * @param PropertyModel $propertyModel Property model
  * @return mixed Property node
  * @throws DomainException If an invalid subproperty should be allocated
  */
 protected function &findPropertyNode(array $propertyPath, array &$propertyTree, &$created, PropertyModel &$propertyModel = null)
 {
     $propertyModel = null;
     $propertyModelName = 'pm';
     $propertyPathSteps = [];
     $data =& $propertyTree;
     // Run through all sub-properties
     foreach ($propertyPath as $property) {
         // If an invalid sub-property should be allocated
         if ($propertyModel !== null) {
             throw new DomainException(sprintf('Property data model of "%s" does not allow sub-properties', implode(self::PROPERTY_TRAVERSAL_SEPARATOR, $propertyPathSteps)), DomainException::INVALID_DOMAIN_SUBPROPERTY);
         }
         $propertyPathSteps[] = $property;
         $propertyModelName .= ucfirst($property);
         /** @var PropertyModel $propertyModel */
         $propertyModel = isset($this->{$propertyModelName}) ? Kernel::create(PropertyModel::class, array_merge([$this->object], $this->{$propertyModelName})) : null;
         // If the sub-property doesn't exist
         if (!array_key_exists($property, $data)) {
             $data[$property] = $propertyModel === null || $propertyModel->isMultivalue() ? [] : null;
             $created = true;
         }
         $data =& $data[$property];
     }
     return $data;
 }
Ejemplo n.º 22
0
 /**
  * Parse and instantiate a relation URL
  *
  * @param string $url URL
  * @param int $coupling Strong coupling
  * @param RepositoryInterface $contextRepository Context repository
  * @return Url URL
  * @throws InvalidArgumentException If the relation URL is invalid
  */
 protected static function parseRelationUrl($url, &$coupling, RepositoryInterface $contextRepository)
 {
     if (strlen($url)) {
         // If the URL requires tight coupling
         if (!strncmp('!', $url, 1)) {
             $coupling = RelationInterface::TIGHT_COUPLING;
             $url = substr($url, 1);
         }
         // Try to instantiate as an apparat URL
         try {
             return Kernel::create(ApparatUrl::class, [$url, true, $contextRepository]);
             // If there's an apparat URL problem: Try to instantiate as a regular URL
         } catch (\Apparat\Object\Domain\Model\Uri\InvalidArgumentException $e) {
             /** @var Url $urlInstance */
             $urlInstance = Kernel::create(Url::class, [$url]);
             if ($urlInstance->isAbsolute()) {
                 return $urlInstance;
             }
         }
     }
     throw new InvalidArgumentException(sprintf('Invalid relation URL "%s"', $url), InvalidArgumentException::INVALID_RELATION_URL);
 }
Ejemplo n.º 23
0
 /**
  * Apparat URL constructor
  *
  * If the constructor does not throw an exception, the URL is valid and
  *
  * 1. either an absolute URL (local or remote) or
  * 2. a relative URL to a known local repository (respectively the to the context repository if given)
  *
  * @param string $url Apparat URL
  * @param boolean $remote Accept remote URL (less strict date component checking)
  * @param RepositoryInterface $contextRepository Context repository
  * @throws ApparatInvalidArgumentException If the URL is absolute but doesn't have the apparat scheme
  * @throws ApparatInvalidArgumentException If this is a local Apparat URL with an unknown repository
  */
 public function __construct($url, $remote = false, RepositoryInterface $contextRepository = null)
 {
     parent::__construct($url, $remote);
     // If it's an absolute URL
     if ($this->isAbsolute()) {
         // If the Apparat URL scheme is invalid
         if (!array_key_exists($this->urlParts['scheme'], self::$schemes)) {
             throw new ApparatInvalidArgumentException(sprintf('Invalid absolute apparat URL "%s"', $url), ApparatInvalidArgumentException::INVALID_ABSOLUTE_APPARAT_URL);
         }
         return;
     }
     // If this URL doesn't have a repository URL and a context repository is given: Inherit its URL
     if (!strlen($this->getPath()) && $contextRepository instanceof RepositoryInterface) {
         $this->urlParts['path'] = $contextRepository->getUrl();
     }
     // If the the repository involved is unknown and cannot be auto-connected
     if (!Kernel::create(Service::class)->isRegistered($this->getPath())) {
         throw new ApparatInvalidArgumentException(sprintf('Unknown local repository URL "%s"', $this->getPath()), ApparatInvalidArgumentException::UNKNOWN_LOCAL_REPOSITORY_URL);
     }
 }
Ejemplo n.º 24
0
 /**
  * Unserialize the string representation of this property
  *
  * @param string $str Serialized property
  * @return SerializablePropertyInterface Property
  */
 public static function unserialize($str)
 {
     return Kernel::create(static::class, [$str]);
 }
Ejemplo n.º 25
0
 /**
  * Translate data to a CommonMark resource part
  *
  * @param string $data Part data
  * @return CommonMarkPart CommonMark resource part
  */
 public function hydrate($data)
 {
     return Kernel::create(CommonMarkPart::class, [$this, $data]);
 }
Ejemplo n.º 26
0
 /**
  * Delete a resource
  *
  * @param string $src Stream-wrapped source
  * @param array ...$parameters Reader parameters
  * @return Move move handler
  * @throws \Apparat\Resource\Ports\InvalidArgumentException If the reader stream wrapper is invalid
  * @api
  */
 public static function delete($src, ...$parameters)
 {
     $reader = self::reader($src, $parameters);
     if ($reader instanceof ReaderInterface) {
         /** @var Delete $deleter */
         $deleter = Kernel::create(Delete::class, [$reader]);
         return $deleter();
     }
     throw self::failInvalidReader();
 }
Ejemplo n.º 27
0
 /**
  * Build a multipart hydrator
  *
  * @param array $config Hydrator configuration
  * @return HydratorInterface Hydrator
  */
 protected static function buildMultipart(array $config)
 {
     // If no multipart hydrator is specified
     if (count($config) < 2) {
         throw new InvalidArgumentException('A multipart hydrator must be specified', InvalidArgumentException::MISSING_MULTIPART_HYDRATOR);
         // Else: if the multipart hydrator is invalid
     } elseif (!strlen(trim($config[1])) || !(new \ReflectionClass(trim($config[1])))->isSubclassOf(AbstractMultipartHydrator::class)) {
         throw new InvalidArgumentException(sprintf('Invalid multipart hydrator class "%s"', trim($config[1])), InvalidArgumentException::INVALID_MULTIPART_HYDRATOR_CLASS);
         // Else: Validate the remaining hydrator arguments
     } elseif (count($config) > 2 && !call_user_func_array(array($config[1], 'validateParameters'), array_slice($config, 2))) {
         throw new InvalidArgumentException('Invalid multipart hydrator parameters', InvalidArgumentException::INVALID_MULTIPART_HYDRATOR_PARAMETERS);
     }
     // Run through all multipart subhydrators
     foreach ($config[0] as $multipartHydrator) {
         // If it's neither a multipart nor a valid single part hydrator
         if (!is_array($multipartHydrator) && !(new \ReflectionClass($multipartHydrator))->implementsInterface(HydratorInterface::class)) {
             throw new InvalidArgumentException(sprintf('Invalid multipart subhydrator class "%s"', $multipartHydrator), InvalidArgumentException::INVALID_MULTIPART_SUBHYDRATOR_CLASS);
         }
     }
     // Instantiate the multipart hydrator
     $multipartHydrator = trim($config[1]);
     $hydratorParameters = array_slice($config, 2);
     array_unshift($hydratorParameters, $config[0]);
     return Kernel::create($multipartHydrator, $hydratorParameters);
 }
Ejemplo n.º 28
0
 /**
  * Set the contents of a part
  *
  * @param string $data Contents
  * @param array $subparts Subparts
  * @return AbstractContentPart New content part
  */
 public function set($data, array $subparts = [])
 {
     unset($subparts);
     $class = get_class($this);
     return Kernel::create($class, [$this->hydrator, $data]);
 }
Ejemplo n.º 29
0
 /**
  * Initialize the aggregate part
  *
  * @param string $data Part data
  * @return AbstractPartAggregate Part aggregate
  */
 public function hydrate($data)
 {
     // If the part aggregate class isn't valid
     if (!$this->aggregateClass || !class_exists($this->aggregateClass) || !(new \ReflectionClass($this->aggregateClass))->implementsInterface(PartAggregateInterface::class)) {
         throw new RuntimeException(sprintf('Invalid part aggregate class "%s"', $this->aggregateClass), RuntimeException::INVALID_PART_AGGREGATE_CLASS);
     }
     unset($data);
     return Kernel::create($this->aggregateClass, [$this, $this->subhydrators, $this->minimumOccurrences, $this->maximumOccurrences]);
 }
Ejemplo n.º 30
0
 /**
  * Translate data to a YAML resource part
  *
  * @param string $data Part data
  * @return YamlPart YAML resource part
  */
 public function hydrate($data)
 {
     return Kernel::create(YamlPart::class, [$this, $data]);
 }