SagaModel constructor
@param {String} id The saga id.
@constructor
7122
function SagaModel (id) {
  if (!id || !_.isString(id)) {
    var err = new Error('No id injected!');
    debug(err);
    throw err;
  }

  this.attributes = {};

  this.id = id;

  this.destroyed = false;

  this.commandsToSend = [];

  this.actionOnCommit = 'create';
}
367210
public Object newInstanceWithId(final Object id)
	{
		try
		{
			final Object o = clazz.newInstance();

			idProperty.set(o, id);

			return o;
		}
		catch (Throwable e)
		{
			throw new RuntimeException("Cannot create new instance of " +
			                           clazz +
			                           " with ID " +
			                           id +
			                           " (of type " +
			                           id.getClass() +
			                           ") populated!", e);
		}
	}
195367
protected D createModelWithId(Object id, T entity) {
		return createModelWithId(id, entity, new Object[0]);
	}
408618
function (id) {
            this.cleanCache();

            // store id to identify changes during callback execution
            if (this._changed) {
                this._changed[id] = true;
            }

            if (this.__delegateMapping) {
                this.__delegateMapping[id].$dispose();
                delete this.__delegateMapping[id];
                this.__idMgr.releaseId(id);
            }
        }
473998
function (ID, events) {
        "use strict";
    
        Object.defineProperty(this, 'ID', {
            'get': function () {
                return ID;
            }
        });
    
        var library;
        (function (ID) {
    
            ID = ID.split('/');
            if (ID[0] === 'libraries') {
                library = beyond.libraries.get(ID[1]);
            }
    
        })(ID);
        Object.defineProperty(this, 'library', {
            'get': function () {
                return library;
            }
        });
    
        var path = ID;
        if (library && path === library.path) {
            path = path + '/main';
        }
    
        path = path.split('/');
        if (library) {
            // Remove /libraries/library
            path.splice(0, 2);
        }
        else {
            // Remove /application
            path.splice(0, 1);
        }
    
        path = path.join('/');
    
        Object.defineProperty(this, 'path', {
            'get': function () {
                return path;
            }
        });
    
        var host;
        if (library) {
            host = beyond.hosts.libraries[library.name].js;
        }
        else {
            host = beyond.hosts.application.js;
        }
        host += path;
        Object.defineProperty(this, 'host', {
            'get': function () {
                return host;
            }
        });
    
        var plugins = new Plugins(this);
        Object.defineProperty(this, 'plugins', {
            'get': function () {
                return plugins;
            }
        });
    
        var texts = new Texts(this);
        Object.defineProperty(this, 'texts', {
            'get': function () {
                return texts;
            }
        });
    
        this.react = new ReactRegister(this, events);
    
        this.control = new Control(this);
    
        var dependencies = new Dependencies(this);
        this.dependencies = dependencies;
    
        this.Action = Action(this, events);
    
        this.invalidateCache = function (actionPath, params) {
    
            var request = new Request(this, actionPath, params);
            var cache = new Cache();
    
            return cache.invalidate(request);
    
        };
    
        this.execute = function () {
    
            var args = [].slice.call(arguments);
    
            // options must be after callback
            var actionPath, params, callback, options;
    
            for (var i in args) {
    
                var arg = args[i];
                switch (typeof arg) {
                    case 'string':
                        actionPath = arg;
                        break;
                    case 'function':
                        callback = arg;
                        break;
                    case 'object':
                        if (callback) options = arg;
                        else params = arg;
                }
    
            }
    
            if (typeof params === 'function' && typeof callback === 'undefined') {
                callback = params;
                params = undefined;
            }
    
            var action = new this.Action(actionPath, params);
            action.onResponse = function (response) {
                if (callback) callback(response);
            };
            action.onError = function (error) {
                if (callback) callback(undefined, error);
            };
            action.execute();
    
        };
    
        var styles = new ModuleStyles(this);
        Object.defineProperty(this, 'styles', {
            'get': function () {
                return styles;
            }
        });
    
        Object.defineProperty(this, 'css', {
            'get': function () {
                return styles;
            }
        });
    
        var templates = new ModuleTemplates(this);
        Object.defineProperty(this, 'templates', {
            'get': function () {
                return templates;
            }
        });
    
        this.render = function (path, params) {
            return templates.render(path, params);
        };
    
        Object.defineProperty(this, 'custom', {
            'get': function () {
    
                if (!library) {
                    return;
                }
    
                var custom = 'application/custom/' + library.name + '/' + this.path;
                return custom;
    
            }
        });
    
        this.socket = function (callback) {
    
            if (this.ID.substr(0, 10) === 'libraries/') {
    
                if (!library.socket) {
                    console.error('library does not support server communication', library.name);
                    return;
                }
                library.socket(function (socket) {
                    callback(socket);
                });
    
            }
            else {
    
                beyond.socket(function (socket) {
                    callback(socket);
                });
    
            }
    
        };
    
        var ready;
        Object.defineProperty(this, 'ready', {
            'get': function () {
                return !!ready;
            }
        });
    
        var callbacks = [];
        this.done = function (callback) {
    
            if (ready) {
                callback(dependencies.modules);
                return;
            }
    
            callbacks.push(callback);
    
        };
    
        this.dependencies.done(function () {
    
            ready = true;
    
            for (var i in callbacks) {
                callbacks[i](dependencies.modules);
            }
            callbacks = undefined;
    
        });
    
    }
562600
public static Timeout create(final TimeoutId id, final String sagaId, final String name, final Date expiredAt, final Object data) {
        Timeout timeout = new Timeout();
        timeout.id = id;
        timeout.sagaId = sagaId;
        timeout.expiredAt = expiredAt;
        timeout.name = name;
        timeout.data = data;

        return timeout;
    }
262367
function ( id ) {
		if ( id === undefined || string.isEmpty( id ) ) {
			throw new Error( label.error.invalidArguments );
		}

		// deferred
		if ( utility.timer[id] !== undefined ) {
			clearTimeout( utility.timer[id] );
			delete utility.timer[id];
		}

		// repeating
		if ( utility.repeating[id] !== undefined ) {
			clearTimeout( utility.repeating[id] );
			delete utility.repeating[id];
		}
	}
1189909
function constructor(models, options) {
      if (!Array.isArray(models)) {
        options = models;
        models = [];
      }

      options = options || {};

      //
      // Set the database name if it was provided in the options.
      //
      if (options.url) this.url = options.url;
      if (options.database) this.database = options.database;

      //
      // Define restricted non-enumerated properties.
      //
      predefine(this, fossa);

      //
      // Call original Backbone Model constructor.
      //
      backbone.Collection.call(this, models, options);
    }
806282
function Store (state: ?any, id: ?string) {
  if (state === undefined || state === null) {
    state = {}
  }
  state = {
    state: state,
    computed: {},
    action: { type: null, payload: null }
  }

  /**
   * @private
   */

  /*
   * TODO: Document members
   */

  this._id = null
  if (id != null && isString(id)) {
    id = id.trim()
    if (id !== '') {
      this._id = id
    }
  }

  /**
   * Stream
   */
  this._stream = u.createStream(state)

  /**
   * Reducers
   */
  this._reducerRelations = null

  /**
   * Middlewares
   */
  this._middlewareRelations = null

  /**
   * Subscriptions
   */
  this._subscriptionRelations = null

  this._computedProperty = {}

  reducerRelation.constructParent(this)
  middlewareRelation.constructParent(this)
  subscriptionRelation.constructParent(this)
  computedPropertyRelation.constructParent(this)
}
796522
function Module(id, parent) {
  this.id = id
  this.parent = parent;
  if (parent && parent.children) {
    parent.children.push(this);
  }
  this.children = [];
  
  this.filename = null;
  this.format = undefined;
  this.loaded = false;
}
225477
function onIceCandidate(id,data)
    {
        if(scope.hasWebRTCSupport())
        {
            getOrCreatePeer(id).onServerMessage(JSON.parse(data));
        }
    }
778456
function (localId, bucketSize) {
    if (!(localId instanceof Id))
        throw new Error('id must be a valid identifier');
    this._bucketSize = bucketSize;
    this._root = new Bucket(bucketSize);
    Object.defineProperty(this, 'id', {value: localId});
}
885157
private static String buildMessage(final String id) {
        if (id == null) {
            return NULL_MESSAGE;
        }

        return format(INVALID_MSG_FMT, id);
    }
934460
function(id) {
            for (var i in this.ids) {
                if (this.ids[i][id]) {
                    return this.ids[i][id];
                }
            }
            return null;
        }
658488
function (id) {
    if (!id || !_.isString(id)) {
      var err = new Error('Please pass a valid string as id!');
      debug(err);
      throw err;
    }

    return new AggregateModel(id, this.modelInitValues);
  }
763800
public final function create($id) {
        $method = 'create'.ucfirst($id);
        if (method_exists($this, $method)) {
            return $this->$method();
        }
        throw new Garp_Browsebox_Exception('No initialization method for id "'.$id.'"');
    }
36056
public function setModelId($id)
    {
        if (is_array($id)) {
            $this->modelId = $id;
        } else {
            $this->modelId = [$id];
        }

        // rebuild the model instance with ID
        if ($this->model) {
            $model = (is_object($this->model)) ? get_class($this->model) : $this->model;

            $this->model = new $model($id);
        }

        return $this;
    }