Set the type of the given refobj

        :param refobj: the reftrack node to edit
        :type refobj: refobj
        :param typ: the entity type
        :type typ: str
        :returns: None
        :rtype: None
        :raises: ValueError
3990
def set_typ(self, refobj, typ):
        
        try:
            enum = JB_ReftrackNode.types.index(typ)
        except ValueError:
            raise ValueError("The given type %s could not be found in available types: %" % (typ, JB_ReftrackNode.types))
        cmds.setAttr("%s.type" % refobj, enum)
260103
def __set_binding(self, dependency, service, reference):
        # type: (Any, Any, ServiceReference) -> None
        
        # Set the value
        setattr(self.instance, dependency.get_field(), dependency.get_value())

        # Call the component back
        self.safe_callback(constants.IPOPO_CALLBACK_BIND, service, reference)

        self.__safe_field_callback(
            dependency.get_field(),
            constants.IPOPO_CALLBACK_BIND_FIELD,
            service,
            reference,
        )
1083858
def update(self, value: Union[RawValue, Value],
               raw: bool = False) -> "InstanceNode":
        
        newval = self.schema_node.from_raw(
            value, self.json_pointer()) if raw else value
        return self._copy(newval)
40366
protected void setMetaTypeService(ServiceReference<MetaTypeService> ref) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "setMetaTypeService", ref);
        metaTypeServiceRef.setReference(ref);
    }
961376
def set_process_ref(self, value):
        
        if not isinstance(value, str):
            raise TypeError("ProcessRef must be set to a String")
        self.__process_ref = value
344515
def set_flow_node_ref_list(self, value):
        
        if value is None or not isinstance(value, list):
            raise TypeError("FlowNodeRefList new value must be a list")
        else:
            for element in value:
                if not isinstance(element, str):
                    raise TypeError("FlowNodeRefList elements in variable must be of String class")
            self.__flow_node_ref_list = value
36872
def update_record(self, identifier, rtype=None, name=None, content=None, **kwargs):
        
        if not rtype and kwargs.get('type'):
            warnings.warn('Parameter "type" is deprecated, use "rtype" instead.',
                          DeprecationWarning)
            rtype = kwargs.get('type')

        return self._update_record(identifier, rtype=rtype, name=name, content=content)
1182002
def type(self, value):
        
        if value not in list(defines.Types.values()):
            raise AttributeError
        self._type = value
114054
def dbType(self, typ):
        
        return self.TypeMap.get(typ, self.TypeMap.get('Default'))
65644
@JRubyMethod(name = "type_id=")
    public static IRubyObject set_type_id(IRubyObject self, IRubyObject type_id) {
        org.yecht.Node node = (org.yecht.Node)self.dataGetStructChecked();
        if(!type_id.isNil()) {
            node.type_id = type_id.convertToString().toString();
        }
        ((RubyObject)self).fastSetInstanceVariable("@type_id", type_id);
        return type_id;
    }
957605
function(obj, type){
		if(!this.enabled){ return;}
		var relation = this.relation[type];
		if(!relation){ return;}

		this.modifyNodes = [];

		switch(relation){
			case 'node':      this.setEdgeByNodeObj(obj); break;
			case 'link':      this.setEdgeByLinkObj(obj); break;
			case 'separator': this.setEdgeBySeparator(obj); break;
			default:          this.modifyOtherInfo(obj,relation); break;
		}

		if(this.modifyNodes.length>0){ this.remakeComponent();}
	}
1139914
public void setType( AstNode node,
                         String type ) {
        CheckArg.isNotNull(node, "node");
        CheckArg.isNotNull(type, "parent");
        node.setProperty(JCR_MIXIN_TYPES, type);
    }
1268345
private Object refObj(Object obj, Element node) throws Exception {
		String id = getAttribute(node, "id");
		//CHECKSTYLE:OFF
		obj = _idMap.get(id);
		//CHECKSTYLE:ON
		if (obj == null) {
			throw new IllegalStateException("No object for id=" + id);
		}
		configure(obj, node, 0);
		return obj;
	}
88145
def type(self, newtype):
        """"""
        self._type = newtype
        if self.is_multi:
            for sibling in self.multi_rep.siblings:
                sibling._type = newtype
1044690
def type(self, type):
        
        if type is None:
            raise ValueError("Invalid value for `type`, must not be `None`")
        allowed_values = ["reservation", "reservation_release", "reservation_termination", "package_renewal", "package_creation", "package_termination"]
        if type not in allowed_values:
            raise ValueError(
                "Invalid value for `type` ({0}), must be one of {1}"
                .format(type, allowed_values)
            )

        self._type = type
603196
public void setRef(Coref v) {
    if (Coref_Type.featOkTst && ((Coref_Type)jcasType).casFeat_ref == null)
      jcasType.jcas.throwFeatMissing("ref", "de.julielab.jules.types.muc7.Coref");
    jcasType.ll_cas.ll_setRefValue(addr, ((Coref_Type)jcasType).casFeatCode_ref, jcasType.ll_cas.ll_getFSRef(v));}
388353
function setType(object, type) {
    Object.defineProperty(object, '_ethersType', { configurable: false, value: type, writable: false });
}