+Show TOC
×Hide TOC

BeanFactory

Kind of class:	public class
Package:	com.bourre.ioc.bean
Inherits from:	none
Implements:	Locator
Classpath:	com.bourre.ioc.bean.BeanFactory
File last modified:	Monday, 24 November 2008, 11:36:55

► View source

▼ Hide source

package com.bourre.ioc.bean
{
    /*
     * Copyright the original author or authors.
     * 
     * Licensed under the MOZILLA PUBLIC LICENSE, Version 1.1 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     * 
     *      http://www.mozilla.org/MPL/MPL-1.1.html
     * 
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */

    /**
     * @author Francis Bourre
     * @author Olympe Dignat
     * @version 1.0
     */
    import com.bourre.collection.HashMap;
    import com.bourre.core.Locator;
    import com.bourre.error.IllegalArgumentException;
    import com.bourre.error.NoSuchElementException;
    import com.bourre.events.EventBroadcaster;
    import com.bourre.log.PixlibDebug;
    import com.bourre.log.PixlibStringifier;
    
    import flash.utils.Dictionary;    

    public class BeanFactory 
        implements Locator
    {
        private static  var _oI : BeanFactory ;
        
        private var _oEB : EventBroadcaster ;
        private var _m : HashMap ;
        
        public static const onRegisterBeanEVENT:String = "onRegisterBean" ;
        public static const onUnregisterBeanEVENT:String = "onUnregisterBean" ;
        
        public static function getInstance() : BeanFactory
        {
            if ( !(BeanFactory._oI is BeanFactory) ) BeanFactory._oI = new BeanFactory( new PrivateConstructorAccess() );
            return BeanFactory._oI;
        }
        
        public static function release():void
        {
            if ( BeanFactory._oI is BeanFactory ) BeanFactory._oI = null;
        }
        
        public function BeanFactory( access : PrivateConstructorAccess )
        {
            _oEB = new EventBroadcaster( this ) ;
            _m = new HashMap() ;
        }
        
        public function  getKeys () : Array
        {
            return _m.getKeys() ;
        }
        
        public function getValues() : Array
        {
            return _m.getValues() ;
        }
        
        public function clear() : void
        {
            _m.clear();
        }
        
        public function  locate ( key : String ) : Object
        {
            if ( isRegistered(key) )
            {
                return _m.get( key ) ;

            } else
            {
                var msg : String = this + ".locate(" + key + ") fails." ;
                PixlibDebug.ERROR( msg ) ;
                throw( new NoSuchElementException( msg ) ) ;
            }
        }
        
        public function isRegistered( key : String ) : Boolean
        {
            return _m.containsKey( key ) ;
        }
        
        public function isBeanRegistered( bean : Object ) : Boolean
        {
            return _m.containsValue( bean ) ;
        }

        public function register ( key : String, bean : Object ) : Boolean
        {
            if ( !( isRegistered( key ) ) && !( isBeanRegistered( bean ) ) )
            {
                _m.put( key, bean ) ;
                _oEB.broadcastEvent( new BeanEvent( BeanFactory.onRegisterBeanEVENT, key, bean ) ) ;
                return true ;

            } else
            {
                var msg:String = "";

                if ( isRegistered( key ) )
                {
                    msg += this+".register(" + key + ", " + bean + ") fails, key is already registered." ;
                }

                if ( isBeanRegistered( bean ) )
                {
                    msg += this + ".register(" + key + ", " + bean + ") fails, bean is already registered.";
                }

                PixlibDebug.ERROR( msg ) ;
                throw( new IllegalArgumentException( msg ) );
                return false ;
            }
        }

        public function unregister ( key : String ) : Boolean
        {
            if ( isRegistered( key ) )
            {
                _m.remove( key ) ;
                _oEB.broadcastEvent( new BeanEvent( BeanFactory.onUnregisterBeanEVENT, key, null ) ) ;
                return true ;
            }
            else
            {
                return false ;
            }
        }

        public function unregisterBean ( bean : Object ) : Boolean
        {
            var key : String = getKey( bean );
            return ( key != null ) ? unregister( key ) : false;
        }
        
        public function getKey( bean : Object ) : String
        {
            var key : String;
            var b : Boolean = isBeanRegistered( bean );

            if ( b )
            {
                var a : Array = _m.getKeys();
                var l : uint = a.length;

                while( -- l > - 1 ) 
                {
                    key = a[ l ];
                    if ( locate( key ) == bean ) return key;
                }
            }
            
            return null;
        }

        public function addListener( listener : BeanFactoryListener ) : Boolean
        {
            return _oEB.addListener( listener );
        }

        public function removeListener( listener : BeanFactoryListener ) : Boolean
        {
            return _oEB.removeListener( listener );
        }

        public function addEventListener( type : String, listener : Object, ... rest ) : Boolean
        {
            return _oEB.addEventListener.apply( _oEB, rest.length > 0 ? [ type, listener ].concat( rest ) : [ type, listener ] );
        }

        public function removeEventListener( type : String, listener : Object ) : Boolean
        {
            return _oEB.removeEventListener( type, listener );
        }

        public function toString() : String 
        {
            return PixlibStringifier.stringify( this );
        }

        public function add( d : Dictionary ) : void
        {
            for ( var key : * in d ) 
            {
                try
                {
                    register( key, d[ key ] as Object );

                } catch( e : IllegalArgumentException )
                {
                    e.message = this + ".add() fails. " + e.message;
                    PixlibDebug.ERROR( e.message );
                    throw( e );
                }
            }
        }
    }
}

internal class PrivateConstructorAccess {}

Summary

Constructor

BeanFactory (access:PrivateConstructorAccess)

Class methods

getInstance : BeanFactory
release : void

Instance methods

getKeys : Array
- Returns an {VISDOC_CODE_BLOCK_13} view of the keys contained in this locator.
getValues : Array
- Returns an {VISDOC_CODE_BLOCK_14} view of the values contained in this locator.
clear : void
locate (key:String) : Object
- Returns the ressource associated with the passed-in {VISDOC_CODE_BLOCK_9}.
isRegistered (key:String) : Boolean
- Returns {VISDOC_CODE_BLOCK_3} is there is a ressource associated
isBeanRegistered (bean:Object) : Boolean
register (key:String, bean:Object) : Boolean
unregister (key:String) : Boolean
unregisterBean (bean:Object) : Boolean
getKey (bean:Object) : String
addListener (listener:BeanFactoryListener) : Boolean
removeListener (listener:BeanFactoryListener) : Boolean
addEventListener (type:String, listener:Object, rest) : Boolean
removeEventListener (type:String, listener:Object) : Boolean
toString : String
add (d:Dictionary) : void
- Adds all ressources contained in the passed-in dictionnary

Event handlers

onRegisterBeanEVENT : String
onUnregisterBeanEVENT : String

Constructor

BeanFactory

public function BeanFactory (

access:PrivateConstructorAccess)

Class methods

getInstance

public static function getInstance (

) : BeanFactory

release

public static function release (

) : void

Instance methods

add

public function add (

d:Dictionary) : void

Adds all ressources contained in the passed-in dictionnary
into this locator instance. If there is keys used both in
the locator and in the dictionnary an exception is thrown.

Parameters:

dictionnary instance which contains ressources
to be added

Throws:

{VISDOC_LINK_0}{VISDOC_CODE_BLOCK_12} — One or more
keys present in the dictionnary already exist in this
locator instance.
#

Specified by:

Locator.add

addEventListener

public function addEventListener (

type:String, listener:Object, rest) : Boolean

addListener

public function addListener (

listener:BeanFactoryListener) : Boolean

clear

public function clear (

) : void

getKey

public function getKey (

bean:Object) : String

getKeys

public function getKeys (

) : Array

Returns an {VISDOC_CODE_BLOCK_13} view of the keys contained in this locator.

Returns:

an array view of the keys contained in this locator
#

Specified by:

Locator.getKeys

getValues

public function getValues (

) : Array

Returns an {VISDOC_CODE_BLOCK_14} view of the values contained in this locator.

Returns:

an array view of the values contained in this locator
#

Specified by:

Locator.getValues

isBeanRegistered

public function isBeanRegistered (

bean:Object) : Boolean

isRegistered

public function isRegistered (

key:String) : Boolean

Returns {VISDOC_CODE_BLOCK_3} is there is a ressource associated
with the passed-in {VISDOC_CODE_BLOCK_4}. To avoid errors when
retreiving ressources from a locator you should systematically
use the {VISDOC_CODE_BLOCK_5} function to check if the
ressource you would access is already accessible before any
call to the {VISDOC_CODE_BLOCK_6} function.

Returns:

{VISDOC_CODE_BLOCK_7} is there is a ressource associated
with the passed-in {VISDOC_CODE_BLOCK_8}.
#

Specified by:

Locator.isRegistered

locate

public function locate (

key:String) : Object

Returns the ressource associated with the passed-in {VISDOC_CODE_BLOCK_9}.
If there is no ressource identified by the passed-in key, the
function will fail with an error. To avoid the throw of an exception
when attempting to access to a ressource, take care to check the
existence of the ressource before trying to access to it.

Parameters:

key:

identifier of the ressource to access

Returns:

the ressource associated with the passed-in {VISDOC_CODE_BLOCK_10}
#

Throws:

{VISDOC_LINK_0}{VISDOC_CODE_BLOCK_11} — There is no ressource
associated with the passed-in key
#

Specified by:

Locator.locate

register

public function register (

key:String, bean:Object) : Boolean

removeEventListener

public function removeEventListener (

type:String, listener:Object) : Boolean

removeListener

public function removeListener (

listener:BeanFactoryListener) : Boolean

toString

public function toString (

) : String

unregister

public function unregister (

key:String) : Boolean

unregisterBean

public function unregisterBean (

bean:Object) : Boolean

Event handlers

onRegisterBeanEVENT

public static const onRegisterBeanEVENT:String = "onRegisterBean"

(read)

onUnregisterBeanEVENT

public static const onUnregisterBeanEVENT:String = "onUnregisterBean"

(read)