Move all the fields to the output buffer.
This is the same as the fieldsToBuffer method, specifying the fieldTypes to move.
@param record The target record.
@param iFieldTypes The field types to move.
767869
public void fieldsToBuffer(FieldList record, int iFieldsTypes)
    {
        m_iFieldsTypes = iFieldsTypes;
        if (this.getHeaderCount() == 0)
            this.clearBuffer();   // Being careful. (Remember to call this at the start anyway)
        int fieldCount = record.getFieldCount();    // Number of fields to write out
        for (int iFieldSeq = Constants.MAIN_FIELD; iFieldSeq <= fieldCount + Constants.MAIN_FIELD - 1; iFieldSeq++)
        {
            FieldInfo field = record.getField(iFieldSeq);
            if (!this.skipField(field))
                this.addNextField(field);
        }
        this.finishBuffer();    //pDestBuff, recordLength, physicalFieldCount);   // two bytes for record length, two for field count
    }
1112606
public final void copyAllFields(Record record, FieldList fieldList)
    {
        for (int i = 0; i < fieldList.getFieldCount(); i++)
        {
            FieldInfo fieldInfo = fieldList.getField(i);
            BaseField field = record.getField(i);
            this.moveFieldToThin(fieldInfo, field, record);
        }
    }
395229
public void init(Record record, BaseField fldRecordTarget, String fsTarget, BaseField fldTarget)
    {
        m_fldToCompare = fldTarget;
        m_fsRecordTarget = fsTarget;
        m_fldRecordTarget = fldRecordTarget;
        super.init(record);
    }
536192
public int doRecordChange(FieldInfo field, int iChangeType, boolean bDisplayOption)
    { // Read a valid record
        int iErrorCode = super.doRecordChange(field, iChangeType, bDisplayOption);      // Initialize the record
        if (iErrorCode == DBConstants.NORMAL_RETURN)
        {
            if ((iChangeType == DBConstants.ADD_TYPE)
                || (iChangeType == DBConstants.UPDATE_TYPE)
                || (iChangeType == DBConstants.DELETE_TYPE))
                    this.updateListener(null);  // Stop listening
            if (iErrorCode == DBConstants.AFTER_REQUERY_TYPE)
//?             || (iErrorCode == DBConstants.SELECT_TYPE))
            {
    //+         ???
            }
        }
        return iErrorCode;
    }
1188388
public void write(WARCRecord record) throws IOException {
        if (bytesWritten > maxSegmentSize) {
            dataStream.close();
            createSegment();
        }
        record.write(dataStream);
    }
316453
public void init(Record record, ScreenLocation itsLocation, BasePanel parentScreen, Converter fieldConverter, int iDisplayFieldDesc, Map<String,Object> properties)
    {
        if (record == null)
            if (parentScreen.getRecord(ClassInfo.CLASS_INFO_FILE) != null)
        {
            iDisplayFieldDesc = iDisplayFieldDesc | ScreenConstants.DETAIL_MODE;
            record = parentScreen.getRecord(ClassInfo.CLASS_INFO_FILE); // Header record
        }
        super.init(record, itsLocation, parentScreen, fieldConverter, iDisplayFieldDesc, properties);
    }
357832
public void printEndRecordData(Rec record, PrintWriter out, int iPrintOptions)
    {
        this.getScreenFieldView().printEndRecordData(record, out, iPrintOptions);
    }
554582
public void writeFieldOffsets(FieldIterator fieldIterator, CodeType codeType)
    { // Now, write all the field offsets out in the header file
        ClassInfo recClassInfo = (ClassInfo)this.getMainRecord();
        boolean firstTime = true;
        String strBaseFieldName;
        String strFieldName = "MainField";     // In case there are no fields
        Record recFieldData = this.getRecord(FieldData.FIELD_DATA_FILE);

        boolean alwaysInclude = false;
        boolean alwaysExclude = false;
        if (recClassInfo.isARecord(false))
        {   // For record, all the fields are in the model class
            if (codeType == CodeType.INTERFACE)
                alwaysInclude = true;
            else
                alwaysExclude = true;
        }
        else
        {   // screen record are thick only - no model
            if (codeType == CodeType.THICK)
                alwaysInclude = true;
            else
                alwaysExclude = true;
        }
        for (int pass = 1; pass <= 2; ++pass) // Do this two times (two passes)
        {
            fieldIterator.close();
            while (fieldIterator.hasNext())
            {
                fieldIterator.next();
                strFieldName = recFieldData.getField(FieldData.FIELD_NAME).getString();
                strBaseFieldName = recFieldData.getField(FieldData.BASE_FIELD_NAME).getString();
                String type = "String";
                switch (pass)
                {
                case 1:     // First, add all fields based on the super.New8 class
                    if (strBaseFieldName.length() > 0)
                    {
                        firstTime = false;
                        String value = convertNameToConstant(strBaseFieldName);
                        String strPre = DBConstants.BLANK;
                        if (recFieldData.getField(FieldData.FIELD_NAME).getString().equals(strBaseFieldName))
                            strPre = "//";
                        strFieldName = convertNameToConstant(strFieldName);
                        boolean includeThis = ((IncludeScopeField)recFieldData.getField(FieldData.INCLUDE_SCOPE)).includeThis(codeType, true);
                        if (alwaysInclude)
                            includeThis = true;
                        if (alwaysExclude)
                            includeThis = false;
                        if (includeThis)
                            m_StreamOut.writeit("\n" + strPre + "public static final " + type + " " + strFieldName + " = " + value + ";");
                    }
                    break;
                case 2:     // Now, add all fields new to this class
                    if (strBaseFieldName.length() == 0)
                    {
                        firstTime = false;
                        boolean includeThis = ((IncludeScopeField)recFieldData.getField(FieldData.INCLUDE_SCOPE)).includeThis(codeType, true);
                        if (alwaysInclude)
                            includeThis = true;
                        if (alwaysExclude)
                            includeThis = false;
                        if (Rec.ID.equals(strFieldName))
                            includeThis = false;    // HACK
                        if (includeThis)
                            m_StreamOut.writeit("\n" + "public static final String " + this.convertNameToConstant(strFieldName) + " = \"" + strFieldName + "\";");
                        break;
                    }
                }
            }
            recFieldData.close();
            if (pass == 2)
            {
                if (!firstTime)
                    m_StreamOut.writeit("\n");
            }
        } // End of pass loop
        
    }
492599
public FieldList move(int iRelPosition) throws DBException
    {
        Record record = ((QueryRecord)m_record).moveTableQuery(iRelPosition);
        if (record != null)
            return (QueryRecord)m_record;
        else
            return null;
    }
883355
public void write(Object[] record) throws IOException, DbaseFileException {

		if (record.length != header.getNumFields()) {
			throw new DbaseFileException("Wrong number of fields "
					+ record.length + " expected " + header.getNumFields());
		}

		buffer.position(0);

		// put the 'not-deleted' marker
		buffer.put((byte) ' ');

		for (int i = 0; i < header.getNumFields(); i++) {
			String fieldString = fieldString(record[i], i);
			if (header.getFieldLength(i) != fieldString
					.getBytes(charset.name()).length) {
				buffer.put(new byte[header.getFieldLength(i)]);
			} else {
				buffer.put(fieldString.getBytes(charset.name()));
			}

		}

		write();
	}
927511
@Override
	public void writeRecord(Record record) throws IOException {
		int numRecFields = record.getNumFields();
		int readPos;

		for (int i = 0; i < this.numFields; i++) {
			readPos = this.recordPositions[i];
			if (readPos < numRecFields) {
				Value v = record.getField(this.recordPositions[i], this.classes[i]);
				if (v != null) {
					if (i != 0) {
						this.wrt.write(this.fieldDelimiter);
					}
					this.wrt.write(v.toString());
				} else {
					if (this.lenient) {
						if (i != 0) {
							this.wrt.write(this.fieldDelimiter);
						}
					} else {
						throw new RuntimeException("Cannot serialize record with <null> value at position: " + readPos);
					}
				}

			} else {
				if (this.lenient) {
					if (i != 0) {
						this.wrt.write(this.fieldDelimiter);
					}
				} else {
					throw new RuntimeException("Cannot serialize record with out field at position: " + readPos);
				}
			}

		}

		// add the record delimiter
		this.wrt.write(this.recordDelimiter);
	}
207511
public void initSharedRecord(Record record)
    {
        FieldListener listener = null;
        try {
            BaseField field = record.getSharedRecordTypeKey();
            field.addListener(listener = new InitOnceFieldHandler(null));
            field.setData(new Integer(0), true, DBConstants.INIT_MOVE);
            field.setData(new Integer(0), true, DBConstants.INIT_MOVE);
            if (field != null)
                if (field.getDataClass() == Integer.class)
            {
                for (int i = 1; ; i++)
                {
                    Integer intData = new Integer(i);
                    field.setData(intData);
                    record.addNew();
                    Record recShared = record.getTable().getCurrentTable().getRecord();
                    if (recShared == null)
                        break;
                    if (recShared == record)
                        break;
                    if (recShared.getField(field.getFieldName()).getValue() != i)
                        break;
                    this.disableAllListeners(recShared);
                }
            }
        } catch (DBException ex) {
            ex.printStackTrace();
        } finally {
            if (listener != null)
                record.removeListener(listener, true);
        }
    }
1188200
public void setRecords(java.util.Collection<Record> records) {
        if (records == null) {
            this.records = null;
            return;
        }

        this.records = new com.amazonaws.internal.SdkInternalList<Record>(records);
    }
857487
public static void setColumnsMap(Record record, Map<String, Object> columns) {
		record.setColumnsMap(columns);
	}
1027195
public int dataToFields(Rec record) throws DBException
    {
        m_iColumn = 1;
        int iErrorCode = super.dataToFields(record);

        KeyArea keyArea = this.getRecord().getKeyArea(0); // Primary index
        keyArea.setupKeyBuffer(null, DBConstants.TEMP_KEY_AREA);        // Save keys for possible update/delete
        if (this.getResultSetType() != DBConstants.SQL_SELECT_TYPE)
            if (CLEANUP_STATEMENTS)
                this.setResultSet(null, this.getResultSetType());  // Close this statement

        return iErrorCode;
    }
847804
@Override
	public void serializeRecord(T record) throws IOException {
		if (CHECKED) {
			if (dataBuffer.hasRemaining()) {
				throw new IllegalStateException("Pending serialization of previous record.");
			}
		}

		serializationBuffer.clear();
		lengthBuffer.clear();

		// write data and length
		record.write(serializationBuffer);

		int len = serializationBuffer.length();
		lengthBuffer.putInt(0, len);

		dataBuffer = serializationBuffer.wrapAsByteBuffer();
	}
1210685
public static void enableAllBehaviors(Record record, boolean bEnableRecordBehaviors, boolean bEnableFieldBehaviors)
    {
        if (record == null)
            return;
        record.setEnableListeners(bEnableRecordBehaviors);   // Disable all file behaviors
        for (int iFieldSeq = 0; iFieldSeq < record.getFieldCount(); iFieldSeq++)
        {
            BaseField field = record.getField(iFieldSeq);
            field.setEnableListeners(bEnableFieldBehaviors);
        }
    }