Thing::NudgePropertyWithUniqueBooleans() - Code Metrics - Inspection of "adjusting indentation" - SignpostMarv/Daft-Schema.org - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 18b445...fadfeb )

by SignpostMarv

created 2019-03-18 21:48 UTC

Thing::NudgePropertyWithUniqueBooleans() A

↳ Parent: Thing

Complexity

Conditions	3
Paths	4

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	3

Importance

Changes

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

<?php
/**
* @author SignpostMarv
*/
declare(strict_types=1);

namespace SignpostMarv\DaftObject\SchemaOrg;

use InvalidArgumentException;
use SignpostMarv\DaftObject\AbstractArrayBackedDaftObject;
use SignpostMarv\DaftObject\DaftJson;
use SignpostMarv\DaftObject\DaftObjectHasPropertiesWithMultiTypedArraysOfUniqueValues;
use SignpostMarv\DaftObject\JsonTypeUtilities;
use SignpostMarv\DaftObject\SchemaOrg\CreativeWork\MediaObject\ImageObject;
use SignpostMarv\DaftObject\SchemaOrg\Intangible\StructuredValue\PropertyValue;

/**
* @property array<int, string> $additionalType
* @property array<int, string> $alternateName
* @property array<int, string> $description
* @property array<int, string> $disambiguatingDescription
* @property array<int, string|PropertyValue> $identifier
* @property array<int, string|ImageObject> $image
* @property array<int, string|CreativeWork> $mainEntityOfPage
* @property array<int, string> $name
* @property array<int, Action> $potentialAction
* @property array<int, string> $sameAs
* @property array<int, CreativeWork|Event> $subjectOf
* @property array<int, Action> $potentialAction
* @property array<int, string> $url
*
* @template-implements DaftJson<Thing>
*/
class Thing extends AbstractArrayBackedDaftObject implements
    DaftJson,
    DaftObjectHasPropertiesWithMultiTypedArraysOfUniqueValues
{
    const SCHEMA_ORG_CONTEXT = 'http://schema.org';

    const SCHEMA_ORG_TYPE = 'Thing';

    const PROPERTIES = [
        '@context',
        '@type',
        'additionalType',
        'alternateName',
        'description',
        'disambiguatingDescription',
        'identifier',
        'image',
        'mainEntityOfPage',
        'name',
        'potentialAction',
        'sameAs',
        'subjectOf',
        'url',
    ];

    const PROPERTIES_WITH_MULTI_TYPED_ARRAYS = [
        'additionalType' => [
            'string',
        ],
        'alternateName' => [
            'string',
        ],
        'description' => [
            'string',
        ],
        'disambiguatingDescription' => [
            'string',
        ],
        'identifier' => [
            'string',
            PropertyValue::class,
        ],
        'image' => [
            'string',
            ImageObject::class,
        ],
        'mainEntityOfPage' => [
            'string',
            CreativeWork::class,
        ],
        'name' => [
            'string',
        ],
        'potentialAction' => [
            Action::class,
        ],
        'sameAs' => [
            'string',
        ],
        'subjectOf' => [
            CreativeWork::class,
            Event::class,
        ],
        'url' => [
            'string',
        ],
    ];

    public function __construct(array $data = [], bool $writeAll = false)
    {
        $missing = array_diff(static::DaftObjectProperties(), array_keys($data));

        /**
        * @var array<int, string>
        */
        $missing = array_combine(
            $missing,
            array_fill(0, count($missing), [])
        );

        /**
        * @var array<string, scalar|array|object|null>
        */
        $data = array_merge(
            $data,
            $missing
        );

        unset($data['@context'], $data['@type']);

        parent::__construct($data, $writeAll);
    }

    public function ObtainContext() : string
    {
        return (string) static::SCHEMA_ORG_CONTEXT;
    }

    public function ObtainType() : string
    {
        return (string) static::SCHEMA_ORG_TYPE;
    }

    /**
    * @return array<int, string>
    */
    public function GetAdditionalType() : array
    {
        /**
        * @var array<int, string>
        */
        $out = $this->ExpectRetrievedValueIsArray('additionalType');

        return $out;
    }

    /**
    * @param array<int, string> $value
    */
    public function SetAdditionalType(array $value) : void
    {
        $this->NudgePropertyValue('additionalType', $value, true);
    }

    /**
    * @return array<int, string>
    */
    public function GetAlternateName() : array
    {
        /**
        * @var array<int, string>
        */
        $out = $this->ExpectRetrievedValueIsArray('alternateName');

        return $out;
    }

    /**
    * @param array<int, string> $value
    */
    public function SetAlternateName(array $value) : void
    {
        $this->NudgePropertyValue('alternateName', $value, true);
    }

    /**
    * @return array<int, string>
    */
    public function GetDescription() : array
    {
        /**
        * @var array<int, string>
        */
        $out = $this->ExpectRetrievedValueIsArray('description');

        return $out;
    }

    /**
    * @param array<int, string> $value
    */
    public function SetDescription(array $value) : void
    {
        $this->NudgePropertyValue('description', $value, true);
    }

    /**
    * @return array<int, string>
    */
    public function GetDisambiguatingDescription() : array
    {
        /**
        * @var array<int, string>
        */
        $out = $this->ExpectRetrievedValueIsArray('disambiguatingDescription');

        return $out;
    }

    /**
    * @param array<int, string> $value
    */
    public function SetDisambiguatingDescription(array $value) : void
    {
        $this->NudgePropertyValue('disambiguatingDescription', $value, true);
    }

    /**
    * @return array<int, string|PropertyValue>
    */
    public function GetIdentifier() : array
    {
        /**
        * @var array<int, string|PropertyValue>
        */
        $out = $this->ExpectRetrievedValueIsArray('identifier');

        return $out;
    }

    /**
    * @param array<int, string|PropertyValue> $value
    */
    public function SetIdentifier(array $value) : void
    {
        $this->NudgePropertyValue('identifier', $value, true);
    }

    /**
    * @return array<int, string|ImageObject>
    */
    public function GetImage() : array
    {
        /**
        * @var array<int, string|ImageObject>
        */
        $out = $this->ExpectRetrievedValueIsArray('image');

        return $out;
    }

    /**
    * @param array<int, string|ImageObject> $value
    */
    public function SetImage(array $value) : void
    {
        $this->NudgePropertyValue('image', $value, true);
    }

    /**
    * @return array<int, string|CreativeWork>
    */
    public function GetMainEntityOfPage() : array
    {
        /**
        * @var array<int, string|CreativeWork>
        */
        $out = $this->ExpectRetrievedValueIsArray('mainEntityOfPage');

        return $out;
    }

    /**
    * @param array<int, string|CreativeWork> $value
    */
    public function SetMainEntityOfPage(array $value) : void
    {
        $this->NudgePropertyValue('mainEntityOfPage', $value, true);
    }

    /**
    * @return array<int, string>
    */
    public function GetName() : array
    {
        /**
        * @var array<int, string>
        */
        $out = $this->ExpectRetrievedValueIsArray('name');

        return $out;
    }

    /**
    * @param array<int, string> $value
    */
    public function SetName(array $value) : void
    {
        $this->NudgePropertyValue('name', $value, true);
    }

    /**
    * @return array<int, Action>
    */
    public function GetPotentialAction() : array
    {
        /**
        * @var array<int, Action>
        */
        $out = $this->ExpectRetrievedValueIsArray('potentialAction');

        return $out;
    }

    /**
    * @param array<int, Action> $value
    */
    public function SetPotentialAction(array $value) : void
    {
        $this->NudgePropertyValue('potentialAction', $value);
    }

    /**
    * @return array<int, string>
    */
    public function GetSameAs() : array
    {
        /**
        * @var array<int, string>
        */
        $out = $this->ExpectRetrievedValueIsArray('sameAs');

        return $out;
    }

    /**
    * @param array<int, string> $value
    */
    public function SetSameAs(array $value) : void
    {
        $this->NudgePropertyValue('sameAs', $value, true);
    }

    /**
    * @return array<int, CreativeWork|Event>
    */
    public function GetSubjectOf() : array
    {
        /**
        * @var array<int, CreativeWork|Event>
        */
        $out = $this->ExpectRetrievedValueIsArray('subjectOf');

        return $out;
    }

    /**
    * @param array<int, CreativeWork|Event> $value
    */
    public function SetSubjectOf(array $value) : void
    {
        $this->NudgePropertyValue('subjectOf', $value, true);
    }

    /**
    * @return array<int, string>
    */
    public function GetUrl() : array
    {
        /**
        * @var array<int, string>
        */
        $out = $this->ExpectRetrievedValueIsArray('url');

        return $out;
    }

    /**
    * @param array<int, string> $value
    */
    public function SetUrl(array $value) : void
    {
        $this->NudgePropertyValue('url', $value, true);
    }

    public function jsonSerialize() : array
    {
        return array_filter(
            parent::jsonSerialize(),
            /**
            * @param scalar|array|object|null $val
            */
            function ($val) : bool {
                return ! is_array($val) || count($val) > 0;
            }
        );
    }

    public static function DaftObjectProperties() : array
    {
        /**
        * @var array<int, string>
        */
        $static = static::PROPERTIES;

        /**
        * @var string
        *
        * @psalm-var class-string<Thing>
        */
        $static_parent = get_parent_class(static::class);

        $parent = $static_parent::DaftObjectProperties();

        return array_unique(array_merge(
            $parent,
            $static
        ));
    }

    /**
    * @return array<string, array<int, string>>
    */
    public static function DaftObjectPropertiesWithMultiTypedArraysOfUniqueValues() : array
    {
        /**
        * @var array<string, array<int, string>>
        */
        $static = static::PROPERTIES_WITH_MULTI_TYPED_ARRAYS;

        /**
        * @var string
        *
        * @psalm-var class-string<Thing>
        */
        $static_parent = get_parent_class(static::class);

        if ($static_parent === get_parent_class(self::class)) {
            return $static;
        }

        $parent = $static_parent::DaftObjectPropertiesWithMultiTypedArraysOfUniqueValues();

        return array_merge(
            $parent,
            $static
        );
    }

    public static function DaftObjectNullableProperties() : array
    {
        /**
        * @var array<int, string>
        */
        $static = static::NULLABLE_PROPERTIES;

        /**
        * @var string
        *
        * @psalm-var class-string<Thing>
        */
        $static_parent = get_parent_class(static::class);

        $parent = $static_parent::DaftObjectNullableProperties();

        return array_unique(array_merge(
            $parent,
            $static
        ));
    }

    public static function DaftObjectExportableProperties() : array
    {
        return static::DaftObjectProperties();
    }

    public static function DaftObjectJsonProperties() : array
    {
        return static::DaftObjectProperties();
    }

    public static function DaftObjectPublicGetters() : array
    {
        /**
        * @var string
        *
        * @psalm-var class-string<Thing>
        */
        $static_parent = get_parent_class(static::class);

        $static = TypeUtilities::DaftObjectPublicGetters(static::class);

        if ($static_parent === get_parent_class(self::class)) {
            return $static;
        }

        return array_unique(array_merge(
            TypeUtilities::DaftObjectPublicGetters($static_parent),
            $static
        ));
    }

    public static function DaftObjectPublicOrProtectedGetters() : array
    {
        /**
        * @var string
        *
        * @psalm-var class-string<Thing>
        */
        $static_parent = get_parent_class(static::class);

        $static = TypeUtilities::DaftObjectPublicOrProtectedGetters(static::class);

        if ($static_parent === get_parent_class(self::class)) {
            return $static;
        }

        return array_unique(array_merge(
            TypeUtilities::DaftObjectPublicOrProtectedGetters($static_parent),
            $static
        ));
    }

    public static function DaftObjectPublicSetters() : array
    {
        /**
        * @var string
        *
        * @psalm-var class-string<Thing>
        */
        $static_parent = get_parent_class(static::class);

        $static = TypeUtilities::DaftObjectPublicSetters(static::class);

        if ($static_parent === get_parent_class(self::class)) {
            return $static;
        }

        return array_unique(array_merge(
            TypeUtilities::DaftObjectPublicSetters($static_parent),
            $static
        ));
    }

    /**
    * @return static
    *
    * @psalm-return Thing
    */
    public static function DaftObjectFromJsonString(
        string $string,
        bool $writeAll = self::BOOL_DEFAULT_WRITEALL
    ) : DaftJson {
        /**
        * @var array<string, scalar|(scalar|array|object|null)[]|object|null>
        */
        $decoded = json_decode($string, true);

        /**
        * @var static
        */
        $out = static::DaftObjectFromJsonArray($decoded, $writeAll);

        return $out;
    }

    /**
    * @return static
    *
    * @psalm-return Thing
    */
    public static function DaftObjectFromJsonArray(
        array $array,
        bool $writeAll = self::BOOL_DEFAULT_WRITEALL
    ) : DaftJson {
        $type = JsonTypeUtilities::ThrowIfNotDaftJson(static::class);

        $multi_type = static::DaftObjectPropertiesWithMultiTypedArraysOfUniqueValues();

        $array_keys = array_keys($array);

        foreach ($array_keys as $k) {
            if ( ! is_string($k)) {
                throw new InvalidArgumentException(
                    'Argument 1 passed to ' .
                    __METHOD__ .
                    '() must have all-string indices!'
                );
            }
        }

        /**
        * @var array<int, string>
        */
        $array_keys = $array_keys;

        $data = array_combine($array_keys, array_map(
            /**
            * @param string $k
            *
            * @return mixed
            */
            function (string $k) use ($array, $multi_type) {
                if (is_array($array[$k])) {
                    return static::DaftObjectFromJsonArrayFromArray($k, $multi_type, $array[$k]);
                }

                return $array[$k];
            },
            $array_keys
        ));

        /**
        * @psalm-var Thing
        *
        * @var Thing
        */
        $out = new $type($data, $writeAll);

        return $out;
    }

    /**
    * @param array<string, array<int, string>> $multi_type
    */
    protected static function DaftObjectFromJsonArrayFromArray(
        string $k,
        array $multi_type,
        array $arr
    ) : array {
        return array_map(
            /**
            * @param mixed $val
            *
            * @return mixed
            */
            function ($val) use ($k, $multi_type) {
                if (
                    is_array($val) &&
                    isset($val['@context'], $val['@type'], $multi_type[$k])
                ) {
                    /**
                    * @psalm-var array<string, array<array-key, array<array-key, mixed>|scalar|object|null>|scalar|object|null>
                    */
                    $val = $val;

                    foreach ($multi_type[$k] as $maybe) {
                        if (
                            is_a($maybe, Thing::class, true) &&
                            $val['@context'] === $maybe::SCHEMA_ORG_CONTEXT &&
                            $val['@type'] === $maybe::SCHEMA_ORG_TYPE
                        ) {
                            return $maybe::DaftObjectFromJsonArray($val);
                        }
                    }
                }

                return $val;
            },
            $arr
        );
    }

    protected function ExpectRetrievedValueIsArray(string $property) : array
    {
        return TypeUtilities::ExpectRetrievedValueIsArray(
            $property,
            $this->RetrievePropertyValueFromData($property),
            static::class
        );
    }

    /**
    * @param array<int, bool> $value
    */
    protected function NudgePropertyWithUniqueBooleans(
        string $property,
        array $value
    ) : void {
        $replace = [];
        if (in_array(true, $value, true)) {
            $replace[] = true;
        }
        if (in_array(false, $value, true)) {
            $replace[] = false;
        }

        $this->NudgePropertyValue($property, $replace);
    }
}


1		<?php
2		/**
3		* @author SignpostMarv
4		*/
5		declare(strict_types=1);
6
7		namespace SignpostMarv\DaftObject\SchemaOrg;
8
9		use InvalidArgumentException;
10		use SignpostMarv\DaftObject\AbstractArrayBackedDaftObject;
11		use SignpostMarv\DaftObject\DaftJson;
12		use SignpostMarv\DaftObject\DaftObjectHasPropertiesWithMultiTypedArraysOfUniqueValues;
13		use SignpostMarv\DaftObject\JsonTypeUtilities;
14		use SignpostMarv\DaftObject\SchemaOrg\CreativeWork\MediaObject\ImageObject;
15		use SignpostMarv\DaftObject\SchemaOrg\Intangible\StructuredValue\PropertyValue;
16
17		/**
18		* @property array<int, string> $additionalType
19		* @property array<int, string> $alternateName
20		* @property array<int, string> $description
21		* @property array<int, string> $disambiguatingDescription
22		* @property array<int, string\|PropertyValue> $identifier
23		* @property array<int, string\|ImageObject> $image
24		* @property array<int, string\|CreativeWork> $mainEntityOfPage
25		* @property array<int, string> $name
26		* @property array<int, Action> $potentialAction
27		* @property array<int, string> $sameAs
28		* @property array<int, CreativeWork\|Event> $subjectOf
29		* @property array<int, Action> $potentialAction
30		* @property array<int, string> $url
31		*
32		* @template-implements DaftJson<Thing>
33		*/
34		class Thing extends AbstractArrayBackedDaftObject implements
35		DaftJson,
36		DaftObjectHasPropertiesWithMultiTypedArraysOfUniqueValues
37		{
38		const SCHEMA_ORG_CONTEXT = 'http://schema.org';
39
40		const SCHEMA_ORG_TYPE = 'Thing';
41
42		const PROPERTIES = [
43		'@context',
44		'@type',
45		'additionalType',
46		'alternateName',
47		'description',
48		'disambiguatingDescription',
49		'identifier',
50		'image',
51		'mainEntityOfPage',
52		'name',
53		'potentialAction',
54		'sameAs',
55		'subjectOf',
56		'url',
57		];
58
59		const PROPERTIES_WITH_MULTI_TYPED_ARRAYS = [
60		'additionalType' => [
61		'string',
62		],
63		'alternateName' => [
64		'string',
65		],
66		'description' => [
67		'string',
68		],
69		'disambiguatingDescription' => [
70		'string',
71		],
72		'identifier' => [
73		'string',
74		PropertyValue::class,
75		],
76		'image' => [
77		'string',
78		ImageObject::class,
79		],
80		'mainEntityOfPage' => [
81		'string',
82		CreativeWork::class,
83		],
84		'name' => [
85		'string',
86		],
87		'potentialAction' => [
88		Action::class,
89		],
90		'sameAs' => [
91		'string',
92		],
93		'subjectOf' => [
94		CreativeWork::class,
95		Event::class,
96		],
97		'url' => [
98		'string',
99		],
100		];
101
102	10220	public function __construct(array $data = [], bool $writeAll = false)
103		{
104	10220	$missing = array_diff(static::DaftObjectProperties(), array_keys($data));
105
106		/**
107		* @var array<int, string>
108		*/
109	10220	$missing = array_combine(
110	10220	$missing,
111	10220	array_fill(0, count($missing), [])
112		);
113
114		/**
115		* @var array<string, scalar\|array\|object\|null>
116		*/
117	10220	$data = array_merge(
118	10220	$data,
119	10220	$missing
120		);
121
122	10220	unset($data['@context'], $data['@type']);
123
124	10220	parent::__construct($data, $writeAll);
125	10220	}
126
127	261	public function ObtainContext() : string
128		{
129	261	return (string) static::SCHEMA_ORG_CONTEXT;
130		}
131
132	261	public function ObtainType() : string
133		{
134	261	return (string) static::SCHEMA_ORG_TYPE;
135		}
136
137		/**
138		* @return array<int, string>
139		*/
140	520	public function GetAdditionalType() : array
141		{
142		/**
143		* @var array<int, string>
144		*/
145	520	$out = $this->ExpectRetrievedValueIsArray('additionalType');
146
147	520	return $out;
148		}
149
150		/**
151		* @param array<int, string> $value
152		*/
153	260	public function SetAdditionalType(array $value) : void
154		{
155	260	$this->NudgePropertyValue('additionalType', $value, true);
156	260	}
157
158		/**
159		* @return array<int, string>
160		*/
161	520	public function GetAlternateName() : array
162		{
163		/**
164		* @var array<int, string>
165		*/
166	520	$out = $this->ExpectRetrievedValueIsArray('alternateName');
167
168	520	return $out;
169		}
170
171		/**
172		* @param array<int, string> $value
173		*/
174	260	public function SetAlternateName(array $value) : void
175		{
176	260	$this->NudgePropertyValue('alternateName', $value, true);
177	260	}
178
179		/**
180		* @return array<int, string>
181		*/
182	520	public function GetDescription() : array
183		{
184		/**
185		* @var array<int, string>
186		*/
187	520	$out = $this->ExpectRetrievedValueIsArray('description');
188
189	520	return $out;
190		}
191
192		/**
193		* @param array<int, string> $value
194		*/
195	260	public function SetDescription(array $value) : void
196		{
197	260	$this->NudgePropertyValue('description', $value, true);
198	260	}
199
200		/**
201		* @return array<int, string>
202		*/
203	520	public function GetDisambiguatingDescription() : array
204		{
205		/**
206		* @var array<int, string>
207		*/
208	520	$out = $this->ExpectRetrievedValueIsArray('disambiguatingDescription');
209
210	520	return $out;
211		}
212
213		/**
214		* @param array<int, string> $value
215		*/
216	260	public function SetDisambiguatingDescription(array $value) : void
217		{
218	260	$this->NudgePropertyValue('disambiguatingDescription', $value, true);
219	260	}
220
221		/**
222		* @return array<int, string\|PropertyValue>
223		*/
224	521	public function GetIdentifier() : array
225		{
226		/**
227		* @var array<int, string\|PropertyValue>
228		*/
229	521	$out = $this->ExpectRetrievedValueIsArray('identifier');
230
231	521	return $out;
232		}
233
234		/**
235		* @param array<int, string\|PropertyValue> $value
236		*/
237	261	public function SetIdentifier(array $value) : void
238		{
239	261	$this->NudgePropertyValue('identifier', $value, true);
240	261	}
241
242		/**
243		* @return array<int, string\|ImageObject>
244		*/
245	520	public function GetImage() : array
246		{
247		/**
248		* @var array<int, string\|ImageObject>
249		*/
250	520	$out = $this->ExpectRetrievedValueIsArray('image');
251
252	520	return $out;
253		}
254
255		/**
256		* @param array<int, string\|ImageObject> $value
257		*/
258	260	public function SetImage(array $value) : void
259		{
260	260	$this->NudgePropertyValue('image', $value, true);
261	260	}
262
263		/**
264		* @return array<int, string\|CreativeWork>
265		*/
266	520	public function GetMainEntityOfPage() : array
267		{
268		/**
269		* @var array<int, string\|CreativeWork>
270		*/
271	520	$out = $this->ExpectRetrievedValueIsArray('mainEntityOfPage');
272
273	520	return $out;
274		}
275
276		/**
277		* @param array<int, string\|CreativeWork> $value
278		*/
279	260	public function SetMainEntityOfPage(array $value) : void
280		{
281	260	$this->NudgePropertyValue('mainEntityOfPage', $value, true);
282	260	}
283
284		/**
285		* @return array<int, string>
286		*/
287	520	public function GetName() : array
288		{
289		/**
290		* @var array<int, string>
291		*/
292	520	$out = $this->ExpectRetrievedValueIsArray('name');
293
294	520	return $out;
295		}
296
297		/**
298		* @param array<int, string> $value
299		*/
300	260	public function SetName(array $value) : void
301		{
302	260	$this->NudgePropertyValue('name', $value, true);
303	260	}
304
305		/**
306		* @return array<int, Action>
307		*/
308	520	public function GetPotentialAction() : array
309		{
310		/**
311		* @var array<int, Action>
312		*/
313	520	$out = $this->ExpectRetrievedValueIsArray('potentialAction');
314
315	520	return $out;
316		}
317
318		/**
319		* @param array<int, Action> $value
320		*/
321	260	public function SetPotentialAction(array $value) : void
322		{
323	260	$this->NudgePropertyValue('potentialAction', $value);
324	260	}
325
326		/**
327		* @return array<int, string>
328		*/
329	520	public function GetSameAs() : array
330		{
331		/**
332		* @var array<int, string>
333		*/
334	520	$out = $this->ExpectRetrievedValueIsArray('sameAs');
335
336	520	return $out;
337		}
338
339		/**
340		* @param array<int, string> $value
341		*/
342	260	public function SetSameAs(array $value) : void
343		{
344	260	$this->NudgePropertyValue('sameAs', $value, true);
345	260	}
346
347		/**
348		* @return array<int, CreativeWork\|Event>
349		*/
350	520	public function GetSubjectOf() : array
351		{
352		/**
353		* @var array<int, CreativeWork\|Event>
354		*/
355	520	$out = $this->ExpectRetrievedValueIsArray('subjectOf');
356
357	520	return $out;
358		}
359
360		/**
361		* @param array<int, CreativeWork\|Event> $value
362		*/
363	260	public function SetSubjectOf(array $value) : void
364		{
365	260	$this->NudgePropertyValue('subjectOf', $value, true);
366	260	}
367
368		/**
369		* @return array<int, string>
370		*/
371	520	public function GetUrl() : array
372		{
373		/**
374		* @var array<int, string>
375		*/
376	520	$out = $this->ExpectRetrievedValueIsArray('url');
377
378	520	return $out;
379		}
380
381		/**
382		* @param array<int, string> $value
383		*/
384	260	public function SetUrl(array $value) : void
385		{
386	260	$this->NudgePropertyValue('url', $value, true);
387	260	}
388
389	261	public function jsonSerialize() : array
390		{
391	261	return array_filter(
392	261	parent::jsonSerialize(),
393		/**
394		* @param scalar\|array\|object\|null $val
395		*/
396		function ($val) : bool {
397	261	return ! is_array($val) \|\| count($val) > 0;
398	261	}
399		);
400		}
401
402	20654	public static function DaftObjectProperties() : array
403		{
404		/**
405		* @var array<int, string>
406		*/
407	20654	$static = static::PROPERTIES;
408
409		/**
410		* @var string
411		*
412		* @psalm-var class-string<Thing>
413		*/
414	20654	$static_parent = get_parent_class(static::class);
415
416	20654	$parent = $static_parent::DaftObjectProperties();
417
418	20654	return array_unique(array_merge(
419	20654	$parent,
420	20654	$static
421		));
422		}
423
424		/**
425		* @return array<string, array<int, string>>
426		*/
427	523	public static function DaftObjectPropertiesWithMultiTypedArraysOfUniqueValues() : array
428		{
429		/**
430		* @var array<string, array<int, string>>
431		*/
432	523	$static = static::PROPERTIES_WITH_MULTI_TYPED_ARRAYS;
433
434		/**
435		* @var string
436		*
437		* @psalm-var class-string<Thing>
438		*/
439	523	$static_parent = get_parent_class(static::class);
440
441	523	if ($static_parent === get_parent_class(self::class)) {
442	523	return $static;
443		}
444
445	521	$parent = $static_parent::DaftObjectPropertiesWithMultiTypedArraysOfUniqueValues();
446
447	521	return array_merge(
448	521	$parent,
449	521	$static
450		);
451		}
452
453	10329	public static function DaftObjectNullableProperties() : array
454		{
455		/**
456		* @var array<int, string>
457		*/
458	10329	$static = static::NULLABLE_PROPERTIES;
459
460		/**
461		* @var string
462		*
463		* @psalm-var class-string<Thing>
464		*/
465	10329	$static_parent = get_parent_class(static::class);
466
467	10329	$parent = $static_parent::DaftObjectNullableProperties();
468
469	10329	return array_unique(array_merge(
470	10329	$parent,
471	10329	$static
472		));
473		}
474
475	478	public static function DaftObjectExportableProperties() : array
476		{
477	478	return static::DaftObjectProperties();
478		}
479
480	521	public static function DaftObjectJsonProperties() : array
481		{
482	521	return static::DaftObjectProperties();
483		}
484
485	521	public static function DaftObjectPublicGetters() : array
486		{
487		/**
488		* @var string
489		*
490		* @psalm-var class-string<Thing>
491		*/
492	521	$static_parent = get_parent_class(static::class);
493
494	521	$static = TypeUtilities::DaftObjectPublicGetters(static::class);
495
496	521	if ($static_parent === get_parent_class(self::class)) {
497	91	return $static;
498		}
499
500	520	return array_unique(array_merge(
501	520	TypeUtilities::DaftObjectPublicGetters($static_parent),
502	520	$static
503		));
504		}
505
506	1	public static function DaftObjectPublicOrProtectedGetters() : array
507		{
508		/**
509		* @var string
510		*
511		* @psalm-var class-string<Thing>
512		*/
513	1	$static_parent = get_parent_class(static::class);
514
515	1	$static = TypeUtilities::DaftObjectPublicOrProtectedGetters(static::class);
516
517	1	if ($static_parent === get_parent_class(self::class)) {
518	1	return $static;
519		}
520
521	1	return array_unique(array_merge(
522	1	TypeUtilities::DaftObjectPublicOrProtectedGetters($static_parent),
523	1	$static
524		));
525		}
526
527	261	public static function DaftObjectPublicSetters() : array
528		{
529		/**
530		* @var string
531		*
532		* @psalm-var class-string<Thing>
533		*/
534	261	$static_parent = get_parent_class(static::class);
535
536	261	$static = TypeUtilities::DaftObjectPublicSetters(static::class);
537
538	261	if ($static_parent === get_parent_class(self::class)) {
539	2	return $static;
540		}
541
542	260	return array_unique(array_merge(
543	260	TypeUtilities::DaftObjectPublicSetters($static_parent),
544	260	$static
545		));
546		}
547
548		/**
549		* @return static
550		*
551		* @psalm-return Thing
552		*/
553	261	public static function DaftObjectFromJsonString(
554		string $string,
555		bool $writeAll = self::BOOL_DEFAULT_WRITEALL
556		) : DaftJson {
557		/**
558		* @var array<string, scalar\|(scalar\|array\|object\|null)[]\|object\|null>
559		*/
560	261	$decoded = json_decode($string, true);
561
562		/**
563		* @var static
564		*/
565	261	$out = static::DaftObjectFromJsonArray($decoded, $writeAll);
566
567	261	return $out;
568		}
569
570		/**
571		* @return static
572		*
573		* @psalm-return Thing
574		*/
575	262	public static function DaftObjectFromJsonArray(
576		array $array,
577		bool $writeAll = self::BOOL_DEFAULT_WRITEALL
578		) : DaftJson {
579	262	$type = JsonTypeUtilities::ThrowIfNotDaftJson(static::class);
580
581	262	$multi_type = static::DaftObjectPropertiesWithMultiTypedArraysOfUniqueValues();
582
583	262	$array_keys = array_keys($array);
584
585	262	foreach ($array_keys as $k) {
586	262	if ( ! is_string($k)) {
587	1	throw new InvalidArgumentException(
588		'Argument 1 passed to ' .
589		__METHOD__ .
590	262	'() must have all-string indices!'
591		);
592		}
593		}
594
595		/**
596		* @var array<int, string>
597		*/
598	261	$array_keys = $array_keys;
599
600	261	$data = array_combine($array_keys, array_map(
601		/**
602		* @param string $k
603		*
604		* @return mixed
605		*/
606		function (string $k) use ($array, $multi_type) {
607	261	if (is_array($array[$k])) {
608	261	return static::DaftObjectFromJsonArrayFromArray($k, $multi_type, $array[$k]);
609		}
610
611	261	return $array[$k];
612	261	},
613	261	$array_keys
614		));
615
616		/**
617		* @psalm-var Thing
618		*
619		* @var Thing
620		*/
621	261	$out = new $type($data, $writeAll);
622
623	261	return $out;
624		}
625
626		/**
627		* @param array<string, array<int, string>> $multi_type
628		*/
629	261	protected static function DaftObjectFromJsonArrayFromArray(
630		string $k,
631		array $multi_type,
632		array $arr
633		) : array {
634	261	return array_map(
635		/**
636		* @param mixed $val
637		*
638		* @return mixed
639		*/
640		function ($val) use ($k, $multi_type) {
641		if (
642	261	is_array($val) &&
643	261	isset($val['@context'], $val['@type'], $multi_type[$k])
644		) {
645		/**
646		* @psalm-var array<string, array<array-key, array<array-key, mixed>\|scalar\|object\|null>\|scalar\|object\|null>
647		*/
648	261	$val = $val;
649
650	261	foreach ($multi_type[$k] as $maybe) {
651		if (
652	261	is_a($maybe, Thing::class, true) &&
653	261	$val['@context'] === $maybe::SCHEMA_ORG_CONTEXT &&
654	261	$val['@type'] === $maybe::SCHEMA_ORG_TYPE
655		) {
656	261	return $maybe::DaftObjectFromJsonArray($val);
657		}
658		}
659		}
660
661	261	return $val;
662	261	},
663	261	$arr
664		);
665		}
666
667	521	protected function ExpectRetrievedValueIsArray(string $property) : array
668		{
669	521	return TypeUtilities::ExpectRetrievedValueIsArray(
670	521	$property,
671	521	$this->RetrievePropertyValueFromData($property),
672	521	static::class
673		);
674		}
675
676		/**
677		* @param array<int, bool> $value
678		*/
679	69	protected function NudgePropertyWithUniqueBooleans(
680		string $property,
681		array $value
682		) : void {
683	69	$replace = [];
684	69	if (in_array(true, $value, true)) {
685	66	$replace[] = true;
686		}
687	69	if (in_array(false, $value, true)) {
688	68	$replace[] = false;
689		}
690
691	69	$this->NudgePropertyValue($property, $replace);
692	69	}
693		}
694

SignpostMarv / Daft-Schema.org

Push — master ( 18b445...fadfeb )

Thing::NudgePropertyWithUniqueBooleans() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like