Return the specified property

@param  mixed $property The property to return
@return mixed
@throws HarvestException
184431
public function get($property)
    {
        switch ($property) {
            case 'code':
                return $this->_code;
            break;
            case 'data':
                return $this->_data;
            break;
            case 'headers':
                return $this->_headers;
            break;
            default:
                if ( $this->_headers != null && array_key_exists($property, $this->_headers) ) {
                    return $this->_headers[$property];
                } else {
                    throw new HarvestException(sprintf('Unknown property %s::%s', get_class($this), $property));
                }
            break;
        }
    }
719144
public function get($property)
    {
        $value = null;

        if ($this->_convert) {
            $property = str_replace( "_", "-", $property );
        } else {
            $property = str_replace( "-", "_", $property );
        }

        if (array_key_exists($property, $this->_values)) {
            return $this->_values[$property];
        } else {
            return null;
        }

    }
1303401
public function get($property) {
		if ($this->isProperty($property)) {
			return $this->properties[$property]->value();
		} else {
      throw new Exception("la propriété '".$property."' est invalide pour l'objet '".get_class($this)."'", '00010004');
		}
	}
588959
public static function fetchProperty($object, $property)
    {
        $refl = new \ReflectionObject($object);
        $prop = $refl->getProperty($property);
        $prop->setAccessible(true);

        return $prop->getValue($object);
    }
23760
protected function getResourceProperty($property)
    {
        if (($value = \Arbit\VCSWrapper\Cache\Manager::get($this->path, $this->currentVersion, $property)) === false) {
            // Refetch the basic mimeTypermation, and cache it.
            $process = new \Arbit\VCSWrapper\GitCli\Process();

            // Fecth for specified version, if set
            if ($this->currentVersion !== null) {
                $process->argument('-r' . $this->currentVersion);
            }

            // Execute mimeTyper command
            $return = $process->argument('propget')->argument('svn:' . $property)->argument(new \SystemProcess\Argument\PathArgument($this->root . $this->path))->execute();

            $value = trim($process->stdoutOutput);
            \Arbit\VCSWrapper\Cache\Manager::cache($this->path, $this->currentVersion, $property, $value);
        }

        return $value;
    }
363827
protected function _lazyLoad($property)
    {
        // check if the property has been unset at some point
        if (array_search($property, $this->_unsetProperties) !== false) {
            return null;
        }

        // check if the property was set as null to begin with
        if (array_key_exists($property, $this->_properties)) {
            return $this->_properties[$property];
        }

        $repository = $this->_repository($property);
        if (!($repository instanceof RepositoryInterface)) {
            return null;
        }

        $association = $repository
            ->associations()
            ->getByProperty($property);

        if ($association === null) {
            return null;
        }

        $repository->loadInto($this, [$association->getName()]);

        // check if the association didn't exist and therefore didn't load
        if (!isset($this->_properties[$property])) {
            return null;
        }

        return $this->_properties[$property];
    }
1049432
public function get($property)
    {
        if (!$this->exists($property)) {
            throw new UndefinedPropertyException($property);
        }

        return $this->data()->$property;
    }
578522
protected function getResourceProperty($property)
    {
        // There currently seems no way to get the property contents inside a
        // checkout.
        return null;

        if (($value = \Arbit\VCSWrapper\Cache\Manager::get($this->path, $this->currentVersion, $property)) === false) {
            $rep   = svn_repos_open($this->root);
            $value = svn_fs_node_prop($rep, $this->path, 'svn:' . $property);
            \Arbit\VCSWrapper\Cache\Manager::cache($this->path, $this->currentVersion, $property, $value);
        }

        return $value;
    }
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);
        }
    }
1298711
public function get($property)
    {
        if (empty($get[ $property ])) {
            if (services()->has($property)) {
                return services()->get($property);
            } elseif (array_key_exists($property, $this->validSubModels)) {
                return $this->loadSubModel($property);
            } elseif (o2system()->__isset($property)) {
                return o2system()->__get($property);
            } elseif (models()->__isset($property)) {
                return models()->get($property);
            }
        }
    }
906054
public function get($property = null, $default = null)
	{
		if (isset($this->_meta->property)) {
			return $this->_meta->property;
		}

		return $default;
	}
121709
protected function getProperty($resource, $property)
    {
        if($property == '_self') {
            return $resource;
        }

        $propertyPath = explode('.', $property);

        if(count($propertyPath) > 1) {
            $property = array_shift($propertyPath);
            $newResource = $this->getProperty($resource, $property);
            if($newResource !== null) {
                $propertyPath = implode('.', $propertyPath);
                return $this->getProperty($newResource, $propertyPath);
            } else {
                return null;
            }
        } else {
            $method = sprintf('is%s', ucfirst($property));
            if(method_exists($resource, $method)) {
                return call_user_func(array($resource, $method));
            }

            $method = sprintf('get%s', ucfirst($property));
            if(method_exists($resource, $method)) {
                return call_user_func(array($resource, $method));
            }
        }

        throw new PropertyNotExistsException(sprintf(
            'Trying to call "get%s" or "is%s" on class "%s", but method does not exists. Maybe you spelled it wrong or you didn\'t add the getter for property "%s"',
            ucfirst($property),
            ucfirst($property),
            get_class($resource),
            $property
        ));
    }
1045940
public function get($property, $default = null)
    {
        if ($this->has($property)) {
            $method = 'get' . Str::studly($property);
            $return = $this->message->{$method}();

            return is_null($return) ? $default : $return;
        }

        return $default;
    }
772324
private function getPropertyValue($property)
    {
        $value  = null;
        $getter = 'get' . SimpleDataObjectConverter::snakeCaseToUpperCamelCase($property);

        if (method_exists($this, $getter)) {
            $value = $this->{$getter}();
        } elseif ($this->returnAdditionalSetting($property)) {
            $value = $this->returnAdditionalSetting($property);
        }

        return $value;
    }
593325
private function getSearchableProperty($property)
    {
        $property = Meta\Reflection::normalizeProperty($property);

        foreach ($this->meta->getIndexedProperties() as $p)
        {
            if (Meta\Reflection::normalizeProperty($p->getName()) == $property)
            {
                return $property;
            }
        }

        //Node properties only have indexing problems
        if($this->meta instanceof Node)
        {
            throw new Exception("Property $property is not indexed or does not exist in {$this->meta->getName()}.");
        }

        //Relations have start/end or indexing problems
        else
        {
            throw new Exception("Property noName is either not indexed, not a start/end, or does not exist in {$this->meta->getName()}.");
        }
    }
834730
protected function getPropertyValue($property, $default = null)
    {
        if (array_key_exists($property, $this->properties)) {
            return $this->properties[$property];
        }

        return $default;
    }
727215
public function getPropertyValues($property)
    {
        $returnValue = null;
        switch ($property) {
            case GenerisRdf::PROPERTY_USER_DEFLG :
                $returnValue = array(DEFAULT_LANG);
                break;
            case GenerisRdf::PROPERTY_USER_UILG :
                $returnValue = array($this->language);
                break;
            case  GenerisRdf::PROPERTY_USER_ROLES :
                $returnValue = $this->taoRoles;
                break;
            case  GenerisRdf::PROPERTY_USER_FIRSTNAME :
                $returnValue = [$this->firstname];
                break;
            case  GenerisRdf::PROPERTY_USER_LASTNAME :
                $returnValue = [$this->lastname];
                break;
            case  OntologyRdfs::RDFS_LABEL :
                $returnValue = [$this->label];
                break;
            default:
                \common_Logger::d('Unkown property ' . $property . ' requested from ' . __CLASS__);
                $returnValue = array();
        }
        return $returnValue;
    }