public void TestRanges()
{
const string test = "SomeEnum ::= Unsigned32 (8 | 10 ..20 | 31 .. 60 )";
Lexer lexer = new Lexer();
StringReader reader = new StringReader(test);
lexer.Parse(reader);
string name = lexer.NextSymbol.ToString();
lexer.NextSymbol.Expect(Symbol.Assign);
lexer.NextSymbol.Expect(Symbol.Unsigned32);
UnsignedType i = new UnsignedType("module", "name", lexer);
Assert.IsTrue(i.Contains(8));
Assert.IsTrue(i.Contains(10));
Assert.IsTrue(i.Contains(15));
Assert.IsTrue(i.Contains(20));
Assert.IsTrue(i.Contains(35));
Assert.IsFalse(i.Contains(4));
Assert.IsFalse(i.Contains(-9));
Assert.IsFalse(i.Contains(25));
Assert.IsFalse(i.Contains(61));
}
private static IEnumerable <byte> UintToUtype(uint number, UnsignedType type)
{
switch (type)
{
case UnsignedType.Byte:
yield return((byte)number);
break;
case UnsignedType.Ushort:
foreach (var b in BitConverter.GetBytes((ushort)number))
{
yield return(b);
}
break;
case UnsignedType.Uint:
foreach (var b in BitConverter.GetBytes(number))
{
yield return(b);
}
break;
}
}
private static SnmpScalarNode GenerateSnmpScalarNode(ObjectType ote, SnmpTreeNode parentNode, bool ignoreAccessibleFlag = false)
{
SnmpScalarNode result;
ITypeAssignment mibType = ote.BaseType;
IntegerType it = (mibType as IntegerType);
if (it != null)
{
if (ote.ReferredType.Name == Symbol.TruthValue.ToString())
{
result = new SnmpScalarNodeTruthValue(parentNode);
}
else if ((it.Type == IntegerType.Types.Integer) || (it.Type == IntegerType.Types.Integer32))
{
result = new SnmpScalarNodeInt(parentNode);
}
else
{
Console.WriteLine(String.Format("Unsupported IntegerType '{0}'!", it.Type));
return(null);
}
if (it.IsEnumeration)
{
result.Restrictions.AddRange(CreateRestrictions(it.Enumeration));
}
else
{
result.Restrictions.AddRange(CreateRestrictions(it.Ranges));
}
}
else
{
UnsignedType ut = (mibType as UnsignedType);
if (ut != null)
{
if ((ut.Type == UnsignedType.Types.Unsigned32) ||
(ut.Type == UnsignedType.Types.Gauge32))
{
result = new SnmpScalarNodeUint(SnmpDataType.Gauge, parentNode);
}
else if (ut.Type == UnsignedType.Types.Counter32)
{
result = new SnmpScalarNodeUint(SnmpDataType.Counter, parentNode);
}
else if (ut.Type == UnsignedType.Types.TimeTicks)
{
result = new SnmpScalarNodeUint(SnmpDataType.TimeTicks, parentNode);
}
else if (ut.Type == UnsignedType.Types.Counter64)
{
result = new SnmpScalarNodeCounter64(parentNode);
if ((ut.Ranges != null) && (ut.Ranges.Count > 0))
{
Console.WriteLine(String.Format("Generation of ranges is not supported for Counter64 type!"));
return(null);
}
}
else
{
Console.WriteLine(String.Format("Unsupported UnsignedType '{0}'!", ut.Type));
return(null);
}
result.Restrictions.AddRange(CreateRestrictions(ut.Ranges));
}
else if (mibType is IpAddressType)
{
result = new SnmpScalarNodeOctetString(SnmpDataType.IpAddress, parentNode);
result.Restrictions.AddRange(CreateRestrictions((mibType as OctetStringType).Size));
}
else if (mibType is OpaqueType)
{
result = new SnmpScalarNodeOctetString(SnmpDataType.Opaque, parentNode);
result.Restrictions.AddRange(CreateRestrictions((mibType as OctetStringType).Size));
}
else if (mibType is OctetStringType)
{
result = new SnmpScalarNodeOctetString(SnmpDataType.OctetString, parentNode);
result.Restrictions.AddRange(CreateRestrictions((mibType as OctetStringType).Size));
}
else if (mibType is ObjectIdentifierType)
{
result = new SnmpScalarNodeObjectIdentifier(parentNode);
}
else if (mibType is BitsType)
{
result = new SnmpScalarNodeBits(parentNode, (uint)((mibType as BitsType).Map.GetHighestValue() + 1));
result.Restrictions.AddRange(CreateRestrictions(mibType as BitsType));
}
else
{
TypeAssignment ta = mibType as TypeAssignment;
if (ta != null)
{
Console.WriteLine(String.Format("Unsupported BaseType: Module='{0}', Name='{1}', Type='{2}'!", ta.Module.Name, ta.Name, ta.Type));
}
else
{
Console.WriteLine(String.Format("Unsupported BaseType: Module='{0}', Name='{1}'!", mibType.Module, mibType.Name));
}
return(null);
}
}
result.Name = _alphaNumericRegex.Replace(ote.Name, "");
result.Oid = ote.Value;
if (ote.Access == MaxAccess.readWrite)
{
result.AccessMode = SnmpAccessMode.ReadWrite;
}
else if (ote.Access == MaxAccess.readOnly)
{
result.AccessMode = SnmpAccessMode.ReadOnly;
}
else if (ote.Access == MaxAccess.readCreate)
{
result.AccessMode = SnmpAccessMode.ReadOnly;
}
else if (ignoreAccessibleFlag && (ote.Access == MaxAccess.notAccessible))
{
result.AccessMode = SnmpAccessMode.NotAccessible;
}
else
{
// not accessible or unsupported access type
return(null);
}
return(result);
}
private static IEnumerable <byte> EncodeWithAutoDictionary(string SourceFilePath)
{
Dictionary <char, uint> chars = new Dictionary <char, uint>();
using (StreamReader sr = new StreamReader(SourceFilePath))
{
HashSet <char> hs = new HashSet <char>();
while (sr.Peek() >= 0)
{
hs.Add((char)sr.Read());
}
uint i = 0;
chars = hs.ToDictionary(c => c, c => i++);
}
long textLength = new FileInfo(SourceFilePath).Length;
int charsCount = chars.Count();
char[] returnCharsArray = new char[charsCount];
foreach (var entry in chars)
{
returnCharsArray[entry.Value] = entry.Key;
}
foreach (var b in BitConverter.GetBytes(charsCount))
{
yield return(b);
}
foreach (var c in returnCharsArray)
{
foreach (var b in BitConverter.GetBytes(c))
{
yield return(b);
}
}
UnsignedType uType = UnsignedType.Uint;
if (charsCount + textLength < 256)
{
uType = UnsignedType.Byte;
}
else if (charsCount + textLength < 65536)
{
uType = UnsignedType.Ushort;
}
else
{
uType = UnsignedType.Uint;
}
yield return((byte)uType);
using (StreamReader sr = new StreamReader(SourceFilePath))
{
Dictionary <string, uint> words = new Dictionary <string, uint>();
uint i = (uint)charsCount;
string w = ((char)sr.Read()).ToString();
while (sr.Peek() >= 0)
{
char entry = (char)sr.Read();
if (words.ContainsKey(w + entry))
{
w = w + entry;
}
else
{
if (w.Length == 1)
{
foreach (var b in UintToUtype(chars[w.First()], uType))
{
yield return(b);
}
}
else
{
foreach (var b in UintToUtype(words[w], uType))
{
yield return(b);
}
}
words.Add(w + entry, i++);
w = entry.ToString();
}
}
if (w.Length == 1)
{
foreach (var b in UintToUtype(chars[w.First()], uType))
{
yield return(b);
}
}
else
{
foreach (var b in UintToUtype(words[w], uType))
{
yield return(b);
}
}
}
}
private static IEnumerable <byte> EncodeUTF8Dictionary(string SourceFilePath)
{
long textLength = new FileInfo(SourceFilePath).Length;
int charsCount = 256;
UnsignedType uType = UnsignedType.Uint;
if (charsCount + textLength < 256)
{
uType = UnsignedType.Byte;
}
else if (charsCount + textLength < 65536)
{
uType = UnsignedType.Ushort;
}
else
{
uType = UnsignedType.Uint;
}
yield return((byte)uType);
using (StreamReader sr = new StreamReader(SourceFilePath))
{
Dictionary <string, uint> words = new Dictionary <string, uint>();
uint i = (uint)charsCount;
string w = ((char)sr.Read()).ToString();
while (sr.Peek() >= 0)
{
char entry = (char)sr.Read();
if (words.ContainsKey(w + entry))
{
w = w + entry;
}
else
{
if (w.Length == 1)
{
foreach (var b in UintToUtype(BitConverter.ToUInt32(Encoding.UTF8.GetBytes(w)), uType))
{
yield return(b);
}
}
else
{
foreach (var b in UintToUtype(words[w], uType))
{
yield return(b);
}
}
words.Add(w + entry, i++);
w = entry.ToString();
}
}
if (w.Length == 1)
{
foreach (var b in UintToUtype(BitConverter.ToUInt32(Encoding.UTF8.GetBytes(w)), uType))
{
yield return(b);
}
}
else
{
foreach (var b in UintToUtype(words[w], uType))
{
yield return(b);
}
}
}
}
//Основной метод для кодирования
internal static IEnumerable <byte> EncodeWithAutoDictionary(string SourceFilePath)
{
//Словарь фраз длиной в 1 символ
Dictionary <char, uint> chars = new Dictionary <char, uint>();
//Заполнение словаря всеми уникальными символами
using (StreamReader sr = new StreamReader(SourceFilePath))
{
HashSet <char> hs = new HashSet <char>();
while (sr.Peek() >= 0)
{
hs.Add((char)sr.Read());
}
uint i = 0;
chars = hs.ToDictionary(c => c, c => i++);
}
//Кодирование словаря
//Перед словарём четырьми битами передаётся количество символов в нём
//Затем код каждого символа длиной по 2 бита
int charsCount = chars.Count();
char[] returnCharsArray = new char[charsCount];
foreach (var entry in chars)
{
returnCharsArray[entry.Value] = entry.Key;
}
foreach (var b in BitConverter.GetBytes(charsCount))
{
yield return(b);
}
foreach (var c in returnCharsArray)
{
foreach (var b in BitConverter.GetBytes(c))
{
yield return(b);
}
}
//Определение того, сколько байтов необходимо выделить на одну запись
//в словаре, в зависимости от максимальной предполагаемой длины словаря
long textLength = new FileInfo(SourceFilePath).Length;
UnsignedType uType = UnsignedType.Uint;
if (charsCount + textLength < 256)
{
uType = UnsignedType.Byte;
}
else if (charsCount + textLength < 65536)
{
uType = UnsignedType.Ushort;
}
else
{
uType = UnsignedType.Uint;
}
yield return((byte)uType);
using (StreamReader sr = new StreamReader(SourceFilePath))
{
//Инициализация словаря фраз длиной от двух символов
Dictionary <string, uint> words = new Dictionary <string, uint>();
//Номер следующей записи в словаре
uint i = (uint)charsCount;
//
string w = ((char)sr.Read()).ToString();
//Пока не достигнут конец потока
while (sr.BaseStream.Position != sr.BaseStream.Length)
{
//Прочитать следующий символ
char entry = (char)sr.Read();
//Если фраза с новым символом содержится в словаре,
//перейти к следующему символу
if (words.ContainsKey(w + entry))
{
w = w + entry;
}
//Иначе добавить в словарь фразу с новым символом
//и принять за фразу новый символ, отправив фразу в поток
else
{
if (w.Length == 1)
{
foreach (var b in UintToUtype(chars[w.First()], uType))
{
yield return(b);
}
}
else
{
foreach (var b in UintToUtype(words[w], uType))
{
yield return(b);
}
}
words.Add(w + entry, i++);
w = entry.ToString();
}
}
//Кодирование последней фразы
if (w.Length == 1)
{
foreach (var b in UintToUtype(chars[w.First()], uType))
{
yield return(b);
}
}
else
{
foreach (var b in UintToUtype(words[w], uType))
{
yield return(b);
}
}
}
}
