public UnknownRecord() 
{

}

 public UnknownRecord(short id,
    short size,
    byte[] data) 
{
        sid     = id;
        size    = size;
        thedata = data;
}

construct an unknown record. No fields are interperated and the record will be serialized in its original form more or less

Parameters:

id - of the record -not validated, just stored for serialization

size - of the data

the - data

 protected  void fillFields(byte[] data,
    short sid) 
{
        sid     = sid;
        thedata = data;
}

 protected  void fillFields(byte[] data,
    short size,
    int offset) 
{
        throw new RecordFormatException(
            "Unknown record cannot be constructed via offset -- we need a copy of the data");
}

called by the constructor, should set class level fields. Should throw runtime exception for bad/icomplete data.

 public short getSid() 
{
        return this.sid;
}

 public byte[] serialize() 
{
        if (thedata == null)
        {
            thedata = new byte[ 0 ];
        }
        byte[] retval = new byte[ thedata.length + 4 ];
        LittleEndian.putShort(retval, 0, sid);
        LittleEndian.putShort(retval, 2, ( short ) (thedata.length));
        if (thedata.length  > 0)
        {
            System.arraycopy(thedata, 0, retval, 4, thedata.length);
        }
        return retval;
}

spit the record out AS IS. no interperatation or identification

 public String toString() 
{
        StringBuffer buffer = new StringBuffer();
        buffer.append("[UNKNOWN RECORD]\n");
        buffer.append("    .id        = ").append(Integer.toHexString(sid))
            .append("\n");
        buffer.append("[/UNKNWON RECORD]\n");
        return buffer.toString();
}

print a sort of string representation ([UNKNOWN RECORD] id = x [/UNKNOWN RECORD])

 protected  void validateSid(short id) 
{
        // if we had a valid sid we wouldn't be using the "Unknown Record" record now would we?
}

NO OP!