Mapping::fromYAML() - Code Metrics - wowstack/php-dbc-parser - Measure and Improve Code Quality continuously with Scrutinizer

Mapping::fromYAML() A
last analyzed 2019-08-16 07:28 UTC

↳ Parent: Mapping

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php

declare(strict_types=1);

namespace Wowstack\Dbc;

use Symfony\Component\Yaml\Yaml;
use Wowstack\Dbc\MappingField as Mappings;
use Wowstack\Dbc\MappingField\MappingFieldInterface;
use Wowstack\Dbc\MappingField\MappingException;

/**
 * Implements the column to field type maps for reading DBC files.
 */
class Mapping
{
    /**
     * @var MappingFieldInterface[]
     */
    protected $fields = [];

    /**
     * @var int
     */
    protected $fieldCount = 0;

    /**
     * @var int
     */
    protected $fieldSize = 0;

    /**
     * @var bool
     */
    protected $hasStrings = false;

    /**
     * Create an instance.
     *
     * @param array $mapping
     *
     * @throws MappingException
     */
    public function __construct(array $mapping = [])
    {
        $fields = isset($mapping['fields']) ? $mapping['fields'] : [];

        foreach ($fields as $fieldName => $fieldData) {
            $this->add($fieldName, $fieldData);
            $this->fieldCount += $this->fields[$fieldName]->getTotalCount();
            $this->fieldSize += $this->fields[$fieldName]->getTotalSize();

            if ('string' === $this->fields[$fieldName]->getType() ||
            'localized_string' === $this->fields[$fieldName]->getType()) {
                $this->hasStrings = true;
            }
        }
    }

    /**
     * Adds a field type to the mapping list.
     *
     * @param string $name
     * @param array  $parameters
     *
     * @throws MappingException
     */
    public function add(string $name, array $parameters)
    {
        if (!isset($parameters['type'])) {
            throw new MappingException('Field definition is missing a type.');
        }

        switch ($parameters['type']) {
            case 'float':
                $field = new Mappings\FloatField($name, $parameters);
                break;
            case 'localized_string':
                $field = new Mappings\LocalizedStringField($name, $parameters);
                break;
            case 'char':
                $field = new Mappings\SignedCharField($name, $parameters);
                break;
            case 'int':
                $field = new Mappings\SignedIntegerField($name, $parameters);
                break;
            case 'string':
                $field = new Mappings\StringField($name, $parameters);
                break;
            case 'uchar':
                $field = new Mappings\UnsignedCharField($name, $parameters);
                break;
            case 'uint':
                $field = new Mappings\UnsignedIntegerField($name, $parameters);
                break;
            case 'foreign_key':
                $field = new Mappings\ForeignKeyField($name, $parameters);
                break;
            default:
                throw new MappingException('Unknown field type specified');
        }

        $this->fields[$name] = $field;
    }

    /**
     * Returns the amount of fields in the mapping.
     *
     * @return int
     */
    public function getFieldCount(): int
    {
        return $this->fieldCount;
    }

    /**
     * Returns the actual amount of columns in the mapping.
     *
     * @return int
     */
    public function getFieldSize(): int
    {
        return $this->fieldSize;
    }

    /**
     * Returns the mapping type for a field.
     *
     * @param string $name
     *
     * @return string
     */
    public function getFieldType(string $name): string
    {
        return $this->fields[$name]->getType();
    }

    /**
     * Create an instance with a mapping from file.
     *
     * @param string $yaml path to YAML file
     *
     * @return Mapping
     *
     * @throws MappingException
     */
    public static function fromYAML(string $yaml): Mapping
    {
        return new self(Yaml::parseFile($yaml));

    }

    /**
     * Returns if a string field is part of the mapping.
     *
     * @return bool
     */
    public function hasStrings(): bool
    {
        return $this->hasStrings;
    }

    /**
     * Returns a list of field names.
     *
     * @return array
     */
    public function getFieldNames(): array
    {
        $fieldNames = [];

        foreach ($this->fields as $field) {
            $fieldList = $field->getParsedFields();
            foreach ($fieldList as $fieldName => $fieldData) {
                $fieldNames[] = $fieldName;
            }
        }

        return $fieldNames;
    }

    /**
     * Returns the resulting parsed field data.
     *
     * @var array
     *
     * @return array
     */
    public function getParsedFields(): array
    {
        $parsedFields = [];

        foreach ($this->fields as $field) {
            $fieldList = $field->getParsedFields();
            foreach ($fieldList as $fieldName => $fieldData) {
                $parsedFields[$fieldName] = $fieldData;
            }
        }

        return $parsedFields;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Wowstack\Dbc;
6
7		use Symfony\Component\Yaml\Yaml;
8		use Wowstack\Dbc\MappingField as Mappings;
9		use Wowstack\Dbc\MappingField\MappingFieldInterface;
10		use Wowstack\Dbc\MappingField\MappingException;
11
12		/**
13		* Implements the column to field type maps for reading DBC files.
14		*/
15		class Mapping
16		{
17		/**
18		* @var MappingFieldInterface[]
19		*/
20		protected $fields = [];
21
22		/**
23		* @var int
24		*/
25		protected $fieldCount = 0;
26
27		/**
28		* @var int
29		*/
30		protected $fieldSize = 0;
31
32		/**
33		* @var bool
34		*/
35		protected $hasStrings = false;
36
37		/**
38		* Create an instance.
39		*
40		* @param array $mapping
41		*
42		* @throws MappingException
43		*/
44	23	public function __construct(array $mapping = [])
45		{
46	23	$fields = isset($mapping['fields']) ? $mapping['fields'] : [];
47
48	23	foreach ($fields as $fieldName => $fieldData) {
49	23	$this->add($fieldName, $fieldData);
50	23	$this->fieldCount += $this->fields[$fieldName]->getTotalCount();
51	23	$this->fieldSize += $this->fields[$fieldName]->getTotalSize();
52
53	23	if ('string' === $this->fields[$fieldName]->getType() \|\|
54	23	'localized_string' === $this->fields[$fieldName]->getType()) {
55	23	$this->hasStrings = true;
56		}
57		}
58	21	}
59
60		/**
61		* Adds a field type to the mapping list.
62		*
63		* @param string $name
64		* @param array $parameters
65		*
66		* @throws MappingException
67		*/
68	23	public function add(string $name, array $parameters)
69		{
70	23	if (!isset($parameters['type'])) {
71	1	throw new MappingException('Field definition is missing a type.');
72		}
73
74	23	switch ($parameters['type']) {
75	23	case 'float':
76	16	$field = new Mappings\FloatField($name, $parameters);
77	16	break;
78	23	case 'localized_string':
79	16	$field = new Mappings\LocalizedStringField($name, $parameters);
80	16	break;
81	23	case 'char':
82	1	$field = new Mappings\SignedCharField($name, $parameters);
83	1	break;
84	23	case 'int':
85	16	$field = new Mappings\SignedIntegerField($name, $parameters);
86	16	break;
87	23	case 'string':
88	5	$field = new Mappings\StringField($name, $parameters);
89	5	break;
90	23	case 'uchar':
91	1	$field = new Mappings\UnsignedCharField($name, $parameters);
92	1	break;
93	23	case 'uint':
94	23	$field = new Mappings\UnsignedIntegerField($name, $parameters);
95	23	break;
96	10	case 'foreign_key':
97	9	$field = new Mappings\ForeignKeyField($name, $parameters);
98	9	break;
99		default:
100	1	throw new MappingException('Unknown field type specified');
101		}
102
103	23	$this->fields[$name] = $field;
104	23	}
105
106		/**
107		* Returns the amount of fields in the mapping.
108		*
109		* @return int
110		*/
111	16	public function getFieldCount(): int
112		{
113	16	return $this->fieldCount;
114		}
115
116		/**
117		* Returns the actual amount of columns in the mapping.
118		*
119		* @return int
120		*/
121	5	public function getFieldSize(): int
122		{
123	5	return $this->fieldSize;
124		}
125
126		/**
127		* Returns the mapping type for a field.
128		*
129		* @param string $name
130		*
131		* @return string
132		*/
133	1	public function getFieldType(string $name): string
134		{
135	1	return $this->fields[$name]->getType();
136		}
137
138		/**
139		* Create an instance with a mapping from file.
140		*
141		* @param string $yaml path to YAML file
142		*
143		* @return Mapping
144		*
145		* @throws MappingException
146		*/
147	23	public static function fromYAML(string $yaml): Mapping
148		{
149	23	return new self(Yaml::parseFile($yaml));
		0 ignored issues – show introduced 2019-04-17 20:35 UTC by Report Bug Copy Issue Report Use parentheses when instantiating classes Loading history...
150		}
151
152		/**
153		* Returns if a string field is part of the mapping.
154		*
155		* @return bool
156		*/
157	11	public function hasStrings(): bool
158		{
159	11	return $this->hasStrings;
160		}
161
162		/**
163		* Returns a list of field names.
164		*
165		* @return array
166		*/
167	2	public function getFieldNames(): array
168		{
169	2	$fieldNames = [];
170
171	2	foreach ($this->fields as $field) {
172	2	$fieldList = $field->getParsedFields();
173	2	foreach ($fieldList as $fieldName => $fieldData) {
174	2	$fieldNames[] = $fieldName;
175		}
176		}
177
178	2	return $fieldNames;
179		}
180
181		/**
182		* Returns the resulting parsed field data.
183		*
184		* @var array
185		*
186		* @return array
187		*/
188	5	public function getParsedFields(): array
189		{
190	5	$parsedFields = [];
191
192	5	foreach ($this->fields as $field) {
193	5	$fieldList = $field->getParsedFields();
194	5	foreach ($fieldList as $fieldName => $fieldData) {
195	5	$parsedFields[$fieldName] = $fieldData;
196		}
197		}
198
199	5	return $parsedFields;
200		}
201		}
202

wowstack / php-dbc-parser

Mapping::fromYAML() A last analyzed 2019-08-16 07:28 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Mapping::fromYAML() A
last analyzed 2019-08-16 07:28 UTC