public static Dictionary <string, int> Facet(Query query, IndexSearcher s, string field)
{
StringIndex stringIndex = FieldCache_Fields.DEFAULT.GetStringIndex(s.GetIndexReader(), field);
int[] c = new int[stringIndex.lookup.Length];
SimpleFacets.FacetCollector facetCollector = new SimpleFacets.FacetCollector(c, stringIndex);
s.Search(query, (HitCollector)facetCollector);
SimpleFacets.DictionaryEntryQueue dictionaryEntryQueue = new SimpleFacets.DictionaryEntryQueue(stringIndex.lookup.Length);
for (int index = 1; index < stringIndex.lookup.Length; ++index)
{
if (c[index] > 0 && stringIndex.lookup[index] != null && stringIndex.lookup[index] != "0")
{
dictionaryEntryQueue.Insert((object)new SimpleFacets.FacetEntry(stringIndex.lookup[index], -c[index]));
}
}
int num = dictionaryEntryQueue.Size();
Dictionary <string, int> dictionary = new Dictionary <string, int>();
for (int index = num - 1; index >= 0; --index)
{
SimpleFacets.FacetEntry facetEntry = dictionaryEntryQueue.Pop() as SimpleFacets.FacetEntry;
dictionary.Add(facetEntry.Value, -facetEntry.Count);
}
return(dictionary);
}
public async Task AddMultipleNonUnique_GetByQuery_ContainsOnlyUnique(int tasksCount)
{
using var index = new StringIndex <string>();
var inputs = new Dictionary <string, IEnumerable <string> >();
for (var i = 0; i < tasksCount; i++)
{
var nonUnique = Guid.NewGuid().ToString();
inputs[Guid.NewGuid().ToString()] = new[] { nonUnique, nonUnique, nonUnique, nonUnique };
}
var tasks = new List <Task>();
foreach (var(q, input) in inputs)
{
tasks.Add(Task.Run(() => index.Add(q, input.Take(2))));
tasks.Add(Task.Run(() => index.Add(q, input.Skip(2))));
}
await Task.WhenAll(tasks);
var getTasks = inputs.Keys.Select(q => Task.Run(() => new { Query = q, Result = index.Get(q) })).ToList();
await Task.WhenAll(getTasks);
foreach (var task in getTasks)
{
var(query, result) = (task.Result.Query, task.Result.Result);
var input = inputs[query].ToList();
Assert.All(input, x => Assert.Contains(x, result));
Assert.Equal(1, result.Count);
Assert.NotEqual(input.Count, result.Count);
Assert.Equal(new HashSet <string>(input), result);
}
}
public static Dictionary <string, int> Facet(Query query, IndexSearcher s, string field)
{
StringIndex stringIndex = FieldCache_Fields.DEFAULT.GetStringIndex(s.GetIndexReader(), field);
int[] array = new int[stringIndex.lookup.Length];
SimpleFacets.FacetCollector results = new SimpleFacets.FacetCollector(array, stringIndex);
s.Search(query, results);
SimpleFacets.DictionaryEntryQueue dictionaryEntryQueue = new SimpleFacets.DictionaryEntryQueue(stringIndex.lookup.Length);
for (int i = 1; i < stringIndex.lookup.Length; i++)
{
if (array[i] > 0 && stringIndex.lookup[i] != null && stringIndex.lookup[i] != "0")
{
dictionaryEntryQueue.Insert(new SimpleFacets.FacetEntry(stringIndex.lookup[i], -array[i]));
}
}
int num = dictionaryEntryQueue.Size();
Dictionary <string, int> dictionary = new Dictionary <string, int>();
for (int j = num - 1; j >= 0; j--)
{
SimpleFacets.FacetEntry facetEntry = dictionaryEntryQueue.Pop() as SimpleFacets.FacetEntry;
dictionary.Add(facetEntry.Value, -facetEntry.Count);
}
return(dictionary);
}
public async Task AddMultipleUnique_GetByQuery_EqualsWithInput(int tasksCount)
{
using var index = new StringIndex <string>();
var inputs = new Dictionary <string, IEnumerable <string> >();
for (var i = 0; i < tasksCount; i++)
{
inputs[Guid.NewGuid().ToString()] = new [] { Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString() }
}
;
var tasks = new List <Task>();
foreach (var(q, input) in inputs)
{
tasks.Add(Task.Run(() => index.Add(q, input)));
}
await Task.WhenAll(tasks);
var getTasks = inputs.Keys.Select(q => Task.Run(() => new { Query = q, Result = index.Get(q) })).ToList();
await Task.WhenAll(getTasks);
foreach (var task in getTasks)
{
var(query, result) = (task.Result.Query, task.Result.Result);
var input = inputs[query];
Assert.All(input, x => Assert.Contains(x, result));
}
}
public void Test_Address_StringIndexSetter_GoodFormat()
{
//Arrange
string Line1 = "unit 1 LineOne";
string Line2 = "15 Some St LineTwo";
string City = "Ball Hills";
string PostCode = "4036";
string State = "QLD";
string Country = "Australia";
var Address = new Address();
Address.Line = new string[] { Line1, Line2 };
Address.City = City;
Address.PostalCode = PostCode;
Address.State = State;
Address.Country = Country;
StringIndex Index = new StringIndex();
//Act
Index = IndexSetterFactory.Create(typeof(StringIndex)).Set(Address, Index) as StringIndex;
//Assert
var ResultString = string.Format("{0} {1} {2} {3} {4} {5}", Line1, Line2, City, PostCode, State, Country);
Assert.AreEqual(Index.String, Pyro.Common.Tools.StringSupport.ToLowerAndRemoveDiacritics(ResultString));
}
public async Task Flush_GetByQuery_ReturnsEmpty(int tasksCount)
{
using var index = new StringIndex <string>();
var inputs = new Dictionary <string, IEnumerable <string> >();
for (var i = 0; i < tasksCount; i++)
{
inputs[Guid.NewGuid().ToString()] = new []
{
Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString()
}
}
;
var tasks = new List <Task>();
foreach (var(q, input) in inputs)
{
tasks.Add(Task.Run(() => index.Add(q, input)));
}
await Task.WhenAll(tasks);
await Task.Run(() => index.Flush());
var getTasks = inputs.Keys.Select(x => Task.Run(() => index.Get(x))).ToList();
await Task.WhenAll(getTasks);
foreach (var task in getTasks)
{
Assert.Empty(task.Result);
}
}
public void RemoveNull_DoNothing()
{
using var index = new StringIndex <string>();
var result = index.Remove(null, new string[0]);
Assert.False(result);
}
public void GetNull_ReturnNothing()
{
using var index = new StringIndex <string>();
var result = index.Get(null);
Assert.Empty(result);
}
public async Task OnAddEmpty_AddEventNotInvoked(int tasksCount)
{
using var index = new StringIndex <string>();
var inputs = new Dictionary <string, IEnumerable <string> >();
for (var i = 0; i < tasksCount; i++)
{
inputs[Guid.NewGuid().ToString()] = new string[0];
}
var triggered = 0;
index.Added += (q, values) =>
{
var input = inputs[q];
Assert.Equal(input, values);
Interlocked.Increment(ref triggered);
};
var tasks = new List <Task>();
foreach (var(q, input) in inputs)
{
tasks.Add(Task.Run(() => index.Add(q, input)));
}
await Task.WhenAll(tasks);
Assert.Equal(0, triggered);
}
public async Task OnAdd_AddEventInvoked_ReturnedAddedValue(int tasksCount)
{
using var index = new StringIndex <string>();
var inputs = new Dictionary <string, string>();
for (var i = 0; i < tasksCount; i++)
{
inputs[Guid.NewGuid().ToString()] = Guid.NewGuid().ToString();
}
var triggered = 0;
index.Added += (q, values) =>
{
var input = inputs[q];
Assert.Equal(new [] { input }, values);
Interlocked.Increment(ref triggered);
};
var tasks = new List <Task>();
foreach (var(q, input) in inputs)
{
tasks.Add(Task.Run(() => index.Add(q, input)));
}
await Task.WhenAll(tasks);
Assert.Equal(tasksCount, triggered);
}
/// <summary>
/// Initialize all the elements of this index, as concurrently as possible.
/// </summary>
/// <param name="progressAction">Action called (from an arbitrary Task thread) to report completion of various index parts.</param>
/// <returns>A task which is complete when the index is fully built.</returns>
public Task InitializeAsync(Action <string> progressAction)
{
// All the things we want to do concurrently to index our data.
// This is broken out as a separate list since it is useful to run these serially sometimes when debugging
// (e.g. when the hacky Span sort code you found online starts hitting stack overflows, whereas the .NET 5
// Span.Sort method just works...).
List <(string, Action)> actions = new List <(string, Action)>
{
("Sorted strings", () => StringIndex = new StringIndex(PackedExecution.StringTable)),
("Indexed pip names", () => PipNameIndex = new NameIndex(PackedExecution.PipTable.PipNameTable)),
("Indexed paths", () => PathIndex = new NameIndex(PackedExecution.PathTable)),
("Indexed pip dependents", () => PipDependents = PackedExecution.PipDependencies.Invert()),
("Indexed file consumers", () => FileConsumers = PackedExecution.ConsumedFiles.Invert()),
("Indexed produced files", () => ProducedFiles =
RelationTable <FileId, PipId>
.FromSingleValueTable(PackedExecution.FileProducer, PackedExecution.PipTable)
.Invert()),
("Indexed input-file-declaring pips", () => InputFileDeclarers = PackedExecution.DeclaredInputFiles.Invert()),
("Indexed input-directory-declaring pips", () => InputDirectoryDeclarers = PackedExecution.DeclaredInputDirectories.Invert()),
("Indexed parent directories", () => ParentDirectories = PackedExecution.DirectoryContents.Invert())
};
// Concurrently generate all the sorted strings, name indices, and inverse relationships that we need.
return(Task.WhenAll(
actions
.Select(tuple => Task.Run(
() =>
{
tuple.Item2();
progressAction(tuple.Item1);
}))
.ToArray()));
}
/// <summary>
/// Initialises a new instance of the ModuleRefMetadataTableRow class
/// </summary>
/// <param name="contents">The contents of the file</param>
/// <param name="offset">The offset of the current row</param>
public ModuleRefMetadataTableRow(byte[] contents, Offset offset, IIndexDetails indexDetails)
{
this.FileOffset = offset;
byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
_name = new StringIndex(contents, sizeOfStringIndex, offset);
}
public void AddNull_DoNothing()
{
using var index = new StringIndex <string>();
index.Add(null, new string[0]);
var result = index.Get(null);
Assert.Empty(result);
}
private void FreezeExtensions()
{
List <ExtensionInfo> mergedExtensions = new List <ExtensionInfo>();
if (m_baseType != null)
{
mergedExtensions.AddRange(m_baseType.Extensions);
}
foreach (ExtensionInfo info in m_definitions.Extensions)
{
info.OwningType = this;
ExtensionInfo baseInfo = null;
if (m_baseType != null)
{
baseInfo = m_baseType.GetExtensionInfo(info.Name);
}
if (baseInfo != null)
{
// field is also present in base; make field compatible
info.Index = baseInfo.Index;
info.DefiningType = baseInfo.DefiningType;
mergedExtensions[baseInfo.Index] = info;
}
else
{
// this is a new field
info.Index = mergedExtensions.Count;
info.DefiningType = this;
mergedExtensions.Add(info);
}
}
if (mergedExtensions.Count > 0)
{
m_extensions = mergedExtensions.ToArray();
m_extensionIndex = new StringIndex(m_extensions);
}
else
{
m_extensions = EmptyArray <ExtensionInfo> .Instance;
m_extensionIndex = StringIndex.Empty;
}
foreach (ExtensionInfo extensionInfo in m_extensions)
{
// if this NodeType defines the extension, add an interface creator
if (extensionInfo.DefiningType == this &&
typeof(IAdapter).IsAssignableFrom(extensionInfo.Type))
{
AddCreator(new ExtensionAdapterCreator(extensionInfo));
}
}
}
public void Contains_ReturnIfContain()
{
var existed = "existed";
var notExisted = "notExisted";
using var index = new StringIndex <string>();
index.Add(existed, Guid.NewGuid().ToString());
Assert.True(index.Contains(existed));
Assert.False(index.Contains(notExisted));
}
/// <summary>
/// Initialises a new instance of the PropertyMetadataTableRow class
/// </summary>
/// <param name="contents">The contents of the file</param>
/// <param name="offset">The offset of this row</param>
public PropertyMetadataTableRow(byte[] contents, Offset offset, IIndexDetails indexDetails)
{
FileOffset = offset;
byte sizeOfBlobIndex = indexDetails.GetSizeOfBlobIndex();
byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
_attributes = (PropertyAttributes)FieldReader.ToUInt16(contents, offset.Shift(2));
_nameIndex = new StringIndex(contents, sizeOfStringIndex, offset);
_typeIndex = FieldReader.ToUInt32(contents, offset.Shift(sizeOfBlobIndex), sizeOfBlobIndex);
}
/// <summary>
/// Initialises a new instance of the FieldMetadataTableRow
/// </summary>
/// <param name="contents">The contents of the file</param>
/// <param name="offset">The offset of the current row</param>
public FieldMetadataTableRow(byte[] contents, Offset offset, IIndexDetails indexDetails)
{
this.FileOffset = offset;
byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
byte sizeOfBlobIndex = indexDetails.GetSizeOfBlobIndex();
_flags = (FieldAttributes)FieldReader.ToUInt16(contents, offset.Shift(2));
_nameIndex = new StringIndex(contents, sizeOfStringIndex, offset);
_signitureIndex = new BlobIndex(sizeOfBlobIndex, contents, Reflection.Signatures.Signatures.Field, offset);
}
/// <summary>
/// Initialises a new instance of the FileMetadataTableRow class
/// </summary>
/// <param name="contents">The contents of the file</param>
/// <param name="offset">The offset of the current row</param>
public FileMetadataTableRow(byte[] contents, Offset offset, IIndexDetails indexDetails)
{
this.FileOffset = offset;
byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
byte sizeOfBlobIndex = indexDetails.GetSizeOfBlobIndex();
_flags = (FileAttributes)FieldReader.ToUInt32(contents, offset.Shift(4));
_nameIndex = new StringIndex(contents, sizeOfStringIndex, offset);
_hashValue = FieldReader.ToUInt32(contents, offset.Shift(sizeOfBlobIndex), sizeOfBlobIndex);
}
public void Test_FhirString_StringIndexSetter_NoAddress()
{
//Arrange
var FhirString = new FhirString();
StringIndex Index = new StringIndex();
//Act
Index = IndexSetterFactory.Create(typeof(StringIndex)).Set(FhirString, Index) as StringIndex;
//Assert
Assert.IsNull(Index);
}
public void Test_Markdown_StringIndexSetter_NoAddress()
{
//Arrange
var Markdown = new Markdown();
StringIndex Index = new StringIndex();
//Act
Index = IndexSetterFactory.Create(typeof(StringIndex)).Set(Markdown, Index) as StringIndex;
//Assert
Assert.IsNull(Index);
}
public void Test_Address_StringIndexSetter_Address_IsNull()
{
//Arrange
var Address = new Address();
StringIndex Index = null;
//Act
ActualValueDelegate <StringIndex> testDelegate = () => IndexSetterFactory.Create(typeof(StringIndex)).Set(Address, Index) as StringIndex;
//Assert
Assert.That(testDelegate, Throws.TypeOf <ArgumentNullException>());
}
public void Test_HumanName_StringIndexSetter_NoAddress()
{
//Arrange
var HumanName = new HumanName();
StringIndex Index = new StringIndex();
//Act
Index = IndexSetterFactory.Create(typeof(StringIndex)).Set(HumanName, Index) as StringIndex;
//Assert
Assert.IsNull(Index);
}
public void Test_Annotation_StringIndexSetter_NoAddress()
{
//Arrange
var Annotation = new Annotation();
StringIndex Index = new StringIndex();
//Act
Index = IndexSetterFactory.Create(typeof(StringIndex)).Set(Annotation, Index) as StringIndex;
//Assert
Assert.IsNull(Index);
}
/// <summary>
/// Initialises a new instance of the TypeRefMetadataTableRow class
/// </summary>
/// <param name="contents">The file contents</param>
/// <param name="offset">The offset for this entry</param>
public TypeRefMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
{
this.FileOffset = offset;
int sizeOfCodedIndex = resolver.GetSizeOfIndex(CodedIndexes.ResolutionScope);
byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
_resolutionScope = resolver.Resolve(CodedIndexes.ResolutionScope,
FieldReader.ToUInt32(contents, offset.Shift(sizeOfCodedIndex), sizeOfCodedIndex)
);
_nameIndex = new StringIndex(contents, sizeOfStringIndex, offset);
_namespaceIndex = new StringIndex(contents, sizeOfStringIndex, offset);
}
/// <summary>
/// Initialises a new instance of the MemberRefMetadataTableRow
/// </summary>
/// <param name="contents">The contents of the file</param>
/// <param name="offset">The offset of this row</param>
public MemberRefMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
{
this.FileOffset = offset;
int sizeOfMemberRefParentIndex = resolver.GetSizeOfIndex(CodedIndexes.MemberRefParent);
byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
byte sizeOfBlobIndex = indexDetails.GetSizeOfBlobIndex();
_class = resolver.Resolve(CodedIndexes.MemberRefParent,
FieldReader.ToUInt32(contents, offset.Shift(sizeOfMemberRefParentIndex), sizeOfMemberRefParentIndex)
);
_name = new StringIndex(contents, sizeOfStringIndex, offset);
_signiture = new BlobIndex(sizeOfBlobIndex, contents, Reflection.Signatures.Signatures.MethodDef, offset);
}
/// <summary>
/// Initialises a new instance of the GenericParamMetadataTableRow class
/// </summary>
/// <param name="contents">The contents of the file</param>
/// <param name="offset">The offset of the current row</param>
public GenericParamMetadataTableRow(byte[] contents, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
{
this.FileOffset = offset;
int sizeOfCodeIndex = resolver.GetSizeOfIndex(CodedIndexes.TypeOrMethodDef);
byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
_number = FieldReader.ToUInt16(contents, offset.Shift(2));
_flags = (GenericParamAttributes)FieldReader.ToUInt16(contents, offset.Shift(2));
_ownerIndex = resolver.Resolve(CodedIndexes.TypeOrMethodDef,
FieldReader.ToUInt32(contents, offset.Shift(sizeOfCodeIndex), sizeOfCodeIndex)
);
_nameIndex = new StringIndex(contents, sizeOfStringIndex, offset);
}
public void AddAndSearchValues()
{
var si = new StringIndex();
si.Add("abcdef", "1");
si.Add("abcdeff", "2");
si.Add("abcdeffg", "3");
si.Add("bcdef", "4");
si.Add("bcdefg", "5");
si.Add("cdefg", "6");
si.Add("cdefgh", "7");
var output = si.GetValuesByPrefixFlattened("abc");
Assert.IsTrue(output.Contains("1") && output.Contains("2") && output.Contains("3"));
}
/// <summary>
/// Initialises a new instance of the ImplMapMetadataTableRow class
/// </summary>
/// <param name="content">The content of the file</param>
/// <param name="offset">The offset of the current row</param>
public ImplMapMetadataTableRow(byte[] content, Offset offset, ICodedIndexResolver resolver, IIndexDetails indexDetails)
{
this.FileOffset = offset;
int sizeOfMemberForwardedIndex = resolver.GetSizeOfIndex(CodedIndexes.MemberForwarded);
byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
byte sizeOfModuleRefIndex = indexDetails.GetSizeOfIndex(MetadataTables.ModuleRef);
_mappingFlags = (PInvokeAttributes)FieldReader.ToUInt16(content, offset.Shift(2));
_memberForward = resolver.Resolve(CodedIndexes.MemberForwarded,
FieldReader.ToUInt32(content, offset.Shift(sizeOfMemberForwardedIndex), sizeOfMemberForwardedIndex)
);
_importName = new StringIndex(content, sizeOfStringIndex, offset);
_importScope = new Index(content, offset, sizeOfModuleRefIndex);
}
/// <summary>
/// Initialises a new instance of the MethodMetadataTableRow class
/// </summary>
/// <param name="contents">The contents of the file</param>
/// <param name="offset">The offset of the current row</param>
public MethodMetadataTableRow(byte[] contents, Offset offset, IIndexDetails indexDetails)
{
this.FileOffset = offset;
byte sizeOfStringIndex = indexDetails.GetSizeOfStringIndex();
byte sizeOfBlobIndex = indexDetails.GetSizeOfBlobIndex();
byte sizeOfParamIndex = indexDetails.GetSizeOfIndex(MetadataTables.Param);
_rva = FieldReader.ToUInt32(contents, offset.Shift(4));
_implFlags = (MethodImplFlags)FieldReader.ToUInt16(contents, offset.Shift(2));
_flags = (MethodAttributes)FieldReader.ToUInt16(contents, offset.Shift(2));
_name = new StringIndex(contents, sizeOfStringIndex, offset);
_signiture = new BlobIndex(sizeOfBlobIndex, contents, Signatures.Signatures.MethodDef, offset);
_paramList = new Index(contents, offset, sizeOfParamIndex);
}
public async Task RemoveMultiple_GetByQuery_NotContainsRemoved(int tasksCount)
{
var skipTake = 3;
using var index = new StringIndex <string>();
var inputs = new Dictionary <string, IEnumerable <string> >();
for (var i = 0; i < tasksCount; i++)
{
inputs[Guid.NewGuid().ToString()] = new []
{
Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString()
}
}
;
var tasks = new List <Task>();
foreach (var(q, input) in inputs)
{
tasks.Add(Task.Run(() => index.Add(q, input)));
}
await Task.WhenAll(tasks);
var removeTasks = new List <Task>();
foreach (var(q, input) in inputs)
{
removeTasks.Add(Task.Run(() => index.Remove(q, input.Take(skipTake))));
}
await Task.WhenAll(removeTasks);
var getTasks = inputs.Keys.Select(q => Task.Run(() => new { Query = q, Result = index.Get(q) })).ToList();
await Task.WhenAll(getTasks);
foreach (var task in getTasks)
{
var(query, result) = (task.Result.Query, task.Result.Result);
var input = inputs[query].ToList();
Assert.All(input.Skip(skipTake), x => Assert.Contains(x, result));
Assert.All(input.Take(skipTake), x => Assert.DoesNotContain(x, result));
Assert.Equal(input.Count - skipTake, result.Count);
}
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 21JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* constructor.
*/
public TabularData(BinaryReader reader, long offset, long size,
DataField[] fields, StringData stringData, StringIndex stringIndex)
: base(reader, offset, size)
{
this._fields = fields;
this._stringData = stringData;
this._stringIndex = stringIndex;
int numberOfField = fields.Length;
_recordSize = 0;
for (int i = 0; i < numberOfField; i++)
{
switch (fields[i].GetFieldType())
{
case DataField.TYPE_CHAR://char
_recordSize += 4;
break;
case DataField.TYPE_INTEGER://int
_recordSize += 4;
break;
case DataField.TYPE_SMALLINT://shot
_recordSize += 2;
break;
case DataField.TYPE_FLOAT://float
_recordSize += 8;
break;
case DataField.TYPE_DECIMAL://float
_recordSize += 8;
break;
case DataField.TYPE_DATE://date
_recordSize += 4;
break;
case DataField.TYPE_LOGICAL://bool
_recordSize += 1;
break;
}
}
}
private static object DecodeEntry(BinaryReader reader, StringIndex index)
{
Stream stream = reader.BaseStream;
long origin = stream.Position;
reader.ReadBytes(8 * (int)index);
int dataoffset = reader.ReadInt32();
int datatype = reader.ReadInt32();
stream.Position = origin;
reader.ReadBytes(dataoffset);
switch (datatype)
{
case 0:
reader.ReadBytes(0x18);
long dataorigin = stream.Position;
int length;
while (stream.Position != stream.Length && reader.ReadByte() != 0)
{
}
length = (int)(stream.Position - dataorigin) - 1;
stream.Position = dataorigin;
var res = ShiftJISFF11Encoding.ShiftJISFF11.GetString(reader.ReadBytes(length), 0, length);
stream.Position = origin;
return res;
case 1:
return reader.ReadInt32();
}
return null;
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 21JUN2009 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
/**
* Open the map file.
*/
public void Open()
{
if (Header != null)
{
return;
}
Header = new Header(_reader, 0, 0);
_recordIndex = new RecordIndex(_reader, Header.IndexOffset,
Header.IndexLength);
_stringIndex = new StringIndex(_reader, Header.StringIndexOffset,
Header.StringIndexLength);
_stringData = new StringData(_reader, Header.StringDataOffset,
Header.StringDataLength);
_geoData = new GeoData(_reader, Header.GeoDataOffset,
Header.GeoDataLength);
TabularData = new TabularData(_reader, Header.TabularDataOffset,
Header.TabularDataLength, Header.Fields,
_stringData, _stringIndex);
_rtreeIndex = new RTreeIndex(_reader, Header.RtreeIndexOffset,
Header.RtreeIndexLength);
_tree = new RTree.RTree(_rtreeIndex.File);
}
