Remove respective core element of handed scoped variable model

        :param ScopedVariableModel model: Scoped variable model which core element should be removed
        :return:
505759
def remove_core_element(self, model):
        
        assert model.scoped_variable.parent is self.model.state
        gui_helper_state_machine.delete_core_element_of_model(model)
1015127
private void restoreNestedVariables() {
	if (nestedVars != null) {
	    Iterator iter = nestedVars.iterator();
	    while (iter.hasNext()) {
		String varName = (String) iter.next();
		varName = findAlias(varName);
		Object obj = originalNestedVars.get(varName);
		if (obj != null) {
		    invokingJspCtxt.setAttribute(varName, obj);
		} else {
		    invokingJspCtxt.removeAttribute(varName, PAGE_SCOPE);
		}
	    }
	}
    }
39620
public boolean remove(final ServerPresentationModel pm) {
        boolean deleted = super.remove(pm);
        if (!deleted) {
            throw new IllegalStateException("Model " + pm + " not found on the server!");
        }
        deleteCommand(getCurrentResponse(), pm.getId());
        return deleted;
    }
589325
private void cascadeMarkedForDeletion()
    {
        List alreadyPrepared = new ArrayList();
        for(int i = 0; i < markedForDeletionList.size(); i++)
        {
            ObjectEnvelope mod = (ObjectEnvelope) markedForDeletionList.get(i);
            // if the object wasn't associated with another object, start cascade delete
            if(!isNewAssociatedObject(mod.getIdentity()))
            {
                cascadeDeleteFor(mod, alreadyPrepared);
                alreadyPrepared.clear();
            }
        }
        markedForDeletionList.clear();
    }
207620
@Override
	protected void removeVariablesSub(Variable[] ti) {
		int[] Ids = new int[ti.length];
		for (int i = 0; i < ti.length;i ++) 
		{
			if (ti[i] instanceof TimePoint) {
				Ids[i] = ((TimePoint)ti[i]).getID();
			}
		}
		//super.removeVariable(ti);
		tpDelete(Ids);
	}
1116654
def get_scoped_variable_m(self, data_port_id):
        
        for scoped_variable_m in self.scoped_variables:
            if scoped_variable_m.scoped_variable.data_port_id == data_port_id:
                return scoped_variable_m
        return None
288249
def relieve_model(self, model):
        
        self.__registered_models.remove(model)
        return super(ExtendedController, self).relieve_model(model)
907049
public void removeElementScoped(TreeElement elem, RemoveInfo removes)
    {
        assert(elem != null);

        // check to see if we can exist without processing this element.  If the element
        // didn't define any attribute then we can.  This is inforced in the addElement method.
        ArrayList attrs = elem.getAttributeList();
        if (attrs == null || attrs.size() == 0)
            return;

        // walk all of the lists and each list looking for attributes that
        // are scoped only to the element
        for (int i = 0; i < _lists.length; i++) {
            ArrayList al = _lists[i];
            assert(al != null);

            int cnt = al.size();
            for (int j = 0; j < cnt; j++) {
                TreeHtmlAttributeInfo attr = (TreeHtmlAttributeInfo) al.get(j);
                assert(attr != null);
                // Remove all of the attributes not scoped to the element itself.  We need to
                // update the indexes because this removes the current item..
                if (!attr.isApplyToDescendents()) {
                    al.remove(j);
                    cnt--;
                    j--;
                    if (removes != null && removes.scopeOverrides) {
                        TreeHtmlAttributeInfo addBack = checkScopeRemoval(i, attr, removes);
                        if (addBack != null) {
                            if (!al.contains(addBack))
                                al.add(addBack);
                        }
                    }
                }
            }
        }
    }
937286
def remove_core_element(self, model):
        
        assert model.data_flow.parent is self.model.state or model.data_flow.parent is self.model.parent.state
        gui_helper_state_machine.delete_core_element_of_model(model)
473148
function(model, options) {
            var index;

            if (_.isArray(model)) {
                _.each(model, function(m) {
                    this.remove(m, options);
                }, this);
                return this;
            }

            options = _.defaults(options || {}, {
                silent: false
            });

            model = this._prepareModel(model);

            _.each(this.models, function(m, i) {
                if (!m || model.id == m.id) {
                    this.models.splice(i, 1);
                    index = i;
                    return;
                }
            }, this);
            delete this._byId[model.id];

            if (options.silent) return this;
            options.index = index;
            if (this._totalCount != null) this._totalCount = _.max([0, this._totalCount - 1]);
            this.trigger('remove', model, this, options);
            this._removeReference(model);

            return this;
        }
1368261
public void pop(GraphicalModel model) {
            assert(model.factors.contains(addedFactor));
            model.factors.remove(addedFactor);
            model.getVariableMetaDataByReference(variable).remove(CliqueTree.VARIABLE_OBSERVED_VALUE);
        }
408540
function(model, options) {
      options || (options = {});
      model = this.getByCid(model) || this.get(model);
      if (!model) return null;
      delete this._byId[model.id];
      delete this._byCid[model.cid];
      this.models.splice(this.indexOf(model), 1);
      this.length--;
      if (!options.silent) model.trigger('remove', model, this, options);
      this._removeReference(model);
      return model;
    }
914219
def _load_scoped_variable_models(self):
        
        self.scoped_variables = []
        for scoped_variable in self.state.scoped_variables.values():
            self._add_model(self.scoped_variables, scoped_variable, ScopedVariableModel)
931472
@RequestMapping(value = "api/group/{groupId}/{overrideId}", method = RequestMethod.DELETE)
    public
    @ResponseBody
    String removeOverride(Model model, @PathVariable int overrideId) {
        pathOverrideService.removeOverride(overrideId);
        return null;
    }
135282
function(model) {
        var modelObj = model.changedAttributes();
        _.each(model.changed, function(value, key) {
          if (typeof value === 'undefined' || value === null) {
            if (key == 'id') {
              delete modelObj[key];
            } else {
              modelObj[key] = null;
            }
          }
        });

        return modelObj;
      }
1152648
def _get_future_expected_model(self, core_element):
        """"""
        for model in self.expected_future_models:
            if model.core_element is core_element:
                # print("expected_future_model found -> remove model:", model, [model], id(model))
                self.expected_future_models.remove(model)
                return model
        return None
76552
def remove_model(self, model, **kwargs):
        
        kwargs['model'] = model
        kwargs['context'] = 'model'
        self.remove_parameters_all(**kwargs)