Returns the type set for the instance passed in parameter.
Type is one of string|config|request|session

@param MoufPropertyDescription $property
@return mixed
774505
protected function getTypeForProperty(MoufPropertyDescriptor $property) {
		if ($property->isPublicFieldProperty()) {
			$propertyName =  $property->getName();
			if ($this->moufManager->hasParameter($this->instanceName, $propertyName)) {
				$defaultValue = $this->moufManager->getParameterType($this->instanceName, $propertyName);
			} else {
				return "string";
			}
		} else {
			// This is a setter.
			$propertyName =  $property->getName();
			if ($this->moufManager->hasParameterForSetter($this->instanceName, $property->getMethodName())) {
				$defaultValue = $this->moufManager->getParameterTypeForSetter($this->instanceName, $property->getMethodName());
			} else {
				return "string";
			}
			
		}
		return $defaultValue;
	}
988875
public function &__get($property)
    {
        $getter = 'get'.\ucfirst($property);
        if (\in_array($property, array('alerts','cfg','status'))) {
            return $this->{$property};
        } elseif (\method_exists($this, $getter)) {
            $return = $this->{$getter}();
            return $return;
        } elseif (isset($this->status[$property])) {
            return $this->status[$property];
        } else {
            $this->debug->log('property', $property);
        }
    }
1330747
public function &__get($property)
    {
        $get[ $property ] = false;

        // CodeIgniter property aliasing
        if ($property === 'load') {
            $property = 'loader';
        }

        if (services()->has($property)) {
            return services()->get($property);
        } elseif (o2system()->__isset($property)) {
            return o2system()->__get($property);
        } elseif ($property === 'model') {
            return models('controller');
        }

        return $get[ $property ];
    }
576065
private function getPropertyValue(array $property, $className = Entity::class)
    {
        $type = $this->getValueType($property);
        return $this->convertValue($type, $property[$type], $className);
    }
1313684
public static function toNativePropertyName($property)
    {
        $propertyNames = array_keys(static::getPropertyPrototypes());

        if (! in_array($property, $propertyNames)) {
            foreach ($propertyNames as $propertyName) {
                if (strtolower($propertyName) === strtolower($property)) {
                    return $propertyName;
                }
            }
        }

        return $property;
    }
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];
    }
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};
        }
    }
142633
final protected static function get_property_error_message($property) {
        $properties = static::properties_definition();
        if (!isset($properties[$property]['message'])) {
            return new lang_string('invaliddata', 'error');
        }
        return $properties[$property]['message'];
    }
621357
public static function valuesForProperty(Property $property)
    {
        $propertyId = $property->id;

        $table = static::tableName();
        $translationsTable = StaticValueTranslation::tableName();
        $db = static::getDb();
        $languageId = Yii::$app->multilingual->language_id;

        if (!isset(static::$valuesByPropertyId[$propertyId])) {
            static::$valuesByPropertyId[$propertyId] = Yii::$app->cache->lazy(
                function () use ($propertyId, $table, $translationsTable, $db, $languageId) {
                    $query = new Query();
                    $rows = $query
                        ->select([
                            'sv.id',
                            'svt.name',
                            'svt.description',
                            'svt.slug',
                        ])
                        ->from($table . ' sv')
                        ->where(['sv.property_id' => $propertyId])
                        ->innerJoin(
                            $translationsTable . 'svt',
                            'svt.model_id = sv.id AND svt.language_id=:language_id',
                            [
                                ':language_id' => $languageId,
                            ]
                        )
                        ->orderBy('sv.sort_order ASC')
                        ->all($db);
                    return ArrayHelper::map(
                        $rows,
                        'id',
                        function ($item) {
                            return [
                                'name' => $item['name'],
                                'description' => $item['description'],
                                'slug' => $item['slug'],
                            ];
                        }
                    );
                },
                "StaticValues:$propertyId:$languageId",
                86400,
                "StaticValues:$propertyId"
            );
        }
        return static::$valuesByPropertyId[$propertyId];
    }
317299
public function getProperty(int $object, string $property)
    {
        $this->protocol->propertyAccessBegin($object, $property);
        $this->protocol->propertyAccessEnd();

        return $this->getResult();
    }
681456
public function getEntityColumnType($entity, $property) {
        $classRef = new \ReflectionClass($entity);
        if ($classRef->hasProperty($property)) {
            $propertyRef = $classRef->getProperty($property);
            $columnRef = $this->annoReader->getPropertyAnnotation($propertyRef, 'Doctrine\ORM\Mapping\Column');
        } else {
            /** Can not find the property on the class. Check the all the Column annotation */
            foreach ($classRef->getProperties() as $propertyRef) {
                $columnRef = $this->annoReader->getPropertyAnnotation($propertyRef, 'Doctrine\ORM\Mapping\Column');
                if ($columnRef->name == $property) {
                    break;
                } else {
                    $columnRef = null;
                }
            }
        }
        if ($columnRef === null) {
            $idRef = $this->annoReader->getPropertyAnnotation($propertyRef, 'Doctrine\ORM\Mapping\Id');
            if ($idRef !== null) {
                return "int";
            } else {
                return "string";
            }
        } else {
            return $this->getColumnType($columnRef->type);
        }
    }
164519
public static function getPropertyValue($object, $property)
    {
        $ref = new \ReflectionClass($object);
        $prop = static::getPrivateProperty($ref, $property);
        $prop->setAccessible(true);
        $value = $prop->getValue($object);
        $prop->setAccessible(false);

        return $value;
    }
367713
private function getProperty(\ReflectionClass $ref, $property)
    {
        $prop = $ref->getProperty($property);
        $prop->setAccessible(true);

        return $prop;
    }
1206639
public function setProperty($property)
    {
        if (!$this->fromExpression && !RestParams::hasPrefix($property)) {
            $property = "o.$property";
        }

        $this->property = $property;

        return $this;
    }
328599
public static function getProperty($object, string $property)
    {
        $getter = \Closure::bind(
            function ($object) use ($property) {
                return $object->{$property};
            },
            null,
            get_class($object)
        );

        return $getter($object);
    }
886738
private function findPropertyFromReference(&$property) : PropertyDefinition
    {
        $traceLevel = $this->propertyDefinitionTraceLevel;

        foreach ($this->propertyReferenceMap as $name => &$propertyReference) {
            if (ReferenceComparer::areEqual($property, $propertyReference)) {

                return $this->properties[$name];
            }
        }

        $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, $traceLevel + 1)[$traceLevel];
        throw new InvalidPropertyDefinitionException($this->class, $trace['file'], $trace['line']);
    }
1170459
public function getDataProperty($property)
    {
        return isset($this->data[$property]) ? $this->data[$property] : null;
    }