Factory.php

Go to the documentation of this file.

<?php

declare(strict_types=1);

namespace ILIAS\Data;

use ILIAS\Data\Clock\ClockFactory;
use ILIAS\Data\Clock\ClockFactoryImpl;
use ILIAS\Data\Meta;

class Factory
{
    // TODO: move this to proper dependency_injection
    private ?Color\Factory $colorfactory = null;
    private ?Dimension\Factory $dimensionfactory = null;
    private ?Meta\Html\Factory $html_metadata_factory = null;
    private ?Meta\Html\OpenGraph\Factory $open_graph_metadata_factory = null;
    private ?Text\Factory $text_factory = null;


    public function ok($value): Result
    {
        return new Result\Ok($value);
    }

    public function error($e): Result
    {
        return new Result\Error($e);
    }

    public function color($value): Color
    {
        if (!$this->colorfactory) {
            $this->colorfactory = new Color\Factory();
        }
        return $this->colorfactory->build($value);
    }

    public function uri(string $uri_string): URI
    {
        return new URI($uri_string);
    }

    public function dataSize($size, ?string $unit = null): DataSize
    {
        if (is_string($size)) {
            $match = [];
            if (!preg_match("/(\d+)\s*([a-zA-Z]+)/", $size, $match)) {
                throw new \InvalidArgumentException("'$size' can't be interpreted as data size.");
            }
            return $this->dataSize((int) $match[1], $match[2]);
        }
        if (is_int($size) && (is_null($unit) || !array_key_exists($unit, DataSize::$abbreviations))) {
            throw new \InvalidArgumentException(
                "Expected second argument to be a unit for data, '$unit' is unknown."
            );
        }
        $unit_size = DataSize::$abbreviations[$unit];
        return new DataSize($size * $unit_size, $unit_size);
    }

    public function password(string $pass): Password
    {
        return new Password($pass);
    }

    public function clientId(string $clientId): ClientId
    {
        return new ClientId($clientId);
    }

    public function refId(int $ref_id): ReferenceId
    {
        return new ReferenceId($ref_id);
    }

    public function objId(int $obj_id): ObjectId
    {
        return new ObjectId($obj_id);
    }

    public function alphanumeric($value): Alphanumeric
    {
        return new Alphanumeric($value);
    }

    public function positiveInteger(int $value): PositiveInteger
    {
        return new PositiveInteger($value);
    }

    public function dateFormat(): DateFormat\Factory
    {
        $builder = new DateFormat\FormatBuilder();
        return new DateFormat\Factory($builder);
    }

    public function range(int $start, int $length): Range
    {
        return new Range($start, $length);
    }

    public function order(string $subject, string $direction): Order
    {
        return new Order($subject, $direction);
    }

    public function version(string $version): Version
    {
        return new Version($version);
    }

    public function link(string $label, URI $url): Link
    {
        return new Link($label, $url);
    }

    public function clock(): ClockFactory
    {
        return new ClockFactoryImpl();
    }

    public function dimension(): Dimension\Factory
    {
        if (!$this->dimensionfactory) {
            $this->dimensionfactory = new Dimension\Factory();
        }
        return $this->dimensionfactory;
    }

    public function dataset(array $dimensions, array $dimension_groups = []): Chart\Dataset
    {
        return new Chart\Dataset($dimensions, $dimension_groups);
    }

    public function htmlMetadata(): Meta\Html\Factory
    {
        if (null === $this->html_metadata_factory) {
            $this->html_metadata_factory = new Meta\Html\Factory();
        }

        return $this->html_metadata_factory;
    }

    public function openGraphMetadata(): Meta\Html\OpenGraph\Factory
    {
        if (null === $this->open_graph_metadata_factory) {
            $this->open_graph_metadata_factory = new Meta\Html\OpenGraph\Factory();
        }

        return $this->open_graph_metadata_factory;
    }

    public function languageTag(string $language_tag): LanguageTag
    {
        return LanguageTag::fromString($language_tag);
    }

    public function text(): Text\Factory
    {
        if ($this->text_factory === null) {
            $md_format = new \ILIAS\Refinery\String\MarkdownFormattingToHTML();
            $this->text_factory = new \ILIAS\Data\Text\Factory(
                new Text\MarkdownFactory(
                    new Text\Shape\Markdown($md_format),
                    new Text\Shape\SimpleDocumentMarkdown($md_format),
                    new Text\Shape\WordOnlyMarkdown($md_format)
                )
            );
        }
        return $this->text_factory;
    }
}