add all transient fields to list.
964102
function addTransient( internalObj, tempObj ) {
			var temp = {}, k, tr = tempObj["transient"] || [];
			tr.push("shortHand");
			for (k = 0; k < tr.length; k++) {
				(temp[tr[k]] = true);
			}
			eachPropertyOf(internalObj.Static, function( v, key ) {
				temp[key] = true;
			});
			eachPropertyOf(internalObj.staticConst, function( v, key ) {
				temp[key] = true;
			});
			internalObj["transient"] = temp;
			internalObj = tempObj = k = temp = undefined;
		}
428501
def AllFieldsFromDescriptor(self, message_descriptor):
    """"""
    self.Clear()
    for field in message_descriptor.fields:
      self.paths.append(field.name)
1287213
public void addMultiValuedField(String fieldName, List<String> values) {

        if ((values != null) && (values.size() > 0)) {
            for (String value : values) {
                m_doc.addField(fieldName, value);
            }
        }
    }
20785
private static void setListParam(Field field, List<?> values) {
        try {
            // Find method: clear() and call it
            Class<?> fieldClass = field.getType();
            Method clearMethod = fieldClass.getMethod("clear");
            clearMethod.invoke(field.get(config));
            
            // Find List method: add(Object) 
            Method addMethod = fieldClass.getMethod("add", Object.class);
            
            // Add each map key/value to field value
            for (Object subParam : values) {
                if (subParam instanceof String) {
                    addMethod.invoke(field.get(config), subParam);
                } else {
                    throw new RuntimeException("Unexpected parameter type for '" + field.getName() + ":" + subParam);
                }
            }
        } catch (NoSuchMethodException  | IllegalArgumentException | InvocationTargetException | IllegalAccessException e) {
            throw new RuntimeException("Error setting configuration parameter '" + field.getName() + "'", e);
        }
    }
604324
def add_fields(self, **fields):
        """"""
        self.__class__ = type(self.__class__.__name__,
                            (self.__class__,), fields)
        for k, v in fields.items():
            v.init_inst(self)
1315847
def _collect_fields(field_parts_list, include_parents):
    """"""
    fields = []
    subpart_lists = defaultdict(list)

    for parts in field_parts_list:
        field, subparts = parts[0], parts[1:]
        if subparts:
            if include_parents and field not in fields:
                fields.append(field)
            subpart_lists[field].append(subparts)
        else:
            fields.append(field)

    subfields = dict((field, _collect_fields(subparts, include_parents))
                     for field, subparts in six.iteritems(subpart_lists))

    return ParsedFieldList(fields, subfields)
554705
def get_field_list(self):
        

        list_out = []
        for field in self.fields:
            list_out.append(field)

        return list_out
93390
private void addToList(List<Object> list, Object value) {
    if (value instanceof List) {
      list.addAll((List) value);
    } else {
      list.add(value);
    }
  }
966592
def add(self, name, value):
        # type: (str, str) -> None
        """"""
        self._last_key = name
        if name in self:
            self._dict[name] = value
            self._as_list[name].append(value)
        else:
            self[name] = value
3058
private void forEachFieldDo(FieldCallBack fieldCallBack) {
		Class<?> clazz = this.getClass();
		
		while (true) {
			
			Field[] fields = clazz.getDeclaredFields();
			try {
				for (Field field : fields) {
					// FIXME: test skipped cases
					// skip Logger object
					if (field.getType() == Logger.class)
						continue;
					// skip fields annotated with @Transient
					if (field.getAnnotation(Transient.class) != null)
						continue;
					// skip serialVersionUID
					if ("serialVersionUID".equals(field.getName()))
						continue;
					field.setAccessible(true);
					fieldCallBack.doForField(field);
				} 
			} catch (IllegalArgumentException e) {
				throw new RuntimeException(e);
			} catch (IllegalAccessException e) {
				throw new RuntimeException(e);
			}
			
			if (clazz.getName().equals(DataObject.class.getName()))
				break;
			
			clazz = clazz.getSuperclass();
		}
	}
290743
def add_log_fields(self, fields: Dict[str, Any]):
        
        self._log_fields.add_fields(fields)
455024
def insert(self, docs, *args, **kwargs):
        """"""
        if isinstance(docs, list):
            return self.insert_many(docs, *args, **kwargs)
        else:
            return self.insert_one(docs, *args, **kwargs)
526293
def add_fields(*fields)
            raise TypeError, "Expected Field arguments" unless fields.all? { |f| f.is_a?(Field) }

            self.Catalog.AcroForm ||= InteractiveForm.new.set_indirect(true)
            self.Catalog.AcroForm.Fields ||= []

            self.Catalog.AcroForm.Fields.concat(fields)
            fields.each do |field| field.set_indirect(true) end

            self
        end
76026
public void addConstant(ConstantField field) {
        constantList.add(field);
        constants.put(field.name, field);
    }
739964
public void addFields(GenericField[] fields)
	{
		for (int i=0; i < fields.length;i++)
		{
			this.fieldMap.put(fields[i].getFieldName(), fields[i]);
		}
	}
32698
void mergeFields() {
        for (int k = 0; k < fields.size(); ++k) {
            HashMap fd = ((AcroFields)fields.get(k)).getFields();
            mergeWithMaster(fd);
        }
    }
233210
public void add(Rec fieldList) throws DBException
    {
        Record record = (Record)fieldList;
        if (((this.getRecord().getOpenMode() & DBConstants.OPEN_REFRESH_AND_LOCK_ON_CHANGE_STRATEGY) != DBConstants.OPEN_REFRESH_AND_LOCK_ON_CHANGE_STRATEGY)
            || (record.isRefreshedRecord()))
                this.restoreMainRecord(record, true);
        super.add(record);
    }