ResourceProperty::getName() - Code Metrics - Inspection of "Merge pull request #26 from CyberiaResurrection/ma..." - Algo-Web/POData - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 143fd7...99a506 )

by Alex

created 2016-12-27 12:47 UTC

ResourceProperty::getName() A

↳ Parent: ResourceProperty

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace POData\Providers\Metadata;

use POData\Common\Messages;
use POData\Providers\Metadata\Type\IType;
use InvalidArgumentException;

class ResourceProperty
{
    /**
     * Property name.
     *
     * @var string
     */
    private $_name;

    /**
     * Property MIME type.
     *
     * @var string
     */
    private $_mimeType;

    /**
     * Property Kind, the possible values are:
     *  ResourceReference
     *  ResourceSetReference
     *  ComplexType
     *  ComplexType + Bag
     *  PrimitiveType
     *  PrimitiveType + Bag
     *  PrimitiveType + Key
     *  PrimitiveType + ETag.
     *
     * @var ResourcePropertyKind
     */
    private $_kind;

    /**
     * ResourceType describes this property.
     *
     * @var ResourceType
     */
    private $_propertyResourceType;

    /**
     * @param string               $name                 Name of the property
     * @param string               $mimeType             Mime type of the property
     * @param ResourcePropertyKind $kind                 The kind of property
     * @param ResourceType         $propertyResourceType ResourceType of the property
     *
     * @throws InvalidArgumentException
     */
    public function __construct($name, $mimeType, $kind, ResourceType $propertyResourceType)
    {
        if (!$this->_isValidPropertyName($name)) {
            throw new InvalidArgumentException(
                'Property name violates OData specification'
            );
        }

        if (!$this->_isValidResourcePropertyKind($kind)) {
            throw new InvalidArgumentException(
                Messages::resourcePropertyInvalidKindParameter('$kind')
            );
        }

        if (!$this->_isResourceKindValidForPropertyKind($kind, $propertyResourceType->getResourceTypeKind())) {
            throw new InvalidArgumentException(
                Messages::resourcePropertyPropertyKindAndResourceTypeKindMismatch(
                    '$kind',
                    '$propertyResourceType'
                )
            );
        }

        $this->_name = $name;
        $this->_mimeType = $mimeType;
        $this->_kind = $kind;
        $this->_propertyResourceType = $propertyResourceType;
    }

    /**
     * Check whether current property is of kind specified by the parameter.
     *
     * @param ResourcePropertyKind $kind kind to check
     *
     * @return bool
     */
    public function isKindOf($kind)
    {
        return ($this->_kind & $kind) == $kind;
    }

    /**
     * Get the property name.
     *
     * @return string
     */
    public function getName()
    {
        return $this->_name;
    }

    /**
     * Get property MIME type.
     *
     * @return string
     */
    public function getMIMEType()
    {
        return $this->_mimeType;
    }

    /**
     * Get property kind.
     *
     * @return ResourcePropertyKind
     */
    public function getKind()
    {
        return $this->_kind;
    }

    /**
     * Get the resource type for this property.
     *
     * @return ResourceType
     */
    public function getResourceType()
    {
        return $this->_propertyResourceType;
    }

    /**
     * Get the kind of resource type.
     *
     * @return ResourceTypeKind
     */
    public function getTypeKind()
    {
        return $this->_propertyResourceType->getResourceTypeKind();
    }

    /**
     * Get the instance type. If the property is of kind 'Complex',
     * 'ResourceReference' or 'ResourceSetReference' then this function returns
     * refernece to ReflectionClass instance for the type. If the property of
     * kind 'Primitive' then this function returns ITYpe instance for the type.
     *
     * @return \ReflectionClass|IType
     */
    public function getInstanceType()
    {
        return $this->_propertyResourceType->getInstanceType();
    }

    /**
     * Check once kind is of another kind.
     *
     * @param ResourcePropertyKind $kind1 First kind
     * @param ResourcePropertyKind $kind2 second kind
     *
     * @return bool
     */
    public static function sIsKindOf($kind1, $kind2)
    {
        return ($kind1 & $kind2) == $kind2;
    }

    /**
     * Checks whether supplied name meets OData specification
     *
     * @param string $name  Field name to be validated
     *
     * @return bool
     */
    private function _isValidPropertyName($name)
    {
        if (!isset($name) || !is_string($name) || empty($name)) {
            return false;
        }
        if ('_' == substr($name, 0)) {
            return false;
        }
        return true;
    }

    /**
     * Checks whether resource property kind is valid or not.
     *
     * @param ResourcePropertyKind $kind The kind to validate
     *
     * @return bool
     */
    private function _isValidResourcePropertyKind($kind)
    {
        return
            !($kind != ResourcePropertyKind::RESOURCE_REFERENCE &&
            $kind != ResourcePropertyKind::RESOURCESET_REFERENCE &&
            $kind != ResourcePropertyKind::COMPLEX_TYPE &&
            ($kind != (ResourcePropertyKind::COMPLEX_TYPE | ResourcePropertyKind::BAG)) &&
            $kind != ResourcePropertyKind::PRIMITIVE &&
            ($kind != (ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::BAG)) &&
            ($kind != (ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY)) &&
            ($kind != (ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::ETAG)));
    }

    /**
     * Check the specified resource kind is valid resource kind for property kind.
     *
     * @param ResourcePropertyKind $pKind The kind of resource property
     * @param ResourceTypeKind     $rKind The kind of resource type
     *
     * @return bool True if resource type kind and property kind matches
     *              otherwise false
     */
    private function _isResourceKindValidForPropertyKind($pKind, $rKind)
    {
        if (self::sIsKindOf($pKind, ResourcePropertyKind::PRIMITIVE)
            && $rKind != ResourceTypeKind::PRIMITIVE
        ) {
            return false;
        }

        if (self::sIsKindOf($pKind, ResourcePropertyKind::COMPLEX_TYPE)
            && $rKind != ResourceTypeKind::COMPLEX
        ) {
            return false;
        }

        if ((self::sIsKindOf($pKind, ResourcePropertyKind::RESOURCE_REFERENCE)
            || self::sIsKindOf($pKind, ResourcePropertyKind::RESOURCESET_REFERENCE))
            && $rKind != ResourceTypeKind::ENTITY
        ) {
            return false;
        }

        return true;
    }
}


1			<?php
2
3			namespace POData\Providers\Metadata;
4
5			use POData\Common\Messages;
6			use POData\Providers\Metadata\Type\IType;
7			use InvalidArgumentException;
8
9			class ResourceProperty
10			{
11			/**
12			* Property name.
13			*
14			* @var string
15			*/
16			private $_name;
17
18			/**
19			* Property MIME type.
20			*
21			* @var string
22			*/
23			private $_mimeType;
24
25			/**
26			* Property Kind, the possible values are:
27			* ResourceReference
28			* ResourceSetReference
29			* ComplexType
30			* ComplexType + Bag
31			* PrimitiveType
32			* PrimitiveType + Bag
33			* PrimitiveType + Key
34			* PrimitiveType + ETag.
35			*
36			* @var ResourcePropertyKind
37			*/
38			private $_kind;
39
40			/**
41			* ResourceType describes this property.
42			*
43			* @var ResourceType
44			*/
45			private $_propertyResourceType;
46
47			/**
48			* @param string $name Name of the property
49			* @param string $mimeType Mime type of the property
50			* @param ResourcePropertyKind $kind The kind of property
51			* @param ResourceType $propertyResourceType ResourceType of the property
52			*
53			* @throws InvalidArgumentException
54			*/
55			public function __construct($name, $mimeType, $kind, ResourceType $propertyResourceType)
56			{
57			if (!$this->_isValidPropertyName($name)) {
58			throw new InvalidArgumentException(
59			'Property name violates OData specification'
60			);
61			}
62
63			if (!$this->_isValidResourcePropertyKind($kind)) {
64			throw new InvalidArgumentException(
65			Messages::resourcePropertyInvalidKindParameter('$kind')
66			);
67			}
68
69			if (!$this->_isResourceKindValidForPropertyKind($kind, $propertyResourceType->getResourceTypeKind())) {
70			throw new InvalidArgumentException(
71			Messages::resourcePropertyPropertyKindAndResourceTypeKindMismatch(
72			'$kind',
73			'$propertyResourceType'
74			)
75			);
76			}
77
78			$this->_name = $name;
79			$this->_mimeType = $mimeType;
80			$this->_kind = $kind;
81			$this->_propertyResourceType = $propertyResourceType;
82			}
83
84			/**
85			* Check whether current property is of kind specified by the parameter.
86			*
87			* @param ResourcePropertyKind $kind kind to check
88			*
89			* @return bool
90			*/
91			public function isKindOf($kind)
92			{
93			return ($this->_kind & $kind) == $kind;
94			}
95
96			/**
97			* Get the property name.
98			*
99			* @return string
100			*/
101			public function getName()
102			{
103			return $this->_name;
104			}
105
106			/**
107			* Get property MIME type.
108			*
109			* @return string
110			*/
111			public function getMIMEType()
112			{
113			return $this->_mimeType;
114			}
115
116			/**
117			* Get property kind.
118			*
119			* @return ResourcePropertyKind
120			*/
121			public function getKind()
122			{
123			return $this->_kind;
124			}
125
126			/**
127			* Get the resource type for this property.
128			*
129			* @return ResourceType
130			*/
131			public function getResourceType()
132			{
133			return $this->_propertyResourceType;
134			}
135
136			/**
137			* Get the kind of resource type.
138			*
139			* @return ResourceTypeKind
140			*/
141			public function getTypeKind()
142			{
143			return $this->_propertyResourceType->getResourceTypeKind();
144			}
145
146			/**
147			* Get the instance type. If the property is of kind 'Complex',
148			* 'ResourceReference' or 'ResourceSetReference' then this function returns
149			* refernece to ReflectionClass instance for the type. If the property of
150			* kind 'Primitive' then this function returns ITYpe instance for the type.
151			*
152			* @return \ReflectionClass\|IType
153			*/
154			public function getInstanceType()
155			{
156			return $this->_propertyResourceType->getInstanceType();
157			}
158
159			/**
160			* Check once kind is of another kind.
161			*
162			* @param ResourcePropertyKind $kind1 First kind
163			* @param ResourcePropertyKind $kind2 second kind
164			*
165			* @return bool
166			*/
167			public static function sIsKindOf($kind1, $kind2)
168			{
169			return ($kind1 & $kind2) == $kind2;
170			}
171
172			/**
173			* Checks whether supplied name meets OData specification
174			*
175			* @param string $name Field name to be validated
176			*
177			* @return bool
178			*/
179			private function _isValidPropertyName($name)
180			{
181			if (!isset($name) \|\| !is_string($name) \|\| empty($name)) {
182			return false;
183			}
184			if ('_' == substr($name, 0)) {
185			return false;
186			}
187			return true;
188			}
189
190			/**
191			* Checks whether resource property kind is valid or not.
192			*
193			* @param ResourcePropertyKind $kind The kind to validate
194			*
195			* @return bool
196			*/
197			private function _isValidResourcePropertyKind($kind)
198			{
199			return
200			!($kind != ResourcePropertyKind::RESOURCE_REFERENCE &&
201			$kind != ResourcePropertyKind::RESOURCESET_REFERENCE &&
202			$kind != ResourcePropertyKind::COMPLEX_TYPE &&
203			($kind != (ResourcePropertyKind::COMPLEX_TYPE \| ResourcePropertyKind::BAG)) &&
204			$kind != ResourcePropertyKind::PRIMITIVE &&
205			($kind != (ResourcePropertyKind::PRIMITIVE \| ResourcePropertyKind::BAG)) &&
206			($kind != (ResourcePropertyKind::PRIMITIVE \| ResourcePropertyKind::KEY)) &&
207			($kind != (ResourcePropertyKind::PRIMITIVE \| ResourcePropertyKind::ETAG)));
208			}
209
210			/**
211			* Check the specified resource kind is valid resource kind for property kind.
212			*
213			* @param ResourcePropertyKind $pKind The kind of resource property
214			* @param ResourceTypeKind $rKind The kind of resource type
215			*
216			* @return bool True if resource type kind and property kind matches
217			* otherwise false
218			*/
219			private function _isResourceKindValidForPropertyKind($pKind, $rKind)
220			{
221			if (self::sIsKindOf($pKind, ResourcePropertyKind::PRIMITIVE)
222			&& $rKind != ResourceTypeKind::PRIMITIVE
223			) {
224			return false;
225			}
226
227			if (self::sIsKindOf($pKind, ResourcePropertyKind::COMPLEX_TYPE)
228			&& $rKind != ResourceTypeKind::COMPLEX
229			) {
230			return false;
231			}
232
233			if ((self::sIsKindOf($pKind, ResourcePropertyKind::RESOURCE_REFERENCE)
234			\|\| self::sIsKindOf($pKind, ResourcePropertyKind::RESOURCESET_REFERENCE))
235			&& $rKind != ResourceTypeKind::ENTITY
236			) {
237			return false;
238			}
239
240			return true;
241			}
242			}
243

Algo-Web / POData

Push — master ( 143fd7...99a506 )

ResourceProperty::getName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like