/*!
\return the value of the attribute named \a $attributeName.
See eZImageAliasHandler::attributes() for which attributes are available.
14108
function attribute( $attributeName )
    {
        if ( in_array( $attributeName,
                       array( 'alternative_text',
                              'original_filename',
                              'is_valid' ) ) )
        {
            return $this->attributeFromOriginal( $attributeName );
        }
        $aliasName = $attributeName;
        return $this->imageAlias( $aliasName );
    }
765657
public function getAttribute($sName)
    {
        if (empty($sName)) {
            return null;
        }

        if (!empty($this->arModelData) && isset($this->arModelData[$sName])) {
            return $this->arModelData[$sName];
        }

        return null;
    }
36943
public function getAttribute($pName)
    {
        if (isset($this->attributes[$pName])) {
            return $this->attributes[$pName];
        }
        return null;
    }
1163461
public function attr($attribute, $value = null)
    {
        if (is_array($attribute)) return $this->attributes($attribute);
        if ($value) return $this->attributes(array($attribute => $value));
    }
1020481
function attribute( $attributeName /*, $attributeList = false*/ )
    {
        if ( in_array( $attributeName,
                       array( 'development',
                              'name', 'summary', 'description',
                              'vendor', 'vendor-dir', 'priority', 'type',
                              'extension', 'source',
                              'version-number', 'release-number', 'release-timestamp',
                              'maintainers', 'documents', 'groups',
                              'simple-file-list', 'file-list',
                              'changelog', 'dependencies',
                              'install', 'uninstall',
                              'install_type',
                              'licence', 'state', 'settings-files' ) ) )
            return $this->Parameters[$attributeName];
        else if ( $attributeName == 'is_installed' )
            return $this->isInstalled;
        else if ( $attributeName == 'ezpublish-version' )
            return $this->Parameters['ezpublish']['version'];
        else if ( $attributeName == 'ezpublish-named-version' )
            return $this->Parameters['ezpublish']['named-version'];
        else if ( $attributeName == 'packaging-timestamp' )
            return $this->Parameters['packaging']['timestamp'];
        else if ( $attributeName == 'packaging-host' )
            return $this->Parameters['packaging']['host'];
        else if ( $attributeName == 'packaging-packager' )
            return $this->Parameters['packaging']['packager'];
        else if ( $attributeName == 'can_read' )
        {
            return $this->canRead();
        }
        else if ( $attributeName == 'can_export' )
        {
            return $this->canExport();
        }
        else if ( $attributeName == 'can_import' )
        {
            return $this->canImport();
        }
        else if ( $attributeName == 'can_install' )
        {
            return $this->canInstall();
        }
        else if ( $attributeName == 'file-count' )
        {
            return $this->fileCount();
        }
        else if ( $attributeName == 'thumbnail-list' )
        {
            return $this->thumbnailList( 'default' );
        }
        else if ( $attributeName == 'is_local' )
        {
            $repositoryInformation = $this->currentRepositoryInformation();
            return ( $repositoryInformation['type'] == 'local' );
        }

        eZDebug::writeError( "No such attribute: $attributeName for eZPackage", __METHOD__ );
        return null;
    }
348004
public function findAttribute($name)
    {
        foreach ($this->attributes as $attribute) {
            if ($attribute->getName() === $name) {
                return $attribute;
            }
        }

        return null;
    }
114601
public function getAttribute($name = null)
    {
        if (empty($name)) {
            return $this->storage;
        } elseif (isset($this->storage[ $name ])) {
            return $this->storage[ $name ];
        }

        return false;
    }
1273571
function attribute( $name )
    {
        switch ( $name )
        {
            case "name" :
            {
                return $this->Name;
            } break;
            case "id" :
            {
                return $this->ID;
            } break;
            case "group_id":
            {
                return $this->GroupID;
            } break;
            case "rules":
            {
                return $this->Rules;
            } break;
            case "multioption_list" :
            {
                return $this->Options;
            } break;
            case "optiongroup_list":
            {
                return $this->ChildGroupList;
            } break;
            default:
            {
                eZDebug::writeError( "Attribute '$name' does not exist", __METHOD__ );
                $retValue = null;
                return $retValue;
            }break;
        }
    }
1232785
function attribute( $attr )
    {
        switch ( $attr )
        {
            case "original_filename":
                return $this->OriginalFilename;
            case "mime_type":
                return $this->Type;
            case "mime_type_category":
                return $this->MimeCategory;
            case "mime_type_part":
                return $this->MimePart;
            case "filename":
                return $this->Filename;
            case "filesize":
                return $this->Size;
            case "is_temporary":
                return $this->IsTemporary;
            default:
            {
                eZDebug::writeError( "Attribute '$attr' does not exist", __METHOD__ );
                return null;
            } break;
        }
    }
1091048
public function getAttrib($attribName)
    {
        return isset($this->attribs[$attribName]) ? $this->attribs[$attribName] : null;
    }
1180170
public function getAttribute($pName) {
		if (isset($this->_attributes[$pName]))
			return $this->_attributes[$pName];
		return NULL;
	}
353268
public function getAttribute($name)
    {
        try {
            return parent::__get($name);
        } catch (UnknownPropertyException $ignore) {
        }

        $path = explode('.', $name);
        $ref = &$this->_dynamicAttributes;

        foreach ($path as $key) {
            if (!isset($ref[$key])) {
                return null;
            }
            $ref = &$ref[$key];
        }

        return $ref;
    }
677108
function attribute( $attr )
    {
        if ( $attr == "post" )
            return $_POST;
        if ( $attr == "get" )
            return $_GET;
        if ( $attr == "session" )
        {
            return eZSession::get();
        }
        $retValue = null;
        return $retValue;
    }
475104
public function getField($attributeName)
    {
        if (isset($this->fieldNameMapping[$attributeName])) {
            $attributeName = $this->fieldNameMapping[$attributeName];
        }

        return $this->getMapping()->getField($attributeName);
    }
1266972
public function getAttribute($name)
    {
        if (!isset($this->attrs[$name]))
        {
            return null;
        }

        return $this->attrs[$name];
    }
994542
public function getAttribute($attributeName)
    {
        // init
        $result = null;

        // action
        foreach ($this->attributes as $attribute) {
            if ($attribute->Name == $attributeName) {
                $result = $attribute;
                break;
            }
        }

        // --- result ---
        return $result;
    }
247025
public function getAttribute($key)
    {
        $inAttributes = array_key_exists($key, $this->attributes);

        // If the key references an attribute, we can just go ahead and return the
        // plain attribute value from the model. This allows every attribute to
        // be dynamically accessed through the _get method without accessors.
        if ($inAttributes || $this->hasGetMutator($key)) {
            return $this->getAttributeValue($key);
        }

        $inPaths = array_key_exists($key, $this->paths);

        // If the key references an path attribute, we can just go ahead and return the
        // plain attribute value from the model.
        if ($inPaths) {
            return $this->getPathValue($key);
        }
    }