bugcore

    0.3.27 • Public • Published


    bugcore

    bugcore is a JavaScript library that provides a foundational architecture for object oriented JS. It is designed to work both within node js as well as directly in the browser.

    bugcore provides a basic class model based on John Resig's simple JavaScript inheritance. In addition the library provides many basic data models and utility classes for common object oriented patterns.

    If the library is missing something you need, please let us know!

    NOTE: This documentation is still being written. If you click on a link and it doesn't go anywhere, it's likely because that portion of the docs hasn't been written yet. If there are parts of the docs you'd like us to focus on, feel free to ask!

    Build Status

    npm version
    Code Climate
    NPM

    Quick Examples

    Creation of a new class

    var Class   = bugcore.Class;
    var Obj     = bugcore.Obj;
     
    var SomeClassConstructor = Class.extend(Obj, {});

    Creation of a new class with an internal _constructor method

    var SomeClassConstructor = Class.extend(Obj, {
        _constructor: function() {
            this._super(); // Call super constructor
        }
    });

    Creation of a new class with overridden equals and hashCode methods

    /**
     * @class
     * @extends {Obj} 
     */
    var SomeClassConstructor = Class.extend(Obj, {
     
        /**
         * @constructs
         * @param {number} a 
         * @param {number} b 
         */
        _constructor: function(a, b) {
     
            this._super(); // Call super constructor
     
            /**
             * @private
             * @type {number} 
             */
            this.a = a;
     
            /**
             * @private
             * @type {string} 
             */
            this.b = b
        },
     
        /**
         * @override
         * @param {*} value 
         * @return {boolean} 
         */
        equals: function(value) {
            if (Class.doesExtend(value, SomeClass)) {
                return (Obj.equals(value.a, this.a) && Obj.equals(value.b, this.b));
            }
            return false;
        },
     
        /**
         * @override
         * @return {number} 
         */
        hashCode: function() {
            if (!this._hashCode) {
                this._hashCode = Obj.hashCode("[SomeClass]" +
                    Obj.hashCode(this.a) + Obj.hashCode(this.b));
            }
            return this._hashCode;
        },
    });

    Use of a Map

    var myMap = new bugcore.Map();
    myMap.put("key1", "value1");
    myMap.put("key2", "value2");
    myMap.get("key1");      // "value1"
    myMap.get("key2");      // "value2"

    Use of a Map with instances as keys

    var myMap       = new bugcore.Map();
     
    // SomeClass is from the above example that uses overridden equals and hashCode methods
    var instance1   = new SomeClass(123, "abc");
    var instance2   = new SomeClass(123, "abc");
    myMap.put(instance1, "value");
    myMap.put(instance2, "value2");
     
    //hash codes and equality checks are equal therefore the two instances are considered
    //the same key even though they are separate instances in memory
    myMap.getCount();       // 1
    myMap.get(instance1)    // "value2"
    myMap.get(instance2)    // "value2"

    Dependencies

    bugcore is dependent upon the bugpack framework

    Download Source

    The source is available for download from GitHub

    From the web, you can download the packaged scripts here

    https://s3.amazonaws.com/public-airbug/bugcore-0.3.27.js
    https://s3.amazonaws.com/public-airbug/bugcore-0.3.27.min.js
    

    Install

    For node js, you can install using Node Package Manager npm

    npm install bugcore
    

    For the web, simply include these scripts in your application

    <script type="text/javascript" src="https://s3.amazonaws.com/public-airbug/bugpack-0.2.2.min.js"></script>
    <script type="text/javascript" src="https://s3.amazonaws.com/public-airbug/bugcore-0.3.27.min.js"></script>

    Usage

    In node js:

    npm will install the bugpack dependency

    var bugcore = require('bugcore');
     
    var map     = new bugcore.Map();

    In the browser:

    <script type="text/javascript" src="https://s3.amazonaws.com/public-airbug/bugpack-0.2.2.js"></script>
    <script type="text/javascript" src="https://s3.amazonaws.com/public-airbug/bugcore-0.3.27.js"></script>
    <script type="text/javascript">
     
        var map = new bugcore.Map();
     
    </script> 

    Documentation

    Change Classes

    Command Classes

    Concurrent Classes

    Core Classes

    Core Interfaces

    Data Classes

    Data Interfaces

    Event Classes

    Event Interfaces

    Flow Classes

    Match Classes

    Observable Classes

    Observable Interfaces

    Promise Classes

    Promise Interfaces

    Proxy Classes

    Proxy Interfaces

    Publisher Classes

    Query Classes

    Query Interfaces

    State Classes

    Stream Classes

    Stream Interfaces

    Throwable Classes

    Trace Classes

    Util Classes

    Validator Classes


    AddAtChange

    TODO


    AddChange

    TODO


    Change

    TODO


    ClearChange

    TODO


    PutChange

    TODO


    RemoveAtChange

    TODO


    RemoveChange

    TODO


    RemovePropertyChange

    TODO


    SetPropertyChange

    TODO


    Command

    TODO


    CommandBatch

    TODO


    CommandProcessor

    TODO


    Lock

    TODO


    LockMap

    TODO


    LockStriped

    TODO


    Semaphore

    TODO


    Class

    Core class used to build other classes.

    Class

    /**
     * @constructor
     * @param {function(new:Constructor)} constructor
     * @param {Array.<Interface>} interfaces 
     * @param {string} name 
     * @param {Class} superclass 
     */
    var Class = function(constructor, interfaces, name, superclass) {

    View code

    Constructor Summary

    Access Signature
    constructor Class({Constructor} constructor, {Array.<Interface>} interfaces, {string} name, {Class} superclass)

    Getters and Setters Summary

    Access Signature Return Type
    public getConstructor() {function(new:Constructor)}
    public getInterfaces() {Array.<Interface>}
    public getName() {string}
    public getSuperclass() {Class}

    Method Summary

    Access Signature Return Type
    public alloc({*...} args) {Constructor}
    public allocWithArray({Array.<*>} args) {Constructor}
    public newInstance({*...} args) {Constructor}
    public newInstanceWithArray({Array.<*>} args) {Constructor}

    Static Method Summary

    Access Signature Return Type
    static public declare({Object.<string, *>} declaration) {function(new:Constructor)}
    static public doesExtend({*} value, {function(new:Constructor)} constructor) {boolean}
    static public doesImplement({*} value, {function(new:Implementable)} implementable) {boolean}
    static public extend({function(new:Constructor)} constructor, {Object.<string, *>} declaration) {function(new:Constructor)}
    static public implement({function(new:Constructor)} constructor, {function(new:Implementable)} implementable) None



    Class(constructor, interfaces, name, superclass)

    Method

    /**
     * @constructor
     * @param {function(new:Constructor)} constructor
     * @param {Array.<Interface>} interfaces 
     * @param {string} name 
     * @param {Class} superclass 
     */
    var Class = function(constructor, interfaces, name, superclass) {

    Parameters

    Name Type Description
    constructor {function(new:Constructor} The Constructor of this class.
    interfaces {Array.<Interface>} Any Interfaces that this Class implements.
    name {string} The name of this Class.
    superclass {Class} The superclass of this Class.

    Examples

    var myClass = new Class(constructor, interfaces, name, superclass);



    Class#getConstructor()

    Get the Class's Constructor function

    Method

    /**
     * @return {function(new:Constructor)}
     */
    getConstructor: function() {

    Parameters

    • None

    Returns

    • {function(new:Constructor)} - The Class's Constructor function.

    Examples

    /** @type {function(new:MyClassConstructor)} */
    var MyClassConstructor  = Class.extend(Obj, {});
     
    /** @type {Class} */
    var MyClass             = MyClassConstructor.getClass();
     
    console.log(MyClassConstructor === MyClass.getConstructor());   // true



    Class#getInterfaces()

    Get the Class's implemented Interfaces

    Method

    /**
     * @return {Array.<Interface>} 
     */
    getInterfaces: function() {

    Parameters

    • None

    Returns

    Examples

    var MyInterface         = Interface.declare({
        myMethod: function() {}
    });
    var MyClassConstructor  = Class.extend(Obj, {
        myMethod: function() {}
    });
     
    Class.implement(MyClassConstructor, MyInterface);
     
    var MyClass = MyClassConstructor.getClass();
    MyClass.getInterfaces();                            // [ MyInterface ]



    ### Class#getName()

    Get the Class's name (if one was supplied)

    Method

    /**
     * @return {string} 
     */
    getName: function() {

    Parameters

    • None

    Returns

    • {string} - The Class's name.

    Examples

    var MyClassConstructor  = Class.extend(Obj, {
        _name: "MyClass"
    });
     
    var MyClass = MyClassConstructor.getClass();
    MyClass.getName();                         // "MyClass"



    ### Class#getSuperclass()

    Get the Class's superclass (if there is one)

    Method

    /**
     * @return {Class} 
     */
    getSuperclass: function() {

    Parameters

    • None

    Returns

    • {Class} - The Class's superclass.

    Examples

    Extended Class

    var MyClassConstructor  = Class.extend(Obj, {});
     
    var MyClass = MyClassConstructor.getClass();
    console.log(MyClass.getSuperclass() === Obj.getClass());    // true

    Declared Class

    var MyBaseClassConstructor  = Class.declare({});
     
    var MyBaseClass = MyBaseClassConstructor.getClass();
    MyBaseClass.getSuperclass();                                // null



    ### Class#alloc()

    This method allocates and returns a new instance of this Class that has only been constructed. It passes all arguments through to the constructor.

    Method

    /**
     * @param {...} args 
     * @return {Constructor} 
     */
    alloc: function(args) {

    Parameters

    Name Type Description
    args {...} Any number of arguments of any type.

    Returns

    Examples

    var BaseBall        = Class.extend(Ball, {});
    var BaseBallClass   = BaseBall.getClass();
    var myBaseBall      = BaseBallClass.alloc("arg1", "arg2");



    ### Class#allocWithArray()

    This method allocates and returns a new instance of this Class that has only been constructed. It uses an array as the arguments to apply to the constructor.

    Method

    /**
     * @param {Array.<*>=} args
     * @return {Constructor} 
     */
    allocWithArray: function(args) {

    Parameters

    Name Type Description
    args {Array.<*>} An array of args to apply to the constructor.

    Returns

    Examples

    var BaseBall        = Class.extend(Ball, {});
    var BaseBallClass   = BaseBall.getClass();
    var myBaseBall      = BaseBallClass.allocWithArray(["arg1", "arg2"]);



    ### Class#newInstance()

    This method returns a new instance of this Class that has been both constructed and initialized. It passes all arguments through to both the constructor as well as the init methods.

    Method

    /**
     * @param {*...} args
     * @return {Constructor} 
     */
    newInstance: function(args) {

    Parameters

    Name Type Description
    args {*...} Any number of arguments of any type.

    Returns

    Examples

    var BaseBall        = Class.extend(Ball, {});
    var BaseBallClass   = BaseBall.getClass();
    var myBaseBall      = BaseBallClass.newInstance("arg1", "arg2");



    ### Class#newInstanceWithArray()

    This method returns a new instance of this Class that has been both constructed and initialized. It uses an array as the arguments to apply to both the constructor and the init methods.

    Method

    /**
     * @param {Array.<*>=} args
     * @return {Constructor} 
     */
    newInstanceWithArray: function(args) {

    Parameters

    Name Type Description
    args {Array.<*>} An array of args to apply to the constructor and init methods.

    Returns

    Examples

    var BaseBall        = Class.extend(Ball, {});
    var BaseBallClass   = BaseBall.getClass();
    var myBaseBall      = BaseBallClass.newInstanceWithArray(["arg1", "arg2"]);



    ### Class.declare(declaration)

    This method is used to declare a low level base class in the bugcore system. Most of the time you should not use this method to declare new classes unless you are sure of what you are doing. Instead use the Class.extend method and extend Obj. By using this method, it will exclude many of the base methods that the rest of the bugcore system depends upon, including hashCode, equals, _internalId, and clone

    Method

    /**
     * @static
     * @param {Object.<string, *>} declaration
     * @return {function(new:Constructor)}
     */
    Class.declare = function(declaration) {

    Parameters

    Name Type Description
    declaration {Object.<string, *>} An object that declares the methods of the new class.

    Returns

    • {function(new:Constructor)} - The newly created class's constructor.

    Examples

    var LowestLevelObject = Class.declare({
        _constructor: function() {
            // No need to call this._super, this is the lowest level.
        }
    });



    ### Class.doesExtend(value, constructor)

    This method is used to determine if a value extends a particular Constructor's Class. Instances of Classes are considered to extend their own Class.

    Method

    /**
     * @static
     * @param {*} value 
     * @param {function(new:Constructor)} constructor
     * @return {boolean} 
     */
    Class.doesExtend = function(value, constructor) {

    Parameters

    Name Type Description
    value {*} The value to determine if it extends the given Constructor's Class
    constructor {function(new:Constructor)} The Constructor used to check if the value extends it's Class

    Returns

    • {boolean} - Whether or not the value extends the given Constructor's Class

    Examples

    var BaseBall = Class.extend(Ball, {});
    var myBaseBall = new BaseBall();
     
    Class.doesExtend(myBaseBall, Ball);         //true
    Class.doesExtend(myBaseBall, BaseBall);     //true



    ### Class.doesImplement(value, implementable)

    This method is used to determine if a value implements a particular Implementable's Interface.

    Method

    /**
     * @static
     * @param {*} value 
     * @param {function(new:Implementable)} implementable
     * @return {boolean} 
     */
    Class.doesImplement = function(value, implementable) {

    Parameters

    Name Type Description
    value {*} The value to determine if it implements the given Implementable's Interface
    constructor {function(new:Constructor)} The Constructor used to check if the value extends it's Class

    Returns

    • {boolean} - Whether or not the value implements the given Implementable's Interface

    Examples

    var IBall   = Interface.declare({});
    var Ball    = Class.declare({});
    Class.implement(Ball, IBall);
     
    var myBall  = new Ball();
     
    Class.doesImplement(myBall, IBall);         //true



    ### Class.extend(constructor, declaration)

    This method is used to extend another Class. It accepts the Class's Constructor as a parameter and the declaration for the new Class.

    Notes

    Method

    /**
     * @static
     * @param {function(new:Constructor)} constructor
     * @param {Object.<string, *>} declaration
     * @return {function(new:Constructor)}
     */
    Class.extend = function(constructor, declaration) {

    Parameters

    Name Type Description
    constructor {function(new:Constructor)} The constructor of the class to extend.
    declaration {Object.<string, *>} An object that declares the methods of the new class.

    Returns

    • {function(new:Constructor)} - The newly created class's constructor.

    Examples

    var BaseBall = Class.extend(Ball, {
     
        _constructor: function(diameter) {
            this._super(); // Call super constructor
            this.diameter = diameter;
        }
     
        throwBall: function() {
     
        }
    });



    ### Class.implement(constructor, implementable)

    This method marks a Class as implementing an Interface. When calling this method it will add the Implementable's Interface to the Class's list of Interfaces. It will also validate that the given Class actually implements all of the methods of the Interface. If the Class does not this method will throw an Error.

    Method

    /**
     * @static
     * @param {function(new:Constructor)} constructor
     * @param {function(new:Implementable)} implementable
     */
    Class.implement = function(constructor, implementable) {

    Parameters

    Name Type Description
    constructor {function(new:Constructor)} The Constructor of the Class to implement the Interface.
    implementable {function(new:Implementable)} The Implementable of the Interface to implement.

    Returns

    • None

    Examples

    Implement an Interface

    var IBall   = Interface.declare({
        throwBall: function() {}
    });
     
    var Ball    = Class.declare({
        throwBall: function() {
            // Implementation of method
        }
    });
     
    Class.implement(Ball, IBall);


    Constructor

    Represents the base instantiable constructor function of all classes declared in the BugCore system using Class.declare

    Class

    /**
     * @constructor
     */
    var Constructor = function() {

    Getters and Setters Summary

    Access Signature Return Type
    public getClass() {Class}

    Static Getters and Setters Summary

    Access Signature Return Type
    static public getClass() {Class}

    Static Methods Summary

    Access Signature Return Type
    static public alloc({*...} args) {Constructor}
    static public allocWithArray({Array.<*>} args) {Constructor}
    static public newInstance({*...} args) {Constructor}
    static public newInstanceWithArray({Array.<*>} args) {Constructor}



    ### Constructor#getClass()

    Get the Class for this instance.

    Method

    /**
     * @return {Class} 
     */
    getClass: function() {

    Parameters

    • None

    Returns

    • {Class} - The Class of this instance.

    Examples

    //TODO BRN: Provide example of Class usage



    ### Constructor.getClass()

    Get the Class for this Constructor.

    Method

    /**
     * @static
     * @return {Class} 
     */
    Constructor.getClass = function() {

    Parameters

    • None

    Returns

    • {Class} - The Class of this Constructor.

    Examples

    //TODO BRN: Provide example of Class usage



    ### Constructor.alloc()

    This method allocates and returns a new instance of the class represented by this Constructor. The new instance has only been constructed and not initialized. The method passes all arguments through to the constructor.

    Method

    /**
     * @static
     * @param {*...}
     * @return {Constructor} 
     */
    Constructor.alloc = function() {

    Parameters

    Name Type Description
    args {...} Any number of arguments of any type.

    Returns

    Examples

    var BaseBall        = Class.extend(Ball, {});
    var myBaseBall      = BaseBall.alloc("arg1", "arg2");



    ### Constructor.allocWithArray()

    This method allocates and returns a new instance of the class represented by this Constructor. The new instance has only been constructed and not initialized. This method uses an array as the arguments to apply to the constructor.

    Method

    /**
     * @static
     * @param {Array.<*>} args
     * @return {Constructor} 
     */
    Constructor.allocWithArray = function(args) {

    Parameters

    Name Type Description
    args {Array.<*>} An array of args to apply to the constructor.

    Returns

    Examples

    var BaseBall        = Class.extend(Ball, {});
    var myBaseBall      = BaseBall.allocWithArray(["arg1", "arg2"]);



    ### Constructor.newInstance()

    This method allocates and returns a new instance of the class represented by this Constructor. The new instance has been both constructed and initialized. This method passes all arguments through to both the constructor as well as the init methods.

    Method

    /**
     * @static
     * @param {*...}
     * @return {Constructor} 
     */
    Constructor.newInstance = function() {

    Parameters

    Name Type Description
    args {*...} Any number of arguments of any type.

    Returns

    Examples

    var BaseBall        = Class.extend(Ball, {});
    var myBaseBall      = BaseBall.newInstance("arg1", "arg2");



    ### Constructor.newInstanceWithArray()

    This method allocates and returns a new instance of the class represented by this Constructor. The new instance has been both constructed and initialized. This method uses an array as the arguments to apply to both the constructor and the init methods.

    Method

    /**
     * @static
     * @param {Array.<*>} args
     * @return {Constructor} 
     */
    Constructor.newInstanceWithArray = function(args) {

    Parameters

    Name Type Description
    args {Array.<*>} An array of args to apply to the constructor and init methods.

    Returns

    Examples

    var BaseBall        = Class.extend(Ball, {});
    var myBaseBall      = BaseBall.newInstanceWithArray(["arg1", "arg2"]);


    Func


    Implementable

    Represents the base function of all interfaces declared in the BugCore system using Interface.declare

    Class

    /**
     * @constructor
     */
    var Implementable = function() {};

    Static Getters and Setters Summary

    Access Signature Return Type
    static public getInterface() {Interface}



    Implementable.getInterface()

    Get the Interface for this Implementable.

    Method

    /**
     * @static
     * @return {Interface} 
     */
    Implementable.getInterface = function() {

    Parameters

    • None

    Returns

    • {Interface} - The Interface of this Implementable.

    Examples

    var MyImplementable = Interface.declare({
        interfaceMethod: function() {
     
        }
    });
    var MyInterface = MyImplementable.getInterface();


    Interface

    Core class used to build interfaces.

    Class

    /**
     * @constructor
     * @param {function(new:Implementable)} implementable
     * @param {string} name 
     * @param {Interface} superinterface 
     */
    var Interface = function(implementable, name, superinterface) {

    Constructor Summary

    Access Signature
    constructor Interface({function(new:Implementable)} implementable, {string} name, {Interface} superinterface)

    Getters and Setters Summary

    Access Signature Return Type
    public getImplementable() {function(new:Implementable)}
    public getName() {string}
    public getSuperinterface() {Interface}

    Static Method Summary

    Access Signature Return Type
    static public declare({Object.<string, *>} declaration) {function(new:Implementable)}
    static public extend({function(new:Implementable)} implementable, {Object.<string, *>} declaration) function(new:Implementable)



    ### Interface(implementable, name, superinterface)

    Constructor for a new Interface. This should not be used directly. Instead, use the Interface.declare method to create a new Interface.

    Method

    /**
     * @constructor
     * @param {function(new:Implementable)} implementable
     * @param {string} name 
     * @param {Interface} superinterface 
     */
    var Interface = function(implementable, name, superinterface) {

    Parameters

    Name Type Description
    implementable {function(new:Implementable} The Implementable of this Interface.
    name {string} The name of this Interface.
    superinterface {Interface} The superinterface of this Interface (optional).

    Examples

    var myInterface = new Interface(implementable, name, superinterface);



    ### Interface#getImplementable()

    Get the Interface's Implementable function.

    Method

    /**
     * @return {function(new:Implementable)}
     */
    getImplementable: function() {

    Parameters

    • None

    Returns

    Examples

    /** @type {function(new:MyInterfaceImplementable)} */
    var MyInterfaceImplementable  = Interface.declare({});
     
    /** @type {Interface} */
    var MyInterface            = MyInterfaceImplementable.getInterface();
     
    console.log(MyInterfaceImplementable === MyInterface.getImplementable());   // true



    ### Interface#getName()

    Get the Interface's name (if one was supplied)

    Method

    /**
     * @return {string} 
     */
    getName: function() {

    Parameters

    • None

    Returns

    • {string} - The Interface's name.

    Examples

    var MyInterfaceImplementable  = Interface.declare({
        _name: "MyInterface"
    });
     
    var MyInterface = MyInterfaceImplementable.getInterface();
    MyInterface.getName();                         // "MyInterface"



    ### Interface#getSuperinterface()

    Get the Interface's superinterface (if there is one)

    Method

    /**
     * @return {Interface} 
     */
    getSuperinterface: function() {

    Parameters

    • None

    Returns

    Examples

    Extended Interface

    var MyInterfaceImplementable  = Interface.extend(SomeInterfaceImplementable, {});
     
    var MyInterface = MyInterfaceImplementable.getInterface();
    console.log(MyInterface.getSuperinterface() === SomeInterfaceImplementable.getInterface());    // true

    Declared Interface

    var MyBaseInterfaceImplementable  = Interface.declare({});
     
    var MyBaseInterface = MyBaseInterfaceImplementable.getInterface();
    MyBaseInterface.getSuperinterface();                                // null



    ### Interface.declare(declaration)

    This method is used to declare a low level base Interface in the bugcore system. Unlike Class.declare this method should be freely used to declare basic interfaces that extend no other Interface.

    Method

    /**
     * @static
     * @param {Object.<string, function(...):*>} declaration
     * @return {function(new:Implementable)}
     */
    Interface.declare = function(declaration) {

    Parameters

    Name Type Description
    declaration {Object.<string, function(...):*>} An object that declares the methods of the new Interface.

    Returns

    Examples

    var MyImplementable = Interface.declare({
        foo: function() {},
        bar: function() {}
    });



    ### Interface.extend(implementable, declaration)

    This method is used to extend and existing interface.

    Method

    /**
     * @static
     * @param {function(new:Implementable)} implementable
     * @param {Object.<string, function(..):*>} declaration
     * @return {function(new:Implementable)}
     */
    Interface.extend = function(implementable, declaration) {

    Parameters

    Name Type Description
    implementable {function(new:Implementable)} The Implementable of the Interface to extend.
    declaration {Object.<string, function(...):*>} An object that declares the methods of the new Interface.

    Returns

    Examples

    var IBall = Interface.declare({
        throwBall: function() {
     
        }
    });
    var IBaseBall = Class.extend(IBall, {
        hitBall: function() {
     
        }
    });


    Obj

    The root class of all other classes in the bugcore library. Provides basic functionality such as hash code support, equality checks and clone support.

    Class

    /**
     * @class
     * @extends {Constructor} 
     * @implements {IClone} 
     * @implements {IEquals} 
     * @implements {IHashCode} 
     */
    var Obj = Class.declare(/** @lends {Obj.prototype} */{

    Extends

    Interfaces

    Constructor Summary

    Access Signature
    constructor _constructor()

    Getters and Setters Summary

    Access Signature Return Type
    public getInternalId() {number}

    Method Summary

    Access Signature Return Type
    public clone({boolean} deep) {*}
    public equals({*} value) {boolean}
    public hashCode() {number}

    Static Method Summary

    Access Signature Return Type
    static public clone({A} value, {boolean} deep) {A}
    static public equals({*} value1, {*} value2) {boolean}
    static public hashCode({*} value) {number}



    Obj#_constructor()

    Method

    /**
     * @constructs
     */
    _constructor: function() {

    Parameters

    • None

    Examples

    var myObj = new Obj();



    Obj#getInternalId()

    Method

    /**
     * @return {number} 
     */
    getInternalId: function() {

    Parameters

    • None

    Returns

    • {number} - The unique internal id for this instance. Unique only to this JS runtime.

    Examples

    var myObj       = new Obj();
    var internalId  = myObj.getInternalId();



    ### Obj#clone(deep)

    By default the clone method will use the instance's Class to instantiate a new instance. It will also iterate through the instance's properties and attempt to clone all properties that are not functions. If a deep clone is being performed, then the clone method will attempt to create a deep copy of each property. If a shallow clone is being performed then a reference to the property value will be set on the new instance.

    Notes

    • _internalId is not cloned for deep or shallow clones. Therefore the clone instance is unique from that of the original.

    Method

    /**
     * @param {boolean=} deep 
     * @return {*} 
     */
    clone: function(deep) {

    Parameters

    Name Type Description
    deep {boolean=} Whether or not to perform a deep clone. Optional - default: false

    Returns

    • {*} - A clone of the instance.

    Examples

    var myObj               = new Obj();
    var shallowCloneObj     = myObj.clone();     //shallow clone
    var deepCloneObj        = myObj.clone(true); //deep clone



    ### Obj#equals(value)

    By default, the equality check will compare this instances _internalId to the value parameter.

    Notes

    • If two instances are equal, they should return the same hash code.

    Method

    /**
     * @param {*} value 
     * @return {boolean} 
     */
    equals: function(value) {

    Parameters

    Name Type Description
    value {*} The value to compare to for equality.

    Returns

    • {boolean} - Whether or not the instance is equal to the value parameter.

    Examples

    Two different instances are not equal

    var obj1   = new Obj();
    var obj2   = new Obj();
    obj1.equals(obj2);      //false

    An instance is equal to itself

    var obj1   = new Obj();
    obj1.equals(obj1);      //true

    Clones are not equal unless the 'equals' method is overridden

    var obj         = new Obj();
    var objClone    = obj.clone();
    obj.equals(objClone);      //false
    var obj         = new Obj();
    var objClone    = obj.clone(true);
    obj.equals(objClone);      //false



    ### Obj#hashCode()

    Returns the objects hashCode. The generation of the hashCode is only run once and then cached.

    Notes

    • If two instances are equal, they should return the same hash code.
    • Equal hash codes is not a guarantee of equality.
    • A hash code should not change for an instance over the lifespan of the instance.
    • Generation of hash codes should be done only using immutable values.

    Method

    /**
     * @return {number} 
     */
    hashCode: function() {

    Parameters

    • None

    Returns

    • {number} - The hash code of this instance.

    Examples

    Get hash code of instance

    var obj         = new Obj();
    var hashCode    = obj.hashCode();



    ### Obj.clone(value, deep)

    Clones the value parameter.

    If the value implements IClone the clone() method will be called to perform a clone of the value. If the value is a basic value such as a number or string it will simply be passed through.

    Method

    /**
     * @static
     * @param {A} value 
     * @param {boolean=} deep 
     * @return {A} 
     * @template A
     */
    Obj.clone = function(value, deep) {

    Notes

    • If the value implements IClone, the clone() method will be used to clone the value.
    • Cloning an object literal will create a new object literal and set references to all iterable property values of the original object.
    • Cloning a Date will create a new Date instance with the same time.
    • Cloning an Array will create a new Array with the same values in the same order.

    Parameters

    Name Type Description
    value {A} The value to clone.
    deep {boolean=} Whether or not to perform a deep clone. Optional - default: false

    Returns

    • {A} - A clone of the value.

    Examples

    var myObj               = new Obj();
    var shallowCloneObj     = Obj.clone(myObj);         //shallow clone
    var myObj               = new Obj();
    var deepCloneObj        = Obj.clone(myObj, true);   //deep clone
    var myString            = "abc123";
    var cloneString         = Obj.clone(myString);      //"abc123"



    ### Obj.equals(value1, value2)

    Checks value1 and value2 for equality.

    If value1 implements IEquals, the value1.equals() method will be used to perform the equality check. Otherwise === is used to compare the two values.

    Notes

    • Two Date instances of the same time are considered equal

    Method

    /**
     * @static
     * @param {*} value1 
     * @param {*} value2 
     * @return {boolean} 
     */
    Obj.equals = function(value1, value2) {

    Parameters

    Name Type Description
    value1 {*} The value to compare value2 to for equality.
    value2 {*} The value to compare value1 to for equality.

    Returns

    • {boolean} - Whether or not the two values are equal.

    Examples

    Two different instances are not equal

    var obj1   = new Obj();
    var obj2   = new Obj();
    Obj.equals(obj1, obj2);         //false

    An instance is equal to itself

    var obj1   = new Obj();
    Obj.equals(obj1, obj1);         //true

    Strings of the same value are equal

    var string1 = "mystring";
    var string2 = "mystring";
    Obj.equals(string1, string2)    //true

    Undefined and null are not equal

    var undefinedValue  = undefined;
    var nullValue       = null;
    Obj.equals(undefinedValue, nullValue) //false

    Two Dates of the same time are equal

    var time    = Date.now();
    var date1   = new Date(time);
    var date2   = new Date(time);
    Obj.equals(date1, date2)        //true



    ### Obj.hashCode(value)

    Returns the hashCode of the value. If the value implements IHashCode, then the value.hashCode() method will be used to generate the hash code.

    Method

    /**
     * @static
     * @param {*} value 
     * @return {number} 
     */
    Obj.hashCode = function(value) {

    Parameters

    Name Type Description
    value {*} The value to generate a hash code for..

    Returns

    • {number} - The hash code of the value.

    Examples

    Get hash code of an instance.

    var myObj       = new Obj();
    var hashCode    = Obj.hashCode(myObj);

    Get hash code of a string.

    var myString    = "abc123";
    var hashCode    = Obj.hashCode(myString);


    IClone

    The base interface for cloning. If your Class can be cloned, you should implement this interface.

    Interface

    /**
     * @interface
     */
    var IClone = Interface.declare({

    Method Summary

    Access Signature Return Type
    public clone({boolean=} deep) {*}



    ### IClone#clone(deep)

    This method returns a clone of the instance that implements this interface. Implementations should respect the deep clone flag.

    Notes

    • Implementations should respect the deep flag.
    • Immutable values need not be cloned on a deep clone.

    Method

    /**
     * @param {boolean=} deep 
     * @return {*} 
     */
    clone: function(deep) {}

    Parameters

    Name Type Description
    deep {boolean=} Whether or not to perform a deep clone. Optional - default: false

    Returns

    • {*} - A clone of the instance.


    IEquals

    The base interface for equality checks. If your Class can be compared for equality against another, you should implement this interface.

    Notes

    • This interfaces must be implemented along with the the IHashCode interface if you want your Class to work properly with the bugcore data classes.
    • If two instances are equal, they should return the same hash code.

    Interface

    /**
     * @interface
     */
    var IEquals = Interface.declare({

    Method Summary

    Access Signature Return Type
    public equals({*} value) {boolean}



    ### IEquals#equals(value)

    This method returns true if the instance that implements this interface is equal to the given value. Returns false if the given value does not equal the instance.

    Notes

    • Implementations should handle any value passed in as a parameter.

    Method

    /**
     * @param {*} value 
     * @return {boolean} 
     */
    equals: function(value) {}

    Parameters

    Name Type Description
    value {*} The value to compare the instance against for equality.

    Returns

    • {boolean} - Returns true if the instance is equal to the given value. False if not.


    IHashCode

    The base interface for generating a hash code for an instance. Used in tandem with the IEquals interface for storing values in HashStore and HashTable.

    Notes

    • This interfaces must be implemented along with the the IEquals interface if you want your Class to work properly with the bugcore data classes.
    • If two instances are equal, they should return the same hash code.
    • If two instances are not they can still return the same hash code. However, this should be avoided to a degree as it will hurt the performance of HashTable and HashStore
    • Equal hash codes does not guarantee equality.

    Interface

    /**
     * @interface
     */
    var IHashCode = Interface.declare({

    Method Summary

    Access Signature Return Type
    public hashCode() {number}



    ### IHashCode#hashCode()

    This method returns a hash code for the current instance.

    Notes

    • Implementations should try to generate a relatively unique hash code for the given instance.
    • If two instances are equal, they should return the same hash code.

    Method

    /**
     * @return {number} 
     */
    hashCode: function() {}

    Parameters

    • None

    Returns

    • {number} - The hash code for the instance.


    Throwable

    The root throwable class of the bugcore system. Has support for more complex stack traces including cause chains.

    Class

    /**
     * @class
     * @extends {Obj} 
     * @implements {IObjectable} 
     */
    var Throwable = Class.extend(Obj, {

    Extends

    Interfaces

    Constructor Summary

    Access Signature
    public _constructor({string} type, {*=} data, {string=} message, {Array.<(Throwable | Error)>=} causes)

    Getters and Setters Summary

    Access Signature Return Type
    public getCauses() {Array.<(Throwable | Error)>}
    public getData() {*}
    public setData({*} data) None
    public getMessage() {string}
    public setMessage({string} message) None
    public getStack() {string}
    public getType() {string}

    Method Summary

    Access Signature Return Type
    public addCause({(Throwable | Error)} cause) {*}
    public toObject() {causes: Array.<(Throwable | Error)>, data: *, message: string, type: string}



    Throwable#_constructor(type, data, message, causes)

    Method

    /**
     * @constructs
     * @param {string} type 
     * @param {*=} data
     * @param {string=} message 
     * @param {Array.<(Throwable | Error)>=} causes
     */
    _constructor: function(type, data, message, causes) {

    Parameters

    Name Type Description
    type {string} The type of throwable.
    data {*=} Any extra data to pass along with this throwable.
    message {string=} A message to add to this throwable. (optional - default: "")
    causes {Array.<(Throwable | Error)>=} An array of other throwables or js errors that caused this throwable. (optional - default: [])

    Examples

    Simple throwable

    var myThrowable = new Throwable("MyThrowable", {}, "Something bad happened");
    throw myThrowable;

    Throwable with cause

    try {
        somethingWillGoWrong();
    } catch (error) {
        var myThrowable     = new Throwable("SomethingWentWrong", {}, "Something went wrong in the somethingWillGoWrong function", [error]);
        throw throwable;
    }



    Throwable#getCauses()

    Get the causes of the Throwable.

    Method

    /**
     * @return {Array.<(Throwable | Error)>}
     */
    getCauses: function() {

    Parameters

    • None

    Returns

    • {Array.<(Throwable | Error)>} - An array of other Throwables or JS Errors that caused this Throwable.

    Examples

    try {
        somethingWillGoWrong();
    } catch (error) {
        var myThrowable     = new Throwable("SomethingWentWrong", {}, "Something went wrong in the somethingWillGoWrong function", [error]);
        var causes          = myThrowable.getCauses();  // [error]
    }



    Throwable#getData()

    Get the data of the Throwable.

    Method

    /**
     * @return {*} 
     */
    getData: function() {

    Parameters

    • None

    Returns

    • {*} - An array of other Throwables or JS Errors that caused this Throwable.

    Examples

    var data            = "some data";
    var myThrowable     = new Throwable("ThrowableType", data, "some message");
     
    myThrowable.getData() === data;     //true



    Throwable#setData(data)

    Set the data of the Throwable.

    Method

    /**
     * @param {*} data 
     */
    setData: function(data) {

    Parameters

    Name Type Description
    data {*} The data to set on the Throwable.

    Returns

    • None

    Examples

    var data            = "some data";
    var myThrowable     = new Throwable("ThrowableType");
    myThrowable.setData(data);
     
    myThrowable.getData() === data;     //true



    Throwable#getMessage()

    Get the message of the Throwable.

    Method

    /**
     * @return {string} 
     */
    getMessage: function() {

    Parameters

    • None

    Returns

    • {string} - The message included with the Throwable.

    Examples

    var message         = "some message";
    var myThrowable     = new Throwable("ThrowableType", null, message);
     
    myThrowable.getMessage() === message;     //true



    Throwable#setMessage(message)

    Set the message of the Throwable.

    Method

    /**
     * @param {string} message 
     */
    setMessage: function(message) {

    Parameters

    Name Type Description
    message {string} The message to set on the Throwable.

    Returns

    • None

    Examples

    var message         = "some message";
    var myThrowable     = new Throwable("ThrowableType");
    myThrowable.setMessage(message);
     
    myThrowable.getMessage() === message;     //true



    Throwable#getStack()

    Get the stack trace of the Throwable.

    Method

    /**
     * @return {string} 
     */
    getStack: function() {

    Parameters

    • None

    Returns

    • {string} - The stack trace of the Throwable.

    Examples

    //TODO



    Throwable#getType()

    Get the type of the Throwable.

    Method

    /**
     * @return {string} 
     */
    getType: function() {

    Parameters

    • None

    Returns

    • {string} - The type of the Throwable.

    Examples

    var myThrowable     = new Throwable("ThrowableType");
     
    myThrowable.getType() === "ThrowableType";     //true



    ### Throwable#addCause(cause)

    Add a cause to the Throwables list of causes.

    Notes

    • All causes will be included in the stack of the throwable.

    Method

    /**
     * @param {(Throwable | Error)} cause
     */
    addCause: function(cause) {

    Parameters

    Name Type Description
    cause {(Throwable | Error)} The cause to add to the Throwable's array of causes.

    Returns

    • None

    Examples

    Add multiple causes to a single throwable

    var myThrowable = new Throwable("MultipleCauses", {}, "Several things went wrong");
     
    //We want this to complete the looping even if a throwable occurs.
    for (var i = 0; i < 10; i++) {
        try {
            somethingMightGoWrong();
        } catch (error) {
            myThrowable.addCause(error);
        }
    }


    BidiMap

    TODO


    Collection

    The root class of several of the data objects. A collection represents a group of items.

    Notes

    • A Collection instance on its own allows for duplicate elements.
    • Order is not maintained in a Collection. Therefore iteration my not be in the order items were added to a collection.

    Class

    /**
     * @class
     * @extends {Obj} 
     * @implements {IArrayable} 
     * @implements {ICollection.<I>} 
     * @implements {IIterable} 
     * @template I
     */
    var Collection = Class.extend(Obj, /** @lends {Collection.prototype} */{

    Extends

    Interfaces

    Constructor Summary

    Access Signature
    public _constructor({(ICollection.<I> | Array.<I>)} items)

    Getters and Setters Summary

    Access Signature Return Type
    public getHashStore() {HashStore}

    Method Summary

    Access Signature Return Type
    public add({I} item) {boolean}
    public addAll({(ICollection.<I> | Array.<I>)} items) None
    public clear() None
    public contains({*} value) {boolean}
    public containsAll({(ICollection.<*> | Array.<*>)} values) {boolean}
    public containsEqual({(ICollection.<*> | Array.<*>)} values) {boolean}
    public forEach({function(I)} func) None
    public getCount() {number}
    public [toValueArray](#Collection_toValueArray() {Array.<I>}
    public countValue({*} value) {number}
    public isEmpty() {boolean}
    public iterator() {IIterator}
    public map({function} fn, {Object} context) {ICollection}
    public remove({*} value) {boolean}
    public removeAll({(ICollection.<*> | Array.<*>)} values) None
    public retainAll({(ICollection.<*> | Array.<*>)} values) None
    public toArray() {Array.<I>}



    ### Collection#_constructor(items)

    Method

    /**
     * @constructs
     * @param {(ICollection.<I> | Array.<I>)=} items
     */
    _constructor: function(items) {

    Parameters

    Name Type Description
    items {(ICollection.<I> | Array.<I>)=} Starting items to add to the Collection (Optional)

    Returns

    • None

    Examples

    No parameters

    var myCollection = new Collection();

    Array parameter

    var items          = [
        "item1",
        "item2"
    ];
    var myCollection    = new Collection(values);

    Other Collection parameter

    var itemsCollection     = new Collection([
        "item1",
        "item2"
    ]);
    var myCollection        = new Collection(itemsCollection);



    ### Collection#getHashStore()

    Method

    /**
     * @return {HashStore} 
     */
    getHashStore: function() {

    Parameters

    • None

    Returns

    • {HashStore} - The underlying HashStore that supports this Collection

    Examples

    var myCollection    = new Collection();
    var hashStore       = myCollection.getHashStore();



    ### Collection#add(item)

    Adds an item to the collection

    Method

    /**
     * @param {I} item 
     * @return {boolean} 
     */
    add: function(item) {

    Parameters

    Name Type Description
    item {I} The item to add to the collection

    Returns

    • {boolean} - Whether or not the item was added to the collection.

    Examples

    var myCollection        = new Collection();
    var myItem              = "myItem";
    var result              = myCollection.add(myItem); // true



    ### Collection#addAll(items)

    Adds an Array or Collection of items to the Collection

    Method

    /**
     * @param {(ICollection.<I> | Array.<I>)} items
     */
    addAll: function(items) {

    Parameters

    Name Type Description
    items {(ICollection.<I> | Array.<I>)} The items to add to the collection. Can either be an Array or another Collection.

    Returns

    • None

    Examples

    Add an array of items.

    var myCollection    = new Collection();
    var myItems         = [
        "item1",
        "item2"
    ];
    myCollection.addAll(myItems);

    Add a Collection of items.

    var myCollection    = new Collection();
    var itemsCollection = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.addAll(itemsCollection);



    ### Collection#clear()

    Removes all of the items from this collection.

    Method

    /**
     *
     */
    clear: function() {

    Parameters

    • None

    Returns

    • None

    Examples

    Empty the Collection

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.getCount();    // 2
     
    myCollection.clear();
    myCollection.getCount();    // 0



    ### Collection#contains(value)

    Checks the Collection to see if it contains a value.

    Method

     /**
     * @param {*} value 
     * @return {boolean} 
     */
    contains: function(value) {

    Parameters

    Name Type Description
    value {*} The value that we're checking if the collection contains.

    Returns

    • {boolean} - True if the value is contained by the Collection. False if not.

    Examples

    Value not contained

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.contains("item3");    // false

    Value contained

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.contains("item2");    // true



    ### Collection#containsAll(values):boolean

    Checks the Collection to see if it contains all of the values in the given argument. If ALL of the values are contained by the collection, this method will return true. Otherwise, false.

    Notes

    • Multiple elements are ignored in this function. e.g. Collection[0,1] containsAll Collection[0,1,1,1] is true If you want to check for exact equality, use the equals function.
    • Empty collections are always contained by another collection e.g. Collection[0,1] containsAll Collection[] is true

    Method

    /**
     * @param {(ICollection.<*> | Array.<*>)} values
     * @return {boolean} 
     */
    containsAll: function(values) {

    Parameters

    Name Type Description
    values {(ICollection.<*> | Array.<*>)} The values that we're checking to see if the collection contains all of them.

    Returns

    • {boolean} - True if the Collection contains all the given values. False if not.

    Examples

    Values not contained

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.containsAll(["item3"]);                        // false

    Partial values contained are not a match.

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.containsAll(["item2", "item3"]);               // false

    Values contained

    var myCollection    = new Collection([
        "item1",
        "item2",
        "item3"
    ]);
    myCollection.containsAll(["item2", "item3"]);               // true

    Exact match is true

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.containsAll(["item1", "item2"]);               // true

    Multiple elements are ignored. Match is true.

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.containsAll(["item1", "item2", "item2"]);      // true

    Empty collections are contained by any collection

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.containsAll([]);                               // true



    ### Collection#containsEqual(values):boolean

    Checks the Collection to see if it contains exactly the values in the given argument. If the collection contains the exact same values as the collection given in the parameter, this method will return true. Otherwise, false.

    Method

    /**
     * @param {(ICollection.<*> | Array.<*>)} values
     * @return {boolean} 
     */
    containsEqual: function(values) {

    Parameters

    Name Type Description
    values {(ICollection.<*> | Array.<*>)} The values that we're checking to see if the collection contains exactly.

    Returns

    • {boolean} - True if the Collection contains exactly the same values as the given values.

    Examples

    Values not contained at all

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.containsEqual(["item3"]);                        // false

    Partial values contained are not a match.

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.containsEqual(["item2", "item3"]);               // false

    Values contained but not an exact match

    var myCollection    = new Collection([
        "item1",
        "item2",
        "item3"
    ]);
    myCollection.containsEqual(["item2", "item3"]);               // false

    Exact match is true

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.containsEqual(["item1", "item2"]);               // true

    Exact match out of order is true

    var myCollection    = new Collection([
        "item2",
        "item1"
    ]);
    myCollection.containsEqual(["item1", "item2"]);               // true

    Multiple elements are considered

    var myCollection    = new Collection([
        "item1",
        "item2",
        "item2"
    ]);
    myCollection.containsEqual(["item1", "item2"]);               // false



    ### Collection#forEach(func)

    forEach executes the provided function once for each element of the Collection.

    Notes

    • Order is not maintained in a Collection. Therefore the order of iteration in items in a Collection is unpredictable.
    • If a value is modified in one iteration and then visited at a later time, its value in the loop is its value at that later time. A value that is deleted before it has been visited will not be visited later. Values added to the Collection over which iteration is occurring may either be visited or omitted from iteration. In general it is best not to add, modify or remove values from the Collection during iteration, other than the value currently being visited. There is no guarantee whether or not an added value will be visited, whether a modified value (other than the current one) will be visited before or after it is modified, or whether a deleted value will be visited before it is deleted.

    Method

    /**
     * @param {function(I)} func
     */
    forEach: function(func) {

    Parameters

    Name Type Description
    func {function(I)} The function to execute for each item

    Returns

    • None

    Examples

    Execute for each item

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    myCollection.forEach(function(item) {
        console.log(item);  // item1 on first pass, item2 on second
    });

    Partial values contained are not a match.

    var myCollection    = new Collection([]);
     
    myCollection.forEach(function(item) {
        console.log(item);  // never executed
    });



    ### Collection#getCount():number

    Returns the number of items in the collection.

    Method

    /**
     * @return {number} 
     */
    getCount: function() {

    Parameters

    • None

    Returns

    • {number} - The number of items in the Collection.

    Examples

    Empty Collection

    var myCollection    = new Collection([]);
     
    myCollection.getCount();   //0

    Starts with 2 items

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
     
    myCollection.getCount()    //2



    ### Collection#toValueArray()

    Returns an Array of the Collection's values.

    Notes

    • Order of items in the Array is unpredictable.
    • This method generates a new Array each time.
    • Manipulating the Array will not affect the Collection.
    • Manipulating the Collection will not affect the returned Array after it has been generated.

    Method

    /**
     * @return {Array.<I>} 
     */
    toValueArray: function() {

    Parameters

    • None

    Returns

    • {Array.<I>} - An Array of the Collection's values.

    Examples

    Empty Collection

    var myCollection    = new Collection([]);
     
    myCollection.toValueArray();   // []

    Starts with 2 items (order of items shown in examples is not indicative of real world results)

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
     
    myCollection.toValueArray()                // ["item1", "item2"]

    Manipulation of Collection after array is returned. (order of items shown in examples is not indicative of real world results)

    var myCollection    = new Collection([
        "item1",
        "item2"
    ]);
    var myValueArray    = myCollection.toValueArray();
     
    myCollection.add("item3")                   // ["item1", "item2"]
     
    console.log(myCollection.toValueArray())   // ["item1", "item2", "item3"]
    console.log(myValueArray)                   // ["item1", "item2"]



    ### Collection#countValue(value)

    Returns an the number or items in the Collection that are equal to the given value.

    Method

    /**
     * @param {*} value 
     * @return {number} 
     */
    countValue: function(value) {

    Parameters

    • None

    Returns

    • {number} - The number of items in the Collection that are equal to the given value.

    Examples

    var myCollection    = new Collection([
        "a",
        "a",
        "b"
    ]);
     
    myCollection.countValue("a");    // 2
    myCollection.countValue("b");    // 1
    myCollection.countValue("c");    // 0



    ### Collection#isEmpty()

    Returns true if the Collection is empty.

    Method

    /**
     * @return {boolean} 
     */
    isEmpty: function() {

    Parameters

    • None

    Returns

    • {true} - True if the Collection is empty.

    Examples

    Empty Collection

    var myCollection    = new Collection([]);
     
    myCollection.isEmpty();     // true

    Not empty Collection

    var myCollection    = new Collection([
        "a"
    ]);
     
    myCollection.isEmpty();     // false



    ### Collection#iterator()

    This method generates an iterator for this Collection.

    Notes

    • Because of the way javascript works and the current lack of Iterator support across browsers. Iterators create a snap shot of the values in the Collection before starting the iteration process. If a value is modified in one iteration and then visited at a later time, its value in the loop is its value when the iteration was started.
    • A value that is deleted before it has been visited WILL be visited later.
    • Values added to the Collection over which iteration is occurring will be omitted from iteration.
    • Iteration order of a Collection is not guaranteed.

    Method

    /**
     * @return {IIterator} 
     */
    iterator: function() {

    Parameters

    • None

    Returns

    Examples

    Iterate Collection

    var myCollection    = new Collection([
        "a",
        "b",
        "c"
    ]);
     
    var iterator = myCollection.iterator();
    while (iterator.hasNext()) {
        var value = iterator.next();
    }

    Iterate past end of Collection

    var myCollection    = new Collection([
        "a",
        "b",
        "c"
    ]);
     
    var iterator = myCollection.iterator();
    iterator.next();    // "a"
    iterator.next();    // "b"
    iterator.next();    // "c"
    iterator.next();    // throws and Exception of type "NoSuchElement"


    Collections

    TODO


    DependencyGraph

    TODO


    Document

    TODO


    DualMap

    TODO


    DualMultiMap

    TODO


    DualMultiSetMap

    TODO


    Graph

    TODO


    GraphEdge

    TODO


    GraphNode

    TODO


    HashStore

    TODO


    HashStoreNode

    TODO


    HashTable

    TODO


    HashTableNode

    TODO


    List

    TODO


    Map

    TODO


    MultiListMap

    TODO


    MultiMap

    TODO


    MultiSetMap

    TODO


    Pair

    TODO


    Queue

    TODO


    ReferenceGraph

    TODO


    Set

    TODO


    Stack

    TODO


    Striped

    TODO


    Tree

    TODO


    TreeNode

    TODO


    UnorderedPair

    TODO


    Url

    TODO


    WeightedList

    TODO


    WeightedListNode

    TODO


    IArrayable

    TODO


    ICollection

    TODO


    IIterable

    TODO


    IIterator

    TODO


    IList

    TODO


    IMap

    TODO


    IObjectable

    TODO


    ISet

    TODO


    Event

    The root event class for all other events in the bugcore system.

    Notes

    • Events can be listened for by type and queried on by the data they contain
    • Events bubble by default

    Class

    /**
     * @class
     * @extends {Obj} 
     */
    var Event = Class.extend(Obj, /** @lends {Event.prototype} */{

    Extends

    Constructor Summary

    Access Signature
    constructor Event({string} type, {*} data)

    Getters and Setters Summary

    Access Signature Return Type
    public getBubbles() {boolean}
    public setBubbles({boolean}) None
    public getCurrentTarget() {*}
    public setCurrentTarget({*} currentTarget) None
    public getData() {*}
    public getTarget() {*}]
    public setTarget({*} target) None
    public getType() {string}

    Method Summary

    Access Signature Return Type
    public isPropagationStopped() {boolean}
    public [stopPropagation(#Event_stopPropagation)() None



    ### Event#_constructor(type, data)

    Method

    /**
     * @constructs
     * @param {string} type 
     * @param {*=} data
     */
    _constructor: function(type, data) {

    Parameters

    Name Type Description
    type {string} The type of this event
    data {*=} Any data to pass along with this Event (Optional)

    Examples

    Simple instantiation

    var myEvent = new Event("MyEvent");

    Dispatching an event

    var myDispatcher = new EventDispatcher();
     
    myDispatcher.dispatchEvent(new Event("MyEvent", {my: "data"}));



    ### Event#getBubbles()

    Whether or not this Event bubbles

    Notes

    • Events bubble by default. So this will return true unless otherwise set.

    Method

    /**
     * @return {boolean} 
     */
    getBubbles: function() {

    Parameters

    • None

    Returns

    • {boolean} - Whether or not this event bubbles

    Examples

    var myEvent    = new Event();
    myEvent.getBubbles();       // true



    ### Event#setBubbles(bubbles)

    Set whether or not this Event should bubble

    Notes

    • Events bubble by default.

    Method

    /**
     * @param {boolean} bubbles 
     */
    setBubbles: function(bubbles) {

    Parameters

    Name Type Description
    bubbles {boolean} The value to set for bubbles

    Returns

    • None

    Examples

    var myEvent    = new Event();
    myEvent.getBubbles();       // true



    ### Event#isPropagationStopped():boolean

    Returns whether or not propagation of this event has stopped.

    Notes

    • Event propagation is not stopped by default.
    • To stop propagation simply call [stopPropagation()]("#Event_stopPorpagation"]

    Method

    /**
     * @return {boolean} 
     */
    isPropagationStopped: function() {

    Parameters

    • None

    Returns

    • {boolean} - Whether or not propagation of this event has stopped.

    Examples

    var myEvent     = new Event();
    myEvent.isPropagationStopped();           // false;
    myEvent.stopPropagation();
    myEvent.isPropagationStopped();           // true;


    EventDispatcher

    TODO


    EventListener

    TODO


    EventPropagator

    TODO


    EventQuery

    TODO


    EventQueryBuilder

    TODO


    EventQueryListener

    TODO


    EventReceiver

    TODO


    IEventDispatcher

    TODO


    IEventPropagator

    TODO


    IEventReceiver

    TODO


    Flow

    TODO


    FlowBuilder

    TODO


    Flows

    TODO


    ForEachParallel

    TODO


    ForEachSeries

    TODO


    ForInParallel

    TODO


    ForInSeries

    TODO


    If

    TODO


    IfBuilder

    TODO


    IterableParallel

    TODO


    IterableSeries

    TODO


    Iteration

    TODO


    IterableFlow

    TODO


    Parallel

    TODO


    Series

    TODO


    Task

    TODO


    WhileParallel

    TODO


    WhileSeries

    TODO


    ObjectPathMatcher

    TODO


    Observable

    TODO


    ObservableArray

    TODO


    ObservableCollection

    TODO


    ObservableList

    TODO


    ObservableMap

    TODO


    ObservableObject

    TODO


    ObservableSet

    TODO


    Observation

    TODO


    ObservationPropagator

    TODO


    Observer

    TODO


    IObservable

    TODO


    IObservationPropagator

    TODO


    Deferred

    TODO


    FinallyHandler

    TODO


    FulfilledHandler

    TODO


    Handler

    TODO


    Promise

    TODO


    Promises

    TODO


    RejectedHandler

    TODO


    Resolver

    TODO


    IPromise

    TODO


    Proxy

    TODO


    ProxyMethod

    TODO


    ProxyObject

    TODO


    ProxyProperty

    TODO


    IProxy

    TODO


    Publisher

    TODO


    PublisherMessage

    TODO


    PublisherSubscription

    TODO


    Query

    TODO


    QueryBuilder

    TODO


    WhereCondition

    TODO


    WhereConditionBuilder

    TODO


    ICondition

    TODO


    IConditionBuilder

    TODO


    StateEvent

    TODO


    StateMachine

    TODO


    ArraySupplier

    TODO


    CollectConsumer

    TODO


    Consumer

    TODO


    EachOperation

    TODO


    FilterOperation

    TODO


    IterableSupplier

    TODO


    MapOperation

    TODO


    ReduceConsumer

    TODO


    Stream

    TODO


    Supplier

    TODO


    Suppliers

    TODO


    IConsumer

    TODO


    IStreamable

    TODO


    IStreamOperation

    TODO


    ISupplier

    TODO


    ArgumentBug

    TODO


    Bug

    TODO


    Exception

    TODO


    MappedParallelException

    TODO


    MappedThrowable

    TODO


    ParallelException

    TODO


    Throwable

    TODO


    Trace

    TODO


    Tracer

    TODO


    ArgUtil

    TODO


    ArrayUtil

    TODO


    Config

    TODO


    DateUtil

    TODO


    HashUtil

    TODO


    HtmlUtil

    TODO


    IdGenerator

    TODO


    LiteralUtil

    TODO


    MathUtil

    TODO


    ObjectUtil

    TODO


    Properties

    TODO


    PropertiesChain

    TODO


    StackTraceUtil

    TODO


    StringUtil

    TODO


    TypeUtil

    Utility class for determining the data type of values.

    Class

    /**
     * @constructor
     */
    var TypeUtil = function() {

    Static Method Summary

    Access Signature Return Type
    static isArguments({*} value) {boolean}
    static isArray({*} value) {boolean}
    static isBoolean({*} value) {boolean}
    static isDate({*} value) {boolean}
    static isFunction({*} value) {boolean}
    static isNan({*} value) {boolean}
    static isNull({*} value) {boolean}
    static isNumber({*} value) {boolean}
    static isObject({*} value) {boolean}
    static isRegExp({*} value) {boolean}
    static isString({*} value) {boolean}
    static isUndefined({*} value) {boolean}
    static toType({*} value) {string}



    ### TypeUtil.isArguments(value):boolean

    Determines if the given value is a native js arguments list.

    Method

    /**
     * @static
     * @param {*} value 
     * @return {boolean} 
     */
    TypeUtil.isArguments = function(value) {

    Parameters

    • value {*} - The value to check for the type of arguments

    Returns

    • {boolean} - Whether or not the value is an arguments.

    Examples

    Arguments literal is an arguments

    var myFunction = function() {
        TypeUtil.isArguments(arguments);    //true
    }

    Instance of Array is not an arguments

    var myArray = [];
    TypeUtil.isArguments(myArray);          //false



    ### TypeUtil.isArray(value):boolean

    Determines if the given value is an array.

    Method

    /**
     * @static
     * @param {*} value 
     * @return {boolean} 
     */
    TypeUtil.isArray = function(value) {

    Parameters

    • value {*} - The value to check for the type of array

    Returns

    • {boolean} - Whether or not the value is an array.

    Examples

    Array literal is an array

    var myArray = [];
    TypeUtil.isArray(myArray);      //true

    Instance of Array is an array

    var myArray = new Array();
    TypeUtil.isArray(myArray);      //true

    Instance of Collection is NOT an array

    var myCollection = new Collection();
    TypeUtil.isArray(myCollection); //false

    number is NOT an array

    var myNumber = 123;
    TypeUtil.isArray(myNumber);     //false



    ### TypeUtil.isBoolean(value):boolean

    Determines if the given value is a boolean.

    Method

    /**
     * @static
     * @param {*} value 
     * @return {boolean} 
     */
    TypeUtil.isBoolean = function(value) {

    Parameters

    • value {*} - The value to check for the type of boolean

    Returns

    • {boolean} - Whether or not the value is a boolean.

    Examples

    Boolean literal true is a boolean

    var myTrueBoolean = true;
    TypeUtil.isBoolean(myTrueBoolean);      //true

    Boolean literal false is a boolean

    var myFalseBoolean = false;
    TypeUtil.isBoolean(myFalseBoolean);     //true

    Instance of a true Boolean is a boolean

    var myTrueBoolean = new Boolean(true);
    TypeUtil.isBoolean(myTrueBoolean);      //true

    Instance of a true Boolean is a boolean

    var myFalseBoolean = new Boolean(false);
    TypeUtil.isBoolean(myFalseBoolean);      //true

    the number 0 is NOT a boolean

    var myNumber =  0;
    TypeUtil.isBoolean(myNumber);           //false




    UuidGenerator

    TODO


    WeightedRandomizer

    TODO


    ValidationMachine

    TODO


    Validator

    TODO


    ValidatorGroup

    TODO


    ValidatorProcessor

    TODO

    Install

    npm i bugcore

    DownloadsWeekly Downloads

    16

    Version

    0.3.27

    License

    none

    Last publish

    Collaborators

    • brianneisler
    • airbug