adds a FIELDDESCRIPTOR to this ClassDescriptor.
@param fld
162213
public void addFieldDescriptor(FieldDescriptor fld)
    {
        fld.setClassDescriptor(this); // BRJ
        if (m_FieldDescriptions == null)
        {
            m_FieldDescriptions = new FieldDescriptor[1];
            m_FieldDescriptions[0] = fld;
        }
        else
        {
            int size = m_FieldDescriptions.length;
            FieldDescriptor[] tmpArray = new FieldDescriptor[size + 1];
            System.arraycopy(m_FieldDescriptions, 0, tmpArray, 0, size);
            tmpArray[size] = fld;
            m_FieldDescriptions = tmpArray;
            // 2. Sort fields according to their getOrder() Property
            Arrays.sort(m_FieldDescriptions, FieldDescriptor.getComparator());
        }

        m_fieldDescriptorNameMap = null;
        m_PkFieldDescriptors = null;
        m_nonPkFieldDescriptors = null;
        m_lockingFieldDescriptors = null;
        m_RwFieldDescriptors = null;
        m_RwNonPkFieldDescriptors = null;
    }
463194
public void addField(String fldName, Type type) {
		fields.put(fldName, type);
		if (myFieldSet != null)
			myFieldSet.add(fldName);
	}
32909
private void addProperties(final PropertyDescriptor[] _properties) throws ColumnBuilderException, ClassNotFoundException {
        for (final PropertyDescriptor property : _properties) {
            if (isValidProperty(property)) {
                addColumn(getColumnTitle(property), property.getName(), property.getPropertyType().getName(), getColumnWidth(property));
            }
        }
        setUseFullPageWidth(true);
    }
779987
def AddDescriptor(self, field_desc):
    """"""
    # Just relay it up to our owner.
    self.late_bound = False
    self.delegate = field_desc
    self.wire_type = self.delegate.wire_type
    self.owner.AddDescriptor(self)
1277874
private void checkFieldDescriptor(FieldDescriptor field) {
        if (field.getContainingType() != metadata.descriptor) {
            throw new RuntimeException("Wrong FieldDescriptor \"" + field.getFullName() + "\" used in message \""
                    + metadata.descriptor.getFullName());
        }
    }
517508
def _AddPropertiesForFields(descriptor, cls):
  """"""
  for field in descriptor.fields:
    _AddPropertiesForField(field, cls)

  if descriptor.is_extendable:
    # _ExtensionDict is just an adaptor with no state so we allocate a new one
    # every time it is accessed.
    cls.Extensions = property(lambda self: _ExtensionDict(self))
747147
public void addField(String fieldName, String type, short flags,
        int value) {
        short fieldNameIndex = itsConstantPool.addUtf8(fieldName);
        short typeIndex = itsConstantPool.addUtf8(type);
        ClassFileField field = new ClassFileField(fieldNameIndex, typeIndex,
            flags);
        field.setAttributes(itsConstantPool.addUtf8("ConstantValue"),
            (short) 0,
            (short) 0,
            itsConstantPool.addConstant(value));
        itsFields.add(field);
    }
337715
public void setFields(FdfReader fdf) throws IOException, DocumentException {
        HashMap fd = fdf.getFields();
        for (Iterator i = fd.keySet().iterator(); i.hasNext();) {
            String f = (String)i.next();
            String v = fdf.getFieldValue(f);
            if (v != null)
                setField(f, v);
        }
    }
106307
private void addIndex(IndexDescriptorDef indexDescDef, TableDef tableDef)
    {
        IndexDef indexDef = tableDef.getIndex(indexDescDef.getName());

        if (indexDef == null)
        {
            indexDef = new IndexDef(indexDescDef.getName(),
                                    indexDescDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_UNIQUE, false));
            tableDef.addIndex(indexDef);
        }

        try
        {
            String             fieldNames = indexDescDef.getProperty(PropertyHelper.OJB_PROPERTY_FIELDS);
            ArrayList          fields     = ((ClassDescriptorDef)indexDescDef.getOwner()).getFields(fieldNames);
            FieldDescriptorDef fieldDef;

            for (Iterator it = fields.iterator(); it.hasNext();)
            {
                fieldDef = (FieldDescriptorDef)it.next();
                indexDef.addColumn(fieldDef.getProperty(PropertyHelper.OJB_PROPERTY_COLUMN));
            }
        }
        catch (NoSuchFieldException ex)
        {
            // won't happen if we already checked the constraints
        }
    }
885178
private <D extends Descriptor> void pushDesriptor(Class<D> type, D descriptor) {
        if (descriptor != null) {
            scannerContext.push(type, descriptor);
            scannerContext.setCurrentDescriptor(descriptor);
        }
    }
890911
public static void addDevelopmentAttributes(FeatureDescriptor descriptor, 
            FaceletContext ctx, TagAttribute displayName, TagAttribute shortDescription, 
            TagAttribute expert, TagAttribute hidden, TagAttribute preferred)
    {
        if (displayName != null)
        {
            descriptor.setDisplayName(displayName.getValue(ctx));
        }
        if (shortDescription != null)
        {
            descriptor.setShortDescription(shortDescription.getValue(ctx));
        }
        if (expert != null)
        {
            descriptor.setExpert(expert.getBoolean(ctx));
        }
        if (hidden != null)
        {
            descriptor.setHidden(hidden.getBoolean(ctx));
        }
        if (preferred != null)
        {
            descriptor.setPreferred(preferred.getBoolean(ctx));
        }
    }
357334
@Override
  public TypeDescription addTypeDescription(TypeDescription definition) {
    if(definition != null && definition.getTag() != null) {
      tagsDefined.add(definition.getTag());
    }
    return super.addTypeDescription(definition);
  }
95494
public void addField(String fieldName, TypeID tid) {
    sTid.getFieldTypeInfos().add(new FieldTypeInfo(fieldName, tid));
  }
358519
def AddDescriptor(cls, field_desc):
    """"""
    if not isinstance(field_desc, ProtoType):
      raise type_info.TypeValueError(
          "%s field '%s' should be of type ProtoType" %
          (cls.__name__, field_desc.name))

    # Ensure the field descriptor knows the class that owns it.
    field_desc.SetOwner(cls)

    # If the field is late bound we do not really add it to the descriptor set
    # yet. We must wait for the LateBindingPlaceHolder() to add it later.
    if field_desc.late_bound:
      # Keep track of unbound fields.
      cls.late_bound_type_infos[field_desc.name] = field_desc
      return

    # Ensure this field number is unique:
    if field_desc.field_number in cls.type_infos_by_field_number:
      raise type_info.TypeValueError(
          "Field number %s for field %s is not unique in %s" %
          (field_desc.field_number, field_desc.name, cls.__name__))

    # We store an index of the type info by tag values to speed up parsing.
    cls.type_infos_by_field_number[field_desc.field_number] = field_desc
    cls.type_infos_by_encoded_tag[field_desc.encoded_tag] = field_desc

    cls.type_infos.Append(field_desc)
    cls.late_bound_type_infos.pop(field_desc.name, None)

    # Add direct accessors only if the class does not already have them.
    if not hasattr(cls, field_desc.name):
      # This lambda is a class method so pylint: disable=protected-access
      # This is much faster than __setattr__/__getattr__
      setattr(
          cls, field_desc.name,
          property(lambda self: self.Get(field_desc.name), lambda self, x: self.
                   _Set(x, field_desc), None, field_desc.description))
1227947
void addWrites(MethodDescriptor methodDescriptor, final Integer lineNumber, FieldDescriptor fieldDescriptor) {
        WritesDescriptor writesDescriptor = scannerContext.getStore().create(methodDescriptor, WritesDescriptor.class, fieldDescriptor);
        writesDescriptor.setLineNumber(lineNumber);
    }
212960
protected void buildField( ClassVisitor cw,
                               FieldDefinition fieldDef) {
        FieldVisitor fv = cw.visitField( Opcodes.ACC_PROTECTED,
                                         fieldDef.getName(),
                                         BuildUtils.getTypeDescriptor( fieldDef.getTypeName() ),
                                         null,
                                         null );


        buildFieldAnnotations( fieldDef, fv );

        fv.visitEnd();
    }
234895
void defineFields(ClassVisitor writer) {
    for (Variable var : allVariables) {
      var.maybeDefineField(writer);
    }
    if (currentCalleeField != null) {
      currentCalleeField.defineField(writer);
    }
    if (currentRendereeField != null) {
      currentRendereeField.defineField(writer);
    }
    if (currentAppendable != null) {
      currentAppendable.defineField(writer);
    }
  }