@function getModel

get model by name. throws error if model not defined.

@param {string} name

@returns {object}

@throws {Error}
349994
function getModel (name) {
    // get global models register
    var models = getGlobal().models
    // require model to be defined
    assert(defined(models[name]), `${name} not defined`)
    // return model
    return models[name]
}
649191
def get_model(model):
    
    try:
        if isinstance(model, str):
            app_label, model_name = model.split('.', 1)
            m = loading.get_model(app_label, model_name)
            if not m:  # pragma: no cover
                raise LookupError()  # Django < 1.7 just returns None
            return m
        elif issubclass(model, models.Model):
            return model
    except (LookupError, ValueError):
        pass
    raise ValueError(model)
166515
function (connectionName, collectionName, obj, cb) {
        if (_.isObject(obj)) {
            try {
                var modelInstance = new this._model(obj);
                return cb(null, modelInstance);
            }
            catch (err) {
                return cb(err, null);
            }
        }
    }
1296894
def find_model_by_table_name(name):
    """"""

    for model in ModelBase._decl_class_registry.values():
        if hasattr(model, '__table__') and model.__table__.fullname == name:
            return model
    return None
857736
function getModel(req, res, next, model) {
		var fullModel = Rhapsody.requireModel(model, true);

		if(!fullModel) {
			Rhapsody.log.verbose('Nonexistent model', 'Couldn\'t find collection %s.', model);
			return responseUtils.respond(res, 400); //Malformed syntax or a bad query
		}

		//This model does not allow REST API
		if(!fullModel.options.allowREST) {
			return responseUtils.respond(res, 404);
		}

		req.fullModel = fullModel;

		next();
	}
910538
function(name) {
			var args = [].slice.call(arguments, 1);
			var factory = this.get(name);
			return factory ? factory.apply(this, args) : null;
		}
1300929
function(err, model) {
                    if (err) {
                        return _fn(err);
                    }
                    if (!model) {
                        return _fn('No model (' + name + ') returned from `adapter.registerModel`');
                    }
                    mycro.models[name] = model;
                    _fn();
                }
1250115
function(elemName) {
      var t = this;
      if (t.isBackbone) {
        return t.model instanceof Backbone.Collection ? t.model.at(elemName) : t.model.get(elemName);
      }
      return t.model[elemName];
    }
226320
private function findModel($model_name, $id = null)
    {
        $model = config('kregel.warden.models.'.$model_name.'.model');
        if (empty($model)) {
            throw new \Exception('There is no model by the name {'.$model_name.'}');
        }
        if (empty($id) | !is_numeric($id)) {
            return new $model();
        }

        return $model::findOrFail($id);
    }
16288
function (query, indexName) {
        var model = this.collection.get(query, indexName);
        if (model && includes(this.models, model)) return model;
    }
538844
function getOrCreateModel(name) {
  var app = this;

  if(!app._models.hasOwnProperty(name)) {
    app._models[name] = model(name);
  }

  return app._models[name];
}
971003
function(name) {
			var val = this.get(name);
			if (typeof val === 'undefined' || val === null || val === '')  {
				return null;
			}

			val = val.split(',').map(utils.trim);
			if (!val.length) {
				return null;
			}
			
			return val;
		}
1031006
function getConfigElement(name) {
    checkIsString('name', name);
    if (config.has(name)) {
        return config.get(name);
    }
}
831921
@Override
    protected ModelService getModelService(String serviceName){
        ModelService service = getCache().get(serviceName);
        if (service == null) {
            getCache().putIfAbsent(serviceName,super.getModelService(serviceName));
            service = getCache().get(serviceName);
        }
        return service;
    }
387029
def get_model(app_label, model_name):
    
    try:
        return apps.get_model(app_label, model_name)
    except AppRegistryNotReady:
        if apps.apps_ready and not apps.models_ready:
            # If the models module of the considered app has not been loaded yet,
            # we try to import it manually in order to retrieve the model class.
            # This trick is usefull in order to get the model class during the
            # ``apps.populate()`` call and the execution of related methods of AppConfig
            # instances (eg. ``ready``).

            # Firts, the config of the consideration must be retrieved
            app_config = apps.get_app_config(app_label)
            # Then the models module is manually imported
            import_module('%s.%s' % (app_config.name, MODELS_MODULE_NAME))
            # Finally, tries to return the registered model class
            return apps.get_registered_model(app_label, model_name)
        else:
            raise
544462
def model_get(method_name):
    

    def model_get(_value, context, **_params):
        method = getattr(context["model"], method_name)
        return _get(method, context["key"], (), {})

    return model_get
1079230
public function getModel(string $name = '')
    {
        if (empty($name)) {
            $name = $this->getComponentsName();
        }

        // Create a model instance from a different app?
        $model = $this->MVCFactory($name, 'Model');

        return $model;
    }