var factory = require("bauer-factory");

// returns type of given argument
var type = factory.type(arg);

factory.isNull(arg)
// same as
factory.type(arg) === "null"

factory.isDefined(arg)
// same as
factory.type(arg) !== "undefined"

factory.isUndefined(arg)
// same as
factory.type(arg) === "undefined"

factory.isDate(arg)
// same as
factory.type(arg) === "date"

factory.isError(arg)
// same as
factory.type(arg) === "error"

factory.isBoolean(arg)
// same as
factory.type(arg) === "boolean"

factory.isArray(arg)
// same as
factory.type(arg) === "array"

factory.isNumber(arg)
// same as
factory.type(arg) === "number"

factory.isString(arg)
// same as
factory.type(arg) === "string"

factory.isObject(arg)
// same as
factory.type(arg) === "object"

factory.isRegExp(arg)
// same as
factory.type(arg) === "regexp"

factory.isFunction(arg)
// same as
factory.type(arg) === "function"

factory.isArguments(arg)
// same as
factory.type(arg) === "arguments"

var func = factory.createMethod({
    0: function() {}, // executed if called with zero arguments
    s: function(s) {}, // executed if called with one string
    sf: function(s) {}, // executed if called with a string and a function
    _: function() {}, // executed if none of the above is matched
});

var func = factory.createMethod({
    o: function() {}, // executed if called with object
    a: function(s) {}, // executed if called with array or arguments
    sffb: function(s,f0,f1,b) {}, // executed if called with a string, two functions and a boolean
});

var func = factory.createMethod({
    5: { // executed if called with five arguments
        sssss: function() {}, // five strings
        assss: function() {}, // one array and four strings
    },
    1: function(arg) {}, // executed if called with one argument
});

var func = factory.createMethod({
    _: function() {},
});

var func = factory.createMethod({
    s: "return this.get(s)", // the given string can be refered as 's'
    ss: "return this.both(s0,s1)", // if it's two strings, just add the index
    f: "this.on('ready',f)", // easy to define aliases
});

var optimized = factory.createMethod({
    s: "return this.get(s)",
    ss: "return this.both(s0,s1)",
    f: "this.on('ready',f)",
},true); // tell factory.method that this function does not use any external var

var Bauer = factory.createClass({
 
    // requires 'events' and inherits EventEmitter from it
    // also accepts functions
    inherits: require("events").EventEmitter,
 
    // called when new Bauer() is executed
    // it can also be routed by factory.method if needed
    constructor: function() {
    },
 
    // methods are created by factory.method
    killTerrorists: {
    },
 
    tortureSuspects: {
    },
 
    doWhateverIsNecessary: function() {},
 
});

var jack = new Bauer();
 
jack.killTerrorists();
 
jack.tortureSuspects();
 
jack.doWhateverIsNecessary();

// accepts same arguments as .createClass
var jack = factory.createObject({
 
    // requires 'events' and inherits EventEmitter from it
    // also accepts functions
    inherits: require("events").EventEmitter,
 
    // called when new Bauer() is executed
    // it can also be routed by factory.method if needed
    constructor: function() {
    },
 
    // methods are created by factory.method
    killTerrorists: {
        s: function() {},
        n: function() {},
    },
 
    tortureSuspects: {
        1: function() {},
        2: function() {},
    },
 
    doWhateverIsNecessary: function() {},
 
});