Unbind all binded calculators
@param undbindFrom
@return
968044
private CALC unbindAll(AbstractCalculator<CALC> undbindFrom) {
        // find root and first child
        AbstractCalculator root = undbindFrom.parentCalculator != null ? undbindFrom.parentCalculator : undbindFrom;
        AbstractCalculator child = root.childCalculator;
        while (root != null) {
            AbstractCalculator tmpParent = root.parentCalculator;
            if (tmpParent == null)
                break;
            else
                root = tmpParent;

            child = root.childCalculator;
        }

        // undbind all from root to last child
        while (child != null) {
            if (child.isUnbind == false)
                root.expression(child, false);

            child.isUnbind = true;
            child = child.childCalculator; // new unbind child
        }

        return (CALC) undbindFrom;
    }
1025085
def unbind(self, func, etype):
        '''
        
        '''
        i= self.event_funcs[etype].index(func)
        del self.event_funcs[etype][i]
418791
def unbind(cell1, transform, moduleDimensions):
  
  cell1Coords = np.unravel_index(cell1, moduleDimensions)
  transformCoords = np.unravel_index(transform, moduleDimensions)
  cell2Coords = [(t + c1) % m
                 for c1, t, m in itertools.izip(cell1Coords, transformCoords,
                                                moduleDimensions)]
  return np.ravel_multi_index(cell2Coords, moduleDimensions)
915926
public function unbindAllModels() {
        foreach ($this->getBindings() as $alias => $binding) {
            $this->unbindModel($alias);
        }
        return $this;
    }
391570
def _unbind(cls, boundname):
        

        try:
            fs = CPE2_3_FS(boundname)
        except:
            # CPE name is not formatted string
            try:
                uri = CPE2_3_URI(boundname)
            except:
                # CPE name is not URI but WFN
                return CPE2_3_WFN(boundname)
            else:
                return CPE2_3_WFN(uri.as_wfn())
        else:
            return CPE2_3_WFN(fs.as_wfn())
478572
def unbind(self):
        """"""
        for variable in self.variables:
            self.__unbind_variable(variable)
        for result in self.results:
            self.__unbind_result(result)
1159182
public static int[] unWrap(Integer... values) {
		if (null == values) {
			return null;
		}
		final int length = values.length;
		if (0 == length) {
			return new int[0];
		}

		final int[] array = new int[length];
		for (int i = 0; i < length; i++) {
			array[i] = values[i].intValue();
		}
		return array;
	}
1057992
@Override
    public void unbindJavaGlobal(List<String> names) {

        List<String> fullNames = new ArrayList<String>(names.size());
        for (String name : names) {
            fullNames.add(buildJavaGlobalName(name));
        }
        ejbJavaColonHelper.removeGlobalBindings(fullNames);
    }
304043
@Override
    protected <T> void unbind(LifecycleManager manager, Class<T> clazz, T object) throws ObjectNotAssociatedException {
        // cancel binding

        Binding binding = STORE.get(clazz);
        if (binding == null) {
            throw new ObjectNotAssociatedException();
        }
        if (!binding.containsKey(object)) {
            throw new ObjectNotAssociatedException();
        }
        binding.remove(object);

        // cancel tracking

        Tracking tracking = TRACK.get(manager);
        tracking.remove(clazz);
    }
1331710
function () {
        var keys = [],
            bindings = getBindings(this);
        for (var k in bindings) {
            if (bindings.hasOwnProperty(k)) {
                this.unbind(k);
            }
        }
    }
1370427
function removeBindings() {
      for (var i = 0; i < this._c.length; i++) {
        this.unbind(this._c[i].children);
      }
    }
1284369
function _unbindDragHandlers(_el) {
            if (!_el._katavorioDrag) return;
            if (prune || orphan) {
                _el._katavorioDrag.off(STOP, _pruneOrOrphan);
            }
            if (!prune && !orphan && revert) {
                _el._katavorioDrag.off(REVERT, _revalidate);
                _el._katavorioDrag.setRevert(null);
            }
        }
790461
def __unset_binding(self, dependency, service, reference):
        # type: (Any, Any, ServiceReference) -> None
        
        # Call the component back
        self.__safe_field_callback(
            dependency.get_field(),
            constants.IPOPO_CALLBACK_UNBIND_FIELD,
            service,
            reference,
        )

        self.safe_callback(constants.IPOPO_CALLBACK_UNBIND, service, reference)

        # Update the injected field
        setattr(self.instance, dependency.get_field(), dependency.get_value())

        # Unget the service
        self.bundle_context.unget_service(reference)
442237
def unbind
      if bound?
        configs.each_pair do |key, config|
          store[key] = config.get(receiver)
        end
        @receiver = nil
      end
      self
    end
630206
@Unbind
    public void unbindFactory(Factory factory) {
        try {
            lock.lock();
            InstanceDeclaration declaration = getDeclarationByFactory(factory);
            if (declaration != null) {
                LOGGER.info("Disposing instance created by");
                declaration.dispose();
                declarations.remove(declaration);
            }
        } finally {
            lock.unlock();
        }
    }
1005303
public <T extends AbstractCalculator> T bind(Class<T> clazz) {
        T childCalc = null;
        try {
            childCalc = clazz.newInstance();
        }
        catch (Exception e) {
            throw new CalculatorException(e);
        }

        if (childCalc instanceof AbstractCalculator) {
            // find last child from root
            AbstractCalculator<CALC> bParent = this;
            while (bParent != null) {
                if (bParent.childCalculator != null)
                    bParent = bParent.childCalculator;
                else
                    break;
            }

            ((AbstractCalculator) childCalc).parentCalculator = bParent;
            ((AbstractCalculator) childCalc).isBind = true;
            bParent.childCalculator = childCalc;
        }
        else {
            throw new CalculatorException("Use calculator which is type of AbstractCalculator", new IllegalArgumentException());
        }

        return childCalc;
    }
324643
public void unbind(ValidationObject validationObject)
    {
        Integer id = System.identityHashCode(validationObject);
    	m_unbinding.add(id);
        List<ProposedValue> proposedValues = new ArrayList<ProposedValue>();
    	ProxyObject proxyObject = getSession().getProxyObject(validationObject);
    	for (ProxyField proxyField: proxyObject.getFieldMap().values())
    	{
    		if (!proxyField.isDerived())
    		{
    			// Figure out if this property contains a list or a known object type
    			// we want to ignore those and only reset primitive objects (long, String etc)
    			Class<?> clazz = proxyField.getPropertyMetadata().getGetMethod().getReturnType();
       			if (clazz.isAssignableFrom(List.class))
    			{
    				continue;
    			}
       			if (getSession().getValidationEngine().getClassMetadata(clazz) != null)
    			{
    				continue;
    			}
    			RuleProxyField ruleProxyField = getRuleProxyField(proxyField);
    			if (ruleProxyField.isDifferent(proxyField.getInitialValue()))
    			{
    				ProposedValue pv = new ProposedValue(ruleProxyField,proxyField.getInitialValue());
    				proposedValues.add(pv);
    			}
    		}    		
    	}
        setValues(proposedValues);
        m_boundObjects.remove(id);
    	m_unbinding.remove(id);
        List<String> kill = new ArrayList<String>();
        for (Map.Entry<String, RuleContext> entry: m_ruleContextsMap.entrySet())
        {
        	if (entry.getValue().getValidationObject() == validationObject)
        	{
        		kill.add(entry.getKey());
        	}
        }

        for (String key: kill)
        {
        	RuleContext rc = m_ruleContextsMap.remove(key);
        	rc.reset();
        }
    }