using System;
using System.Collections;
using System.Collections.Specialized;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using NWN.FileTypes.Tools;
namespace NWN.FileTypes.Gff
{
/// <summary>
/// This enum defines the data types supported by GffFields. Simple
/// data items are stored directly in the GffField's DataOrDataOffset
/// field, complex data items are stored in the complex data byte
/// array, with the offset to the data being in DataOrDataOffset.
/// </summary>
public enum GffFieldType
{
#region values
Byte = 0,
Char = 1,
Word = 2,
Short = 3,
DWord = 4,
Int = 5,
DWord64 = 6, // complex
Int64 = 7, // complex
Float = 8,
Double = 9, // complex
ExoString = 10, // complex
ResRef = 11, // complex
ExoLocString = 12, // complex
Void = 13, // complex
Struct = 14, // complex
List = 15, // complex
#endregion
}
/// <summary>
/// Class to define a localized string. Localized strings in GFF
/// files can be stored in one of two ways, either a tlk index for
/// lookup in dialog.tlk (or the custom tlk) or as a list of strings
/// for various languages. This class supports both.
/// </summary>
public class ExoLocString
{
#region public properties/methods
/// <summary>
/// Default constructor
/// </summary>
public ExoLocString() : this(0, true, string.Empty) {}
/// <summary>
/// Class constructor
/// </summary>
/// <param name="languageID">Language ID</param>
/// <param name="male">True if string is masculine</param>
/// <param name="val">String</param>
public ExoLocString(uint languageID, bool male, string val)
{
StringInfo info = new StringInfo();
info.LanguageID = languageID;
info.Male = male;
info.Text = val;
strings = new ArrayList();
strings.Add(info);
}
/// <summary>
/// Class constructor to create an ExoLocString from the GFF
/// file's raw data.
/// </summary>
/// <param name="buffer">Byte array containing the raw data</param>
/// <param name="offset">Offset to the data</param>
public ExoLocString(Byte[] buffer, int offset)
{
strings = new ArrayList();
// Get the total size in bytes of the ExoLocString.
uint size = BitConverter.ToUInt32(buffer, offset);
offset += 4;
// Get the dialog.tlk StrRef, if it is valid (not -1) then
// we are doine.
strRef = BitConverter.ToUInt32(buffer, offset);
offset += 4;
if (0xffffffff != strRef) return;
// Get the number of sub-strings in the ExoLocString and
// build StringInfo objects for each of them, adding them
// to our collection.
uint count = BitConverter.ToUInt32(buffer, offset);
offset += 4;
for (int i = 0; i < count; i++)
{
// Get the sub-string's languageID and length.
uint stringID = BitConverter.ToUInt32(buffer, offset);
offset += 4;
uint length = BitConverter.ToUInt32(buffer, offset);
offset += 4;
// Create the string info object, and fill it in with the
// proper data.
StringInfo info = new StringInfo();
info.LanguageID = stringID / 2;
info.Male = 0 == stringID % 2;
info.Text = RawGffData.DeserializeString(buffer, offset, (int) length);
offset += (int) length;
strings.Add(info);
}
}
/// <summary>
/// Serializes the object to a byte array
/// </summary>
/// <returns>The serialized byte array</returns>
public byte[] Serialize()
{
// First figure out how many bytes we need. We start with 12 bytes
// for the overall byte count, dialog.tlk reference, and embedded
// string count. Once we figure out how big the buffer has to be allocate it.
uint count = 12;
foreach (StringInfo info in strings)
{
// Add 8 for language and length, and add the string length.
count += 8 + (uint) info.Text.Length;
}
byte[] bytes = new byte[count];
int offset = 0;
// Write the overall byte count and dialog.tlk reference. Note that the
// first 4 bytes containing the size are NOT counted in the byte count.
byte[] data = BitConverter.GetBytes(count - 4);
data.CopyTo(bytes, offset);
offset += data.Length;
data = BitConverter.GetBytes(strRef);
data.CopyTo(bytes, offset);
offset += data.Length;
// Write the embedded string count.
data = BitConverter.GetBytes((uint) strings.Count);
data.CopyTo(bytes, offset);
offset += data.Length;
// Write all of the strings.
foreach (StringInfo info in strings)
{
// Write the language value.
uint language = (info.LanguageID * 2) + (uint) (info.Male ? 0 : 1);
data = BitConverter.GetBytes(language);
data.CopyTo(bytes, offset);
offset += data.Length;
// Write the length.
data = BitConverter.GetBytes((uint) info.Text.Length);
data.CopyTo(bytes, offset);
offset += data.Length;
// Write the string data.
for (int i = 0; i < info.Text.Length; i++, offset++)
bytes[offset] = (byte) info.Text[i];
}
return bytes;
}
/// <summary>
/// Override ToString() to give menaingful output for the object. For
/// tlk references it's the tlk index as a string, for embedded strings
/// it's the first string in the list.
/// </summary>
/// <returns>A string representation of the object.</returns>
public override string ToString()
{
// If the string is a dialog.tlk lookup then
// just return the lookup index as a string.
if (0xffffffff != strRef) return strRef.ToString();
// If it's text is embedded just return the first
// entry.
if (0 == strings.Count) return string.Empty;
return ((StringInfo) strings[0]).Text;
}
#endregion
#region private nested classes/fields
/// <summary>
/// This class defines a single instance of an embedded string
/// in the raw data. The string is stored in the raw data as
/// language (4 bytes), length (4 bytes), and text. Language
/// is the language ID * 2 with 1 added if the text is female.
/// We break this data apart and store it in a code friendly
/// manner in this object. A collection of these objects is then
/// built for all of the embedded strings.
/// </summary>
private class StringInfo
{
public uint LanguageID;
public bool Male;
public string Text;
}
uint strRef;
private ArrayList strings;
#endregion
}
/// <summary>
/// This class defines a GffFieldSchema. It allows Gff derived classes
/// to define the schema of their files.
/// </summary>
public class GffFieldSchema
{
#region public properties/methods
/// <summary>
/// Gets the UIName of the field.
/// </summary>
public string UIName { get { return uiName; } }
/// <summary>
/// Gets the tag of the field.
/// </summary>
public string Tag { get { return tag; } }
/// <summary>
/// Gets the data type of the field
/// </summary>
public GffFieldType Type { get { return type; } }
/// <summary>
/// Gets the structure ID, only menaingful for lists and structures.
/// </summary>
uint StructureID { get { return structID; } }
/// <summary>
/// Gets the child fields of the structure, only meaningful for structures.
/// </summary>
public GffSchemaCollection Children { get { return children; } }
/// <summary>
/// Class constructor
/// </summary>
/// <param name="uiName">Display name of the field</param>
/// <param name="label">Tag of the field</param>
/// <param name="type">Data type of the field</param>
public GffFieldSchema(string uiName, string tag, GffFieldType type) :
this(uiName, tag, type, 0, null) {}
/// <summary>
/// Class constructor
/// </summary>
/// <param name="uiName">Display name of the field</param>
/// <param name="label">Tag of the field</param>
/// <param name="type">Data type of the field</param>
/// <param name="structureID">Structure ID of the field, only meaningful
/// for lists and structures</param>
/// <param name="children">Schema for the structure's child fields</param>
public GffFieldSchema(string uiName, string tag, GffFieldType type,
uint structID, GffSchemaCollection children)
{
this.uiName = uiName;
this.tag = tag;
this.type = type;
this.structID = structID;
this.children = children;
}
/// <summary>
/// Creates a GffField derived object based on the schema.
/// </summary>
public GffField CreateField()
{
// Create the field and assign it's structure ID if it's a structure.
GffField field = GffFieldFactory.CreateField(type);
if (GffFieldType.Struct == type)
((GffStructField) field).StructureType = structID;
return field;
}
#endregion
#region private fields/properties/methods
private string uiName;
private string tag;
private GffFieldType type;
private uint structID;
private GffSchemaCollection children;
#endregion
}
/// <summary>
/// This class is the collection class for GffFieldSchema objects, the
/// collection as a whole defines the schema for a file.
/// </summary>
public class GffSchemaCollection: DictionaryBase
{
#region public properties/methods
/// <summary>
/// Indexer to lookup a schema based on it's label.
/// </summary>
public GffFieldSchema this[string label]
{ get { return InnerHashtable[label] as GffFieldSchema; } }
/// <summary>
/// Indexer to get the index'th DictionaryEntry in the collection.
/// It uses the ordered entries list to give the entries back in the same
/// order that they were placed in the collection.
/// </summary>
public GffFieldSchema this[int index]
{ get { return (GffFieldSchema) orderedEntries[index]; } }
/// <summary>
/// Class constructor.
/// </summary>
public GffSchemaCollection()
{
orderedEntries = new ArrayList();
}
/// <summary>
/// Adds a field schema to the dictionary.
/// </summary>
/// <param name="field">The field's schema</param>
public void Add(GffFieldSchema field)
{
// Add the entry to the hashtable in the dictionary, then
// add it to the end of our ordered entries collection. The
// ordered entries collectoin will allow us to traverse the
// dictionary in the order that the entries were added, preserving
// this order.
InnerHashtable.Add(field.UIName, field);
orderedEntries.Add(field);
}
/// <summary>
/// Replace GetEnumerator() to return an enumerator that uses the
/// orderedEntries collection rather than the dictionary to enumerate
/// the objects.
/// </summary>
/// <returns>The dictionary enumerator</returns>
public new IEnumerator GetEnumerator()
{
return new Enumerator(orderedEntries);
}
#endregion
#region private fields/properties/methods
private ArrayList orderedEntries;
/// <summary>
/// Nested class to enumerate the dictionary entries using the
/// orderedEntries collection rather than the dictionary. This allows
/// us to enumerate them in the order they were added.
/// </summary>
private class Enumerator: IEnumerator
{
#region implementation
public object Current { get { return baseEnumerator.Current; } }
public bool MoveNext() { return baseEnumerator.MoveNext(); }
public void Reset() { baseEnumerator.Reset(); }
public Enumerator(ArrayList list) { baseEnumerator = list.GetEnumerator(); }
private IEnumerator baseEnumerator;
#endregion
}
#endregion
}
/// <summary>
/// This structure defines the header of a GFF file.
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack=1, CharSet=CharSet.Ansi)]
public struct GffHeader
{
#region public properties
public string FileType
{ get { return RawGffData.DeserializeString(fileType, 0, fileType.Length).Trim(); } }
public string VersionText
{ get { return RawGffData.DeserializeString(version, 0, version.Length); } }
public int StructOffset
{
get { return structOffset; }
set { structOffset = value; }
}
public int StructCount
{
get { return structCount; }
set { structCount = value; }
}
public int FieldOffset
{
get { return fieldOffset; }
set { fieldOffset = value; }
}
public int FieldCount
{
get { return fieldCount; }
set { fieldCount = value; }
}
public int LabelOffset
{
get { return labelOffset; }
set { labelOffset = value; }
}
public int LabelCount
{
get { return labelCount; }
set { labelCount = value; }
}
public int FieldDataOffset
{
get { return fieldDataOffset; }
set { fieldDataOffset = value; }
}
public int FieldDataCount
{
get { return fieldDataCount; }
set { fieldDataCount = value; }
}
public int FieldIndecesOffset
{
get { return fieldIndecesOffset; }
set { fieldIndecesOffset = value; }
}
public int FieldIndecesCount
{
get { return fieldIndecesCount; }
set { fieldIndecesCount = value; }
}
public int ListIndecesOffset
{
get { return listIndecesOffset; }
set { listIndecesOffset = value; }
}
public int ListIndecesCount
{
get { return listIndecesCount; }
set { listIndecesCount = value; }
}
#endregion
#region public methods
public GffHeader(string type)
{
// Add the current GFF file version to the header.
const string verText = "V3.2";
version = new byte[4];
for (int i = 0; i < version.Length; i++)
version[i] = (byte) verText[i];
// Add the file type to the file.
type = type.ToUpper();
fileType = new byte[4];
for (int i = 0; i < fileType.Length; i++)
fileType[i] = i >= type.Length ? (byte) ' ' : (byte) type[i];
// Initialize all other fields.
fieldCount = 0;
fieldDataCount = 0;
fieldDataOffset = 0;
fieldIndecesCount = 0;
fieldIndecesOffset = 0;
fieldOffset = 0;
labelCount = 0;
labelOffset = 0;
listIndecesCount = 0;
listIndecesOffset = 0;
structCount = 0;
structOffset = 0;
}
/// <summary>
/// Constructor to deserialize the GffHeader from a stream.
/// </summary>
/// <param name="s"></param>
public GffHeader(Stream s)
{
// Let the raw serializer do the real work then just convert the
// returned object to an ErfHeader.
NWNLogger.Log(0, "GffHeader.GffHeader deserializing bytes");
object o = RawSerializer.Deserialize(typeof(GffHeader), s);
if (null == o) NWNLogger.Log(10, "RawSerializer.Deserialize returned null!!!");
if (null == o) throw new NWNException("Invalid Header in stream");
this = (GffHeader) o;
NWNLogger.Log(1, "GffHeader.GffHeader deserialized version {0}:{1}:{2}:{3}",
version[0], version[1], version[2], version[3]);
}
/// <summary>
/// Serializes the GffHeader to a stream.
/// </summary>
/// <param name="s">The stream to serialize to.</param>
public void Serialize(Stream s)
{
RawSerializer.Serialize(s, this);
}
#endregion
#region private fields
[MarshalAs(UnmanagedType.ByValArray, SizeConst=4)] private byte[] fileType;
[MarshalAs(UnmanagedType.ByValArray, SizeConst=4)] private byte[] version;
private Int32 structOffset;
private Int32 structCount;
private Int32 fieldOffset;
private Int32 fieldCount;
private Int32 labelOffset;
private Int32 labelCount;
private Int32 fieldDataOffset;
private Int32 fieldDataCount;
private Int32 fieldIndecesOffset;
private Int32 fieldIndecesCount;
private Int32 listIndecesOffset;
private Int32 listIndecesCount;
#endregion
}
/// <summary>
/// This class contains the raw GFF file data, either buffered as read from
/// the file (when reading) or in buf
/// </summary>
public class RawGffData
{
#region public nested structures
[StructLayout(LayoutKind.Sequential, Pack=1, CharSet=CharSet.Ansi)]
public struct RawGffStruct
{
#region public fields/properties/methods
public UInt32 Type;
public UInt32 DataOrDataOffset;
public UInt32 FieldCount;
/// <summary>
/// Class constructor
/// </summary>
/// <param name="type">Structure type ID</param>
public RawGffStruct(UInt32 type)
{
Type = type;
DataOrDataOffset = 0;
FieldCount = 0;
}
/// <summary>
/// Constructor to deserialize the RawGffStruct from a stream.
/// </summary>
/// <param name="s"></param>
public RawGffStruct(Stream s)
{
try
{
byte[] bytes = new Byte[4];
s.Read(bytes, 0, bytes.Length);
Type = BitConverter.ToUInt32(bytes, 0);
s.Read(bytes, 0, bytes.Length);
DataOrDataOffset = BitConverter.ToUInt32(bytes, 0);
s.Read(bytes, 0, bytes.Length);
FieldCount = BitConverter.ToUInt32(bytes, 0);
}
catch
{
throw new NWNException("Invalid struct in stream");
}
}
/// <summary>
/// Serializes the GffStruct to a stream.
/// </summary>
/// <param name="s">The stream to serialize to.</param>
public void Serialize(Stream s)
{
byte[] bytes = BitConverter.GetBytes(Type);
s.Write(bytes, 0, bytes.Length);
bytes = BitConverter.GetBytes(DataOrDataOffset);
s.Write(bytes, 0, bytes.Length);
bytes = BitConverter.GetBytes(FieldCount);
s.Write(bytes, 0, bytes.Length);
}
#endregion
}
/// <summary>
/// This structure defines the raw file gff field. This is used
/// to load/save GffFields to files, but the in memory representation
/// of a field is different.
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack=1, CharSet=CharSet.Ansi)]
public struct RawGffField
{
#region public fields/properties/methods
public UInt32 Type;
public UInt32 LabelIndex;
public UInt32 DataOrDataOffset;
/// <summary>
/// Class constructor
/// </summary>
/// <param name="type">Data type of the field</param>
public RawGffField(GffFieldType type)
{
Type = (UInt32) type;
LabelIndex = 0;
DataOrDataOffset = 0;
}
/// <summary>
/// Constructor to deserialize the RawGffField from a stream.
/// </summary>
/// <param name="s"></param>
public RawGffField(Stream s)
{
try
{
byte[] bytes = new Byte[4];
s.Read(bytes, 0, bytes.Length);
Type = BitConverter.ToUInt32(bytes, 0);
s.Read(bytes, 0, bytes.Length);
LabelIndex = BitConverter.ToUInt32(bytes, 0);
s.Read(bytes, 0, bytes.Length);
DataOrDataOffset = BitConverter.ToUInt32(bytes, 0);
}
catch
{
throw new NWNException("Invalid field in stream");
}
}
/// <summary>
/// Serializes the RawGffField to a stream.
/// </summary>
/// <param name="s">The stream to serialize to.</param>
public void Serialize(Stream s)
{
byte[] bytes = BitConverter.GetBytes(Type);
s.Write(bytes, 0, bytes.Length);
bytes = BitConverter.GetBytes(LabelIndex);
s.Write(bytes, 0, bytes.Length);
bytes = BitConverter.GetBytes(DataOrDataOffset);
s.Write(bytes, 0, bytes.Length);
}
/// <summary>
/// Deserializes an array of RawGffFields from a stream.
/// </summary>
/// <param name="s">The stream</param>
/// <param name="count">The number of fields to deserialize</param>
/// <returns>The deserialized array</returns>
public static RawGffField[] Deserialize(Stream s, int count)
{
RawGffField[] fields = new RawGffField[count];
for (int i = 0; i < count; i++)
fields[i] = new RawGffField(s);
return fields;
}
/// <summary>
/// Serializes an array of RawGffFields to a stream.
/// </summary>
/// <param name="s">The stream</param>
/// <param name="fields">The array of fields to serialize</param>
public static void Serialize(Stream s, RawGffField[] fields)
{
foreach (RawGffField gff in fields)
gff.Serialize(s);
}
#endregion
}
#endregion
#region public methods
/// <summary>
/// Constructor to create a RawGffData object used for writing a GFF file.
/// </summary>
public RawGffData()
{
access = FileAccess.Write;
structsStream = new MemoryStream();
fieldsStream = new MemoryStream();
complexDataStream = new MemoryStream();
fieldIndecesStream = new MemoryStream();
listIndecesStream = new MemoryStream();
labelsStream = new MemoryStream();
}
/// <summary>
/// Constructor to create a RawGffData object used for reading a GFF file
/// </summary>
/// <param name="s">Stream for the file</param>
/// <param name="header">The file's header</param>
public RawGffData(Stream s, GffHeader header)
{
access = FileAccess.Read;
// Read the various pieces of the GFF file into memory, placing
// each in a read only memory stream.
structsStream = CreateReadingStream(s, header.StructOffset,
header.StructCount * Marshal.SizeOf(typeof(RawGffStruct)));
fieldsStream = CreateReadingStream(s, header.FieldOffset,
header.FieldCount * Marshal.SizeOf(typeof(RawGffField)));
labelsStream = CreateReadingStream(s, header.LabelOffset,
header.LabelCount * ResRefLength);
complexDataStream = CreateReadingStream(s, header.FieldDataOffset,
header.FieldDataCount);
fieldIndecesStream = CreateReadingStream(s, header.FieldIndecesOffset,
header.FieldIndecesCount);
listIndecesStream = CreateReadingStream(s, header.ListIndecesOffset,
header.ListIndecesCount);
}
/// <summary>
/// This method initializes the module header based on the contents of
/// the raw data object.
/// </summary>
/// <param name="header">The header to initialize</param>
public void InitializeHeader(ref GffHeader header)
{
int offset = Marshal.SizeOf(typeof(GffHeader));
header.StructCount = (int) structsStream.Length / Marshal.SizeOf(typeof(RawGffStruct));;
header.StructOffset = offset;
offset += (int) structsStream.Length;
header.FieldCount = (int) fieldsStream.Length / Marshal.SizeOf(typeof(RawGffField));
header.FieldOffset = offset;
offset += (int) fieldsStream.Length;
header.LabelCount = (int) labelsStream.Length / ResRefLength;
header.LabelOffset = offset;
offset += (int) labelsStream.Length;
header.FieldDataCount = (int) complexDataStream.Length;
header.FieldDataOffset = offset;
offset += (int) complexDataStream.Length;
header.FieldIndecesCount = (int) fieldIndecesStream.Length;
header.FieldIndecesOffset = offset;
offset += (int) fieldIndecesStream.Length;
header.ListIndecesCount = (int) listIndecesStream.Length;
header.ListIndecesOffset = offset;
}
/// <summary>
/// Saves the raw data to the specified stream.
/// </summary>
/// <param name="s">The stream in which to save the raw data</param>
public void Save(Stream s)
{
byte[] bytes = structsStream.GetBuffer();
s.Write(bytes, 0, (int) structsStream.Length);
bytes = fieldsStream.GetBuffer();
s.Write(bytes, 0, (int) fieldsStream.Length);
bytes = labelsStream.GetBuffer();
s.Write(bytes, 0, (int) labelsStream.Length);
bytes = complexDataStream.GetBuffer();
s.Write(bytes, 0, (int) complexDataStream.Length);
bytes = fieldIndecesStream.GetBuffer();
s.Write(bytes, 0, (int) fieldIndecesStream.Length);
bytes = listIndecesStream.GetBuffer();
s.Write(bytes, 0, (int) listIndecesStream.Length);
s.Flush();
}
/// <summary>
/// Gets the index'th structure.
/// </summary>
/// <param name="index">The index of the structure to get</param>
/// <returns>A RawGffStruct containing a copy of the data for the
/// index'th structure</returns>
public RawGffStruct GetStruct(uint index)
{
// Make sure that the index is valid.
int size = Marshal.SizeOf(typeof(RawGffStruct));
int count = (int) structsStream.Length / size;
if (index >= count) throw new ArgumentOutOfRangeException();
// Seek to the index'th struct and return it.
structsStream.Seek(index * size, SeekOrigin.Begin);
return new RawGffStruct(structsStream);
}
/// <summary>
/// Adds a new structure to the end of the structure stream. This method
/// is only valid for write access raw data.
/// </summary>
/// <param name="rawStruct">The structure to add</param>
/// <returns>The index of the addes structure, it is always added to the
/// end of the list</returns>
public uint AddStruct(RawGffStruct rawStruct)
{
if (FileAccess.Write != access) throw new InvalidOperationException();
// Seek to the end of the stream and add the struct.
structsStream.Seek(0, SeekOrigin.End);
rawStruct.Serialize(structsStream);
// Count the number of structs in the stream and return the index of
// the last one, which is the one we just added.
int count = (int) structsStream.Length / Marshal.SizeOf(typeof(RawGffStruct));
return (uint) (count - 1);
}
/// <summary>
/// Updates a structure that has already been written.
/// </summary>
/// <param name="index">The index of the structure to update</param>
/// <param name="rawStruct">The new data</param>
public void UpdateStruct(uint index, RawGffStruct rawStruct)
{
if (FileAccess.Write != access) throw new InvalidOperationException();
// Make sure that the index is valid.
int size = Marshal.SizeOf(typeof(RawGffStruct));
int count = (int) structsStream.Length / size;
if (index >= count) throw new ArgumentOutOfRangeException();
// Seek to the structure in the stream and update the struct.
structsStream.Seek(index * size, SeekOrigin.Begin);
rawStruct.Serialize(structsStream);
}
/// <summary>
/// Gets the index'th field.
/// </summary>
/// <param name="index">The index of the field to get</param>
/// <returns>A RawGffField containing a copy of the data for the
/// index'th field</returns>
public RawGffField GetField(uint index)
{
// Make sure that the index is valid.
int size = Marshal.SizeOf(typeof(RawGffField));
int count = (int) fieldsStream.Length / size;
if (index >= count) throw new ArgumentOutOfRangeException();
// Seek to the index'th struct and return it.
fieldsStream.Seek(index * size, SeekOrigin.Begin);
return new RawGffField(fieldsStream);
}
/// <summary>
/// Adds a new field to the end of the structure stream. This method
/// is only valid for write access raw data.
/// </summary>
/// <param name="rawStruct">The field to add</param>
/// <returns>The index of the addes field, it is always added to the
/// end of the list</returns>
public uint AddField(RawGffField rawField)
{
if (FileAccess.Write != access) throw new InvalidOperationException();
// Seek to the end of the stream and add the struct.
fieldsStream.Seek(0, SeekOrigin.End);
rawField.Serialize(fieldsStream);
// Count the number of structs in the stream and return the index of
// the last one, which is the one we just added.
int count = (int) fieldsStream.Length / Marshal.SizeOf(typeof(RawGffField));
return (uint) (count - 1);
}
/// <summary>
/// Gets the index'th label.
/// </summary>
/// <param name="index">The index of the label to get</param>
/// <returns>The label</returns>
public string GetLabel(uint index)
{
// Make sure that the index is valid.
int count = (int) labelsStream.Length / ResRefLength;
if (index >= count) throw new ArgumentOutOfRangeException();
// Seek to the index'th struct and return it.
labelsStream.Seek(index * ResRefLength, SeekOrigin.Begin);
byte[] bytes = new byte[ResRefLength];
labelsStream.Read(bytes, 0, bytes.Length);
return RawGffData.DeserializeString(bytes, 0, ResRefLength);
}
/// <summary>
/// Gets the index of the given label, or -1 if it is not in the list.
/// </summary>
/// <param name="label">The label to get the index of</param>
/// <returns>The index of the label or -1 if it is not in the list</returns>
public int GetLabelIndex(string label)
{
// Loop through all of the strings looking for the specified label,
// returning it's index if we find it.
int count = (int) labelsStream.Length / ResRefLength;
for (int i = 0; i < count; i++)
if (label == GetLabel((uint) i)) return i;
// We didn't find it return -1.
return -1;
}
/// <summary>
/// Adds a label to the end of the list, returning the index of the
/// added label.
/// </summary>
/// <param name="label">The label to add</param>
/// <returns>The index of the added label</returns>
public uint AddLabel(string label)
{
if (FileAccess.Write != access) throw new InvalidOperationException();
// Create a 16 byte byte array from the label (padding with 0's if
// necessary, and write that to the stream.
byte[] bytes = new byte[ResRefLength];
for (int i = 0; i < ResRefLength; i++)
bytes[i] = i < label.Length ? (byte) label[i] : (byte) 0;
labelsStream.Write(bytes, 0, bytes.Length);
// Get the count and return the index of the last entry, which is what
// we just added.
int count = (int) labelsStream.Length / ResRefLength;
return (uint) (count - 1);
}
/// <summary>
/// Reads a byte array from the complex data.
/// </summary>
/// <param name="offset">Offset into the complex data to start reading</param>
/// <param name="buffer">Buffer in which to place the read data</param>
/// <param name="length">Number of bytes to read</param>
/// <returns>The number of bytes read</returns>
public int ReadComplexData(uint offset, byte[] buffer, int length)
{
complexDataStream.Seek((int) offset, SeekOrigin.Begin);
return complexDataStream.Read(buffer, 0, length);
}
/// <summary>
/// Gets the complex data byte array to allow direct access. The
/// array should only be read from in this manner.
/// </summary>
/// <returns>The complex data byte array</returns>
public byte[] GetComplexDataBuffer()
{
return complexDataStream.GetBuffer();
}
/// <summary>
/// Writes a byte array to the complex data.
/// </summary>
/// <param name="buffer">The buffer to write</param>
/// <param name="length">The number of bytes to write</param>
/// <returns>The offset of the written data</returns>
public uint WriteComplexData(byte[] buffer, int length)
{
if (FileAccess.Write != access) throw new InvalidOperationException();
// Seek to the end and save that position.
complexDataStream.Seek(0, SeekOrigin.End);
uint pos = (uint) complexDataStream.Position;
// Write the data and return it's offset.
complexDataStream.Write(buffer, 0, length);
return pos;
}
/// <summary>
/// Gets a field index from the given offset.
/// </summary>
/// <param name="offset">The offset (in bytes) to the field index, this is
/// NOT n index, it is the number of bytes</param>
/// <returns>The field index</returns>
public uint GetFieldIndex(uint offset)
{
return BitConverter.ToUInt32(fieldIndecesStream.GetBuffer(), (int) offset);
}
/// <summary>
/// Adds a field index to the end of the list.
/// </summary>
/// <param name="index">The index to add</param>
/// <returns>The offset of the written index</returns>
public uint AddFieldIndex(uint index)
{
if (FileAccess.Write != access) throw new InvalidOperationException();
// Seek to the end and save that position.
fieldIndecesStream.Seek(0, SeekOrigin.End);
int pos = (int) fieldIndecesStream.Position;
// Write the data and return it's offset.
byte[] bytes = BitConverter.GetBytes(index);
fieldIndecesStream.Write(bytes, 0, bytes.Length);
return (uint) pos;
}
/// <summary>
/// Adds a range of field indeces to the end of the list.
/// </summary>
/// <param name="indeces">The indeces to add</param>
/// <returns>The offset of the written indeces</returns>
public uint AddFieldIndeces(uint[] indeces)
{
// Add all of the indeces, saving the offset of the first added index.
uint offset = 0;
for (int i = 0; i < indeces.Length; i++)
{
uint offsetCurrent = AddFieldIndex(indeces[i]);
if (0 == i) offset = offsetCurrent;
}
return offset;
}
/// <summary>
/// Gets the collection of list indeces at the given offset.
/// </summary>
/// <param name="offset">The offset of the list indeces</param>
/// <returns>An array of list indeces read from the given offset</returns>
public uint[] GetListIndeces(uint offset)
{
// Get the list count.
byte[] bytes = listIndecesStream.GetBuffer();
uint count = BitConverter.ToUInt32(bytes, (int) offset);
offset += 4;
// Read the list indeces from the stream into a uint array and
// return it.
uint[] indeces = new uint[count];
for (int i = 0; i < count; i++, offset += 4)
indeces[i] = BitConverter.ToUInt32(bytes, (int) offset);
return indeces;
}
/// <summary>
/// Adds a collection of list indeces to the end of the list.
/// </summary>
/// <param name="indeces">The indeces to add</param>
/// <returns>The offset of the written indeces</returns>
public uint AddListIndeces(uint[] indeces)
{
if (FileAccess.Write != access) throw new InvalidOperationException();
// Seek to the end and save that position.
listIndecesStream.Seek(0, SeekOrigin.End);
int pos = (int) listIndecesStream.Position;
// Write the number of list indeces first.
byte[] bytes = BitConverter.GetBytes((uint) indeces.Length);
listIndecesStream.Write(bytes, 0, bytes.Length);
// Write the list indeces
for (int i = 0; i < indeces.Length; i++)
{
bytes = BitConverter.GetBytes(indeces[i]);
listIndecesStream.Write(bytes, 0, bytes.Length);
}
// Return the offset to the data.
return (uint) pos;
}
#endregion
#region public static methods
/// <summary>
/// Deserializes a string from a byte array.
/// </summary>
/// <param name="bytes">The bytes to deserialize</param>
/// <param name="offset">The offset into the byte array</param>
/// <param name="length">The maximum length of the string, which may be
/// null padded in the byte array</param>
/// <returns>A string object for the string</returns>
public static string DeserializeString(byte[] bytes, int offset, int length)
{
// Calculate the actual number of used characters, which may be less
// than the length.
int used = 0;
for (used = 0; used < length; used++)
if (0 == bytes[offset + used]) break;
// Create a character array and copy the used characters to it.
char[] chars = new char[used];
for (int i = 0; i < used; i++)
chars[i] = (char) bytes[offset + i];
// Create a string from the character array.
return new string(chars);
}
#endregion
#region private fields/properties/methods
private const int ResRefLength = 16;
private FileAccess access;
private MemoryStream structsStream;
private MemoryStream fieldsStream;
private MemoryStream complexDataStream;
private MemoryStream fieldIndecesStream;
private MemoryStream listIndecesStream;
private MemoryStream labelsStream;
/// <summary>
/// This method creates a read-only MemoryStream object from a piece of
/// the passed stream.
/// </summary>
/// <param name="s">The source stream</param>
/// <param name="offset">The offset into the source stream to start the
/// memory stream at</param>
/// <param name="length">The length of the memory stream in bytes</param>
/// <returns>A read only memory stream representing the specified
/// piece of the source stream</returns>
private MemoryStream CreateReadingStream(Stream s, int offset, int length)
{
s.Seek(offset, SeekOrigin.Begin);
byte[] bytes = new byte[length];
if (bytes.Length != s.Read(bytes, 0, bytes.Length))
throw new NWNException("Corrupt file");
return new MemoryStream(bytes, 0, bytes.Length, false, true);
}
#endregion
}
/// <summary>
/// This interface defines the serialization protocol that all GffField
/// derived objects must implement.
/// </summary>
public interface IGffFieldSerialize
{
#region properties/methods
/// <summary>
/// Deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void Deserialize(RawGffData.RawGffField rawField, RawGffData rawData);
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 Serialize(RawGffData rawData);
#endregion
}
/// <summary>
/// This class defines a field in a GFF field. A field is a single data
/// value in the GFF file. Classes derived from this must implement
/// the IGffFieldSerialize interface.
/// </summary>
public abstract class GffField
{
#region public properties/methods
/// <summary>
/// Returns true if the field is a complex field. Non-complex
/// fields have their data stored directly in the
/// GffField.DataOrDataOffset, complex fields store an offset
/// and the real data is in the raw complex data.
/// </summary>
public bool IsComplex
{
get
{
switch (fieldType)
{
case GffFieldType.DWord64:
case GffFieldType.Int64:
case GffFieldType.Double:
case GffFieldType.ExoString:
case GffFieldType.ResRef:
case GffFieldType.ExoLocString:
case GffFieldType.Void:
case GffFieldType.Struct:
case GffFieldType.List:
return true;
}
return false;
}
}
/// <summary>
/// Returns true if the field is a structure.
/// </summary>
public bool IsStruct { get { return GffFieldType.Struct == fieldType; } }
/// <summary>
/// Returns true if the field is a list.
/// </summary>
public bool IsList { get { return GffFieldType.List == fieldType; } }
/// <summary>
/// Gets the data type of the field.
/// </summary>
public GffFieldType Type { get { return fieldType; } }
/// <summary>
/// Gets/sets the field value.
/// </summary>
public object Value
{
get { return fieldValue; }
set { fieldValue = value; }
}
/// <summary>
/// Gets/sets the field value. This property will provide a way to get at
/// the object boxed value even when invoked from within a derived class
/// that will replace the Value property.
/// </summary>
public object BoxedValue
{
get { return fieldValue; }
set { fieldValue = value; }
}
/// <summary>
/// Override ToString() to do a ToString() on the value.
/// </summary>
public override string ToString()
{
return Value.ToString();
}
#endregion
#region protected methods
/// <summary>
/// Class constructor
/// </summary>
/// <param name="fieldType">The data type of the field.</param>
/// <param name="fieldValue">The field's value</param>
protected GffField(GffFieldType fieldType, object fieldValue)
{
// Make sure the derived class implements IGffSerialize
if (!(this is IGffFieldSerialize)) throw new NWNException("Must implement IGffSerialize");
this.fieldType = fieldType;
this.fieldValue = fieldValue;
}
#endregion
#region private fields/properties/methods
private GffFieldType fieldType;
private object fieldValue;
#endregion
}
/// <summary>
/// Class that implements a GFF byte field.
/// </summary>
public class GffByteField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new byte Value
{
get { return (byte) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffByteField() : this(0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffByteField(byte val) : base(GffFieldType.Byte, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = (byte) rawField.DataOrDataOffset;
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
return (UInt32) Value;
}
#endregion
}
/// <summary>
/// Class that implements a GFF char field.
/// </summary>
public class GffCharField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new sbyte Value
{
get { return (sbyte) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffCharField() : this(0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffCharField(sbyte val) : base(GffFieldType.Char, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = (sbyte) rawField.DataOrDataOffset;
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
return (UInt32) Value;
}
#endregion
}
/// <summary>
/// Class that implements a GFF word field.
/// </summary>
public class GffWordField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new ushort Value
{
get { return (ushort) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffWordField() : this(0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffWordField(ushort val) : base(GffFieldType.Word, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = (ushort) rawField.DataOrDataOffset;
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
return (UInt32) Value;
}
#endregion
}
/// <summary>
/// Class that implements a GFF short field.
/// </summary>
public class GffShortField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new short Value
{
get { return (short) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffShortField() : this(0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffShortField(short val) : base(GffFieldType.Short, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = (short) rawField.DataOrDataOffset;
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
return (UInt32) Value;
}
#endregion
}
/// <summary>
/// Class that implements a GFF DWord field.
/// </summary>
public class GffDWordField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new uint Value
{
get { return (uint) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffDWordField() : this(0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffDWordField(uint val) : base(GffFieldType.DWord, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = (uint) rawField.DataOrDataOffset;
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
return (UInt32) Value;
}
#endregion
}
/// <summary>
/// Class that implements a GFF Int field.
/// </summary>
public class GffIntField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new int Value
{
get { return (int) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffIntField() : this(0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffIntField(int val) : base(GffFieldType.Int, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = (int) rawField.DataOrDataOffset;
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
return (UInt32) Value;
}
#endregion
}
/// <summary>
/// Class that implements a GFF DWord64 field.
/// </summary>
public class GffDWord64Field: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new ulong Value
{
get { return (ulong) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffDWord64Field() : this(0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffDWord64Field(ulong val) : base(GffFieldType.DWord64, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = BitConverter.ToUInt64(rawData.GetComplexDataBuffer(),
(int) rawField.DataOrDataOffset);
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
byte[] bytes = BitConverter.GetBytes(Value);
return rawData.WriteComplexData(bytes, bytes.Length);
}
#endregion
}
/// <summary>
/// Class that implements a GFF Int64 field.
/// </summary>
public class GffInt64Field: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new long Value
{
get { return (long) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffInt64Field() : this(0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffInt64Field(long val) : base(GffFieldType.Int64, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = BitConverter.ToInt64(rawData.GetComplexDataBuffer(),
(int) rawField.DataOrDataOffset);
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
byte[] bytes = BitConverter.GetBytes(Value);
return rawData.WriteComplexData(bytes, bytes.Length);
}
#endregion
}
/// <summary>
/// Class that implements a GFF float field.
/// </summary>
public class GffFloatField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new float Value
{
get { return (float) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffFloatField() : this(0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffFloatField(float val) : base(GffFieldType.Float, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
byte[] bytes = BitConverter.GetBytes(rawField.DataOrDataOffset);
Value = BitConverter.ToSingle(bytes, 0);
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
byte[] bytes = BitConverter.GetBytes(Value);
return BitConverter.ToUInt32(bytes, 0);
}
#endregion
}
/// <summary>
/// Class that implements a GFF double field.
/// </summary>
public class GffDoubleField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new double Value
{
get { return (double) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffDoubleField() : this(0.0) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffDoubleField(double val) : base(GffFieldType.Double, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = BitConverter.ToDouble(rawData.GetComplexDataBuffer(),
(int) rawField.DataOrDataOffset);
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
byte[] bytes = BitConverter.GetBytes(Value);
return rawData.WriteComplexData(bytes, bytes.Length);
}
#endregion
}
/// <summary>
/// Class that implements a GFF ExoString field.
/// </summary>
public class GffExoStringField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new string Value
{
get { return (string) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffExoStringField() : this(string.Empty) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffExoStringField(string val) : base(GffFieldType.ExoString, val) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
byte[] bytes = rawData.GetComplexDataBuffer();
uint length = BitConverter.ToUInt32(bytes, (int) rawField.DataOrDataOffset);
Value = RawGffData.DeserializeString(bytes,
(int) rawField.DataOrDataOffset + 4, (int) length);
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
// Write the string length first, saving the offset of the written
// position.
byte[] bytes = BitConverter.GetBytes(Value.Length);
uint offset = rawData.WriteComplexData(bytes, bytes.Length);
// Now write the string data.
bytes = new byte[Value.Length];
for (int i = 0; i < Value.Length; i++)
bytes[i] = (byte) Value[i];
rawData.WriteComplexData(bytes, bytes.Length);
// return the offset of our data.
return offset;
}
#endregion
}
/// <summary>
/// Class that implements a GFF ResRef field.
/// </summary>
public class GffResRefField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new string Value
{
get { return (string) BoxedValue; }
set
{
if (value.Length > 16) throw new OverflowException("ResRefs can only be 16 characters");
BoxedValue = value.ToLower();
}
}
/// <summary>
/// Default constructor.
/// </summary>
public GffResRefField() : this(string.Empty) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="val"></param>
public GffResRefField(string val) :
base(GffFieldType.ResRef, val)
{
if (Value.Length > 16) throw new OverflowException("ResRefs can only be 16 characters");
}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
byte[] bytes = rawData.GetComplexDataBuffer();
byte length = bytes[rawField.DataOrDataOffset];
Value = RawGffData.DeserializeString(bytes,
(int) rawField.DataOrDataOffset + 1, (int) length);
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
// Write the string length first, saving the offset of the written
// position.
byte[] bytes = new Byte[1];
bytes[0] = (byte) Value.Length;
uint offset = rawData.WriteComplexData(bytes, bytes.Length);
// Now write the string data.
bytes = new byte[Value.Length];
for (int i = 0; i < Value.Length; i++)
bytes[i] = (byte) Value[i];
rawData.WriteComplexData(bytes, bytes.Length);
// return the offset of our data.
return offset;
}
#endregion
}
/// <summary>
/// Class that implements a GFF ExoLocString field.
/// </summary>
public class GffExoLocStringField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new ExoLocString Value
{
get { return (ExoLocString) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffExoLocStringField() : this(0, true, string.Empty) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="languageID">Language ID</param>
/// <param name="male">True if string is masculine</param>
/// <param name="val">String</param>
public GffExoLocStringField(uint languageID, bool male, string val) :
base(GffFieldType.ExoLocString, new ExoLocString(languageID, male, val)) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
Value = new ExoLocString(rawData.GetComplexDataBuffer(),
(int) rawField.DataOrDataOffset);
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
byte[] bytes = Value.Serialize();
return rawData.WriteComplexData(bytes, bytes.Length);
}
#endregion
}
/// <summary>
/// Class that implements a GFF bag of bytes field.
/// </summary>
public class GffVoidField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new MemoryStream Value
{
get { return (MemoryStream) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffVoidField() : this(new MemoryStream()) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="stream">The memory stream containing the data</param>
public GffVoidField(MemoryStream stream) : base(GffFieldType.Void, stream) {}
/// <summary>
/// Override ToString() to do a ToString() on the value.
/// </summary>
public override string ToString()
{
// Generate a string showing the hex byte values.
return BitConverter.ToString(Value.GetBuffer(), 0);
}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
// Determine the length of the bob.
byte[] complexData = rawData.GetComplexDataBuffer();
uint length = BitConverter.ToUInt32(complexData, (int) rawField.DataOrDataOffset);
// Copy the data from the complex data byte array to a local byte array.
byte[] bytes = new Byte[length];
for (int i = 0; i < length; i++)
bytes[i] = complexData[rawField.DataOrDataOffset + 4 + i];
// Save the data in a memory stream.
Value = new MemoryStream(bytes, 0, bytes.Length, true, true);
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
byte[] bytes = BitConverter.GetBytes((uint) Value.Length);
uint offset = rawData.WriteComplexData(bytes, bytes.Length);
rawData.WriteComplexData(Value.GetBuffer(), (int) Value.Length);
return offset;
}
#endregion
}
/// <summary>
/// Class that implements a GFF structure field.
/// </summary>
public class GffStructField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Gets/sets the structure type.
/// </summary>
public uint StructureType
{
get { return structureType; }
set { structureType = value; }
}
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new GffFieldDictionary Value
{
get { return (GffFieldDictionary) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffStructField() : this(new GffFieldDictionary()) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="stream">The memory stream containing the data</param>
public GffStructField(GffFieldDictionary dict) : base(GffFieldType.Struct, dict)
{
structureType = 0;
}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
// Save the structure type.
RawGffData.RawGffStruct rawStruct = rawData.GetStruct(rawField.DataOrDataOffset);
structureType = rawStruct.Type;
// Fill in the field dictionary and assign it to our value.
Value = GetFieldStruct(rawStruct, rawData);
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
return SaveFieldStruct(structureType, Value, rawData);
}
#endregion
#region public static methods
public static GffFieldDictionary GetFieldStruct(RawGffData.RawGffStruct gstruct,
RawGffData rawData)
{
// Loop through all of the fields in the struct adding them to the
// collection.
GffFieldDictionary fields = new GffFieldDictionary();
for (int i = 0; i < gstruct.FieldCount; i++)
{
// Get the index of the current field. If the structure has 1
// member then the offset is in DataOrDataOffset directly, if not
// then DataOrDataOffset points to an array of DWORD indeces in
// the raw field indeces block.
uint fieldIndex = 1 == gstruct.FieldCount ?
gstruct.DataOrDataOffset :
rawData.GetFieldIndex((uint) (gstruct.DataOrDataOffset + (i * 4)));
// Get the data label.
RawGffData.RawGffField rawField = rawData.GetField(fieldIndex);
string label = rawData.GetLabel(rawField.LabelIndex);
// Create a GffField object for the field and add it to the
// dictionary, using the label as the key.
GffField field = GffFieldFactory.CreateField(rawField, rawData);
fields.Add(label, field);
}
return fields;
}
/// <summary>
/// Saves all of the data associated with the given structure.
/// </summary>
/// <param name="type">The type ID of the structure</param>
/// <param name="dict">The structure's dictionary</param>
/// <param name="rawData">The raw data in which to save the structure</param>
/// <returns>The index of the structure in the raw data</returns>
public static uint SaveFieldStruct(uint type, GffFieldDictionary dict,
RawGffData rawData)
{
// Create the structure and fill in the data we can then add it. Note
// that we can't fill in the DataOrDataOffset yet since we don't know
// what that value is until after all of the fields have been added.
// We will update the structure when we are done.
RawGffData.RawGffStruct rawStruct = new RawGffData.RawGffStruct(type);
rawStruct.FieldCount = (uint) dict.Count;
rawStruct.DataOrDataOffset = 0;
uint structureIndex = rawData.AddStruct(rawStruct);
// Create an array to hold all of the field index values and loop through
// the dictionary to store all of the structure elements.
uint[] indeces = new uint[dict.Count];
uint i = 0;
foreach (DictionaryEntry entry in dict)
{
// Get the label and field from the entry.
string label = (string) entry.Key;
GffField field = (GffField) entry.Value;
// Create a raw field for the field.
RawGffData.RawGffField rawField = new RawGffData.RawGffField(field.Type);
// Get the index of the label, adding it if it's not in the raw data.
rawField.LabelIndex = (uint) rawData.GetLabelIndex(label);
if (0xffffffff == rawField.LabelIndex)
rawField.LabelIndex = (uint) rawData.AddLabel(label);
// Serialize the field's data and save the offset to the serialized
// data (for some fields the offset may be the data itself).
IGffFieldSerialize serialize = (IGffFieldSerialize) field;
rawField.DataOrDataOffset = serialize.Serialize(rawData);
// Add the field to the raw data, saving the index of the added
// field in our index array.
indeces[i++] = rawData.AddField(rawField);
}
// If we have multiple fields, we have to add the index array to the
// field indeces and save the offset, otherwise we can just save the
// field index as our data offset. Once we do this we have to update
// the structure to store the offset.
rawStruct.DataOrDataOffset = 1 == dict.Count ?
indeces[0] : rawData.AddFieldIndeces(indeces);
rawData.UpdateStruct(structureIndex, rawStruct);
// Return the structure's index.
return structureIndex;
}
#endregion
#region private fields/properties/methods
uint structureType;
#endregion
}
/// <summary>
/// Class that implements a GFF list field.
/// </summary>
public class GffListField: GffField, IGffFieldSerialize
{
#region public properties/methods
/// <summary>
/// Replace GffField.Value with a type specific property.
/// </summary>
public new GffFieldCollection Value
{
get { return (GffFieldCollection) BoxedValue; }
set { BoxedValue = value; }
}
/// <summary>
/// Default constructor.
/// </summary>
public GffListField() : this(new GffFieldCollection()) {}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="stream">The memory stream containing the data</param>
public GffListField(GffFieldCollection coll) : base(GffFieldType.List, coll) {}
#endregion
#region IGffFieldSerialize implementation
/// <summary>
/// Override to deserialize the object from the GFF file's binary data.
/// </summary>
/// <param name="rawField">The raw field from the GFF</param>
/// <param name="rawData">The GFF's raw file data</param>
void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData)
{
// Get the list of structure indeces for the items in the list
uint[] indeces = rawData.GetListIndeces(rawField.DataOrDataOffset);
// Create a field collection for the structures, and loop through
// the index array.
GffFieldCollection fields = new GffFieldCollection();
for (int i = 0; i < indeces.Length; i++)
{
// Get the raw structure data for this structure.
RawGffData.RawGffStruct rawStruct = rawData.GetStruct(indeces[i]);
// Create a GffStructField object for the structure and set it's
// structure type.
GffStructField field = (GffStructField)
GffFieldFactory.CreateField(GffFieldType.Struct);
field.StructureType = rawStruct.Type;
// Create a dummy field object so we can deserialize the structure,
// set it's DataOrDataOffset to the structure index.
RawGffData.RawGffField dummyField = new RawGffData.RawGffField(GffFieldType.Struct);
dummyField.LabelIndex = 0;
dummyField.DataOrDataOffset = indeces[i];
// Deserialize the structure.
((IGffFieldSerialize) field).Deserialize(dummyField, rawData);
// Add the structure to the collection.
fields.Add(field);
}
Value = fields;
}
/// <summary>
/// Override to serialize the object to a byte array that can be stored
/// in the GFF's binary data. It serializes the data according to
/// BioWare's GFF file specification. Simple data items are returned
/// in the return value, complex items are stored in the stream and 0
/// is returned.
/// </summary>
/// <param name="rawData">The raw data in which to store the field's
/// data.</param>
/// <returns>For simple items the return value contains the item's
/// data and the stream is uneffected. For complex items, the
/// return value is the offset of the written data and the items's
/// data is added to the end of the stream.</returns>
UInt32 IGffFieldSerialize.Serialize(RawGffData rawData)
{
// Create an array to hold all of the structure indeces,
// then loop through all of the structures, serializing
// them and saving the returned offsets.
uint[] indeces = new uint[Value.Count];
for (int i = 0; i < Value.Count; i++)
{
IGffFieldSerialize serialize = (IGffFieldSerialize) Value[i];
indeces[i] = serialize.Serialize(rawData);
}
// Add the index array to the list indeces and return that offset.
return rawData.AddListIndeces(indeces);
}
#endregion
}
/// <summary>
/// This class is a factory class to create GffField derived objects.
/// </summary>
public class GffFieldFactory
{
#region public static methods
/// <summary>
/// Creates a GffField derived object for the specified field type.
/// </summary>
/// <param name="type">The type of object to create</param>
/// <returns>The created GffField derived object</returns>
public static GffField CreateField(GffFieldType type)
{
switch (type)
{
case GffFieldType.Byte:
return new GffByteField();
case GffFieldType.Char:
return new GffCharField();
case GffFieldType.Word:
return new GffWordField();
case GffFieldType.Short:
return new GffShortField();
case GffFieldType.DWord:
return new GffDWordField();
case GffFieldType.Int:
return new GffIntField();
case GffFieldType.Float:
return new GffFloatField();
case GffFieldType.DWord64:
return new GffDWord64Field();
case GffFieldType.Int64:
return new GffInt64Field();
case GffFieldType.Double:
return new GffDoubleField();
case GffFieldType.ResRef:
return new GffResRefField();
case GffFieldType.ExoString:
return new GffExoStringField();
case GffFieldType.Void:
return new GffVoidField();
case GffFieldType.Struct:
return new GffStructField();
case GffFieldType.List:
return new GffListField();
case GffFieldType.ExoLocString:
return new GffExoLocStringField();
default:
throw new NWNException("Unsupported data type");
}
}
/// <summary>
/// Creates a GffField derived object and deserializes the field's data
/// into the created object.
/// </summary>
/// <param name="rawField">The raw field data for the object to create</param>
/// <param name="rawData">The raw GFF file data</param>
/// <returns>The created GffField derived object</returns>
public static GffField CreateField(RawGffData.RawGffField rawField,
RawGffData rawData)
{
// Create an empty GffField object.
GffField field = CreateField((GffFieldType) rawField.Type);
// Get the field's IGffFieldSerialize implementation.
IGffFieldSerialize serialize = field as IGffFieldSerialize;
if (null == serialize) throw new InvalidCastException("IGffSerialize not implemented");
// Deserialize the object.
serialize.Deserialize(rawField, rawData);
return field;
}
#endregion
}
/// <summary>
/// This class implements a dictionary based collection of GffField
/// objects. This is used to store the data for a structure in the
/// GFF file, where each data element may be referenced by it's label.
/// Any data item with a data type of struct (including the root top
/// level struct) has a GffFieldDictionary object as it's value.
/// </summary>
public class GffFieldDictionary: DictionaryBase
{
#region public properties/methods
/// <summary>
/// Indexer to lookup a field based on it's label.
/// </summary>
public GffField this[string label]
{ get { return InnerHashtable[label] as GffField; } }
/// <summary>
/// Indexer to get the index'th DictionaryEntry in the collection.
/// It uses the ordered entries list to give the entries back in the same
/// order that they were placed in the collection.
/// </summary>
public DictionaryEntry this[int index]
{ get { return (DictionaryEntry) orderedEntries[index]; } }
/// <summary>
/// Class constructor.
/// </summary>
public GffFieldDictionary()
{
orderedEntries = new ArrayList();
}
/// <summary>
/// Adds a field to the dictionary.
/// </summary>
/// <param name="label">The field's label</param>
/// <param name="field">The field's data</param>
public void Add(string label, GffField field)
{
// Add the entry to the hashtable in the dictionary, then
// add it to the end of our ordered entries collection. The
// ordered entries collectoin will allow us to traverse the
// dictionary in the order that the entries were added, preserving
// this order.
InnerHashtable.Add(label, field);
DictionaryEntry entry = new DictionaryEntry(label, field);
orderedEntries.Add(entry);
}
/// <summary>
/// Replace GetEnumerator() to return an enumerator that uses the
/// orderedEntries collection rather than the dictionary to enumerate
/// the objects.
/// </summary>
/// <returns>The dictionary enumerator</returns>
public new IDictionaryEnumerator GetEnumerator()
{
return new Enumerator(orderedEntries);
}
#endregion
#region private fields/properties/methods
private ArrayList orderedEntries;
/// <summary>
/// Nested class to enumerate the dictionary entries using the
/// orderedEntries collection rather than the dictionary. This allows
/// us to enumerate them in the order they were added.
/// </summary>
private class Enumerator: IDictionaryEnumerator
{
#region implementation
public DictionaryEntry Entry { get { return (DictionaryEntry) Current; } }
public object Key { get { return Entry.Key; } }
public object Value { get { return Entry.Value; } }
public object Current { get { return baseEnumerator.Current; } }
public bool MoveNext() { return baseEnumerator.MoveNext(); }
public void Reset() { baseEnumerator.Reset(); }
public Enumerator(ArrayList list) { baseEnumerator = list.GetEnumerator(); }
private IEnumerator baseEnumerator;
#endregion
}
#endregion
}
/// <summary>
/// This class implements a collection of GffField objects. This is used
/// to store the data for a list in the GFF file. Any data item with a
/// data type of list has a GffFieldCollection object as it's value. Lists
/// in GFF files are always lists of structures (even if the structures only
/// have 1 item) so each GffField in the list should be a structure (which
/// means that it's value will be a GffFieldDictionary).
/// </summary>
public class GffFieldCollection: CollectionBase
{
#region public properties/methods
/// <summary>
/// Indexer to access the individual GffField objects.
/// </summary>
public GffField this[int index]
{
get
{
return InnerList[index] as GffField;
}
}
/// <summary>
/// Class constructor
/// </summary>
public GffFieldCollection()
{
}
/// <summary>
/// Adds a field to the end of the collection.
/// </summary>
/// <param name="field"></param>
public void Add(GffField field)
{
InnerList.Add(field);
}
/// <summary>
/// Adds a field at the specified position in the collection.
/// </summary>
/// <param name="index">The index of the field to add</param>
/// <param name="field">The field to add</param>
public void Insert(int index, GffField field)
{
InnerList.Insert(index, field);
}
#endregion
}
/// <summary>
/// This class implements a GFF file. This is a generic file format used
/// by BioWare to store various game items. It provides the base functionality
/// to read/write the GFF file into a data tree. GFF files are trees,
/// consisting of a top level structure, which contains fields, which themselves
/// may be structures or lists of structures. Each field in the tree is
/// represented by a GffField object, the value of which is dependent on the
/// data type of the field. Structures are represented by GffFieldDictionary
/// objects, and lists by GffFieldCollection objects.
///
/// The various kinds of GFF files may derive from this base class to gain
/// the load/save functionality, and then provide easier access to the file
/// data.
/// </summary>
public class Gff
{
#region public properties/methods
/// <summary>
/// Gets the file name of the GFF file.
/// </summary>
public string Name { get { return Path.GetFileName(fileName); } }
/// <summary>
/// Property to provide access to the GFF file's top level structure.
/// </summary>
public GffFieldDictionary TopLevel { get { return topLevel; } }
/// <summary>
/// Class constructor to create a GFF object from a file.
/// </summary>
/// <param name="fileName">The file to load.</param>
public Gff(string fileName)
{
using (FileStream reader = new FileStream(fileName, FileMode.Open,
FileAccess.Read, FileShare.Read))
{
LoadStream(reader);
this.fileName = fileName;
}
}
/// <summary>
/// Class constructor to create a GFF object from a stream. The GFF file
/// should begin at the stream's current seek point.
/// </summary>
/// <param name="stream">The stream to create the object from.</param>
public Gff(Stream stream)
{
LoadStream(stream);
fileName = "";
}
/// <summary>
/// Saves the GFF, overwriting the old copy.
/// </summary>
public void Save()
{
SaveAs(fileName);
}
/// <summary>
/// Saves the GFF, using a new file name.
/// </summary>
/// <param name="fileName">The new file name for the GFF</param>
public void SaveAs(string fileName)
{
// Save the top level structure to the raw data.
RawGffData rawData = new RawGffData();
GffStructField.SaveFieldStruct(0xffffffff, topLevel, rawData);
// Create a header for the GFF file.
string type = Path.GetExtension(fileName);
type = type.Substring(1, type.Length - 1);
GffHeader header = new GffHeader(type);
rawData.InitializeHeader(ref header);
// Create the disk file and save the header and raw data.
using (FileStream writer = new FileStream(fileName, FileMode.Create,
FileAccess.Write, FileShare.Write))
{
header.Serialize(writer);
rawData.Save(writer);
writer.Close();
}
}
#endregion
#region protected properties/methods
/// <summary>
/// Gets the GffField derived object for the given schema. It will check
/// the top level structure for the field, if it is not found then it will
/// create it and add it to the top level structure.
/// </summary>
/// <param name="schema">The field's schema</param>
/// <returns>The GffField derived object for the field.</returns>
protected GffField GetField (GffFieldSchema schema) { return GetField(schema, topLevel); }
/// <summary>
/// Gets the GffField derived object for the given schema. It will check
/// the passed field dictionary for the field, if it is not found then it will
/// create it and add it to the dictionary.
/// </summary>
/// <param name="schema">The field's schema</param>
/// <param name="dict">The field dictionary to check</param>
/// <returns>The GffField derived object for the field.</returns>
protected GffField GetField (GffFieldSchema schema, GffFieldDictionary dict)
{
// Look up the field for the label. If we cannot look it up then
// it has not been added to the module info file, we need to add
// it ourselves.
GffField field = dict[schema.Tag];
if (null == field)
{
field = schema.CreateField();
dict.Add(schema.Tag, field);
}
return field;
}
#endregion
#region private fields/properties/methods
private string fileName;
private GffFieldDictionary topLevel;
/// <summary>
/// Loads the GFF file from the specified stream.
/// </summary>
/// <param name="stream">The stream to load the GFF file from.s</param>
private void LoadStream(Stream stream)
{
// Read the header.
NWNLogger.Log(0, "Gff.LoadStream loading header");
GffHeader header = new GffHeader(stream);
NWNLogger.Log(1, "Gff.LoadStream version {0}", header.VersionText);
if ("V3.2" != header.VersionText)
throw new NWNException("Version {0} GFF files are unsupported", header.VersionText);
NWNLogger.Log(0, "Gff.LoadStream reading raw GFF data");
RawGffData rawData = new RawGffData(stream, header);
topLevel = GffStructField.GetFieldStruct(rawData.GetStruct(0), rawData);
}
#endregion
}
}