public RecordField AddSubFields
(
string encodedText
)
{
RecordField parsed = Parse(encodedText);
if (!ReferenceEquals(parsed, null))
{
if (!string.IsNullOrEmpty(parsed.Text))
{
Text += parsed.Text;
}
AddSubFields(parsed.SubFields);
}
return(this);
}
public static int Compare
(
IrbisRecord record1,
IrbisRecord record2,
bool verbose
)
{
IEnumerator <RecordField> enum1 = record1.Fields.GetEnumerator();
IEnumerator <RecordField> enum2 = record2.Fields.GetEnumerator();
while (true)
{
bool next1 = enum1.MoveNext();
bool next2 = enum2.MoveNext();
if ((!next1) && (!next2))
{
break;
}
if (!next1)
{
return(-1);
}
if (!next2)
{
return(1);
}
RecordField field1 = enum1.Current;
RecordField field2 = enum2.Current;
int result = RecordField.Compare
(
field1,
field2,
verbose
);
if (result != 0)
{
return(result);
}
}
return(0);
}
/// <summary>
/// Установка поля.
/// </summary>
public IrbisRecord SetField
(
string tag,
int occurrence,
string newText
)
{
RecordField field = Fields
.GetField(tag)
.GetOccurrence(occurrence);
if (!ReferenceEquals(field, null))
{
field.Text = newText;
}
return(this);
}
public IrbisRecord DecodeRecord()
{
IrbisRecord result = new IrbisRecord
{
Mfn = Leader.Mfn,
Status = (RecordStatus)Leader.Status,
PreviousOffset = Leader.Previous,
Version = Leader.Version
};
foreach (MstDictionaryEntry entry in Dictionary)
{
RecordField field = DecodeField(entry);
result.Fields.Add(field);
}
return(result);
}
public RecordField Reparse
(
string text
)
{
RecordField parsed = Parse
(
Tag,
text
);
if (!ReferenceEquals(parsed, null))
{
Text = parsed.Text;
_subFields.Clear();
_subFields.AddRange(parsed._subFields);
}
return(this);
}
/// <summary>
/// Sets the field.
/// </summary>
/// <param name="tag">The tag.</param>
/// <param name="text">The text.</param>
/// <returns></returns>
/// <remarks>Устанавливает значение только для
/// первого повторения поля (если в записи их несколько)!
/// </remarks>
public IrbisRecord SetField
(
string tag,
string text
)
{
RecordField field = Fields
.GetField(tag)
.FirstOrDefault();
if (field == null)
{
field = new RecordField(tag);
Fields.Add(field);
}
field.Text = text;
return(this);
}
/// <summary>
/// Добавление поля (в конец списка полей)
/// с указанными меткой и подполями.
/// </summary>
/// <param name="tag">Метка поля.</param>
/// <param name="code">Код первого подполя.</param>
/// <param name="text">Текст первого подполя.</param>
/// <param name="others">Коды и тексты последующих
/// подполей.</param>
/// <returns>this</returns>
public IrbisRecord AddField
(
string tag,
char code,
string text,
params object[] others
)
{
RecordField field = new RecordField(tag);
field.AddSubField(code, text);
for (int i = 0; i < others.Length; i += 2)
{
char c = (char)others [i];
string t = (string)others [i + 1];
field.AddSubField(c, t);
}
Fields.Add(field);
return(this);
}
public void ExportField
(
XmlWriter writer,
RecordField field
)
{
string localName = "FIELD." + field.Tag.ToUpper();
writer.WriteStartElement(localName);
ExportText(writer, field);
foreach (SubField subField in field.SubFields)
{
ExportSubField
(
writer,
subField
);
}
writer.WriteEndElement();
}
public IrbisRecord RemoveField
(
string tag,
int occurrence
)
{
RecordField[] found = Fields.GetField(tag);
if (occurrence < 0)
{
occurrence = found.Length + occurrence;
}
if (occurrence >= 0)
{
RecordField target = found.Skip(occurrence).FirstOrDefault();
if (!ReferenceEquals(target, null))
{
Fields.Remove(target);
}
}
return(this);
}
public IrbisRecord SetSubField
(
string tag,
char code,
string text
)
{
RecordField field = Fields
.GetField(tag)
.FirstOrDefault();
if (field == null)
{
field = new RecordField(tag);
Fields.Add(field);
}
field.SetSubField(code, text);
return(this);
}
internal static void _EncodeField
(
StringBuilder builder,
RecordField field
)
{
int fieldNumber = field.Tag.SafeParseInt32();
if (fieldNumber != 0)
{
builder.AppendFormat
(
"{0}#",
fieldNumber
);
}
else
{
builder.AppendFormat
(
"{0}#",
field.Tag
);
}
if (!string.IsNullOrEmpty(field.Text))
{
builder.Append(field.Text);
}
foreach (SubField subField in field.SubFields)
{
_EncodeSubField
(
builder,
subField
);
}
builder.Append("\x001F\x001E");
}
public IrbisRecord MergeParse
(
string[] text,
int skipLines
)
{
if (skipLines > 0)
{
text = text.Skip(skipLines).ToArray();
}
if (text.Length > 2)
{
Regex regex = new Regex(@"^(-?\d+)\#(\d*)?");
Match match = regex.Match(text[0]);
Mfn = Math.Abs(int.Parse(match.Groups[1].Value));
if (match.Groups[2].Length > 0)
{
Status = (RecordStatus)int.Parse(match.Groups[2].Value);
}
match = regex.Match(text[1]);
if (match.Groups[2].Length > 0)
{
Version = int.Parse(match.Groups[2].Value);
}
}
foreach (string line in text.Skip(2))
{
RecordField field = RecordField.Parse(line);
if (field != null)
{
Fields.Add(field);
}
}
return(this);
}
public static string GatherSubfields
(
this IrbisRecord record,
string tag,
string separator,
params char[] codes
)
{
RecordField field = record
.Fields
.GetField(tag)
.FirstOrDefault();
if (ReferenceEquals(field, null))
{
return(null);
}
List <string> list = new List <string>();
foreach (char code in codes)
{
string[] text = field
.GetSubField(code)
.GetSubFieldText();
list.AddRange(text);
}
if (list.Count == 0)
{
return(null);
}
return(string.Join
(
separator,
list.ToArray()
));
}
public static VisitInfo Parse(RecordField field)
{
VisitInfo result = new VisitInfo
{
Database = FM(field, 'g'),
Index = FM(field, 'a'),
Inventory = FM(field, 'b'),
Barcode = FM(field, 'h'),
Sigla = FM(field, 'k'),
DateGivenString = FM(field, 'd'),
Department = FM(field, 'v'),
DateExpectedString = FM(field, 'e'),
DateReturnedString = FM(field, 'f'),
DateProlongString = FM(field, 'l'),
Lost = FM(field, 'u'),
Description = FM(field, 'c'),
Responsible = FM(field, 'i'),
TimeIn = FM(field, '1'),
TimeOut = FM(field, '2')
};
return(result);
}
/// <summary>
/// Строит представление записи в виде JSON,
/// характерном для ИРБИС.
/// </summary>
public string ToIrbisJson()
{
JObject result = new JObject();
string[] tags = Fields
.Select(field => field.Tag)
.Distinct()
.ToArray();
foreach (string tag in tags)
{
RecordField[] fields = Fields.GetField(tag);
JProperty tagProperty = new JProperty(tag);
for (int i = 0; i < fields.Length; i++)
{
JProperty repeatProperty = new JProperty(i.ToString());
tagProperty.Add(repeatProperty);
RecordField field = fields[i];
if (!string.IsNullOrEmpty(field.Text))
{
JProperty textProperty = new JProperty("*", field.Text);
repeatProperty.Add(textProperty);
}
foreach (SubField subField in field.SubFields)
{
JProperty subProperty = new JProperty
(
subField.CodeString,
subField.Text
);
repeatProperty.Add(subProperty);
}
}
}
return(result.ToString());
}
private static void AddSubField
(
RecordField field,
char code,
StringBuilder value
)
{
if (code != 0)
{
if (value.Length == 0)
{
field.SubFields.Add(new SubField(code));
}
else
{
field.SubFields.Add(new SubField
(
code,
value.ToString()
));
}
}
value.Length = 0;
}
/// <summary>
/// Парсинг текстового проедставления поля
/// </summary>
/// <param name="tag"></param>
/// <param name="body"></param>
/// <returns></returns>
public static RecordField Parse
(
string tag,
string body
)
{
RecordField result = new RecordField(tag);
int first = body.IndexOf('^');
if (first != 0)
{
if (first < 0)
{
result.Text = body;
body = string.Empty;
}
else
{
result.Text = body.Substring
(
0,
first
);
body = body.Substring(first);
}
}
var code = (char)0;
var value = new StringBuilder();
foreach (char c in body)
{
if (c == '^')
{
AddSubField
(
result,
code,
value
);
code = (char)0;
}
else
{
if (code == 0)
{
code = c;
}
else
{
value.Append(c);
}
}
}
AddSubField
(
result,
code,
value
);
return(result);
}
public static IrbisRecord ReadIso
(
Stream strm,
Encoding enc
)
{
IrbisRecord result = new IrbisRecord();
byte[] marker = new byte[5];
// Считываем длину записи
if (strm.Read(marker, 0, 5) != 5)
{
return(null);
}
int reclen = _ToInt(marker, 0, 5);
byte[] record = new byte[reclen];
int need = reclen - 5;
// А затем и ее остаток
if (strm.Read(record, 5, need) != need)
{
return(null);
}
// простая проверка, что мы имеем дело с нормальной ISO-записью
if (record[reclen - 1] != RecordDelimiter)
{
return(null);
}
// Превращаем в Unicode
char[] chars = enc.GetChars(record, 0, reclen);
int baseAddress = _ToInt(record, 12, 5) - 1;
int start = baseAddress;
// Пошли по полям (при помощи словаря)
for (int dic = MarkerLength; ; dic += 12)
{
// находим следующее поле
// Если нарвались на разделитель, заканчиваем
if ((record[dic] == FieldDelimiter) ||
(start > (reclen - 4)))
{
break;
}
string tag = new string(chars, dic, 3);
RecordField fld = new RecordField(tag);
bool isFixed = tag.StartsWith("00");
result.Fields.Add(fld);
start++;
int end;
if (isFixed)
{
for (end = start; ; end++)
{
if (record[end] == FieldDelimiter)
{
break;
}
}
fld.Text = new string(chars, start, end - start);
start = end;
}
else
{
start += 2;
while (true)
{
// находим подполя
if (record[start] == FieldDelimiter)
{
break;
}
if (record[start] != SubfieldDelimiter)
{
// Нарвались на поле без подполей
for (end = start; ; end++)
{
if ((record[end] == FieldDelimiter) ||
(record[end] == SubfieldDelimiter))
{
break;
}
}
fld.Text = new string
(chars,
start,
end - start);
}
else
{
// Декодируем подполя
SubField sub = new SubField
(chars[++start]);
fld.SubFields.Add(sub);
start++;
for (end = start; ; end++)
{
if ((record[end] == FieldDelimiter) ||
(record[end] == SubfieldDelimiter))
{
break;
}
}
sub.Text = new string
(chars,
start,
end - start);
}
start = end;
}
}
}
return(result);
}
public static int Compare
(
RecordField field1,
RecordField field2,
bool verbose
)
{
int result = string.CompareOrdinal(field1.Tag, field2.Tag);
if (result != 0)
{
if (verbose)
{
Console.WriteLine
(
"Field1 Tag={0}, Field2 Tag={1}",
field1.Tag,
field2.Tag
);
}
return(result);
}
if (!string.IsNullOrEmpty(field1.Text) ||
!string.IsNullOrEmpty(field2.Text))
{
result = string.CompareOrdinal(field1.Text, field2.Text);
if (result != 0)
{
if (verbose)
{
Console.WriteLine
(
"Field1 Text={0}, Field2 Text={1}",
field1.Text,
field2.Text
);
}
return(result);
}
}
IEnumerator <SubField> enum1 = field1.SubFields.GetEnumerator();
IEnumerator <SubField> enum2 = field2.SubFields.GetEnumerator();
while (true)
{
bool next1 = enum1.MoveNext();
bool next2 = enum2.MoveNext();
if ((!next1) && (!next2))
{
break;
}
if (!next1)
{
return(-1);
}
if (!next2)
{
return(1);
}
SubField subField1 = enum1.Current;
SubField subField2 = enum2.Current;
result = SubField.Compare
(
subField1,
subField2,
verbose
);
if (result != 0)
{
return(result);
}
}
return(0);
}
