model-admin.js

require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
var process=require("__browserify_process");if (!process.EventEmitter) process.EventEmitter = function () {};

var EventEmitter = exports.EventEmitter = process.EventEmitter;
var isArray = typeof Array.isArray === 'function'
    ? Array.isArray
    : function (xs) {
        return Object.prototype.toString.call(xs) === '[object Array]'
    }
;
function indexOf (xs, x) {
    if (xs.indexOf) return xs.indexOf(x);
    for (var i = 0; i < xs.length; i++) {
        if (x === xs[i]) return i;
    }
    return -1;
}

// By default EventEmitters will print a warning if more than
// 10 listeners are added to it. This is a useful default which
// helps finding memory leaks.
//
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
var defaultMaxListeners = 10;
EventEmitter.prototype.setMaxListeners = function(n) {
  if (!this._events) this._events = {};
  this._events.maxListeners = n;
};


EventEmitter.prototype.emit = function(type) {
  // If there is no 'error' event listener then throw.
  if (type === 'error') {
    if (!this._events || !this._events.error ||
        (isArray(this._events.error) && !this._events.error.length))
    {
      if (arguments[1] instanceof Error) {
        throw arguments[1]; // Unhandled 'error' event
      } else {
        throw new Error("Uncaught, unspecified 'error' event.");
      }
      return false;
    }
  }

  if (!this._events) return false;
  var handler = this._events[type];
  if (!handler) return false;

  if (typeof handler == 'function') {
    switch (arguments.length) {
      // fast cases
      case 1:
        handler.call(this);
        break;
      case 2:
        handler.call(this, arguments[1]);
        break;
      case 3:
        handler.call(this, arguments[1], arguments[2]);
        break;
      // slower
      default:
        var args = Array.prototype.slice.call(arguments, 1);
        handler.apply(this, args);
    }
    return true;

  } else if (isArray(handler)) {
    var args = Array.prototype.slice.call(arguments, 1);

    var listeners = handler.slice();
    for (var i = 0, l = listeners.length; i < l; i++) {
      listeners[i].apply(this, args);
    }
    return true;

  } else {
    return false;
  }
};

// EventEmitter is defined in src/node_events.cc
// EventEmitter.prototype.emit() is also defined there.
EventEmitter.prototype.addListener = function(type, listener) {
  if ('function' !== typeof listener) {
    throw new Error('addListener only takes instances of Function');
  }

  if (!this._events) this._events = {};

  // To avoid recursion in the case that type == "newListeners"! Before
  // adding it to the listeners, first emit "newListeners".
  this.emit('newListener', type, listener);

  if (!this._events[type]) {
    // Optimize the case of one listener. Don't need the extra array object.
    this._events[type] = listener;
  } else if (isArray(this._events[type])) {

    // Check for listener leak
    if (!this._events[type].warned) {
      var m;
      if (this._events.maxListeners !== undefined) {
        m = this._events.maxListeners;
      } else {
        m = defaultMaxListeners;
      }

      if (m && m > 0 && this._events[type].length > m) {
        this._events[type].warned = true;
        console.error('(node) warning: possible EventEmitter memory ' +
                      'leak detected. %d listeners added. ' +
                      'Use emitter.setMaxListeners() to increase limit.',
                      this._events[type].length);
        console.trace();
      }
    }

    // If we've already got an array, just append.
    this._events[type].push(listener);
  } else {
    // Adding the second element, need to change to array.
    this._events[type] = [this._events[type], listener];
  }

  return this;
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.once = function(type, listener) {
  var self = this;
  self.on(type, function g() {
    self.removeListener(type, g);
    listener.apply(this, arguments);
  });

  return this;
};

EventEmitter.prototype.removeListener = function(type, listener) {
  if ('function' !== typeof listener) {
    throw new Error('removeListener only takes instances of Function');
  }

  // does not use listeners(), so no side effect of creating _events[type]
  if (!this._events || !this._events[type]) return this;

  var list = this._events[type];

  if (isArray(list)) {
    var i = indexOf(list, listener);
    if (i < 0) return this;
    list.splice(i, 1);
    if (list.length == 0)
      delete this._events[type];
  } else if (this._events[type] === listener) {
    delete this._events[type];
  }

  return this;
};

EventEmitter.prototype.removeAllListeners = function(type) {
  if (arguments.length === 0) {
    this._events = {};
    return this;
  }

  // does not use listeners(), so no side effect of creating _events[type]
  if (type && this._events && this._events[type]) this._events[type] = null;
  return this;
};

EventEmitter.prototype.listeners = function(type) {
  if (!this._events) this._events = {};
  if (!this._events[type]) this._events[type] = [];
  if (!isArray(this._events[type])) {
    this._events[type] = [this._events[type]];
  }
  return this._events[type];
};

EventEmitter.listenerCount = function(emitter, type) {
  var ret;
  if (!emitter._events || !emitter._events[type])
    ret = 0;
  else if (typeof emitter._events[type] === 'function')
    ret = 1;
  else
    ret = emitter._events[type].length;
  return ret;
};

},{"__browserify_process":4}],"./lib/ServerAdminEvents.js":[function(require,module,exports){
module.exports=require('WHy8x9');
},{}],3:[function(require,module,exports){
var events = require('events');

exports.isArray = isArray;
exports.isDate = function(obj){return Object.prototype.toString.call(obj) === '[object Date]'};
exports.isRegExp = function(obj){return Object.prototype.toString.call(obj) === '[object RegExp]'};


exports.print = function () {};
exports.puts = function () {};
exports.debug = function() {};

exports.inspect = function(obj, showHidden, depth, colors) {
  var seen = [];

  var stylize = function(str, styleType) {
    // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
    var styles =
        { 'bold' : [1, 22],
          'italic' : [3, 23],
          'underline' : [4, 24],
          'inverse' : [7, 27],
          'white' : [37, 39],
          'grey' : [90, 39],
          'black' : [30, 39],
          'blue' : [34, 39],
          'cyan' : [36, 39],
          'green' : [32, 39],
          'magenta' : [35, 39],
          'red' : [31, 39],
          'yellow' : [33, 39] };

    var style =
        { 'special': 'cyan',
          'number': 'blue',
          'boolean': 'yellow',
          'undefined': 'grey',
          'null': 'bold',
          'string': 'green',
          'date': 'magenta',
          // "name": intentionally not styling
          'regexp': 'red' }[styleType];

    if (style) {
      return '\u001b[' + styles[style][0] + 'm' + str +
             '\u001b[' + styles[style][1] + 'm';
    } else {
      return str;
    }
  };
  if (! colors) {
    stylize = function(str, styleType) { return str; };
  }

  function format(value, recurseTimes) {
    // Provide a hook for user-specified inspect functions.
    // Check that value is an object with an inspect function on it
    if (value && typeof value.inspect === 'function' &&
        // Filter out the util module, it's inspect function is special
        value !== exports &&
        // Also filter out any prototype objects using the circular check.
        !(value.constructor && value.constructor.prototype === value)) {
      return value.inspect(recurseTimes);
    }

    // Primitive types cannot have properties
    switch (typeof value) {
      case 'undefined':
        return stylize('undefined', 'undefined');

      case 'string':
        var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                                                 .replace(/'/g, "\\'")
                                                 .replace(/\\"/g, '"') + '\'';
        return stylize(simple, 'string');

      case 'number':
        return stylize('' + value, 'number');

      case 'boolean':
        return stylize('' + value, 'boolean');
    }
    // For some reason typeof null is "object", so special case here.
    if (value === null) {
      return stylize('null', 'null');
    }

    // Look up the keys of the object.
    var visible_keys = Object_keys(value);
    var keys = showHidden ? Object_getOwnPropertyNames(value) : visible_keys;

    // Functions without properties can be shortcutted.
    if (typeof value === 'function' && keys.length === 0) {
      if (isRegExp(value)) {
        return stylize('' + value, 'regexp');
      } else {
        var name = value.name ? ': ' + value.name : '';
        return stylize('[Function' + name + ']', 'special');
      }
    }

    // Dates without properties can be shortcutted
    if (isDate(value) && keys.length === 0) {
      return stylize(value.toUTCString(), 'date');
    }

    var base, type, braces;
    // Determine the object type
    if (isArray(value)) {
      type = 'Array';
      braces = ['[', ']'];
    } else {
      type = 'Object';
      braces = ['{', '}'];
    }

    // Make functions say that they are functions
    if (typeof value === 'function') {
      var n = value.name ? ': ' + value.name : '';
      base = (isRegExp(value)) ? ' ' + value : ' [Function' + n + ']';
    } else {
      base = '';
    }

    // Make dates with properties first say the date
    if (isDate(value)) {
      base = ' ' + value.toUTCString();
    }

    if (keys.length === 0) {
      return braces[0] + base + braces[1];
    }

    if (recurseTimes < 0) {
      if (isRegExp(value)) {
        return stylize('' + value, 'regexp');
      } else {
        return stylize('[Object]', 'special');
      }
    }

    seen.push(value);

    var output = keys.map(function(key) {
      var name, str;
      if (value.__lookupGetter__) {
        if (value.__lookupGetter__(key)) {
          if (value.__lookupSetter__(key)) {
            str = stylize('[Getter/Setter]', 'special');
          } else {
            str = stylize('[Getter]', 'special');
          }
        } else {
          if (value.__lookupSetter__(key)) {
            str = stylize('[Setter]', 'special');
          }
        }
      }
      if (visible_keys.indexOf(key) < 0) {
        name = '[' + key + ']';
      }
      if (!str) {
        if (seen.indexOf(value[key]) < 0) {
          if (recurseTimes === null) {
            str = format(value[key]);
          } else {
            str = format(value[key], recurseTimes - 1);
          }
          if (str.indexOf('\n') > -1) {
            if (isArray(value)) {
              str = str.split('\n').map(function(line) {
                return '  ' + line;
              }).join('\n').substr(2);
            } else {
              str = '\n' + str.split('\n').map(function(line) {
                return '   ' + line;
              }).join('\n');
            }
          }
        } else {
          str = stylize('[Circular]', 'special');
        }
      }
      if (typeof name === 'undefined') {
        if (type === 'Array' && key.match(/^\d+$/)) {
          return str;
        }
        name = JSON.stringify('' + key);
        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
          name = name.substr(1, name.length - 2);
          name = stylize(name, 'name');
        } else {
          name = name.replace(/'/g, "\\'")
                     .replace(/\\"/g, '"')
                     .replace(/(^"|"$)/g, "'");
          name = stylize(name, 'string');
        }
      }

      return name + ': ' + str;
    });

    seen.pop();

    var numLinesEst = 0;
    var length = output.reduce(function(prev, cur) {
      numLinesEst++;
      if (cur.indexOf('\n') >= 0) numLinesEst++;
      return prev + cur.length + 1;
    }, 0);

    if (length > 50) {
      output = braces[0] +
               (base === '' ? '' : base + '\n ') +
               ' ' +
               output.join(',\n  ') +
               ' ' +
               braces[1];

    } else {
      output = braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
    }

    return output;
  }
  return format(obj, (typeof depth === 'undefined' ? 2 : depth));
};


function isArray(ar) {
  return Array.isArray(ar) ||
         (typeof ar === 'object' && Object.prototype.toString.call(ar) === '[object Array]');
}


function isRegExp(re) {
  typeof re === 'object' && Object.prototype.toString.call(re) === '[object RegExp]';
}


function isDate(d) {
  return typeof d === 'object' && Object.prototype.toString.call(d) === '[object Date]';
}

function pad(n) {
  return n < 10 ? '0' + n.toString(10) : n.toString(10);
}

var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
              'Oct', 'Nov', 'Dec'];

// 26 Feb 16:19:34
function timestamp() {
  var d = new Date();
  var time = [pad(d.getHours()),
              pad(d.getMinutes()),
              pad(d.getSeconds())].join(':');
  return [d.getDate(), months[d.getMonth()], time].join(' ');
}

exports.log = function (msg) {};

exports.pump = null;

var Object_keys = Object.keys || function (obj) {
    var res = [];
    for (var key in obj) res.push(key);
    return res;
};

var Object_getOwnPropertyNames = Object.getOwnPropertyNames || function (obj) {
    var res = [];
    for (var key in obj) {
        if (Object.hasOwnProperty.call(obj, key)) res.push(key);
    }
    return res;
};

var Object_create = Object.create || function (prototype, properties) {
    // from es5-shim
    var object;
    if (prototype === null) {
        object = { '__proto__' : null };
    }
    else {
        if (typeof prototype !== 'object') {
            throw new TypeError(
                'typeof prototype[' + (typeof prototype) + '] != \'object\''
            );
        }
        var Type = function () {};
        Type.prototype = prototype;
        object = new Type();
        object.__proto__ = prototype;
    }
    if (typeof properties !== 'undefined' && Object.defineProperties) {
        Object.defineProperties(object, properties);
    }
    return object;
};

exports.inherits = function(ctor, superCtor) {
  ctor.super_ = superCtor;
  ctor.prototype = Object_create(superCtor.prototype, {
    constructor: {
      value: ctor,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
};

var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
  if (typeof f !== 'string') {
    var objects = [];
    for (var i = 0; i < arguments.length; i++) {
      objects.push(exports.inspect(arguments[i]));
    }
    return objects.join(' ');
  }

  var i = 1;
  var args = arguments;
  var len = args.length;
  var str = String(f).replace(formatRegExp, function(x) {
    if (x === '%%') return '%';
    if (i >= len) return x;
    switch (x) {
      case '%s': return String(args[i++]);
      case '%d': return Number(args[i++]);
      case '%j': return JSON.stringify(args[i++]);
      default:
        return x;
    }
  });
  for(var x = args[i]; i < len; x = args[++i]){
    if (x === null || typeof x !== 'object') {
      str += ' ' + x;
    } else {
      str += ' ' + exports.inspect(x);
    }
  }
  return str;
};

},{"events":1}],4:[function(require,module,exports){
// shim for using process in browser

var process = module.exports = {};

process.nextTick = (function () {
    var canSetImmediate = typeof window !== 'undefined'
    && window.setImmediate;
    var canPost = typeof window !== 'undefined'
    && window.postMessage && window.addEventListener
    ;

    if (canSetImmediate) {
        return function (f) { return window.setImmediate(f) };
    }

    if (canPost) {
        var queue = [];
        window.addEventListener('message', function (ev) {
            if (ev.source === window && ev.data === 'process-tick') {
                ev.stopPropagation();
                if (queue.length > 0) {
                    var fn = queue.shift();
                    fn();
                }
            }
        }, true);

        return function nextTick(fn) {
            queue.push(fn);
            window.postMessage('process-tick', '*');
        };
    }

    return function nextTick(fn) {
        setTimeout(fn, 0);
    };
})();

process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];

process.binding = function (name) {
    throw new Error('process.binding is not supported');
}

// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};

},{}],5:[function(require,module,exports){

},{}],6:[function(require,module,exports){
var Attribute = function (owner, attribute, type) {
    this.owner = owner;
    this.attribute = attribute;
    this.type = type;
};

module.exports = Attribute;

},{}],"hqu3+/":[function(require,module,exports){
var Historian = function () {
    var history = [];
    var idTracker = 0;

    this.getHistoryPool = function() {
        return historyPool;
    };

    this.generateId = function () {
        idTracker = idTracker + 1;
    };
};

Historian.prototype.recordHistory = function (historyObject) {
    var pool = this.getHistoryPool();

    var newId = generateId();
    historyObject.id = newId;
    pool.push(historyObject);
};

module.exports = Historian;

},{}],"zklePh":[function(require,module,exports){
var ModelAdminEvents = require("./ModelAdminEvents");

var HistoryInterpreter = function (modelAdmin) {
    var admin = modelAdmin;

    this.getAdmin = function () {
        return admin;
    };
};

var recreateHistory = function (historyObject) {
    //var admin = this.getAdmin();
    //var eventName = historyObject.eventName;
    //var eventParams = historyObject.eventParams;
    //var modelObject;

    //Create history depending on the case
    //if (eventName === ModelAdminEvents.MODEL_CREATED) {
        //admin.createModel(eventParams.modelName);
    //} else if (eventName === ModelAdminEvents.MODEL_DELETED) {
        //admin.deleteModel(eventParams.modelName);
    //} else if (eventName === ModelObjectEvents.ATTRIBUTE_ADDED) {
        ////resolve conflicts later on
        //modelObject = admin.getModel(eventParams.modelName);
        //modelObject.addAttribute(eventParms.attribute, eventParams.type);
    //} else if (eventName === ModelObjectEvents.ATTRIBUTE_REMOVED) {
        ////resolve conflicts later on
        //modelObject = admin.getModel(eventParams.modelName);
        //modelObject.removeAttribute(eventParms.attribute);
    //} else if (eventName === ModelObjectEvents.RELATIONSHIP_ADDED) {
        ////resolve conflicts later on
        //modelObject = admin.getModel(eventParams.modelName);
        //modelObject.addRelationship(eventParams.model, eventParams.type);
    //} else if (eventName === ModelObjectEvents.RELATIONSHIP_REMOVED) {
        ////resolve conflicts later on
        //modelObject = admin.getModel(eventParams.modelName);
        //modelObject.removeRelationship(eventParms.model);
    //} else {
        //throw new Error ("Unknown event!");
    //}
};

module.exports = HistoryInterpreter;

},{"./ModelAdminEvents":"AuZHws"}],"juKjgH":[function(require,module,exports){
var HistoryWriter = function () {
};

HistoryWriter.prototype.writeHistory = function (actor, evt, params) {
    var historyObject = {};

    historyObject.actor = actor;
    historyObject.eventName = evt;
    historyObject.eventParams = params;

    return historyObject;
};

module.exports = HistoryWriter;

},{}],"dM8Aoc":[function(require,module,exports){
var ModelObject = require ('./ModelObject');
var ModelAdminEvents = require ('./ModelAdminEvents');
var util = require("util");
var events = require("events");

var ModelAdmin = function (adminId) {
    var id = adminId;
    var modelPool = [];

    this.getHistorian = function () {

    };

    this.getModelPool = function () {
        return modelPool;
    };

    this.getId = function () {
        return id;
    };
};

util.inherits(ModelAdmin, events.EventEmitter);

ModelAdmin.prototype.createModel = function (name) {
    var modelPool = this.getModelPool();

    //Check if the model name is already taken
    for (var i = 0; i < modelPool.length; i++) {
        if (modelPool[i].modelName === name) {
            throw new Error ("Model Name is already taken.");
        }
    }

	var newModel = new ModelObject (name);

    modelPool.push (newModel);
    this.emit(ModelAdminEvents.MODEL_CREATED, newModel);

    return newModel;
};

ModelAdmin.prototype.getModel = function (name) {
    var modelPool = this.getModelPool();

    for (var i = 0; i < modelPool.length; i++) {
        if (modelPool[i].modelName === name) {
            return modelPool[i];
        }
    }

    //throw error if nothing is found
    throw new Error("Model is non existent.");
};

ModelAdmin.prototype.deleteModel = function (name) {
    var modelPool = this.getModelPool();
    var succeeded = false;

    for (var i = 0; i < modelPool.length; i++) {
        if (modelPool[i].modelName === name) {
            modelObject = modelPool.splice(i,1)[0];
            succeeded = true;
        }
    }

    if (!succeeded) {
        throw new Error ("Model is non existent.");
    }

    this.emit(ModelAdminEvents.MODEL_DELETED, modelObject);
    return modelObject;
};

ModelAdmin.prototype.addAttribute = function (modelName, attribute, type) {
    var model = this.getModel(modelName);
    var attributeObj = model.addAttribute(attribute, type);
    this.emit(ModelAdminEvents.ATTRIBUTE_ADDED, attributeObj);
};

ModelAdmin.prototype.removeAttribute = function (modelName, attribute) {
    var model = this.getModel(modelName);
    var attributeObj = model.removeAttribute(attribute);
    this.emit(ModelAdminEvents.ATTRIBUTE_REMOVED, attributeObj);
};

ModelAdmin.prototype.addRelationship = function (modelName, withModel, type) {
    var model = this.getModel(modelName);
    var relationshipObj = model.addRelationship(withModel, type);
    this.emit(ModelAdminEvents.RELATIONSHIP_ADDED, relationshipObj);
};

ModelAdmin.prototype.removeRelationship = function (modelName, withModel) {
    var model = this.getModel(modelName);
    var relationshipObj = model.removeRelationship(withModel);
    this.emit(ModelAdminEvents.RELATIONSHIP_REMOVED, relationshipObj);
};

ModelAdmin.prototype.modelToJson = function () {
    var modelPool = this.getModelPool();
    var modelAdminJson = {};

    modelAdminJson.id = this.getId();
    modelAdminJson.models = [];

    for (var i = 0; i < modelPool.length; i++) {
        var model = modelPool[i];
        var modelEntry = {};

        modelEntry.name = model.modelName;
        modelEntry.attributes = [];
        modelEntry.relationships = [];

        //loop through the attributes
        var attributes = model.getAttributes();

        for (var j = 0; j < attributes.length; j++) {
            var attributeObj = attributes[j];
            var attributeEntry = {};
            attributeEntry[attributeObj.attribute] = attributeObj.type;

            modelEntry.attributes.push(attributeEntry);
        }

        //loop through relationships
        var relationships = model.getRelationships();

        for (var k = 0; k < relationships.length; k++) {
            var relationshipObj = relationships[k];
            var relationshipEntry = {};
            relationshipEntry[relationshipObj.withModel] = relationshipObj.type;

            modelEntry.relationships.push(relationshipEntry);
        }

        modelAdminJson.models.push(modelEntry);
    }

    modelAdminJson = JSON.stringify(modelAdminJson);

    return modelAdminJson;
};

module.exports = ModelAdmin;

},{"./ModelAdminEvents":"AuZHws","./ModelObject":12,"events":1,"util":3}],"AuZHws":[function(require,module,exports){
var ModelAdminEvents = {
    MODEL_CREATED : 'modelCreated',
    MODEL_DELETED : 'modelDeleted',
    ATTRIBUTE_ADDED: 'modelAtrributeAdded',
    ATTRIBUTE_REMOVED: 'modelAttributeRemoved',
    RELATIONSHIP_ADDED: 'modelRelationshipAdded',
    RELATIONSHIP_REMOVED: 'modelRelationshipRemoved'
};

module.exports = ModelAdminEvents;

},{}],12:[function(require,module,exports){
var Attribute = require ("./Attribute");
var Relationship = require ("./Relationship");
var util = require("util");

var ModelObject = function (modelName) {
    if (typeof modelName === 'undefined') {
        throw Error (new Error ('Model Name parameter required.'));
    }

    this.modelName = modelName;

    var attributes = [];
    var relationships = [];

    this.getAttributes = function () {
        return attributes;
    };

    this.getRelationships = function () {
        return relationships;
    };
};

ModelObject.prototype.addAttribute = function (attribute, type) {
    var attributeArr = this.getAttributes();

    //Check if attribute is taken
    for (var i = 0; i < attributeArr.length; i++) {
        if (attributeArr[i].attribute === attribute) {
            throw new Error("Attribute name already taken.");
        }
    }

    var newAttribute = new Attribute (this.modelName, attribute, type);
    attributeArr.push(newAttribute);
    return newAttribute;
};

ModelObject.prototype.removeAttribute = function(attribute) {
    var attributeArr = this.getAttributes();
    var succeeded = false;

    for (var i = 0; i < attributeArr.length; i++) {
        if (attributeArr[i].attribute === attribute) {
            attributeObject = attributeArr.splice(i, 1)[0];
            succeeded = true;
        }
    }

    if (!succeeded) {
        throw new Error("Attribute is non existent.");
    }

    return attributeObject;
};

ModelObject.prototype.addRelationship = function (withModel, type) {
    var relationshipArr = this.getRelationships();

    //Check if relatioship is taken
    for (var i = 0; i < relationshipArr.length; i++) {
        if (relationshipArr[i].withModel === withModel) {
            throw new Error("Relationship exists.");
        }
    }

    var newRelationship = new Relationship (this.modelName, withModel, type);
    relationshipArr.push(newRelationship);
    return newRelationship;
};

ModelObject.prototype.removeRelationship = function (withModel) {
    var relationshipArr = this.getRelationships();
    var relationshipObject;
    var succeeded = false;

    for (var i = 0; i < relationshipArr.length; i++) {
        if (relationshipArr[i].withModel === withModel) {
            relationshipObject = relationshipArr.splice(i, 1)[0];
            succeeded = true;
        }
    }

    if (!succeeded) {
        throw new Error("Relationship is non existent.");
    }

    return relationshipObject;
};

module.exports = ModelObject;

},{"./Attribute":6,"./Relationship":14,"util":3}],"./lib/Historian.js":[function(require,module,exports){
module.exports=require('hqu3+/');
},{}],14:[function(require,module,exports){
var Relationship = function (owner, withModel, type) {
    this.owner = owner;
    this.withModel = withModel;
    this.type = type;
};

module.exports = Relationship;

},{}],"./lib/HistoryInterpreter.js":[function(require,module,exports){
module.exports=require('zklePh');
},{}],"./lib/ModelAdmin.js":[function(require,module,exports){
module.exports=require('dM8Aoc');
},{}],"./lib/ModelAdminEvents.js":[function(require,module,exports){
module.exports=require('AuZHws');
},{}],"WHy8x9":[function(require,module,exports){
var ServerAdminEvents = {
    MODEL_CREATED : 'serverModelCreated',
    MODEL_DELETED : 'serverModelDeleted',
    ATTRIBUTE_ADDED : 'serverAttributeAdded',
    ATTRIBUTE_REMOVED : 'serverAttributeRemoved',
    RELATIONSHIP_ADDED : 'serverRelationshipAdded',
    RELATIONSHIP_REMOVED : 'serverRelationshipRemoved',
    SOCKET_CONNECTED : 'socketConnected'
};

module.exports = ServerAdminEvents;

},{}],"./lib/HistoryWriter.js":[function(require,module,exports){
module.exports=require('juKjgH');
},{}]},{},[5])
;