@param string $property

@return string
420145
private function getRootProperty($property)
    {
        return ($pos = strpos($property, '.')) !== false ? substr($property, 0, $pos) : $property;
    }
1089196
public function getProperty($name, $property)
    {
        $result = null;
        if($this->has($name))
        {
            if(isset($this->_data[$name]->$property)) {
                $result = $this->_data[$name]->$property;
            }
        }

        return $result;
    }
500556
protected function getPropertyValue(string $property) : ?string
    {
        // For now, all unprefixed variables are also runtime variables.  If that ever changes this
        // logic will change with it.
        $isBuildVar = in_array($property, array_keys($this->directVariables));
        $isRuntimeVar = in_array($property, array_keys($this->directVariablesRuntime));
        $isUnprefixedVar = in_array($property, array_keys($this->unPrefixedVariablesRuntime));

        if ($isBuildVar) {
            $value = $this->getValue($this->directVariables[$property]);
        }
        else if ($isUnprefixedVar) {
            $value = $this->environmentVariables[$this->unPrefixedVariablesRuntime[$property]] ?? null;
        }
        else if ($isRuntimeVar) {
            $value = $this->getValue($this->directVariablesRuntime[$property]);
        }
        else {
            $value = null;
        }

        return $value;
    }
71627
public static function getPropertyTypes(\ReflectionProperty $property)
    {
        $hash = $property->class.'-'.$property->getName();

        if (isset(self::$propertyTypes[$hash])) {
            return self::$propertyTypes[$hash];
        }

        $doc = $property->getDocComment();
        preg_match('/@var\s([\w\\\|\[\]]+)/', $doc, $matches);
        $types = [];
        if (isset($matches[1])) {
            $types = explode('|', $matches[1]);
        }

        self::$propertyTypes[$hash] = $types;

        return $types;
    }
950660
public function get(string $property)
    {
        $properties = explode('.', $property);
        $value = $this->rawConfig;

        foreach ($properties as $property) {
            if (!array_key_exists($property, $value)) {
                return null;
            }

            $value = $value[$property];
        }

        return $value;
    }
1186695
public function getPropertyClass(\ReflectionProperty $property) : ?string
    {
        $types = $this->getPropertyTypes($property);

        if (count($types) === 1) {
            $type = $types[0];

            if ($type[0] === '\\') {
                return substr($type, 1);
            }
        }

        return null;
    }
534359
public function group($property)
    {
        $list = [];

        /** @var ObjectInterface $element */
        foreach ($this->getIterator() as $element) {
            $list[(string) $element->getProperty($property)][] = $element;
        }

        return $list;
    }
645045
public function getOPT($property)
	{
		if (isset($this->_OPT[$property])) {
			return $this->_OPT[$property];
		}
		return null;
	}
615126
protected function getPropertyType($property)
    {
        if (!array_key_exists($property, get_class_vars('ShopgateConfig'))) {
            return 'string';
        }

        $r   = new \ReflectionProperty('ShopgateConfig', $property);
        $doc = $r->getDocComment();
        preg_match_all('#@var ([a-zA-Z-_]*(\[\])?)(.*?)\n#s', $doc, $annotations);

        $value = 'string';
        if (count($annotations) > 0 && isset($annotations[1][0])) {
            $value = $annotations[1][0];
        }

        return $value;
    }
1291775
final protected static function get_property_default_value($property) {
        $properties = static::properties_definition();
        if (!isset($properties[$property]['default'])) {
            return null;
        }
        $value = $properties[$property]['default'];
        if ($value instanceof \Closure) {
            return $value();
        }
        return $value;
    }
547282
public function getAlias($property)
    {
        $alias = null;

        if (isset($this->_alias[$property])) {
            $alias = $this->_alias[$property];
        }

        return $alias;
    }
1356128
protected function RetrievePropertyValueFromData(string $property)
    {
        $isNullable = in_array(
            $property,
            static::DaftObjectNullableProperties(),
            DefinitionAssistant::IN_ARRAY_STRICT_MODE
        );

        if ( ! array_key_exists($property, $this->data) && ! $isNullable) {
            throw Exceptions\Factory::PropertyNotNullableException(static::class, $property);
        } elseif ($isNullable) {
            return $this->data[$property] ?? null;
        }

        return $this->data[$property];
    }
450353
protected function getFieldByProperty($property)
    {
        foreach ($this->getFields() as $key => $annotatedField) {
            if ($property === $key) {
                return $annotatedField;
            }
        }

        return null;
    }
154728
public function get($property, $default = null)
    {

        //if its an array of properties;
        if (is_array($property)) {
            $values = array();

            foreach ($property as $key => $prop) {
                if (isset($this->$prop)) {
                    $values[$prop] = $this->$prop;
                }
            }
            return (!empty($values)) ? $values : $default;
        }

        if (isset($this->$property)) {
            return $this->$property;
        }
        return $default;
    }
767664
private function generateGetResultBody(Property $property): string
    {
        if ($this->wrapperClass === null) {
            return sprintf('return $this->%s;', $property->getName());
        }

        return sprintf(
            'return new %s($this->%s);',
            Normalizer::getClassNameFromFQN($this->wrapperClass),
            $property->getName()
        );
    }
561366
protected function reFormatForCompatibility($property)
    {
        switch (true) {
            case ($property == 'header'):
                $property = 'context';
                break;

            case ($property == 'stack'):
                $property = 'stack_traces';
                break;

            case ($property == 'filePath'):
                $property = 'file_path';
                break;

            default:
                # code...
                break;
        }

        return $property;
    }
752820
protected function getExpression($property, $argn = 0) {
		$type = $this->entity->getProperty($property)->getType();
		return isset($type) ? ('%{' . "$argn:$type" . '}') : ('%{' . $argn . '}') ;
	}