Check if a property can have multiple values.

@access public
@author Cédric Alfonsi, <cedric.alfonsi@tudor.lu>
@return boolean
322149
public function isMultiple()
    {
        $returnValue = (bool) false;

        if(is_null($this->multiple )){
        	$multipleProperty = $this->getProperty(GenerisRdf::PROPERTY_MULTIPLE);
			$multiple = $this->getOnePropertyValue($multipleProperty);
			 
			if(is_null($multiple)){
				$returnValue = false;
			}
			else{
				$returnValue = ($multiple->getUri() == GenerisRdf::GENERIS_TRUE);
			}
        	$this->multiple = $returnValue;
        }
 
        $returnValue = $this->multiple;
        return (bool) $returnValue;
    }
27644
private function hasSttyAvailable(): bool
    {
        if (null !== self::$stty) {
            return self::$stty;
        }

        exec('stty 2>&1', $output, $exitcode);

        return self::$stty = 0 === $exitcode;
    }
160308
function is_valid_value($value) {
        if(is_array($value)) {
            if(!$this->val_multi) {
                return false;
            }
            else {
                foreach($value as $oneval) {
                    if(!rfc2445_is_valid_value($oneval, $this->val_type)) {
                        return false;
                    }
                }
            }
            return true;
        }
        return rfc2445_is_valid_value($value, $this->val_type);
    }
303101
protected function haveSiblingsDefalutValues()
    {
        $function = $this->getDeclaringFunction();
        if (null === $function) {
            throw new ReflectionException('Could not get the declaring function reflection.');
        }

        /** @var \ReflectionParameter[] $remainingParameters */
        $remainingParameters = array_slice($function->getParameters(), $this->parameterIndex + 1);
        foreach ($remainingParameters as $reflectionParameter) {
            if (!$reflectionParameter->isDefaultValueAvailable()) {
                return false;
            }
        }

        return true;
    }
140102
public function hasScalarKeys() {
    if ($this->key instanceof ScalarNode) {
      return $this->array instanceof ArrayLookupNode ? $this->array->hasScalarKeys() : TRUE;
    }
    else {
      return FALSE;
    }
  }
343387
public function has_required_properties() {

        return (
            ! empty( $this->plural_name )
            && ! empty( $this->post_type )
            && ! empty( $this->singular_name )
            && ! empty( $this->slug )
        );

    }
355435
public function has($property)
    {
        foreach ((array)$property as $prop) {
            $has = $this->_parentHas($prop);

            if ($has === false) {
                $has = $this->_lazyLoad($prop);
                if ($has === null) {
                    return false;
                }
            }
        }

        return true;
    }
982778
public function setMultiple($values, $ttl = null): bool
    {
        foreach ($values as $key => $val) {
            $result = $this->set($key, $val, $ttl);

            if (false === $result) {
                return false;
            }
        }

        return true;
    }
1276099
public function isSetter() {
    	$methodName = $this->getName();
    	
    	   
    	if (strpos($methodName, "set") === 0 && strlen($methodName)>3) {
    		// A setter must have exactly one compulsory parameter
    		$parameters = $this->getParameters();
    		if (count($parameters) == 0) {
    			return false;
    		}
    		if (count($parameters)>1) {
    			for ($i=1, $count=count($parameters); $i<$count; $i++) {
    				$param = $parameters[$i];
    				if (!$param->isDefaultValueAvailable()) {
    					return false;
    				}
    			}
    		}
    		
    		return true;
    	}
    	return false;
    }
407977
public function hasProperty( $propertyName ) {
			
			if ( self::isProperty( $propertyName ) ) {
			
				return array_key_exists( $propertyName, $this->properties );
			
			} else {
			
				return false;
			
			}
		}
408032
public function isMultiLine(): bool
    {
        $openingToken = $this->getBlockStartToken();
        $closingToken = $this->getBlockEndToken();

        return $openingToken['line'] < $closingToken['line'];
    }
1259208
public function valid()
    {

        if ($this->container['date'] === null) {
            return false;
        }
        if ($this->container['refId'] === null) {
            return false;
        }
        if ($this->container['refType'] === null) {
            return false;
        }
        $allowedValues = $this->getRefTypeAllowableValues();
        if (!in_array($this->container['refType'], $allowedValues)) {
            return false;
        }
        $allowedValues = $this->getFirstPartyTypeAllowableValues();
        if (!in_array($this->container['firstPartyType'], $allowedValues)) {
            return false;
        }
        $allowedValues = $this->getSecondPartyTypeAllowableValues();
        if (!in_array($this->container['secondPartyType'], $allowedValues)) {
            return false;
        }
        return true;
    }
290711
public function valid()
    {

        $allowed_values = $this->getStateAllowableValues();
        if (!in_array($this->container['state'], $allowed_values)) {
            return false;
        }
        return true;
    }
491759
public function isValidProperty(string $property)
    {
        if (!empty($this->validProperties) && !array_key_exists($property, $this->validProperties)) {
            return false;
        }

        return true;
    }
1066107
public function isRangePrice()
    {
        if ($this->_blIsRangePrice === null) {
            $this->setRangePrice(false);

            if ($this->_hasAnyVariant()) {
                $dPrice = $this->_getPrice();
                $dMinPrice = $this->_getVarMinPrice();
                $dMaxPrice = $this->_getVarMaxPrice();

                if ($dMinPrice != $dMaxPrice) {
                    $this->setRangePrice();
                } elseif (!$this->isParentNotBuyable() && $dMinPrice != $dPrice) {
                    $this->setRangePrice();
                }
            }
        }

        return $this->_blIsRangePrice;
    }
1361774
public function exceedsLimit()
    {
        if ($this->limit === null) {
            return false;
        }

        return $this->relatedValues->count() >= $this->limit;
    }
512948
public function isDeletable() {
		
		$inverseForeignKeys = $this->db->getInverseForeignKeys(static::TABLE_NAME);
		
		foreach ($inverseForeignKeys as $r) {
			
			// only if restrict it could be not deletable
			if ('RESTRICT' != $r->DELETE_RULE) continue;
			
			// get the property name
			$propertyName = $this->getMappedProperty($r->REFERENCED_COLUMN_NAME);
			
			return !$this->checkRecordExists($r->TABLE_NAME, $r->COLUMN_NAME, $this->$propertyName);
			
		}
		
		// nothing found, is deletable
		return TRUE;
		
	}