How to use

getFixedSize

method

in

com.healthmarketscience.jackcess.DataType

 if ( length < 3 ) {
  column.setType( DataType.BYTE );
  length = DataType.BYTE.getFixedSize();
 } else {
  if ( length < 5 ) {
   column.setType( DataType.INT );
   length = DataType.INT.getFixedSize();
  } else {
   column.setType( DataType.LONG );
   length = DataType.LONG.getFixedSize();
case ValueMetaInterface.TYPE_NUMBER:
 column.setType( DataType.DOUBLE );
 length = DataType.DOUBLE.getFixedSize();
 break;
case ValueMetaInterface.TYPE_DATE:
 column.setType( DataType.SHORT_DATE_TIME );
 length = DataType.SHORT_DATE_TIME.getFixedSize();
 break;
case ValueMetaInterface.TYPE_STRING:
case ValueMetaInterface.TYPE_BOOLEAN:
 column.setType( DataType.BOOLEAN );
 length = DataType.BOOLEAN.getFixedSize();
 break;
case ValueMetaInterface.TYPE_BIGNUMBER:
 column.setType( DataType.NUMERIC );
 length = DataType.NUMERIC.getFixedSize();
 break;

public int getFixedSize() {
 return getFixedSize(null);
}

private static boolean isPseudoGuidColumn(
  DataType dataType, String propName, int dataSize, Object value)
 throws IOException
{
 // guids seem to be marked as "binary" fields
 return((dataType == DataType.BINARY) &&
     ((dataSize == DataType.GUID.getFixedSize()) ||
     ((dataSize == -1) && ColumnImpl.isGUIDValue(value))) &&
     PropertyMap.GUID_PROP.equalsIgnoreCase(propName));
}

 @Override
 protected ByteBuffer writeRealData(Object obj, int remainingRowLength,
                   ByteOrder order)
  throws IOException
 {
  // we should only be working with fixed length types
  ByteBuffer buffer = writeFixedLengthField(
    obj, prepareWrappedCalcValue(getType().getFixedSize(), order));
  buffer.rewind();
  return buffer;
 }
}

public short getLength() {
 return ((_length != null) ? _length :
     (short)(!_type.isVariableLength() ? _type.getFixedSize() :
         _type.getDefaultSize()));
}

 public short getNextFixedOffset(ColumnBuilder col) {
  short offset = _fixedOffset;
  _fixedOffset += col.getType().getFixedSize(col.getLength());
  return offset;
 }
}

/**
 * Serialize an Object into a raw byte value for this column
 * @param obj Object to serialize
 * @param order Order in which to serialize
 * @return A buffer containing the bytes
 * @usage _advanced_method_
 */
protected ByteBuffer writeFixedLengthField(Object obj, ByteOrder order)
 throws IOException
{
 int size = getType().getFixedSize(_columnLength);
 ByteBuffer buffer = writeFixedLengthField(
   obj, PageChannel.createBuffer(size, order));
 buffer.flip();
 return buffer;
}

/**
 * @usage _advanced_method_
 */
protected ColumnImpl(TableImpl table, String name, DataType type,
           int colNumber, int fixedOffset, int varLenIndex) {
 _table = table;
 _name = name;
 _type = type;
 if(!_type.isVariableLength()) {
  _columnLength = (short)type.getFixedSize();
 } else {
  _columnLength = (short)type.getMaxSize();
 }
 _variableLength = type.isVariableLength();
 _autoNumber = false;
 _calculated = false;
 _autoNumberGenerator = null;
 _columnNumber = (short)colNumber;
 _columnIndex = colNumber;
 _displayIndex = colNumber;
 _fixedDataOffset = fixedOffset;
 _varLenTableIndex = varLenIndex;
}

  decVal, getType().getFixedSize() - 1);
if(buffer.order() != ByteOrder.BIG_ENDIAN) {
 fixNumericByteOrder(intValBytes);

  getType().getFixedSize(), order);
writeNumericValue(buffer, obj);
buffer.flip();

dt = TypesMap.map2Jackcess(AccessType.valueOf(types[seq].toUpperCase(Locale.US)));
cb.setType(dt);
cb.setLengthInUnits((short) dt.getFixedSize());

colDataLen = column.getType().getFixedSize(column.getLength());

 (col.getFixedDataOffset() >= fixedOffset)) {
fixedOffset = col.getFixedDataOffset() +
 col.getType().getFixedSize(col.getLength());

if(getLength() < getType().getFixedSize()) {
 throw new IllegalArgumentException(withErrorContext(
   "Invalid fixed length size " + getLength()));