Sets children

        :param val: List of citation children
179679
def children(self, val: list):
        
        final_value = []
        if val is not None:
            for citation in val:
                if citation is None:
                    continue
                elif not isinstance(citation, (BaseCitation, type(self))):
                    raise TypeError("Citation children should be Citation")
                else:
                    if isinstance(self, BaseCitation):
                        citation.root = self.root
                    else:
                        citation.root = self
                    final_value.append(citation)

        self._children = final_value
1232798
def set_payload(self,val):
    
    self._options = self._options._replace(payload = val)
579424
def _setDatasets(self, metadata):
        """"""
        # Pull the lot into a list
        cols = list(self.getCSVReader(metadata))

        # sort the cols by view name and ordinal (they come sorted, but lets be sure)
        cols.sort(key=lambda x: [x['viewname'], int(x['ordinal'])])

        # Now group them by their viewname
        for key, grp in groupby(cols, key=lambda x: x["viewname"]):
            self.datasets[key] = list(grp)
638743
function setNestedValue(data, field, value) {
        var fieldParts = _.isArray(field) ? field : field.split('.');

        // if no nesting, just set the value
        if (fieldParts.length === 1) {
            data[field] = _.isString(value) ? value.trim() : value;
            return;
        }

        // make sure the parent value exists
        data[fieldParts[0]] = data[fieldParts[0]] || {};

        // recursively call to go down a level
        setNestedValue(data[fieldParts[0]], fieldParts.slice(1, fieldParts.length), value);
    }
616289
def setVal(self, name, val):
        
        if self._autoFixNames:
            name = self._fixName(name)
        self._fieldValDict[name] = val
1203831
def set_child_lane_set(self, value):
        
        if value is None:
            self.__child_lane_set = value
        elif not isinstance(value, lane_set.LaneSet):
            raise TypeError("ChildLaneSet must be a LaneSet")
        else:
            self.__child_lane_set = value
1102786
def add_child(self, u, v):
        ''' 
        '''

        if u == -1:
            self.root = v
            self.adj_list[v] = []
            return
        if v not in self.adj_list[u]:
            self.adj_list[u].append(v)
        if v not in self.adj_list:
            self.adj_list[v] = []
482233
def set_model(self, model):
        
        self._model = model
        for c in self.childItems:
            c.set_model(model)
416143
def children_types( record, index, key='refs', stop_types=STOP_TYPES ):
    """"""
    types = {}
    for child in children( record, index, key, stop_types=stop_types ):
        types.setdefault(child['type'],[]).append( child )
    return types
102367
def set_projection(self, val):
        
        knownproj = ["SIN", "ZEA", "TAN", "NCP", "AIT", "ZEA"]  # etc
        assert val.upper() in knownproj
        self._coord["projection"] = val.upper()
1354584
def set_nested(self, klist, value):
        """"""
        keys = list(klist)
        if len(keys) > 0:
            curr_dict = self
            last_key = keys.pop()
            for key in keys:
                if not curr_dict.has_key(key) or not isinstance(curr_dict[key], 
                                                                NestedDict):
                    curr_dict[key] = type(self)()
                curr_dict = curr_dict[key]
            curr_dict[last_key] = value
229907
def update_child_models(self, _, name, info):
        

        # Update is_start flag in child states if the start state has changed (eventually)
        if info.method_name in ['start_state_id', 'add_transition', 'remove_transition']:
            self.update_child_is_start()

        if info.method_name in ["add_transition", "remove_transition", "transitions"]:
            (model_list, data_list, model_name, model_class, model_key) = self._get_model_info("transition")
        elif info.method_name in ["add_data_flow", "remove_data_flow", "data_flows"]:
            (model_list, data_list, model_name, model_class, model_key) = self._get_model_info("data_flow")
        elif info.method_name in ["add_state", "remove_state", "states"]:
            (model_list, data_list, model_name, model_class, model_key) = self._get_model_info("state", info)
        elif info.method_name in ["add_scoped_variable", "remove_scoped_variable", "scoped_variables"]:
            (model_list, data_list, model_name, model_class, model_key) = self._get_model_info("scoped_variable")
        else:
            return

        if isinstance(info.result, Exception):
            # Do nothing if the observed function raised an exception
            pass
        elif "add" in info.method_name:
            self.add_missing_model(model_list, data_list, model_name, model_class, model_key)
        elif "remove" in info.method_name:
            destroy = info.kwargs.get('destroy', True)
            recursive = info.kwargs.get('recursive', True)
            self.remove_specific_model(model_list, info.result, model_key, recursive, destroy)
        elif info.method_name in ["transitions", "data_flows", "states", "scoped_variables"]:
            self.re_initiate_model_list(model_list, data_list, model_name, model_class, model_key)
520265
public void updateChildrenTypes(ModelNode address, List<ModelNode> modelNodes) {

        TreeItem  rootItem = findTreeItem(tree, address);
        addChildrenTypes((ModelTreeItem) rootItem, modelNodes);

    }
940178
def recurse(cls_or_slf, node, attrpath=None, attrpaths=[], siblings=[], level=0, value_dims=True):
        
        level, lines = cls_or_slf.node_info(node, attrpath, attrpaths, siblings, level, value_dims)
        attrpaths = ['.'.join(k) for k in node.keys()] if  hasattr(node, 'children') else []
        siblings = [node.get(child) for child in attrpaths]
        for attrpath in attrpaths:
            lines += cls_or_slf.recurse(node.get(attrpath), attrpath, attrpaths=attrpaths,
                                 siblings=siblings, level=level+1, value_dims=value_dims)
        return lines
712081
def set_val(self, nval):
        
        file_obj = file(os.path.join(self._base, self._attr), 'w')
        try:
            file_obj.write(str(nval) + '\n')
        finally:
            file_obj.close()
292726
def append(self, val):
        
        self.values.append(val)
        self.value = self.values[0]
753372
def duplicate_child_info(child_ref)
      @title ||= child_ref.title
      @type ||= child_ref.subset_operators
      @definition ||= child_ref.definition
      @status ||= child_ref.status
      @code_list_id ||= child_ref.code_list_id
      @temporal_references = child_ref.temporal_references if @temporal_references.empty?
      @subset_operators ||= child_ref.subset_operators
      @variable ||= child_ref.variable
      @value ||= child_ref.value
    end