/// <summary>
/// Create a section header from file
/// </summary>
/// <param name="entries"></param>
/// <param name="reader"></param>
/// <param name="mainHeader"></param>
public SectionHeader(List <Entry> entries, Reader reader, Header mainHeader)
{
this.reader = reader;
this.mainHeader = mainHeader;
this.entries = entries;
this.name = new DataEntry(entries, this.mainHeader.is32Bit, "name", this.mainHeader.sectionHeaderBaseAddress, SectionSymbols.SECTION_NAME_SIZE, EntrySize._8Bits);
this.virtualSize = processSectionValue("virtualSize");
this.virtualAddress = processSectionValue("virtualAddress");
this.sizeOfRawData = processSectionValue("sizeOfRawData");
this.pointerToRawData = processSectionValue("pointerToRawData");
this.pointerToRelocations = processSectionValue("pointerToRelocations");
// TODO : understand where this is used
//this.pointerToLineNumbers = processSectionValue("pointerToLineNumbers");
this.numberOfRelocations = processSectionValue("numberOfRelocations");
this.numberOfLinenumbers = processSectionValue("numberOfLinenumbers");
this.characteristics = processSectionValue("characteristics");
foreach (var item in entries)
{
item.readValue(this.reader);
}
}
protected override MonotonicBlockPackedReader GetOrdIndexInstance(IndexInput data, FieldInfo field,
NumericEntry entry)
{
data.Seek(entry.Offset);
return(new MonotonicBlockPackedReader((IndexInput)data.Clone(), entry.PackedIntsVersion, entry.BlockSize, entry.Count,
true));
}
internal virtual Int64Values GetNumeric(NumericEntry entry)
{
IndexInput data = (IndexInput)this.data.Clone();
data.Seek(entry.Offset);
switch (entry.format)
{
case Lucene45DocValuesConsumer.DELTA_COMPRESSED:
BlockPackedReader reader = new BlockPackedReader(data, entry.PackedInt32sVersion, entry.BlockSize, entry.Count, true);
return(reader);
case Lucene45DocValuesConsumer.GCD_COMPRESSED:
long min = entry.minValue;
long mult = entry.gcd;
BlockPackedReader quotientReader = new BlockPackedReader(data, entry.PackedInt32sVersion, entry.BlockSize, entry.Count, true);
return(new Int64ValuesAnonymousInnerClassHelper(min, mult, quotientReader));
case Lucene45DocValuesConsumer.TABLE_COMPRESSED:
long[] table = entry.table;
int bitsRequired = PackedInt32s.BitsRequired(table.Length - 1);
PackedInt32s.Reader ords = PackedInt32s.GetDirectReaderNoHeader(data, PackedInt32s.Format.PACKED, entry.PackedInt32sVersion, (int)entry.Count, bitsRequired);
return(new Int64ValuesAnonymousInnerClassHelper2(table, ords));
default:
throw new Exception();
}
}
private void ReadSortedField(int fieldNumber, IndexInput meta /*, FieldInfos infos // LUCENENET: Never read */)
{
// sorted = binary + numeric
if (meta.ReadVInt32() != fieldNumber)
{
throw new Exception("sorted entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
if (meta.ReadByte() != Lucene45DocValuesFormat.BINARY)
{
throw new Exception("sorted entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
BinaryEntry b = ReadBinaryEntry(meta);
binaries[fieldNumber] = b;
if (meta.ReadVInt32() != fieldNumber)
{
throw new Exception("sorted entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
if (meta.ReadByte() != Lucene45DocValuesFormat.NUMERIC)
{
throw new Exception("sorted entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
NumericEntry n = ReadNumericEntry(meta);
ords[fieldNumber] = n;
}
/// <summary>
/// Create a PE header from file
/// </summary>
/// <param name="reader">the reader</param>
/// <param name="dosHeader">the previous DOS header</param>
public PE_Header(Reader reader, DOS_Header dosHeader)
{
this.reader = reader;
this.entries = new List <Entry>();
this.dosHeader = dosHeader;
if (!isValidPeHeader())
{
throw new BadPeHeaderException();
}
this.headerBaseAddress = this.dosHeader.peHeaderOffset.getValue() + HeaderSymbols.PE_HEADER.Length; // PE..
setupStruct();
// simple proxy
this.PeHeaderOffset = dosHeader.peHeaderOffset;
///
/// init values
///
foreach (var item in entries)
{
item.readValue(this.reader);
}
}
protected override MonotonicBlockPackedReader GetOrdIndexInstance(IndexInput data, FieldInfo field,
NumericEntry entry)
{
data.Seek(entry.Offset);
return new MonotonicBlockPackedReader((IndexInput)data.Clone(), entry.PackedIntsVersion, entry.BlockSize, entry.Count,
true);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private index.NumericDocValues loadNumeric(NumericEntry entry) throws java.io.IOException
private NumericDocValues loadNumeric(NumericEntry entry)
{
data.seek(entry.offset + entry.missingBytes);
switch (entry.byteWidth)
{
case 1:
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final byte[] values = new byte[entry.count];
sbyte[] values = new sbyte[entry.count];
data.readBytes(values, 0, entry.count);
ramBytesUsed_Renamed.addAndGet(RamUsageEstimator.sizeOf(values));
return(new NumericDocValuesAnonymousInnerClassHelper(this, values));
}
case 2:
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final short[] values = new short[entry.count];
short[] values = new short[entry.count];
for (int i = 0; i < entry.count; i++)
{
values[i] = data.readShort();
}
ramBytesUsed_Renamed.addAndGet(RamUsageEstimator.sizeOf(values));
return(new NumericDocValuesAnonymousInnerClassHelper2(this, values));
}
case 4:
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int[] values = new int[entry.count];
int[] values = new int[entry.count];
for (int i = 0; i < entry.count; i++)
{
values[i] = data.readInt();
}
ramBytesUsed_Renamed.addAndGet(RamUsageEstimator.sizeOf(values));
return(new NumericDocValuesAnonymousInnerClassHelper3(this, values));
}
case 8:
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long[] values = new long[entry.count];
long[] values = new long[entry.count];
for (int i = 0; i < entry.count; i++)
{
values[i] = data.readLong();
}
ramBytesUsed_Renamed.addAndGet(RamUsageEstimator.sizeOf(values));
return(new NumericDocValuesAnonymousInnerClassHelper4(this, values));
}
default:
throw new AssertionError();
}
}
public override SortedDocValues GetSorted(FieldInfo field)
{
int valueCount = (int)binaries[field.Number].Count;
BinaryDocValues binary = GetBinary(field);
NumericEntry entry = ords[field.Number];
IndexInput data = (IndexInput)this.data.Clone();
data.Seek(entry.Offset);
BlockPackedReader ordinals = new BlockPackedReader(data, entry.PackedInt32sVersion, entry.BlockSize, entry.Count, true);
return(new SortedDocValuesAnonymousInnerClassHelper(valueCount, binary, ordinals));
}
private NumericDocValues LoadNumeric(FieldInfo field)
{
NumericEntry entry = numerics[field.Number];
data.Seek(entry.offset + entry.missingBytes);
switch (entry.format)
{
case TABLE_COMPRESSED:
int size = data.ReadVInt32();
if (size > 256)
{
throw new CorruptIndexException(
"TABLE_COMPRESSED cannot have more than 256 distinct values, input=" + data);
}
var decode = new long[size];
for (int i = 0; i < decode.Length; i++)
{
decode[i] = data.ReadInt64();
}
int formatID = data.ReadVInt32();
int bitsPerValue = data.ReadVInt32();
var ordsReader = PackedInt32s.GetReaderNoHeader(data, PackedInt32s.Format.ById(formatID),
entry.packedIntsVersion, maxDoc, bitsPerValue);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(decode) + ordsReader.RamBytesUsed());
return(new NumericDocValuesAnonymousInnerClassHelper(this, decode, ordsReader));
case DELTA_COMPRESSED:
int blockSize = data.ReadVInt32();
var reader = new BlockPackedReader(data, entry.packedIntsVersion, blockSize, maxDoc,
false);
ramBytesUsed.AddAndGet(reader.RamBytesUsed());
return(reader);
case UNCOMPRESSED:
var bytes = new byte[maxDoc];
data.ReadBytes(bytes, 0, bytes.Length);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(bytes));
// LUCENENET: IMPORTANT - some bytes are negative here, so we need to pass as sbyte
return(new NumericDocValuesAnonymousInnerClassHelper2(this, (sbyte[])(Array)bytes));
case GCD_COMPRESSED:
long min = data.ReadInt64();
long mult = data.ReadInt64();
int quotientBlockSize = data.ReadVInt32();
var quotientReader = new BlockPackedReader(data, entry.packedIntsVersion,
quotientBlockSize, maxDoc, false);
ramBytesUsed.AddAndGet(quotientReader.RamBytesUsed());
return(new NumericDocValuesAnonymousInnerClassHelper3(this, min, mult, quotientReader));
default:
throw new InvalidOperationException();
}
}
private NumericDocValues LoadNumeric(NumericEntry entry)
{
data.Seek(entry.offset + entry.missingBytes);
switch (entry.byteWidth)
{
case 1:
{
var values = new byte[entry.count];
data.ReadBytes(values, 0, entry.count);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
// LUCENENET: IMPORTANT - some bytes are negative here, so we need to pass as sbyte
return(new NumericDocValuesAnonymousClass((sbyte[])(Array)values));
}
case 2:
{
var values = new short[entry.count];
for (int i = 0; i < entry.count; i++)
{
values[i] = data.ReadInt16();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return(new NumericDocValuesAnonymousClass2(values));
}
case 4:
{
var values = new int[entry.count];
for (var i = 0; i < entry.count; i++)
{
values[i] = data.ReadInt32();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return(new NumericDocValuesAnonymousClass3(values));
}
case 8:
{
var values = new long[entry.count];
for (int i = 0; i < entry.count; i++)
{
values[i] = data.ReadInt64();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return(new NumericDocValuesAnonymousClass4(values));
}
default:
throw AssertionError.Create();
}
}
private NumericDocValues LoadNumeric(NumericEntry entry)
{
data.Seek(entry.offset + entry.missingBytes);
switch (entry.byteWidth)
{
case 1:
{
var values = new byte[entry.count];
data.ReadBytes(values, 0, entry.count);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
// LUCENENET: IMPORTANT - some bytes are negative here, so we need to pass as sbyte
return(new NumericDocValuesAnonymousInnerClassHelper((sbyte[])(Array)values));
}
case 2:
{
var values = new short[entry.count];
for (int i = 0; i < entry.count; i++)
{
values[i] = data.ReadShort();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return(new NumericDocValuesAnonymousInnerClassHelper2(this, values));
}
case 4:
{
var values = new int[entry.count];
for (var i = 0; i < entry.count; i++)
{
values[i] = data.ReadInt();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return(new NumericDocValuesAnonymousInnerClassHelper3(values));
}
case 8:
{
var values = new long[entry.count];
for (int i = 0; i < entry.count; i++)
{
values[i] = data.ReadLong();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return(new NumericDocValuesAnonymousInnerClassHelper4(values));
}
default:
throw new System.InvalidOperationException();
}
}
private void setupStruct()
{
// TODO : clear the code
// x32 and x64 don't change anything here
this.Architecture = new TypeEntry <Machines>(entries, true, "Architecture", headerBaseAddress, EntrySize._16Bits);
this.NumberOfSection = new NumericEntry(entries, true, "NumberOfSection", headerBaseAddress, EntrySize._16Bits);
this.TimeDateStamp = new NumericEntry(entries, true, "TimeDateStamp", headerBaseAddress, EntrySize._32Bits);
this.PointerToSymbolTable = new NumericEntry(entries, true, "PointerToSymbolTable", headerBaseAddress, EntrySize._32Bits);
this.NumberOfSymbols = new NumericEntry(entries, true, "NumberOfSymbols", headerBaseAddress, EntrySize._32Bits);
this.SizeOfOptionalHeader = new NumericEntry(entries, true, "SizeOfOptionalHeader", headerBaseAddress, EntrySize._16Bits);
this.Characteristics = new NumericEntry(entries, true, "Characteristics", headerBaseAddress, EntrySize._16Bits);
}
private NumericDocValues LoadNumeric(FieldInfo field)
{
NumericEntry entry = numerics[field.Number];
data.Seek(entry.Offset);
switch (entry.Format)
{
case TABLE_COMPRESSED:
int size = data.ReadVInt32();
if (size > 256)
{
throw new CorruptIndexException("TABLE_COMPRESSED cannot have more than 256 distinct values, input=" + data);
}
var decode = new long[size];
for (int i = 0; i < decode.Length; i++)
{
decode[i] = data.ReadInt64();
}
int formatID = data.ReadVInt32();
int bitsPerValue = data.ReadVInt32();
PackedInt32s.Reader ordsReader = PackedInt32s.GetReaderNoHeader(data, PackedInt32s.Format.ById(formatID), entry.PackedInt32sVersion, maxDoc, bitsPerValue);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(decode) + ordsReader.RamBytesUsed());
return(new NumericDocValuesAnonymousClass(decode, ordsReader));
case DELTA_COMPRESSED:
int blockSize = data.ReadVInt32();
var reader = new BlockPackedReader(data, entry.PackedInt32sVersion, blockSize, maxDoc, false);
ramBytesUsed.AddAndGet(reader.RamBytesUsed());
return(reader);
case UNCOMPRESSED:
byte[] bytes = new byte[maxDoc];
data.ReadBytes(bytes, 0, bytes.Length);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(bytes));
return(new NumericDocValuesAnonymousClass2(bytes));
case GCD_COMPRESSED:
long min = data.ReadInt64();
long mult = data.ReadInt64();
int quotientBlockSize = data.ReadVInt32();
BlockPackedReader quotientReader = new BlockPackedReader(data, entry.PackedInt32sVersion, quotientBlockSize, maxDoc, false);
ramBytesUsed.AddAndGet(quotientReader.RamBytesUsed());
return(new NumericDocValuesAnonymousClass3(min, mult, quotientReader));
default:
throw AssertionError.Create();
}
}
private NumericDocValues LoadNumeric(FieldInfo field)
{
NumericEntry entry = Numerics[field.Number];
Data.Seek(entry.Offset);
switch (entry.Format)
{
case TABLE_COMPRESSED:
int size = Data.ReadVInt();
if (size > 256)
{
throw new CorruptIndexException("TABLE_COMPRESSED cannot have more than 256 distinct values, input=" + Data);
}
long[] decode = new long[size];
for (int i = 0; i < decode.Length; i++)
{
decode[i] = Data.ReadLong();
}
int formatID = Data.ReadVInt();
int bitsPerValue = Data.ReadVInt();
PackedInts.Reader ordsReader = PackedInts.GetReaderNoHeader(Data, PackedInts.Format.ById(formatID), entry.PackedIntsVersion, MaxDoc, bitsPerValue);
RamBytesUsed_Renamed.AddAndGet(RamUsageEstimator.SizeOf(decode) + ordsReader.RamBytesUsed());
return(new NumericDocValuesAnonymousInnerClassHelper(this, decode, ordsReader));
case DELTA_COMPRESSED:
int blockSize = Data.ReadVInt();
BlockPackedReader reader = new BlockPackedReader(Data, entry.PackedIntsVersion, blockSize, MaxDoc, false);
RamBytesUsed_Renamed.AddAndGet(reader.RamBytesUsed());
return(reader);
case UNCOMPRESSED:
byte[] bytes = new byte[MaxDoc];
Data.ReadBytes(bytes, 0, bytes.Length);
RamBytesUsed_Renamed.AddAndGet(RamUsageEstimator.SizeOf(bytes));
return(new NumericDocValuesAnonymousInnerClassHelper2(this, bytes));
case GCD_COMPRESSED:
long min = Data.ReadLong();
long mult = Data.ReadLong();
int quotientBlockSize = Data.ReadVInt();
BlockPackedReader quotientReader = new BlockPackedReader(Data, entry.PackedIntsVersion, quotientBlockSize, MaxDoc, false);
RamBytesUsed_Renamed.AddAndGet(quotientReader.RamBytesUsed());
return(new NumericDocValuesAnonymousInnerClassHelper3(this, min, mult, quotientReader));
default:
throw new InvalidOperationException();
}
}
private void setupStruct(ref int offset)
{
// TODO : clear the code
this.OffsetToData = new NumericEntry(null, true, "OffsetToData", offset, EntrySize._32Bits);
offset += (int)this.OffsetToData.getRawSize();
this.DataSize = new NumericEntry(null, true, "DataSize", offset, EntrySize._32Bits);
offset += (int)this.DataSize.getRawSize();
this.CodePage = new NumericEntry(null, true, "CodePage", offset, EntrySize._32Bits);
offset += (int)this.CodePage.getRawSize();
this.Reserved = new NumericEntry(null, true, "Reserved", offset, EntrySize._32Bits);
offset += (int)this.Reserved.getRawSize();
}
/// <summary>
/// Create a PE header from memory
/// </summary>
/// <param name="dosHeader">the previous DOS header</param>
public PE_Header(DOS_Header dosHeader)
{
///
/// init header
///
this.entries = new List <Entry>();
this.dosHeader = dosHeader;
this.headerBaseAddress = this.dosHeader.peHeaderOffset.getValue() + HeaderSymbols.PE_HEADER.Length; // PE..
setupStruct();
// simple proxy
this.PeHeaderOffset = dosHeader.peHeaderOffset;
///
/// init values
///
// x32 bit as default
this.Architecture.setValue(Machines.INTEL386);
// new PE objects are empty
this.NumberOfSection.setValue(0);
// indicates when the file was created
// TODO
this.TimeDateStamp.setValue(0);
// new PE objects don't have symbols
this.PointerToSymbolTable.setValue(0);
// new PE objects don't have symbols
this.NumberOfSymbols.setValue(0);
// will be written after creating it
this.SizeOfOptionalHeader.setValue(0);
int characteristics = (int)Types.Characteristics.IMAGE_FILE_EXECUTABLE_IMAGE + (int)Types.Characteristics.IMAGE_FILE_LARGE_ADDRESS_AWARE;
// general characteristics
this.Characteristics.setValue(characteristics);
}
private static NumericEntry ReadNumericEntry(IndexInput meta) // LUCENENET: CA1822: Mark members as static
{
var entry = new NumericEntry {
offset = meta.ReadInt64(), count = meta.ReadInt32(), missingOffset = meta.ReadInt64()
};
if (entry.missingOffset != -1)
{
entry.missingBytes = meta.ReadInt64();
}
else
{
entry.missingBytes = 0;
}
entry.byteWidth = meta.ReadByte();
return(entry);
}
private static NumericEntry ReadNumericEntry(IndexInput meta)
{
var entry = new NumericEntry {
offset = meta.ReadLong(), count = meta.ReadInt(), missingOffset = meta.ReadLong()
};
if (entry.missingOffset != -1)
{
entry.missingBytes = meta.ReadLong();
}
else
{
entry.missingBytes = 0;
}
entry.byteWidth = meta.ReadByte();
return(entry);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private NumericEntry readNumericEntry(store.IndexInput meta) throws java.io.IOException
private NumericEntry readNumericEntry(IndexInput meta)
{
NumericEntry entry = new NumericEntry();
entry.offset = meta.readLong();
entry.count = meta.readInt();
entry.missingOffset = meta.readLong();
if (entry.missingOffset != -1)
{
entry.missingBytes = meta.readLong();
}
else
{
entry.missingBytes = 0;
}
entry.byteWidth = meta.readByte();
return(entry);
}
internal static NumericEntry ReadNumericEntry(IndexInput meta)
{
NumericEntry entry = new NumericEntry();
entry.format = meta.ReadVInt32();
entry.missingOffset = meta.ReadInt64();
entry.PackedInt32sVersion = meta.ReadVInt32();
entry.Offset = meta.ReadInt64();
entry.Count = meta.ReadVInt64();
entry.BlockSize = meta.ReadVInt32();
switch (entry.format)
{
case Lucene45DocValuesConsumer.GCD_COMPRESSED:
entry.minValue = meta.ReadInt64();
entry.gcd = meta.ReadInt64();
break;
case Lucene45DocValuesConsumer.TABLE_COMPRESSED:
if (entry.Count > int.MaxValue)
{
throw new Exception("Cannot use TABLE_COMPRESSED with more than MAX_VALUE values, input=" + meta);
}
int uniqueValues = meta.ReadVInt32();
if (uniqueValues > 256)
{
throw new Exception("TABLE_COMPRESSED cannot have more than 256 distinct values, input=" + meta);
}
entry.table = new long[uniqueValues];
for (int i = 0; i < uniqueValues; ++i)
{
entry.table[i] = meta.ReadInt64();
}
break;
case Lucene45DocValuesConsumer.DELTA_COMPRESSED:
break;
default:
throw new Exception("Unknown format: " + entry.format + ", input=" + meta);
}
return(entry);
}
public override IBits GetDocsWithField(FieldInfo field)
{
switch (field.DocValuesType)
{
case DocValuesType.SORTED_SET:
return(DocValues.DocsWithValue(GetSortedSet(field), maxDoc));
case DocValuesType.SORTED:
return(DocValues.DocsWithValue(GetSorted(field), maxDoc));
case DocValuesType.BINARY:
BinaryEntry be = binaries[field.Number];
return(GetMissingBits(field.Number, be.missingOffset, be.missingBytes));
case DocValuesType.NUMERIC:
NumericEntry ne = numerics[field.Number];
return(GetMissingBits(field.Number, ne.missingOffset, ne.missingBytes));
default:
throw AssertionError.Create();
}
}
private void setupStruct(ref int offset)
{
// TODO : clear the code
this.Characteristics = new NumericEntry(null, true, "Characteristics", offset, EntrySize._32Bits);
offset += this.Characteristics.getRawSize();
this.TimeDateStamp = new NumericEntry(null, true, "TimeDateStamp", offset, EntrySize._32Bits);
offset += (int)this.TimeDateStamp.getRawSize();
this.MajorVersion = new NumericEntry(null, true, "MajorVersion", offset, EntrySize._16Bits);
offset += (int)this.MajorVersion.getRawSize();
this.MinorVersion = new NumericEntry(null, true, "MinorVersion", offset, EntrySize._16Bits);
offset += (int)this.MinorVersion.getRawSize();
this.NumberOfNamedEntries = new NumericEntry(null, true, "NumberOfNamedEntries", offset, EntrySize._16Bits);
offset += (int)this.NumberOfNamedEntries.getRawSize();
this.NumberOfIdEntries = new NumericEntry(null, true, "NumberOfIdEntries", offset, EntrySize._16Bits);
offset += (int)this.NumberOfIdEntries.getRawSize();
}
private void ReadSortedSetFieldWithAddresses(int fieldNumber, IndexInput meta, FieldInfos infos)
{
// sortedset = binary + numeric (addresses) + ordIndex
if (meta.ReadVInt32() != fieldNumber)
{
throw new Exception("sortedset entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
if (meta.ReadByte() != Lucene45DocValuesFormat.BINARY)
{
throw new Exception("sortedset entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
BinaryEntry b = ReadBinaryEntry(meta);
binaries[fieldNumber] = b;
if (meta.ReadVInt32() != fieldNumber)
{
throw new Exception("sortedset entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
if (meta.ReadByte() != Lucene45DocValuesFormat.NUMERIC)
{
throw new Exception("sortedset entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
NumericEntry n1 = ReadNumericEntry(meta);
ords[fieldNumber] = n1;
if (meta.ReadVInt32() != fieldNumber)
{
throw new Exception("sortedset entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
if (meta.ReadByte() != Lucene45DocValuesFormat.NUMERIC)
{
throw new Exception("sortedset entry for field: " + fieldNumber + " is corrupt (resource=" + meta + ")");
}
NumericEntry n2 = ReadNumericEntry(meta);
ordIndexes[fieldNumber] = n2;
}
public override IBits GetDocsWithField(FieldInfo field)
{
switch (field.DocValuesType)
{
case DocValuesType.SORTED_SET:
return(DocValues.DocsWithValue(GetSortedSet(field), maxDoc));
case DocValuesType.SORTED:
return(DocValues.DocsWithValue(GetSorted(field), maxDoc));
case DocValuesType.BINARY:
BinaryEntry be = binaries[field.Number];
return(GetMissingBits(be.missingOffset));
case DocValuesType.NUMERIC:
NumericEntry ne = numerics[field.Number];
return(GetMissingBits(ne.missingOffset));
default:
throw new InvalidOperationException();
}
}
public override Bits GetDocsWithField(FieldInfo field)
{
switch (field.DocValuesType)
{
case FieldInfo.DocValuesType_e.SORTED_SET:
return(DocValues.DocsWithValue(GetSortedSet(field), maxDoc));
case FieldInfo.DocValuesType_e.SORTED:
return(DocValues.DocsWithValue(GetSorted(field), maxDoc));
case FieldInfo.DocValuesType_e.BINARY:
BinaryEntry be = binaries[field.Number];
return(GetMissingBits(field.Number, be.missingOffset, be.missingBytes));
case FieldInfo.DocValuesType_e.NUMERIC:
NumericEntry ne = numerics[field.Number];
return(GetMissingBits(field.Number, ne.missingOffset, ne.missingBytes));
default:
throw new System.ArgumentOutOfRangeException();
}
}
private void setupStruct(ref int baseOffset)
{
// TODO : clear the code
// we don't care about x32 or x64
this.lastsize = new NumericEntry(entries, true, "lastsize", baseOffset, EntrySize._16Bits);
this.nblocks = new NumericEntry(entries, true, "nblocks", baseOffset, EntrySize._16Bits);
this.nreloc = new NumericEntry(entries, true, "nreloc", baseOffset, EntrySize._16Bits);
this.hdrsize = new NumericEntry(entries, true, "hdrsize", baseOffset, EntrySize._16Bits);
this.minalloc = new NumericEntry(entries, true, "minalloc", baseOffset, EntrySize._16Bits);
this.maxalloc = new NumericEntry(entries, true, "maxalloc", baseOffset, EntrySize._16Bits);
this.ss = new NumericEntry(entries, true, "ss", baseOffset, EntrySize._16Bits);
this.sp = new NumericEntry(entries, true, "sp", baseOffset, EntrySize._16Bits);
this.checksum = new NumericEntry(entries, true, "checksum", baseOffset, EntrySize._16Bits);
this.ip = new NumericEntry(entries, true, "ip", baseOffset, EntrySize._16Bits);
this.cs = new NumericEntry(entries, true, "cs", baseOffset, EntrySize._16Bits);
this.relocpos = new NumericEntry(entries, true, "relocpos", baseOffset, EntrySize._16Bits);
this.noverlay = new NumericEntry(entries, true, "noverlay", baseOffset, EntrySize._16Bits);
this.reserved1 = new DataEntry(entries, true, "reserved1", baseOffset, 4, EntrySize._16Bits);
this.oem_id = new NumericEntry(entries, true, "oem_id", baseOffset, EntrySize._16Bits);
this.oem_info = new NumericEntry(entries, true, "oem_info", baseOffset, EntrySize._16Bits);
this.reserved2 = new DataEntry(entries, true, "reserved2", baseOffset, 10, EntrySize._16Bits);
this.peHeaderOffset = new NumericEntry(entries, true, "peHeaderOffset", baseOffset, EntrySize._32Bits);
}
public ResourceDirectoryEntry(Resources resources, Reader reader, List <Entry> entries, ref int offset)
{
this.reader = reader;
this.resources = resources;
this.entries = entries;
this.localEntries = new List <Entry>();
this.resourceTables = new List <ResourceDirectoryTable>();
this.dataEntry = null;
this.Name = new NumericEntry(null, true, "Name", offset, EntrySize._32Bits);
offset += (int)this.Name.getRawSize();
this.OffsetToData = new NumericEntry(null, true, "OffsetToData", offset, EntrySize._32Bits);
offset += (int)this.OffsetToData.getRawSize();
this.Name.readValue(this.reader);
this.localEntries.Add(this.Name);
this.OffsetToData.readValue(this.reader);
this.localEntries.Add(this.OffsetToData);
}
private void irListaCentroTrabajo(List <string> Lista)
{
PanelPropiedades = new ObservableCollection <StackPanel>();
PanelPropiedadesCadena = new ObservableCollection <StackPanel>();
PanelPropiedadesBool = new ObservableCollection <StackPanel>();
PanelPropiedadesOpcionales = new ObservableCollection <StackPanel>();
IApplicationContext ctx;
XmlApplicationContext file;
ICentroTrabajo _elCentroTrabajo;
ObservableCollection <Propiedad> propiedades_Numericas = new ObservableCollection <Propiedad>();
ObservableCollection <PropiedadBool> propiedades_Bool = new ObservableCollection <PropiedadBool>();
ObservableCollection <PropiedadCadena> propiedades_Cadenas = new ObservableCollection <PropiedadCadena>();
ObservableCollection <PropiedadOptional> propiedades_Opcionales = new ObservableCollection <PropiedadOptional>();
ObservableCollection <NumericEntry> propiedadesNumeric = new ObservableCollection <NumericEntry>();
ObservableCollection <BoolEntry> propiedadesBool = new ObservableCollection <BoolEntry>();
ObservableCollection <StringEntry> propiedadesCadena = new ObservableCollection <StringEntry>();
ObservableCollection <OptionalEntry> propiedadesOpcionales = new ObservableCollection <OptionalEntry>();
PropiedadesViewModel = new ObservableCollection <PropiedadViewModel>();
PropiedadesCadenaViewModel = new ObservableCollection <PropiedadCadenaViewModel>();
PropiedadesBoolViewModel = new ObservableCollection <PropiedadBoolViewModel>();
PropiedadesOptionalViewModel = new ObservableCollection <PropiedadOptionalViewModel>();
DialogService dialog = new DialogService();
file = new XmlApplicationContext(@"\\agufileserv2\INGENIERIA\RESPRUTAS\RrrrUUUUUULLL\RepositoryCentroTrabajoDisenoProceso.xml");
ctx = file;
foreach (string item in Lista)
{
//Obtenemos el ID del Centro de Trabajo.
int a = ListaCentroTrabajo.Where(x => x.CentroTrabajo == item).ToList().Count;
if (a != 0)
{
string id = ListaCentroTrabajo.Where(x => x.CentroTrabajo == item).FirstOrDefault().ObjetoXML;
//Obtenemos un objeto del Centro de Trabajo.
_elCentroTrabajo = (ICentroTrabajo)ctx.GetObject(id);
// Asignamos el Centro de Trabajo a la lista.
ListaCreadaCentroTrabajo.Add(_elCentroTrabajo);
}
}
foreach (ICentroTrabajo centroTrabajo in ListaCreadaCentroTrabajo)
{
foreach (Propiedad propiedad in centroTrabajo.PropiedadesRequeridadas)
{
NumericEntry numeric = new NumericEntry();
PropiedadViewModel propiedadViewModel = new PropiedadViewModel(propiedad);
numeric.DataContext = propiedadViewModel;
//Validar si el nombre esta en la lista de duplicados
int b = ListaDuplicado.Where(x => x == propiedad.Nombre).ToList().Count;
if (b > 0)
{
numeric.Name = propiedad.Nombre;
propiedades_Numericas.Add(propiedad);
propiedadesNumeric.Add(numeric);
PropiedadesViewModel.Add(propiedadViewModel);
}
else
{
if (propiedades_Numericas.Where(x => x.Nombre == propiedad.Nombre).ToList().Count == 0)
{
numeric.Name = propiedad.Nombre;
propiedades_Numericas.Add(propiedad);
propiedadesNumeric.Add(numeric);
PropiedadesViewModel.Add(propiedadViewModel);
}
}
}
foreach (PropiedadBool propiedadBool in centroTrabajo.PropiedadesRequeridasBool)
{
BoolEntry boolEntry = new BoolEntry();
PropiedadBoolViewModel propiedadBoolViewModel = new PropiedadBoolViewModel(propiedadBool);
boolEntry.DataContext = propiedadBoolViewModel;
//Validar si el nombre esta en la lista de duplicados
int b = ListaDuplicado.Where(x => x == propiedadBool.Nombre).ToList().Count;
if (b > 0)
{
propiedades_Bool.Add(propiedadBool);
propiedadesBool.Add(boolEntry);
PropiedadesBoolViewModel.Add(propiedadBoolViewModel);
}
else
{
if (propiedades_Bool.Where(x => x.Nombre == propiedadBool.Nombre).ToList().Count == 0)
{
propiedades_Bool.Add(propiedadBool);
propiedadesBool.Add(boolEntry);
PropiedadesBoolViewModel.Add(propiedadBoolViewModel);
}
}
}
foreach (PropiedadCadena propiedadCadena in centroTrabajo.PropiedadesRequeridasCadena)
{
StringEntry stringEntry = new StringEntry();
PropiedadCadenaViewModel propiedadCadenaViewModel = new PropiedadCadenaViewModel(propiedadCadena);
stringEntry.DataContext = propiedadCadenaViewModel;
//Validar si el nombre esta en la lista de duplicados
int b = ListaDuplicado.Where(x => x == propiedadCadena.Nombre).ToList().Count;
if (b > 0)
{
propiedades_Cadenas.Add(propiedadCadena);
propiedadesCadena.Add(stringEntry);
PropiedadesCadenaViewModel.Add(propiedadCadenaViewModel);
}
else
{
if (propiedades_Cadenas.Where(x => x.Nombre == propiedadCadena.Nombre).ToList().Count == 0)
{
propiedades_Cadenas.Add(propiedadCadena);
propiedadesCadena.Add(stringEntry);
PropiedadesCadenaViewModel.Add(propiedadCadenaViewModel);
}
}
}
foreach (PropiedadOptional propiedadOpcional in centroTrabajo.PropiedadesRequeridasOpcionles)
{
OptionalEntry optionalEntry = new OptionalEntry();
PropiedadOptionalViewModel propiedadOpcionalViewModel = new PropiedadOptionalViewModel(propiedadOpcional);
optionalEntry.DataContext = propiedadOpcionalViewModel;
//Validar si el nombre esta en la lista de duplicados
int b = ListaDuplicado.Where(x => x == propiedadOpcional.Nombre).ToList().Count;
if (b > 0)
{
propiedades_Opcionales.Add(propiedadOpcional);
propiedadesOpcionales.Add(optionalEntry);
PropiedadesOptionalViewModel.Add(propiedadOpcionalViewModel);
}
else
{
if (propiedades_Opcionales.Where(x => x.Nombre == propiedadOpcional.Nombre).ToList().Count == 0)
{
propiedades_Opcionales.Add(propiedadOpcional);
propiedadesOpcionales.Add(optionalEntry);
PropiedadesOptionalViewModel.Add(propiedadOpcionalViewModel);
}
}
}
}
foreach (NumericEntry numericEntry in propiedadesNumeric)
{
try
{
StackPanel panel = new StackPanel();
panel.Orientation = System.Windows.Controls.Orientation.Horizontal;
panel.Name = numericEntry.Name;
panel.Children.Add(numericEntry);
PanelPropiedades.Add(panel);
}
catch (Exception a)
{
string aa = a.Message;
}
}
foreach (BoolEntry boolEntry in propiedadesBool)
{
try
{
StackPanel panel = new StackPanel();
panel.Orientation = System.Windows.Controls.Orientation.Horizontal;
panel.Children.Add(boolEntry);
PanelPropiedadesBool.Add(panel);
}
catch (Exception a)
{
string aa = a.Message;
}
}
foreach (StringEntry stringEntry in propiedadesCadena)
{
try
{
StackPanel panel = new StackPanel();
panel.Orientation = System.Windows.Controls.Orientation.Horizontal;
panel.Children.Add(stringEntry);
PanelPropiedadesCadena.Add(panel);
}
catch (Exception a)
{
string aa = a.Message;
}
}
foreach (OptionalEntry optionalEntry in propiedadesOpcionales)
{
try
{
StackPanel panel = new StackPanel();
panel.Orientation = System.Windows.Controls.Orientation.Horizontal;
panel.Children.Add(optionalEntry);
PanelPropiedadesOpcionales.Add(panel);
}
catch (Exception a)
{
string aa = a.Message;
}
}
vista = new FrmVistaWPF();
vista.DataContext = this;
vista.ShowDialog();
//if (vista.DialogResult.HasValue && vista.DialogResult.Value)
//{
// foreach (var item in ListaCreadaCentroTrabajo)
// {
// //Agrega a la lista los datos por mostrar en el Datagrid
// ListaMostrar.Add(item);
// }
//}
}
private void ReadFields(IndexInput meta, FieldInfos infos)
{
int fieldNumber = meta.ReadVInt();
while (fieldNumber != -1)
{
int fieldType = meta.ReadByte();
if (fieldType == NUMBER)
{
var entry = new NumericEntry {offset = meta.ReadLong(), missingOffset = meta.ReadLong()};
if (entry.missingOffset != -1)
{
entry.missingBytes = meta.ReadLong();
}
else
{
entry.missingBytes = 0;
}
entry.format = meta.ReadByte();
switch (entry.format)
{
case DELTA_COMPRESSED:
case TABLE_COMPRESSED:
case GCD_COMPRESSED:
case UNCOMPRESSED:
break;
default:
throw new CorruptIndexException("Unknown format: " + entry.format + ", input=" + meta);
}
if (entry.format != UNCOMPRESSED)
{
entry.packedIntsVersion = meta.ReadVInt();
}
numerics[fieldNumber] = entry;
}
else if (fieldType == BYTES)
{
var entry = new BinaryEntry
{
offset = meta.ReadLong(),
numBytes = meta.ReadLong(),
missingOffset = meta.ReadLong()
};
if (entry.missingOffset != -1)
{
entry.missingBytes = meta.ReadLong();
}
else
{
entry.missingBytes = 0;
}
entry.minLength = meta.ReadVInt();
entry.maxLength = meta.ReadVInt();
if (entry.minLength != entry.maxLength)
{
entry.packedIntsVersion = meta.ReadVInt();
entry.blockSize = meta.ReadVInt();
}
binaries[fieldNumber] = entry;
}
else if (fieldType == FST)
{
var entry = new FSTEntry {offset = meta.ReadLong(), numOrds = meta.ReadVLong()};
fsts[fieldNumber] = entry;
}
else
{
throw new CorruptIndexException("invalid entry type: " + fieldType + ", input=" + meta);
}
fieldNumber = meta.ReadVInt();
}
}
private void ReadFields(IndexInput meta, FieldInfos infos)
{
int fieldNumber = meta.ReadVInt32();
while (fieldNumber != -1)
{
// check should be: infos.fieldInfo(fieldNumber) != null, which incorporates negative check
// but docvalues updates are currently buggy here (loading extra stuff, etc): LUCENE-5616
if (fieldNumber < 0)
{
// trickier to validate more: because we re-use for norms, because we use multiple entries
// for "composite" types like sortedset, etc.
throw new CorruptIndexException("Invalid field number: " + fieldNumber + ", input=" + meta);
}
int fieldType = meta.ReadByte();
if (fieldType == NUMBER)
{
var entry = new NumericEntry();
entry.Offset = meta.ReadInt64();
entry.Format = (sbyte)meta.ReadByte();
switch (entry.Format)
{
case DELTA_COMPRESSED:
case TABLE_COMPRESSED:
case GCD_COMPRESSED:
case UNCOMPRESSED:
break;
default:
throw new CorruptIndexException("Unknown format: " + entry.Format + ", input=" + meta);
}
if (entry.Format != UNCOMPRESSED)
{
entry.PackedInt32sVersion = meta.ReadVInt32();
}
numerics[fieldNumber] = entry;
}
else if (fieldType == BYTES)
{
BinaryEntry entry = new BinaryEntry();
entry.Offset = meta.ReadInt64();
entry.NumBytes = meta.ReadInt64();
entry.MinLength = meta.ReadVInt32();
entry.MaxLength = meta.ReadVInt32();
if (entry.MinLength != entry.MaxLength)
{
entry.PackedInt32sVersion = meta.ReadVInt32();
entry.BlockSize = meta.ReadVInt32();
}
binaries[fieldNumber] = entry;
}
else if (fieldType == FST)
{
FSTEntry entry = new FSTEntry();
entry.Offset = meta.ReadInt64();
entry.NumOrds = meta.ReadVInt64();
fsts[fieldNumber] = entry;
}
else
{
throw new CorruptIndexException("invalid entry type: " + fieldType + ", input=" + meta);
}
fieldNumber = meta.ReadVInt32();
}
}
internal static NumericEntry ReadNumericEntry(IndexInput meta)
{
NumericEntry entry = new NumericEntry();
entry.Format = meta.ReadVInt();
entry.MissingOffset = meta.ReadLong();
entry.PackedIntsVersion = meta.ReadVInt();
entry.Offset = meta.ReadLong();
entry.Count = meta.ReadVLong();
entry.BlockSize = meta.ReadVInt();
switch (entry.Format)
{
case Lucene45DocValuesConsumer.GCD_COMPRESSED:
entry.MinValue = meta.ReadLong();
entry.Gcd = meta.ReadLong();
break;
case Lucene45DocValuesConsumer.TABLE_COMPRESSED:
if (entry.Count > int.MaxValue)
{
throw new Exception("Cannot use TABLE_COMPRESSED with more than MAX_VALUE values, input=" + meta);
}
int uniqueValues = meta.ReadVInt();
if (uniqueValues > 256)
{
throw new Exception("TABLE_COMPRESSED cannot have more than 256 distinct values, input=" + meta);
}
entry.Table = new long[uniqueValues];
for (int i = 0; i < uniqueValues; ++i)
{
entry.Table[i] = meta.ReadLong();
}
break;
case Lucene45DocValuesConsumer.DELTA_COMPRESSED:
break;
default:
throw new Exception("Unknown format: " + entry.Format + ", input=" + meta);
}
return entry;
}
/// <summary>
/// Returns an address instance for sortedset ordinal lists.
/// <para/>
/// @lucene.internal
/// </summary>
protected virtual MonotonicBlockPackedReader GetOrdIndexInstance(IndexInput data, FieldInfo field, NumericEntry entry)
{
MonotonicBlockPackedReader ordIndex;
lock (ordIndexInstances)
{
if (!ordIndexInstances.TryGetValue(field.Number, out MonotonicBlockPackedReader ordIndexInstance))
{
data.Seek(entry.Offset);
ordIndexInstance = new MonotonicBlockPackedReader(data, entry.PackedInt32sVersion, entry.BlockSize, entry.Count, false);
ordIndexInstances[field.Number] = ordIndexInstance;
ramBytesUsed.AddAndGet(ordIndexInstance.RamBytesUsed() + RamUsageEstimator.NUM_BYTES_INT32);
}
ordIndex = ordIndexInstance;
}
return(ordIndex);
}
public override NumericDocValues GetNumeric(FieldInfo field)
{
NumericEntry entry = numerics[field.Number];
return(GetNumeric(entry));
}
internal virtual LongValues GetNumeric(NumericEntry entry)
{
IndexInput data = (IndexInput)this.Data.Clone();
data.Seek(entry.Offset);
switch (entry.Format)
{
case Lucene45DocValuesConsumer.DELTA_COMPRESSED:
BlockPackedReader reader = new BlockPackedReader(data, entry.PackedIntsVersion, entry.BlockSize, entry.Count, true);
return reader;
case Lucene45DocValuesConsumer.GCD_COMPRESSED:
long min = entry.MinValue;
long mult = entry.Gcd;
BlockPackedReader quotientReader = new BlockPackedReader(data, entry.PackedIntsVersion, entry.BlockSize, entry.Count, true);
return new LongValuesAnonymousInnerClassHelper(this, min, mult, quotientReader);
case Lucene45DocValuesConsumer.TABLE_COMPRESSED:
long[] table = entry.Table;
int bitsRequired = PackedInts.BitsRequired(table.Length - 1);
PackedInts.Reader ords = PackedInts.GetDirectReaderNoHeader(data, PackedInts.Format.PACKED, entry.PackedIntsVersion, (int)entry.Count, bitsRequired);
return new LongValuesAnonymousInnerClassHelper2(this, table, ords);
default:
throw new Exception();
}
}
/// <summary>
/// returns an address instance for sortedset ordinal lists
/// @lucene.internal
/// </summary>
protected internal virtual MonotonicBlockPackedReader GetOrdIndexInstance(IndexInput data, FieldInfo field, NumericEntry entry)
{
MonotonicBlockPackedReader ordIndex;
lock (OrdIndexInstances)
{
MonotonicBlockPackedReader ordIndexInstance;
if (!OrdIndexInstances.TryGetValue(field.Number, out ordIndexInstance))
{
data.Seek(entry.Offset);
ordIndexInstance = new MonotonicBlockPackedReader(data, entry.PackedIntsVersion, entry.BlockSize, entry.Count, false);
OrdIndexInstances[field.Number] = ordIndexInstance;
RamBytesUsed_Renamed.AddAndGet(ordIndexInstance.RamBytesUsed() + RamUsageEstimator.NUM_BYTES_INT);
}
ordIndex = ordIndexInstance;
}
return ordIndex;
}
private void ReadFields(IndexInput meta, FieldInfos infos)
{
int fieldNumber = meta.ReadVInt();
while (fieldNumber != -1)
{
// check should be: infos.fieldInfo(fieldNumber) != null, which incorporates negative check
// but docvalues updates are currently buggy here (loading extra stuff, etc): LUCENE-5616
if (fieldNumber < 0)
{
// trickier to validate more: because we re-use for norms, because we use multiple entries
// for "composite" types like sortedset, etc.
throw new CorruptIndexException("Invalid field number: " + fieldNumber + ", input=" + meta);
}
int fieldType = meta.ReadByte();
if (fieldType == NUMBER)
{
var entry = new NumericEntry {Offset = meta.ReadLong(), Format = (sbyte)meta.ReadByte()};
switch (entry.Format)
{
case DELTA_COMPRESSED:
case TABLE_COMPRESSED:
case GCD_COMPRESSED:
case UNCOMPRESSED:
break;
default:
throw new CorruptIndexException("Unknown format: " + entry.Format + ", input=" + meta);
}
if (entry.Format != UNCOMPRESSED)
{
entry.PackedIntsVersion = meta.ReadVInt();
}
Numerics[fieldNumber] = entry;
}
else if (fieldType == BYTES)
{
BinaryEntry entry = new BinaryEntry();
entry.Offset = meta.ReadLong();
entry.NumBytes = meta.ReadLong();
entry.MinLength = meta.ReadVInt();
entry.MaxLength = meta.ReadVInt();
if (entry.MinLength != entry.MaxLength)
{
entry.PackedIntsVersion = meta.ReadVInt();
entry.BlockSize = meta.ReadVInt();
}
Binaries[fieldNumber] = entry;
}
else if (fieldType == FST)
{
FSTEntry entry = new FSTEntry();
entry.Offset = meta.ReadLong();
entry.NumOrds = meta.ReadVLong();
Fsts[fieldNumber] = entry;
}
else
{
throw new CorruptIndexException("invalid entry type: " + fieldType + ", input=" + meta);
}
fieldNumber = meta.ReadVInt();
}
}
private NumericDocValues LoadNumeric(NumericEntry entry)
{
data.Seek(entry.offset + entry.missingBytes);
switch (entry.byteWidth)
{
case 1:
{
var values = new byte[entry.count];
data.ReadBytes(values, 0, entry.count);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return new NumericDocValuesAnonymousInnerClassHelper(values);
}
case 2:
{
var values = new short[entry.count];
for (int i = 0;i < entry.count;i++)
{
values[i] = data.ReadShort();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return new NumericDocValuesAnonymousInnerClassHelper2(this, values);
}
case 4:
{
var values = new int[entry.count];
for (var i = 0;i < entry.count;i++)
{
values[i] = data.ReadInt();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return new NumericDocValuesAnonymousInnerClassHelper3(values);
}
case 8:
{
var values = new long[entry.count];
for (int i = 0;i < entry.count;i++)
{
values[i] = data.ReadLong();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return new NumericDocValuesAnonymousInnerClassHelper4(values);
}
default:
throw new AssertionError();
}
}
private static NumericEntry ReadNumericEntry(IndexInput meta)
{
var entry = new NumericEntry { offset = meta.ReadLong(), count = meta.ReadInt(), missingOffset = meta.ReadLong() };
if (entry.missingOffset != -1)
{
entry.missingBytes = meta.ReadLong();
}
else
{
entry.missingBytes = 0;
}
entry.byteWidth = meta.ReadByte();
return entry;
}
private NumericDocValues LoadNumeric(NumericEntry entry)
{
data.Seek(entry.offset + entry.missingBytes);
switch (entry.byteWidth)
{
case 1:
{
var values = new byte[entry.count];
data.ReadBytes(values, 0, entry.count);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
// LUCENENET: IMPORTANT - some bytes are negative here, so we need to pass as sbyte
return new NumericDocValuesAnonymousInnerClassHelper((sbyte[])(Array)values);
}
case 2:
{
var values = new short[entry.count];
for (int i = 0; i < entry.count; i++)
{
values[i] = data.ReadShort();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return new NumericDocValuesAnonymousInnerClassHelper2(this, values);
}
case 4:
{
var values = new int[entry.count];
for (var i = 0; i < entry.count; i++)
{
values[i] = data.ReadInt();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return new NumericDocValuesAnonymousInnerClassHelper3(values);
}
case 8:
{
var values = new long[entry.count];
for (int i = 0; i < entry.count; i++)
{
values[i] = data.ReadLong();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
return new NumericDocValuesAnonymousInnerClassHelper4(values);
}
default:
throw new System.InvalidOperationException();
}
}
