CheckList.as

Go to the documentation of this file.

import gugga.collections.ArrayList;
import gugga.debug.Assertion;
import gugga.events.EventDispatcher;
import gugga.collections.IIterable;
import gugga.collections.IIterator;
import gugga.collections.ArrayListIterator;

[Event("completed")]

class  gugga.collections.CheckList 
        extends EventDispatcher implements IIterable
{
        private var mRegisteredObjects:ArrayList;
        private var mCheckedObjects:ArrayList;
        
        public function get RegisteredObjects() : ArrayList
        {
                return mRegisteredObjects.clone();
        }
        
        public function get CheckedObjects() : ArrayList
        {
                return mCheckedObjects.clone();
        }
        
        public function get UncheckedObjects() : ArrayList
        {
                var result : ArrayList = new ArrayList();
                for (var i : Number = 0; i < mRegisteredObjects.length; i++)
                {
                        var item : Object = mRegisteredObjects[i];
                        if(!isObjectChecked(item))
                        {
                                result.addItem(item);
                        }
                }
                
                return result;
        }
        
        public function CheckList()
        {
                mRegisteredObjects = new ArrayList();
                mCheckedObjects = new ArrayList();
        }
        
        public function add(aObject:Object):Void
        {
                Assertion.failIfReturnsTrue(
                        this, isObjectRegistered, [aObject], 
                        "Object already added", this, arguments);
                
                mRegisteredObjects.push(aObject);
        }
        
        public function remove(aObject : Object) : Void
        {
                mRegisteredObjects.removeItem(aObject);
                mCheckedObjects.removeItem(aObject);
        }
                
        public function check(aObject:Object):Void
        {
                Assertion.failIfReturnsFalse(
                        this, isObjectRegistered, [aObject], 
                        "Trying to check unregistered object", this, arguments);
                
                if(!isObjectChecked(aObject))
                {
                        mCheckedObjects.push(aObject);  
                        
                        //TODO: Should be tested
                        if(isCompleted())
                        {
                                dispatchEvent({type: "completed", target: this});
                        }
                }
        }
        
        public function reset():Void
        {
                mCheckedObjects = new ArrayList();
        }
        
        public function isObjectRegistered(aObject:Object):Boolean
        {       
                var isRegistered:Boolean = mRegisteredObjects.containsItem(aObject);
                return isRegistered;
        }
        
        public function isObjectChecked(aObject:Object):Boolean
        {       
                var isChecked:Boolean = mCheckedObjects.containsItem(aObject);
                return isChecked;
        }
                
        public function isCompleted():Boolean
        {
                if(mCheckedObjects.length == mRegisteredObjects.length)
                {
                        return true;
                }
                else
                {
                        return false;
                }
        }
        
        public function getIterator () : IIterator
        {
                return new ArrayListIterator(this.RegisteredObjects);
        }
        
        public function getCheckedObjectsIterator () : IIterator
        {
                return new ArrayListIterator(this.CheckedObjects);
        }
        
        public function getUncheckedObjectsIterator () : IIterator
        {
                return new ArrayListIterator(this.UncheckedObjects);
        }
}

---