Storeman\VaultConfiguration

Complexity

Total Complexity

24

Size/Duplication

Total Lines	202
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getConfiguration()	0	4	1
A	getTitle()	0	4	1
A	setTitle()	0	6	1
A	getAdapter()	0	4	1
A	setAdapter()	0	6	1
A	getLockAdapter()	0	4	1
A	setLockAdapter()	0	6	1
A	getIndexMerger()	0	4	1
A	setIndexMerger()	0	6	1
A	getConflictHandler()	0	4	1
A	setConflictHandler()	0	6	1
A	getOperationListBuilder()	0	4	1
A	setOperationListBuilder()	0	6	1
A	getSettings()	0	4	1
A	getSetting()	0	4	2
A	setSettings()	0	6	1
A	setSetting()	0	6	1
A	exchangeArray()	0	13	3
A	getArrayCopy()	0	8	1
A	loadValidatorMetadata()	0	9	1

<?php

namespace Storeman;

use Storeman\Validation\Constraints as StoremanAssert;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Mapping\ClassMetadata;
use Zend\Stdlib\ArraySerializableInterface;

class VaultConfiguration implements ArraySerializableInterface
{
    /**
     * @var Configuration
     */
    protected $configuration;

    /**
     * An arbitrary user-defined title that helps to identity a vault by some user-specific information.
     *
     * @var string
     */
    protected $title = 'unknown';

    /**
     * Identifier for the vault adapter to use.
     *
     * @var string
     */
    protected $adapter = 'unknown';

    /**
     * Identifier for the lock adapter to use.
     *
     * @var string
     */
    protected $lockAdapter = 'storage';

    /**
     * Identifier for the index merger to be used.
     *
     * @var string
     */
    protected $indexMerger = 'standard';

    /**
     * Identifier for the conflict handler to use.
     *
     * @var string
     */
    protected $conflictHandler = 'panicking';

    /**
     * Identifier for the operation list builder to use.
     *
     * @var string
     */
    protected $operationListBuilder = 'standard';

    /**
     * Map with additional storageAdapter- or lockAdapter-specific settings.
     *
     * @var array
     */
    protected $settings = [];

    public function __construct(Configuration $configuration)
    {
        $this->configuration = $configuration;
        $this->configuration->addVault($this);
    }

    public function getConfiguration(): Configuration
    {
        return $this->configuration;
    }

    public function getTitle(): string
    {
        return $this->title;
    }

    public function setTitle(string $title): VaultConfiguration
    {
        $this->title = $title;

        return $this;
    }

    public function getAdapter(): string
    {
        return $this->adapter;
    }

    public function setAdapter(string $adapter): VaultConfiguration
    {
        $this->adapter = $adapter;

        return $this;
    }

    public function getLockAdapter(): string
    {
        return $this->lockAdapter;
    }

    public function setLockAdapter(string $lockAdapter): VaultConfiguration
    {
        $this->lockAdapter = $lockAdapter;

        return $this;
    }

    public function getIndexMerger(): string
    {
        return $this->indexMerger;
    }

    public function setIndexMerger(string $indexMerger): VaultConfiguration
    {
        $this->indexMerger = $indexMerger;

        return $this;
    }

    public function getConflictHandler(): string
    {
        return $this->conflictHandler;
    }

    public function setConflictHandler(string $conflictHandler): VaultConfiguration
    {
        $this->conflictHandler = $conflictHandler;

        return $this;
    }

    public function getOperationListBuilder(): string
    {
        return $this->operationListBuilder;
    }

    public function setOperationListBuilder(string $operationListBuilder): VaultConfiguration
    {
        $this->operationListBuilder = $operationListBuilder;

        return $this;
    }

    public function getSettings(): array
    {
        return $this->settings;
    }

    public function getSetting(string $name)
    {
        return isset($this->settings[$name]) ? $this->settings[$name] : null;
    }

    public function setSettings(array $settings): VaultConfiguration
    {
        $this->settings = $settings;

        return $this;
    }

    public function setSetting(string $name, $value): VaultConfiguration
    {
        $this->settings[$name] = $value;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function exchangeArray(array $array)
    {
        if ($diff = array_diff(array_keys($array), array_keys($this->getArrayCopy())))
        {
            throw new \InvalidArgumentException("Invalid index(es): " . implode(',', $diff));
        }

        foreach ($array as $key => $value)
        {
            // using setter to prevent skipping validation
            call_user_func([$this, 'set' . ucfirst($key)], $value);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getArrayCopy()
    {
        $array = get_object_vars($this);

        unset($array['configuration']);

        return $array;
    }

    public static function loadValidatorMetadata(ClassMetadata $metadata)
    {
        $metadata->addPropertyConstraint('title', new Assert\NotBlank());
        $metadata->addPropertyConstraint('adapter', new StoremanAssert\StorageAdapterExists());
        $metadata->addPropertyConstraint('conflictHandler', new StoremanAssert\ConflictHandlerExists());
        $metadata->addPropertyConstraint('indexMerger', new StoremanAssert\IndexMergerExists());
        $metadata->addPropertyConstraint('lockAdapter', new StoremanAssert\LockAdapterExists());
        $metadata->addPropertyConstraint('operationListBuilder', new StoremanAssert\OperationListBuilderExists());
    }
}