public int[] SearchSimple(string key)
{
if (string.IsNullOrEmpty(key))
{
return(new int[0]);
}
TermLink[] result = new TermLink[0];
if (key.EndsWith("$"))
{
key = key.Substring(0, key.Length - 1);
if (!string.IsNullOrEmpty(key))
{
result = SearchStart(key);
}
}
else
{
result = SearchExact(key);
}
return(result
.Select(link => link.Mfn)
.Distinct()
.ToArray());
}
private bool Equals(TermLink other)
{
return((Mfn == other.Mfn) &&
(Tag == other.Tag) &&
(Occurrence == other.Occurrence) &&
(Index == other.Index));
}
public static IfpRecord Read
(
Stream stream,
long offset
)
{
//new ObjectDumper()
// .DumpStream(stream, offset, 100);
stream.Position = offset;
IfpRecord result = new IfpRecord
{
LowOffset = stream.ReadInt32Network(),
HighOffset = stream.ReadInt32Network(),
TotalLinkCount = stream.ReadInt32Network(),
BlockLinkCount = stream.ReadInt32Network(),
Capacity = stream.ReadInt32Network()
};
for (int i = 0; i < result.BlockLinkCount; i++)
{
TermLink link = TermLink.Read(stream);
result.Links.Add(link);
}
return(result);
}
//public static void Write(Stream stream, SpecialPostingBlockEntry entry)
//{
// TermLink.Write(stream, entry.FirstPosting ?? new TermLink());
// stream.WriteInt64Network(entry.Offset);
//}
public static int Write(byte[] buffer, SpecialPostingBlockEntry entry, int offset)
{
var size = TermLink.Write(buffer, entry.FirstPosting, offset);
offset += size;
buffer.WriteInt64Network(entry.Offset, offset);
size += 8;
return(size);
}
//public static SpecialPostingBlockEntry Read(Stream stream)
//{
// var result = new SpecialPostingBlockEntry
// {
// FileOffset = stream.Position,
// FirstPosting = TermLink.Read(stream),
// Offset = stream.ReadInt64Network()
// };
// return result;
//}
public static SpecialPostingBlockEntry Read(byte[] buffer, int offset)
{
//ibatrak чтение из буфера
var result = new SpecialPostingBlockEntry
{
FirstPosting = TermLink.Read(buffer, offset),
Offset = buffer.ReadInt64Network(offset + TermLink.RecordSize)
};
return(result);
}
public static TermLink Read(Stream stream)
{
TermLink result = new TermLink
{
Mfn = stream.ReadInt32Network(),
Tag = stream.ReadInt32Network(),
Occurrence = stream.ReadInt32Network(),
Index = stream.ReadInt32Network()
};
return(result);
}
/// <summary>
/// ibatrak Запись данных обыкновенного формата
/// </summary>
private static int Write(byte[] buffer, IfpRecord ifpRecord, int offset)
{
var size = WriteLeader(buffer, ifpRecord, offset);
offset += size;
for (int i = 0; i < ifpRecord.Links.Count; i++)
{
var linkSize = TermLink.Write(buffer, ifpRecord.Links[i], offset);
offset += linkSize;
size += linkSize;
}
return(size);
}
///// <summary>
///// ibatrak установка ссылки на следующую запись
///// </summary>
//private static void SetNext(Stream stream, IfpRecord ifpRecord, long next, TermLink link, int newBlocks)
//{
// if (ifpRecord.FullOffset != next && next > 0)
// {
// var r = ifpRecord;
// //поиск последней записи по цепочке
// //метод вызывается только для последней записи, потребности в этом нет
// //оставлено для совместимости
// while (r.FullOffset > 0)
// {
// r = ReadLeader(stream, r.FullOffset);
// }
// if (r.Special)
// {
// //дальше работаем со вложенной записью
// var nestedRecord = r._NestedRecordLeaders[r._NestedRecordLeaders.Length - 1];
// //установка ссылки на новую запись в спец блок, если есть место
// if (r._NestedRecordLeaders.Length < r._SpecialBlock.Length)
// {
// var specialBlockEntry = r._SpecialBlock[r._NestedRecordLeaders.Length];
// if (specialBlockEntry.Offset == 0)
// {
// specialBlockEntry.Offset = next;
// specialBlockEntry.FirstPosting = link;
// //обновим счетчик блоков
// r.BlockLinkCount += newBlocks;
// if (ifpRecord._NestedRecordLeaders == null || !ifpRecord._NestedRecordLeaders.Contains(nestedRecord))
// {
// //если запись не является вложенной, то записать спец блок
// stream.Position = specialBlockEntry.FileOffset;
// SpecialPostingBlockEntry.Write(stream, specialBlockEntry);
// }
// }
// }
// r = nestedRecord;
// }
// r.FullOffset = next;
// //обновить ссылку на следующую запись в последней по цепочке записи, если она отличается от текущей
// //и не содержится во вложенных
// if (r != ifpRecord && (ifpRecord._NestedRecordLeaders == null || !ifpRecord._NestedRecordLeaders.Contains(r)))
// WriteLeader(stream, r, r._FileOffset);
// }
//}
/// <summary>
/// Запись данных в простом формате или со спец блоками
/// </summary>
private static int Write(Stream stream, IfpRecord ifpRecord, long offset, bool padding)
{
int size = 0;
byte[] buffer = null;
//обработка обычной записи
if (!ifpRecord.Special)
{
//в записи обыкновенного формата указываем либо указатель на следующую из параметров
//либо обозначаем последнюю запись
size = LeaderSize + ifpRecord.Links.Count * TermLink.RecordSize;
buffer = new byte[size];
Write(buffer, ifpRecord, 0);
}
else
{
//обработка записи со спец блоком
var links = ifpRecord.Links.ToArray();
//если нет - делаем запись со спец-блоком
//здесь записи делятся по 254, то есть будет минимум 2 блока
var blockCount = ifpRecord._NestedRecordLeaders != null ? ifpRecord._NestedRecordLeaders.Length :
(int)Math.Ceiling((double)links.Length / (double)PostingsInBlock);
int specialBlockSize = ifpRecord.Capacity * SpecialPostingBlockEntry.RecordSize;
size = /*размер первой записи*/ LeaderSize /*в первой записи ссылок нет*/ +
/*размер спец блока*/ specialBlockSize +
(ifpRecord._NestedRecordLeaders == null ? /*размер вложенных записей только если они будут созданы*/
/*размер записей по числу блоков*/ LeaderSize * blockCount + links.Length * TermLink.RecordSize : 0);
buffer = new byte[size];
ifpRecord.Links.Clear();
//устанавливается через Special
//ifpRecord.LowOffset = -1001;
//ifpRecord.HighOffset = -1001;
//уже сделали ifpRecord.Links.Clear(); будет запись только заголовка
//int bufferOffset = Write(buffer, ifpRecord, 0);
int bufferOffset = WriteLeader(buffer, ifpRecord, 0);
//запись спец блока
//пишем записи спец блока по количеству Capacity
int linksWritten = 0;
for (int i = 0; i < ifpRecord.Capacity; i++)
{
int count = 0;
var entry = ifpRecord._SpecialBlock != null ? ifpRecord._SpecialBlock[i] : new SpecialPostingBlockEntry();
//генерация адресов для новых записей спец блока
if (ifpRecord._NestedRecordLeaders == null && i < blockCount)
{
//в ирбисе здесь номер слова из первой ссылки, зачем непонятно
entry.FirstPosting = links[linksWritten];
//ссылка на место за спец блоком + размер записей обыкновенного формата столько,
//сколько указывают предыдущие записи спец блока
entry.Offset = offset +
/*размер первой записи*/ LeaderSize +
/*рамер спец блока*/ specialBlockSize +
/*размер записей обыкновенного формата*/ LeaderSize * i + linksWritten * TermLink.RecordSize;
//ifpRecord._NestedRecordLeaders уже null
//if (ifpRecord._NestedRecordLeaders != null)
// count = Math.Min(links.Length - linksWritten, ifpRecord._NestedRecordLeaders[i].TotalLinkCount);
//else
// count = Math.Min(links.Length - linksWritten, PostingsInBlock);
count = Math.Min(links.Length - linksWritten, PostingsInBlock);
linksWritten += count;
}
bufferOffset += SpecialPostingBlockEntry.Write(buffer, entry, bufferOffset);
}
linksWritten = 0;
for (int i = 0; i < blockCount; i++)
{
//если обновляется существующая запись, количество ссылок брать из существующих блоков
int count = 0;
IfpRecord nestedRecord = null;
//здесь пишем записи обычного формата
if (ifpRecord._NestedRecordLeaders != null)
{
//для старой вложенной записи перезаписываем блок по количеству записей в заголовке
//вместимость в ссылках и ссылки на следующие блоки не переписываем
count = Math.Min(links.Length - linksWritten, ifpRecord._NestedRecordLeaders[i].Capacity);
nestedRecord = ifpRecord._NestedRecordLeaders[i];
nestedRecord.TotalLinkCount = count;
nestedRecord.BlockLinkCount = count;
}
else
{
//для новой записи записываем PostingsInBlock
count = Math.Min(links.Length - linksWritten, PostingsInBlock);
nestedRecord = new IfpRecord
{
TotalLinkCount = count,
BlockLinkCount = count,
Capacity = count
};
if (i < blockCount - 1)
{
//ссылка на место сразу за этой записью
nestedRecord.FullOffset = offset +
/*размер первой записи*/ LeaderSize +
/*рамер спец блока*/ specialBlockSize +
/*размер предыдущих записей + размер этой записи*/ LeaderSize * (i + 1) + (linksWritten + count) * TermLink.RecordSize;
}
else
{
//в последней записи обыкновенного формата обозначаем последнюю запись
nestedRecord.Last = true;
}
}
var linksBlock = new TermLink[count];
Array.Copy(links, linksWritten, linksBlock, 0, linksBlock.Length);
nestedRecord.Links.AddRange(linksBlock);
linksWritten += count;
//старые вложенные записи пишутся на старое место
if (ifpRecord._NestedRecordLeaders != null)
{
Write(stream, nestedRecord, nestedRecord._FileOffset, padding);
}
else
{
bufferOffset += Write(buffer, nestedRecord, bufferOffset);
}
}
}
if (buffer.Length != size)
{
throw new InvalidOperationException("Ошибка записи ifp");
}
//выравнивание размера файла
if (padding && (offset + buffer.Length) > stream.Length)
{
long newSize = LeaderSize + (long)Math.Ceiling((double)(offset + buffer.Length - LeaderSize) / (double)BlockSize) * BlockSize;
stream.SetLength(newSize);
}
if (stream.Seek(offset, SeekOrigin.Begin) != offset)
{
throw new IOException();
}
stream.Write(buffer, 0, buffer.Length);
stream.Flush();
return(size);
}
public static IfpRecord Read
(
Stream stream,
long offset
)
{
//new ObjectDumper()
// .DumpStream(stream, offset, 100);
//ibatrak чтение лидера вынесено отдельно
//stream.Position = offset;
//IfpRecord result = new IfpRecord
// {
// LowOffset = stream.ReadInt32Network(),
// HighOffset = stream.ReadInt32Network(),
// TotalLinkCount = stream.ReadInt32Network(),
// BlockLinkCount = stream.ReadInt32Network(),
// Capacity = stream.ReadInt32Network(),
// _FileOffset = offset
// };
IfpRecord result = ReadLeader(stream, offset);
//ibatrak чтение вложенных записей в спец блоке
//Специальный формат записи .ifp
//В этом случае первой записью является специальный блок,
//который представляет собой заголовок (обыкновенного формата), в котором смещения имеют специальные значения = -1001, и набор вхождений следующего формата:
//Число бит Параметр Описание
//32 POSTING 1-я ссылка из записи обыкновенного формата
//32 LOW младшее слово смещения на следующую запись (если нет 0)
//32 HIGH старшее слово смещения на следующую запись (если нет 0)
//Число вхождений кратно 4. Записи, на которые ссылается специальный блок связаны между собой как описано выше.
//Общее количество ссылок для данного термина сохраняется только в специальном блоке.
if (result.Special)
{
//irbis64.dll делает так
//читает первые 24 байта блока спец ссылок
//берет первую запись, адрес из нее в файле и читает записей IFP
//по количеству result.BlockLinkCount
//записи спец блока идут по количеству Capacity
//каждая указывает на запись обычного формата
//также в каждой записи обычного формата FullOffset указывает на следующую запись (кроме последней)
//это должно соответствовать
var specBlock = new SpecialPostingBlockEntry[result.Capacity];
var specBlockBuffer = new byte[result.Capacity * SpecialPostingBlockEntry.RecordSize];
var fileOffset = stream.Position;
if (stream.Read(specBlockBuffer, 0, specBlockBuffer.Length) != specBlockBuffer.Length)
{
throw new IOException();
}
for (int i = 0; i < result.Capacity; i++)
{
var entry = SpecialPostingBlockEntry.Read(specBlockBuffer, i * SpecialPostingBlockEntry.RecordSize);
entry.FileOffset = fileOffset + i + SpecialPostingBlockEntry.RecordSize;
specBlock[i] = entry;
}
//запомнить для редактирования
result._SpecialBlock = specBlock;
var nonEmptyEntries = specBlock.Where(e => e.Offset > 0).Count();
if (nonEmptyEntries != result.BlockLinkCount)
{
throw new InvalidOperationException("Ошибка чтения ifp offset=" + offset);
}
var nestedRecords = new IfpRecord[result.BlockLinkCount];
for (int i = 0; i < result.BlockLinkCount; i++)
{
if (specBlock[i].Offset <= 0 ||
(i > 0 && nestedRecords[i - 1].FullOffset != specBlock[i].Offset))
{
throw new InvalidOperationException("Ошибка чтения ifp offset=" + offset);
}
var nestedRecord = Read(stream, specBlock[i].Offset);
nestedRecords[i] = nestedRecord;
}
var links = nestedRecords.SelectMany(r => r.Links).ToArray();
if (links.Length != result.TotalLinkCount)
{
throw new InvalidOperationException("Ошибка чтения ifp offset=" + offset);
}
result.Links.AddRange(links);
result._NestedRecordLeaders = nestedRecords.ToArray();
foreach (var r in nestedRecords)
{
r._links.Clear();
}
return(result);
}
//ibatrak до сюда
//ibatrak читаем ссылки за раз, так быстрее
var linkBuffer = new byte[result.BlockLinkCount * TermLink.RecordSize];
if (stream.Read(linkBuffer, 0, linkBuffer.Length) != linkBuffer.Length)
{
throw new IOException();
}
for (int i = 0; i < result.BlockLinkCount; i++)
{
TermLink link = TermLink.Read(linkBuffer, i * TermLink.RecordSize);
result.Links.Add(link);
}
//for (int i = 0; i < result.BlockLinkCount; i++)
//{
// TermLink link = TermLink.Read(stream);
// result.Links.Add(link);
//}
return(result);
}
