Set the new value for the attribute separator.
        
        When the new value is assigned a new tree is generated.
504733
def attr_sep(self, new_sep: str) -> None:
        
        self._attr_sep = new_sep
        self._filters_tree = self._generate_filters_tree()
1291814
function(name, value, refresh) {
        this.root.setNodesProperty(name,value);
        if (refresh) {
            this.root.refresh();
        }
    }
542455
def set_value(obj, attrs, value, _copy=False):
    
    for attr in attrs:
        if _copy:
            value = copy(value)
        setattr(obj, attr, value)
1339041
def set_leaf_dist(self, attr_value, dist):
        
        assert self.attr_name
        assert self.tree.data.is_valid(self.attr_name, attr_value), \
            "Value %s is invalid for attribute %s." \
                % (attr_value, self.attr_name)
        if self.is_continuous_class:
            assert isinstance(dist, CDist)
            assert self.attr_name
            self._attr_value_cdist[self.attr_name][attr_value] = dist.copy()
#            self.n += dist.count
        else:
            assert isinstance(dist, DDist)
            # {attr_name:{attr_value:count}}
            self._attr_value_counts[self.attr_name][attr_value] += 1
            # {attr_name:total}
            self._attr_value_count_totals[self.attr_name] += 1
            # {attr_name:{attr_value:{class_value:count}}}
            for cls_value, cls_count in iteritems(dist.counts):
                self._attr_class_value_counts[self.attr_name][attr_value] \
                    [cls_value] += cls_count
1071536
public static void setPropertyValue( final Object root,
                                         final Object newValue,
                                         final String... properties ) {

        Object object = root;

        int index = 0;


        try {

            for ( String property : properties ) {


                Map<String, FieldAccess> fields = getFieldsFromObject( object );
                FieldAccess field = fields.get( property );


                if ( isDigits( property ) ) {
                    /* We can index numbers and names. */
                    object = idx ( object, StringScanner.parseInt(property) );

                } else {

                    if ( field == null ) {
                        die( Str.sputs(
                                        "We were unable to access property=", property,
                                        "\nThe properties passed were=", properties,
                                        "\nThe root object is =", root.getClass().getName(),
                                        "\nThe current object is =", object.getClass().getName()
                                )
                        );
                    }


                    if ( index == properties.length - 1 ) {
                        field.setValue( object, newValue );
                    } else {
                        object = field.getObject( object );
                    }
                }

                index++;
            }
        } catch (Exception ex) {
            Exceptions.requireNonNull(root, "Root cannot be null");
            handle(ex, "Unable to set property for root object", className(root),
                    "for property path", properties, "with new value", newValue,
                    "last object in the tree was",
                    className(object), "current property index", index);
        }

    }
178793
def set_attribute(self, name, value):
        """"""
        self.attribute_name = name
        self.attribute = value
939458
static void assign(ManyValueAttributeValue v1, AttributeValue v2) {
		if (v2 != null) {
			v1.setTopType(v2.getType());
		}
		if (v2 == null || !v2.isAssigned()) {
			v1.setMultipleValues(true);
		} else {
			assert v2.isAssigned();
			if (!v1.isAssigned()) {
				v1.setValue(v2);
			} else if (!v2.equals(v1)) {
				v1.setMultipleValues(true);
				if (!v1.isAssignableFrom(v2)) {
					if (!v2.isAssignableFrom(v1)) {
						v1.setInternalValue(null, AttributeType.OBJECT);
					} else {
						v1.setInternalValue(null, v2.getType());
					}
				}
			}
		}
	}
635604
public void setAttribute(Object key, Object value) {
		if (attributes == null) {
			attributes = new HashMap(5);
		}
		attributes.put(key, value);
	}
824290
function (attributes) {
                var attrBinding = this._attributesBinding;
                if (attrBinding) {
                    this.__json.setValue(attrBinding.inside, attrBinding.to, attributes);
                } else {
                    this._applyNewAttributes(attributes);
                }
            }
816987
void setAttr(String name, int flags)
    {

        if (null == m_attrs)
            m_attrs = new StringToIntTable();

        m_attrs.put(name, flags);
    }
1362103
private function updateAttribute($name, $value, $separator)
    {
        array_set($this->attribute, $name, implode($separator, $value));

        return $this;
    }
1226851
def setField(self, new_value):
        
        self.B = self.B._replace(val=new_value)
1037944
def _setter(self, obj, value):
        
        if isinstance(value, DynamicValue):  # execute lambda values.
            fvalue = value()

        else:
            fvalue = value

        self._validate(data=fvalue, owner=obj)

        if self._fset_ is not None:
            self._fset_(obj, fvalue)

        else:
            setattr(obj, self._attrname(), value)

        # notify obj about the new value.
        if isinstance(obj, Schema):
            obj._setvalue(self, fvalue)
415584
private void addAttribute(int list, TreeHtmlAttributeInfo attr, RemoveInfo removes)
    {
        ArrayList al = _lists[list];
        // if the array list is the empty list then we need to allocate a new array list
        if (al == empty) {
            al = new ArrayList();
            _lists[list] = al;
        }

        // check to see if this attribute is already inside the tree.
        int cnt = al.size();
        for (int i = 0; i < cnt; i++) {
            TreeHtmlAttributeInfo a = (TreeHtmlAttributeInfo) al.get(i);
            assert(a != null);
            if (a.getAttribute().equals(attr.getAttribute())) {
                removes.removes.add(a);
                if (!attr.isApplyToDescendents()) {
                    removes.scopeOverrides = true;
                }
                al.remove(a);
                break;
            }
        }

        // add this to the list
        al.add(attr);
    }
998577
public void renameNodesWithAttributeValue(String oldName, String newName, String attributeName, String attributeValue) {
		List<Node> nodes = getNodesFromTreeByName(oldName);
		Iterator i = nodes.iterator();
		while (i.hasNext()) {
			Node n = (Node) i.next();
			n.setName(newName);
		}
	}
958798
public final void setAttribute(@NonNull String newAttribute) {
        searcher.removeFacet(attribute).addFacet(newAttribute);
        updateRefinementWithNewName(newAttribute);
        attribute = newAttribute;
    }
234139
public void setAttr(String attr) {
		String[] list = attr.split(";");
		for (int i = 0; i < list.length; ++i) {
			String[] val = list[i].split("=");
			if (val.length != 2)
				return ;
			getElement().setAttribute(val[0].trim(), val[1].trim());
		}
	}