Get only one property from a variable
@param string $variableId on which we want the property
@param string $property to retrieve
@return int|string the property retrieved
8159
public function getVariableProperty($variableId, $property)
    {
        list($itemUri, $propertyName) = $this->extractResultVariableProperty($variableId);
        $response =  $this->unserializeVariableValue(
            $this->getPersistence()->hGet(
                self::PREFIX_CALL_ID.$itemUri,
                $propertyName
            )
        );
        $variable = unserialize($response[0]->variable);

        $getter = 'get'.ucfirst($property);
        if (method_exists($variable, $getter)) {
            return $variable->$getter();
        }

        return '';
    }
268175
public Object get(Object property) {
        if (property instanceof String)
            return getProperty((String)property);
        return null;
    }
12309
public static function getVariableValues(Variable $variable) {

        $returnValue = array();

        $baseType = $variable->getBaseType();
        $cardinalityType = $variable->getCardinality();
        $value = $variable->getValue();
        
        // This only works if the variable has a value ;)
        if ($value !== null) {
            
            if ($baseType === BaseType::IDENTIFIER) {
            
                if ($cardinalityType === Cardinality::SINGLE) {
            
                    $returnValue[] = $value->getValue();
                }
                else if($cardinalityType === Cardinality::MULTIPLE) {
            
                    foreach($variable->getValue() as $value) {
            
                        $returnValue[] = $value->getValue();
                    }
                }
            }
        }

        return $returnValue;
    }
1059480
public static function getGetPost($variableName)
    {

        $value = null;

        if (isset($_GET[$variableName])) {
            $value = $_GET[$variableName];
        }

        if (isset($_POST[$variableName])) {
            $value = $_POST[$variableName];
        }

        $value = self::stripSlashesDeep($value);

        return $value;
    }
633937
public function &__get($property)
    {
        if (isset($this->{'_'.$property})) {
            if ($property == 'filepath' && empty($this->_filepath)) {
                $this->_filepath = self::$_locators[$this->_type]->findPath($this);
            }

            if ($property == 'classname' && empty($this->_classname)) {
                $this->_classname = self::$_locators[$this->_type]->findClass($this);
            }

            return $this->{'_'.$property};
        }
    }
122521
private function get_alias( $property )
	{
		if ( in_array( $property, $this->aliases ) )
			return array_search( $property, $this->aliases );

		return $property;
	}
551065
public function &get($property)
    {
        $get = &$this->_parentGet($property);

        if ($get === null) {
            $get = $this->_lazyLoad($property);
        }

        return $get;
    }
1204423
public function get($property = '')
    {
        $data = $this->getData();

        if (! $property) {
            return $data;
        }

        return array_get($data, $property, '');
    }
25544
public function &offsetGet($property)
	{
		$null = null;
		
		if(array_key_exists($property, $this->list))
			return $this->list[$property];
		
		return $null;
	}
824346
public function getProperty($var = null)
    {
        if (null === $var) {
            return $this->properties;
        }

        if (isset($this->properties[$var])) {
            return $this->properties[$var];
        }

        return;
    }
477880
public static function get_property_definition($property) {

        self::fill_properties_cache();

        if (!array_key_exists($property, self::$propertiescache)) {
            throw new coding_exception('Invalid property requested.');
        }

        return self::$propertiescache[$property];
    }
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];
    }
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;
    }
556673
public Object getProperty(String property) {
        try {
            return super.getProperty(property);
        } catch (MissingPropertyException e) {
            Object r = context.getVariableWithDefaultValue(property,MISSING);
            if (r==MISSING) throw e;
            return r;
        }
    }
1137050
public static function extractValueFromEntity($entity, $property)
    {
        $getter = self::createGetter($entity, $property);

        return $entity->$getter();
    }
310982
public String getFirstPropertyValue(String property) {
        Iterator<String> it = getValues(property).iterator();
        return it.hasNext() ? it.next() : null;
    }
315889
public function getPropertyMultivalueById($id)
    {
        $property = $this->getPropertyById($id);

        return $property !== null ? $property->getValues() : null;
    }