ConverterHolder::hasType() - Code Metrics - pomm-project/Foundation - Measure and Improve Code Quality continuously with Scrutinizer

ConverterHolder::hasType() A
last analyzed 2020-12-01 08:51 UTC

↳ Parent: ConverterHolder

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php
/*
 * This file is part of Pomm's Foundation package.
 *
 * (c) 2014 - 2017 Grégoire HUBERT <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PommProject\Foundation\Converter;

use PommProject\Foundation\Exception\ConverterException;

/**
 * ConverterHolder
 *
 * Responsible of holding all converters associated with their corresponding
 * types.
 *
 * @package   Foundation
 * @copyright 2014 - 2017 Grégoire HUBERT
 * @author    Grégoire HUBERT
 * @license   X11 {@link http://opensource.org/licenses/mit-license.php}
 */
class ConverterHolder
{
    protected $converters = [];
    protected $types = [];

    /**
     * registerConverter
     *
     * Declare a converter and assign types to it.
     *
     * @param  string             $name
     * @param  ConverterInterface $converter
     * @param  array              $types
     * @param  bool               $strict
     * @return ConverterHolder    $this
     */
    public function registerConverter($name, ConverterInterface $converter, array $types, $strict = null)
    {
        $this->addConverter($name, $converter, $strict);

        foreach ($types as $type) {
            $this->addTypeToConverter($name, $type);
        }

        return $this;
    }

    /**
     * addConverter
     *
     * Add a converter with a new name. If strict is set to true and the
     * converter for this type has already been registered, then it throws and
     * exception.
     *
     * @param  string             $name
     * @param  ConverterInterface $converter
     * @param  bool               $strict (default true)
     * @throws ConverterException if $name already exists and strict.
     * @return ConverterHolder    $this
     */
    protected function addConverter($name, ConverterInterface $converter, $strict = null)
    {
        $strict = $strict === null ? true : (bool) $strict;

        if ($strict && $this->hasConverterName($name)) {
            throw new ConverterException(
                sprintf(
                    "A converter named '%s' already exists. (Known converters are {%s}).",
                    $name,
                    join(', ', $this->getConverterNames())
                )
            );
        }

        $this->converters[$name] = $converter;

        return $this;
    }

    /**
     * hasConverterName
     *
     * Tell if the converter exists or not.
     *
     * @param  string $name
     * @return bool
     */
    public function hasConverterName($name)
    {
        return (bool) isset($this->converters[$name]);
    }

    /**
     * getConverter
     *
     * Return the converter associated with this name. If no converters found,
     * NULL is returned.
     *
     * @param  string             $name
     * @return ConverterInterface
     */
    public function getConverter($name)
    {
        return $this->hasConverterName($name) ? $this->converters[$name] : null;
    }

    /**
     * getConverterNames
     *
     * Returns an array with the names of the registered converters.
     *
     * @return array
     */
    public function getConverterNames()
    {
        return array_keys($this->converters);
    }

    /**
     * addTypeToConverter
     *
     * Make the given converter to support a new PostgreSQL type. If the given
     * type is already defined, it is overrided with the new converter.
     *
     * @param  string          $name
     * @param  string          $type
     * @throws  ConverterException if $name does not exist.
     * @return ConverterHolder $this
     */
    public function addTypeToConverter($name, $type)
    {
        if (!$this->hasConverterName($name)) {
            throw new ConverterException(
                sprintf(
                    "No such converter name '%s'. Registered converters are {%s}.",
                    $name,
                    join(', ', $this->getConverterNames())
                )
            );
        }

        $this->types[$type] = $name;

        return $this;
    }

    /**
     * getConverterForType
     *
     * Returns the converter instance for the given type.
     *
     * @param  string             $type
     * @throws  ConverterException if there are no converters associated.
     * @return ConverterInterface
     */
    public function getConverterForType($type)
    {
        if (!$this->hasType($type)) {
            throw new ConverterException(
                sprintf(
                    "No converters associated with type '%s'. Handled types are {%s}.",
                    $type,
                    join(', ', $this->getTypes())
                )
            );
        }

        return $this->converters[$this->types[$type]];
    }

    /**
     * hasType
     *
     * Does the type exist ?
     *
     * @param  string $type
     * @return bool
     */
    public function hasType($type)
    {
        return (bool) isset($this->types[$type]);
    }

    /**
     * getTypes
     *
     * Return the list of handled types.
     *
     * @return array
     */
    public function getTypes()
    {
        return array_keys($this->types);
    }

    /**
     * getTypesWithConverterName
     *
     * Return the list of types with the related converter name.
     *
     * @return array
     */
    public function getTypesWithConverterName()
    {
        return $this->types;
    }
}


1		<?php
2		/*
3		* This file is part of Pomm's Foundation package.
4		*
5		* (c) 2014 - 2017 Grégoire HUBERT <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10		namespace PommProject\Foundation\Converter;
11
12		use PommProject\Foundation\Exception\ConverterException;
13
14		/**
15		* ConverterHolder
16		*
17		* Responsible of holding all converters associated with their corresponding
18		* types.
19		*
20		* @package Foundation
21		* @copyright 2014 - 2017 Grégoire HUBERT
22		* @author Grégoire HUBERT
23		* @license X11 {@link http://opensource.org/licenses/mit-license.php}
24		*/
25		class ConverterHolder
26		{
27		protected $converters = [];
28		protected $types = [];
29
30		/**
31		* registerConverter
32		*
33		* Declare a converter and assign types to it.
34		*
35		* @param string $name
36		* @param ConverterInterface $converter
37		* @param array $types
38		* @param bool $strict
39		* @return ConverterHolder $this
40		*/
41		public function registerConverter($name, ConverterInterface $converter, array $types, $strict = null)
42		{
43		$this->addConverter($name, $converter, $strict);
44
45		foreach ($types as $type) {
46		$this->addTypeToConverter($name, $type);
47		}
48
49		return $this;
50		}
51
52		/**
53		* addConverter
54		*
55		* Add a converter with a new name. If strict is set to true and the
56		* converter for this type has already been registered, then it throws and
57		* exception.
58		*
59		* @param string $name
60		* @param ConverterInterface $converter
61		* @param bool $strict (default true)
62		* @throws ConverterException if $name already exists and strict.
63		* @return ConverterHolder $this
64		*/
65		protected function addConverter($name, ConverterInterface $converter, $strict = null)
66		{
67		$strict = $strict === null ? true : (bool) $strict;
68
69	View Code Duplication	if ($strict && $this->hasConverterName($name)) {
70		throw new ConverterException(
71		sprintf(
72		"A converter named '%s' already exists. (Known converters are {%s}).",
73		$name,
74		join(', ', $this->getConverterNames())
75		)
76		);
77		}
78
79		$this->converters[$name] = $converter;
80
81		return $this;
82		}
83
84		/**
85		* hasConverterName
86		*
87		* Tell if the converter exists or not.
88		*
89		* @param string $name
90		* @return bool
91		*/
92		public function hasConverterName($name)
93		{
94		return (bool) isset($this->converters[$name]);
95		}
96
97		/**
98		* getConverter
99		*
100		* Return the converter associated with this name. If no converters found,
101		* NULL is returned.
102		*
103		* @param string $name
104		* @return ConverterInterface
105		*/
106		public function getConverter($name)
107		{
108		return $this->hasConverterName($name) ? $this->converters[$name] : null;
109		}
110
111		/**
112		* getConverterNames
113		*
114		* Returns an array with the names of the registered converters.
115		*
116		* @return array
117		*/
118		public function getConverterNames()
119		{
120		return array_keys($this->converters);
121		}
122
123		/**
124		* addTypeToConverter
125		*
126		* Make the given converter to support a new PostgreSQL type. If the given
127		* type is already defined, it is overrided with the new converter.
128		*
129		* @param string $name
130		* @param string $type
131		* @throws ConverterException if $name does not exist.
132		* @return ConverterHolder $this
133		*/
134		public function addTypeToConverter($name, $type)
135		{
136	View Code Duplication	if (!$this->hasConverterName($name)) {
137		throw new ConverterException(
138		sprintf(
139		"No such converter name '%s'. Registered converters are {%s}.",
140		$name,
141		join(', ', $this->getConverterNames())
142		)
143		);
144		}
145
146		$this->types[$type] = $name;
147
148		return $this;
149		}
150
151		/**
152		* getConverterForType
153		*
154		* Returns the converter instance for the given type.
155		*
156		* @param string $type
157		* @throws ConverterException if there are no converters associated.
158		* @return ConverterInterface
159		*/
160		public function getConverterForType($type)
161		{
162		if (!$this->hasType($type)) {
163		throw new ConverterException(
164		sprintf(
165		"No converters associated with type '%s'. Handled types are {%s}.",
166		$type,
167		join(', ', $this->getTypes())
168		)
169		);
170		}
171
172		return $this->converters[$this->types[$type]];
173		}
174
175		/**
176		* hasType
177		*
178		* Does the type exist ?
179		*
180		* @param string $type
181		* @return bool
182		*/
183		public function hasType($type)
184		{
185		return (bool) isset($this->types[$type]);
186		}
187
188		/**
189		* getTypes
190		*
191		* Return the list of handled types.
192		*
193		* @return array
194		*/
195		public function getTypes()
196		{
197		return array_keys($this->types);
198		}
199
200		/**
201		* getTypesWithConverterName
202		*
203		* Return the list of types with the related converter name.
204		*
205		* @return array
206		*/
207		public function getTypesWithConverterName()
208		{
209		return $this->types;
210		}
211		}
212

pomm-project / Foundation

ConverterHolder::hasType() A last analyzed 2020-12-01 08:51 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ConverterHolder::hasType() A
last analyzed 2020-12-01 08:51 UTC