Build the Values from the Definition.
962401
private void parseDefinition() {
        values = new ArrayList<DSLVariableValue>();
        if (getDefinition() == null) {
            return;
        }

        int variableStart = definition.indexOf("{");
        while (variableStart >= 0) {
            int variableEnd = getIndexForEndOfVariable(definition,
                                                       variableStart);
            String variable = definition.substring(variableStart + 1,
                                                   variableEnd);
            values.add(parseValue(variable));
            variableStart = definition.indexOf("{",
                                               variableEnd);
        }
    }
1235200
def build(self, **values: Any) -> str:
        """"""
        converted_values = {
            key: self._converters[key].to_url(value)
            for key, value in values.items()
            if key in self._converters
        }
        result = self._builder.format(**converted_values).split('|', 1)[1]
        query_string = urlencode(
            {
                key: value
                for key, value in values.items()
                if key not in self._converters and key not in self.defaults
            },
            doseq=True,
        )
        if query_string:
            result = "{}?{}".format(result, query_string)
        return result
1122520
def extend_values(dictionary, key, items):
    """"""
    values = dictionary.get(key, [])
    try:
        values.extend(items)
    except TypeError:
        raise TypeError('Expected a list, got: %r' % items)
    dictionary[key] = values
1217952
protected function buildDimensionValues()
    {
        $dimensionValues = [];
        foreach ($this->dimensions as $dimension) {
            /** @var NodeDimension $dimension */
            $dimensionValues[$dimension->getName()][] = $dimension->getValue();
        }
        $this->dimensionsHash = Utility::sortDimensionValueArrayAndReturnDimensionsHash($dimensionValues);
        $this->dimensionValues = $dimensionValues;
    }
1162536
def build_for_each(self, db, safe_mode=False, extra=None):
        """"""
        result = dict()
        for var, query in iteritems(self.for_each):
            result[var] = db.query(
                query,
                additional_locals=extra,
                safe_mode=safe_mode
            )
        return result
1069893
def build(self, builder):
        """"""

        params = dict(OID=self.oid, Name=self.name)
        if self.field_number is not None:
            params["FieldNumber"] = str(self.field_number)

        builder.start("mdsol:LabelDef", params)

        for translation in self.translations:
            translation.build(builder)

        for view_restriction in self.view_restrictions:
            view_restriction.build(builder)

        builder.end("mdsol:LabelDef")
783919
def from_definition(self, table: Table, version: int):
        """"""
        self.table(table)
        self.add_columns(*table.columns.get_with_version(version))
        return self
781648
public function build()
    {
        parent::build();

        $value = $this->validator->arrayGet($this->suppliedOptions, 'value', true);

        //we need to set the value to 'false' when it is falsey so it plays nicely with select2
        if (!$value && $value !== '') {
            $this->suppliedOptions['value'] = 'false';
        }
    }
445892
def _make_definition(self, definition):
        
        if not definition:
            return EndpointDefinition()
        if isinstance(definition, EndpointDefinition):
            return definition
        elif len(definition) == 1:
            return EndpointDefinition(
                func=definition[0],
            )
        elif len(definition) == 2:
            return EndpointDefinition(
                func=definition[0],
                response_schema=definition[1],
            )
        elif len(definition) == 3:
            return EndpointDefinition(
                func=definition[0],
                request_schema=definition[1],
                response_schema=definition[2],
            )
        elif len(definition) == 4:
            return EndpointDefinition(
                func=definition[0],
                request_schema=definition[1],
                response_schema=definition[2],
                header_func=definition[3],
            )
1138447
def _build(lhs, rhs):
    """"""
    _check_under_condition()
    final_predicate, pred_set = _current_select()
    _check_and_add_pred_set(lhs, pred_set)
    _predicate_map.setdefault(lhs, []).append((final_predicate, rhs))
900339
def build_definitions_example(self):
        """"""
        for def_name, def_spec in self.specification.get('definitions', {}).items():
            self.build_one_definition_example(def_name)
339782
def build_increments(self):
        
        self.enforce_bounds()
        self.add_transform_columns()
        par_groups = self.parameter_data.groupby("pargp").groups
        inctype = self.parameter_groups.groupby("inctyp").groups
        for itype,inc_groups in inctype.items():
            pnames = []
            for group in inc_groups:
                pnames.extend(par_groups[group])
                derinc = self.parameter_groups.loc[group,"derinc"]
                self.parameter_data.loc[par_groups[group],"derinc"] = derinc
            if itype == "absolute":
                self.parameter_data.loc[pnames,"increment"] = \
                    self.parameter_data.loc[pnames,"derinc"]
            elif itype == "relative":
                self.parameter_data.loc[pnames,"increment"] = \
                    self.parameter_data.loc[pnames,"derinc"] * \
                    self.parameter_data.loc[pnames,"parval1"]
            elif itype == "rel_to_max":
                mx = self.parameter_data.loc[pnames,"parval1"].max()
                self.parameter_data.loc[pnames,"increment"] = \
                    self.parameter_data.loc[pnames,"derinc"] * mx
            else:
                raise Exception('Pst.get_derivative_increments(): '+\
                                'unrecognized increment type:{0}'.format(itype))

        #account for fixed pars
        isfixed = self.parameter_data.partrans=="fixed"
        self.parameter_data.loc[isfixed,"increment"] = \
            self.parameter_data.loc[isfixed,"parval1"]
270735
public static Value.Builder makeValue(Iterable<Value> values) {
    return Value.newBuilder().setArrayValue(ArrayValue.newBuilder().addAllValues(values));
  }
422365
def build(cls, node):
    """"""
    if not isinstance(node, gast.FunctionDef):
      raise ValueError
    namer = cls()
    namer.names.update(get_names(node))
    return namer
456940
def build(self, field: Field) -> Mapping[str, Any]:
        
        return dict(self.iter_parsed_values(field))
885861
def build(self, **kwargs):
        """"""
        self.lexer = ply.lex.lex(object=self, **kwargs)
1013511
def build_from_info(cls, info):
        
        terms = []
        for term_info in info['terms']:
            terms.append(SplineTerm.build_from_info(term_info))
        return cls(*terms)