Add a field to this tuple (a tuple need not have any fields).
160422
public void addField(JMFType field) {
    if (field == null)
      throw new NullPointerException("Tuple field cannot be null");
    JSType newField = (JSType)field;
    if (fields == null)
      fields = new JSType[1];
    else {
      JSType[] oldFields = fields;
      fields = new JSType[oldFields.length + 1];
      System.arraycopy(oldFields, 0, fields, 0, oldFields.length);
    }
    newField.parent = this;
    newField.siblingPosition = fields.length - 1;
    fields[newField.siblingPosition] = newField;
  }
747155
private void add(Field f) {

        m_fields.put(f.name(), f);
        m_doc.add(f);
    }
1137686
def add(self, *args, **kwargs):
        
        return self._apply(operator.add, *args, **kwargs)
1336750
def add(self, key, val):
        
        key_lower = key.lower()
        new_vals = key, val
        # Keep the common case aka no item present as fast as possible
        vals = _dict_setdefault(self, key_lower, new_vals)
        if new_vals is not vals:
            # new_vals was not inserted, as there was a previous one
            if isinstance(vals, list):
                # If already several items got inserted, we have a list
                vals.append(val)
            else:
                # vals should be a tuple then, i.e. only one item so far
                # Need to convert the tuple to list for further extension
                _dict_setitem(self, key_lower, [vals[0], vals[1], val])
965918
def add_empty_fields(untl_dict):
    """"""
    # Iterate the ordered UNTL XML element list to determine
    # which elements are missing from the untl_dict.
    for element in UNTL_XML_ORDER:
        if element not in untl_dict:
            # Try to create an element with content and qualifier.
            try:
                py_object = PYUNTL_DISPATCH[element](
                    content='',
                    qualifier='',
                )
            except:
                # Try to create an element with content.
                try:
                    py_object = PYUNTL_DISPATCH[element](content='')
                except:
                    # Try to create an element without content.
                    try:
                        py_object = PYUNTL_DISPATCH[element]()
                    except:
                        raise PyuntlException(
                            'Could not add empty element field.'
                        )
                    else:
                        untl_dict[element] = [{'content': {}}]
                else:
                    # Handle element without children.
                    if not py_object.contained_children:
                        untl_dict[element] = [{'content': ''}]
                    else:
                        untl_dict[element] = [{'content': {}}]
            else:
                # Handle element without children.
                if not py_object.contained_children:
                    untl_dict[element] = [{'content': '', 'qualifier': ''}]
                else:
                    untl_dict[element] = [{'content': {}, 'qualifier': ''}]
            # Add empty contained children.
            for child in py_object.contained_children:
                untl_dict[element][0].setdefault('content', {})
                untl_dict[element][0]['content'][child] = ''
    return untl_dict
599415
public CMAContentType addField(CMAField field) {
    if (fields == null) {
      fields = new ArrayList<CMAField>();
    }

    fields.add(field);
    return this;
  }
359702
def add_field(self, name, ftype, docfield=None):
        
        self.schema.add_field(name, ftype)
        self[name] = docfield or DocField.FromType(ftype)
581856
def add(self, name, attr=None, value=None):
        ""

        if isinstance(name, tuple) or isinstance(name, list):
            name, attr, value = self.__set_iter_value(name)

        if attr is None:
            attr = name

        if value is None:
            value = attr

        self.__data += (self.get_const_string(name=name, value=value),)
        # set attribute as slugfiy
        self.__dict__[s_attr(attr)] = self.__data[-1]
575610
def field(self, name, fieldType="C", size="50", decimal=0):
        """"""
        self.fields.append((name, fieldType, size, decimal))
1296593
public FieldStatsOptions addField(Field field) {

		Assert.notNull(field, "Field for statistics must not be 'null'.");

		state.fields.add(field);
		return new FieldStatsOptions(field, state);
	}
352448
def add_fields(self, **fields):
        
        query = {}
        for field in fields:
            query[field] = fields[field]
        self._q.append({'$addFields': query})
        return self
550266
@Nonnull
    public BugInstance addField(FieldVariable field) {
        return addField(field.getClassName(), field.getFieldName(), field.getFieldSig(), field.isStatic());
    }
840596
function addToFields(fieldName, options) {
	if (inFields(fieldName, options)) return;
	options.fields = options.fields.concat([fieldName]);
}
95494
public void addField(String fieldName, TypeID tid) {
    sTid.getFieldTypeInfos().add(new FieldTypeInfo(fieldName, tid));
  }
1113547
public void add(final Field _field)
    {
        this.fields.put(_field.getId(), _field);
        this.fieldName2Field.put(_field.getName(), _field);
        if (_field.getReference() != null && _field.getReference().length() > 0) {
            final String ref = _field.getReference();
            int index;
            int end = 0;
            while ((index = ref.indexOf("$<", end)) > 0) {
                index += 2;
                end = ref.indexOf(">", index);
                addFieldExpr(ref.substring(index, end));
            }
        }
        _field.setCollectionUUID(getUUID());
    }
393402
public function addField(string $field, string $value): self
    {
        $this->fields[$field] = $value;

        return $this;
    }
1168646
def add_fields(self, fields):
        
        for k, v in fields.items():
            if k not in self._fields:
                self._fields[k] = v