internal override int Update()
{
var output = new BerMemoryOutput();
var implicitTag = new BerTag(BerClass.Universal, BerTypeNumber, true);
var childrenLength = 0;
foreach (var child in this)
{
childrenLength += child.IsDirty
? child.Update()
: child.EncodedLength;
}
BerEncoding.EncodeTag(output, Tag.ToContainer());
BerEncoding.EncodeLength(output, BerDefinitions.IndefiniteLength);
BerEncoding.EncodeTag(output, implicitTag);
BerEncoding.EncodeLength(output, BerDefinitions.IndefiniteLength);
_encodedFrameHeader = output.ToArray();
EncodedLength = childrenLength + _encodedFrameHeader.Length + BerEncoding.IndefiniteLengthTerminator.Length;
return(EncodedLength);
}
/// <summary>
/// Pre-encodes the BER header and returns the byte length of the encoded node.
/// Overridden to recursively pre-encode all descendants.
/// </summary>
/// <returns>The length of the encoded node.</returns>
internal override int Update()
{
var output = new BerMemoryOutput();
var implicitTag = BerType.IsApplicationDefined(BerTypeNumber)
? new BerTag(BerClass.Application, BerTypeNumber & ~BerType.ApplicationFlag, true)
: new BerTag(BerClass.Universal, BerTypeNumber, true);
_childrenLength = 0;
foreach (var child in _nodes)
{
_childrenLength += child.IsDirty
? child.Update()
: child.EncodedLength;
}
var implicitLength = _childrenLength + BerEncoding.GetHeaderLength(implicitTag, _childrenLength);
BerEncoding.EncodeTag(output, Tag.ToContainer());
BerEncoding.EncodeLength(output, implicitLength);
BerEncoding.EncodeTag(output, implicitTag);
BerEncoding.EncodeLength(output, _childrenLength);
_encodedHeader = output.ToArray();
EncodedLength = _childrenLength + _encodedHeader.Length;
return(EncodedLength);
}
void Test_ReaderWriter()
{
var output = new BerMemoryOutput();
var writer = new EmberWriter(output);
writer.WriteSequenceBegin(new BerTag(DefaultClass, 1));
for (uint index = 0; index <= 20; index++)
{
writer.Write(new BerTag(DefaultClass, index + 111122), index);
}
var oid = new int[100];
for (int index = 0; index < oid.Length; index++)
{
oid[index] = 1000 + index;
}
writer.WriteRelativeOid(new BerTag(DefaultClass, 500000), oid);
writer.WriteContainerEnd();
Console.WriteLine("\r\n------------------------ Reader, Writer");
var asyncReader = new AsyncDomReader(null);
asyncReader.ReadBytes(output.Memory);
var root = asyncReader.DetachRoot();
Console.WriteLine(GetXml(root));
}
public void Write(BerTag tag, double value)
{
var valueOutput = new BerMemoryOutput();
var valueLength = BerEncoding.EncodeReal(valueOutput, value);
WriteOuterHeader(tag, valueLength + 2);
BerEncoding.EncodeTag(_output, new BerTag(BerType.Real));
BerEncoding.EncodeLength(_output, valueLength);
_output.WriteBytes(valueOutput.Memory);
}
public void Write(BerTag tag, string value)
{
var valueOutput = new BerMemoryOutput();
var valueLength = BerEncoding.EncodeUtf8String(valueOutput, value);
var innerTag = new BerTag(BerType.UTF8String);
WriteOuterHeader(tag, valueLength + BerEncoding.GetHeaderLength(innerTag, valueLength));
BerEncoding.EncodeTag(_output, innerTag);
BerEncoding.EncodeLength(_output, valueLength);
_output.WriteBytes(valueOutput.Memory);
}
internal override int Update()
{
var output = new BerMemoryOutput();
BerEncoding.EncodeTag(output, Tag.ToContainer());
BerEncoding.EncodeLength(output, 2);
BerEncoding.EncodeTag(output, new BerTag(BerTypeNumber));
BerEncoding.EncodeLength(output, 0);
Encoded = output.ToArray();
EncodedLength = Encoded.Length;
return(EncodedLength);
}
void Test_Real()
{
var values = new[] { 32.1, 32.125, 32.123, 100, 200, 300, -1000, 5.5005005, 777777777.123456789 };
foreach (var value in values)
{
var output = new BerMemoryOutput();
BerEncoding.EncodeReal(output, value);
var input = new BerMemoryInput(output.Memory);
var decodedValue = BerEncoding.DecodeReal(input, output.Length);
Console.WriteLine("value={0} decoded={1}", value, decodedValue);
}
}
void Test_Real2()
{
var encoded = new byte[] { 0xC0, 0x04, 0xDF };
var input = new BerMemoryInput(encoded);
var decoded = BerEncoding.DecodeReal(input, encoded.Length);
Console.WriteLine("decoded={0}", decoded);
var output = new BerMemoryOutput();
var reencoded = BerEncoding.EncodeReal(output, decoded);
var bytes = output.ToArray();
Console.WriteLine("reencoded={0}", BytesToString(bytes));
}
/// <summary>
/// Pre-encodes the BER header and returns the byte length of the encoded node.
/// Overriden to encode the entire TLTLV
/// </summary>
/// <returns>The length of the encoded node.</returns>
internal override int Update()
{
var output = new BerMemoryOutput();
BerEncoding.EncodeTag(output, Tag.ToContainer());
BerEncoding.EncodeLength(output, 3);
BerEncoding.EncodeTag(output, new BerTag(BerType.Boolean));
BerEncoding.EncodeLength(output, 1);
BerEncoding.EncodeBoolean(output, Value);
Encoded = output.ToArray();
EncodedLength = Encoded.Length;
return(EncodedLength);
}
/// <summary>
/// Pre-encodes the BER header and returns the byte length of the encoded node.
/// Overriden to encode the entire TLTLV
/// </summary>
/// <returns>The length of the encoded node.</returns>
internal override int Update()
{
var output = new BerMemoryOutput();
var valueLength = BerEncoding.GetLongLength(Value);
BerEncoding.EncodeTag(output, Tag.ToContainer());
BerEncoding.EncodeLength(output, valueLength + 2);
BerEncoding.EncodeTag(output, new BerTag(BerType.Integer));
BerEncoding.EncodeLength(output, valueLength);
BerEncoding.EncodeLong(output, Value, valueLength);
Encoded = output.ToArray();
EncodedLength = Encoded.Length;
return(EncodedLength);
}
/// <summary>
/// Pre-encodes the BER header and returns the byte length of the encoded node.
/// Overriden to encode the entire TLTLV
/// </summary>
/// <returns>The length of the encoded node.</returns>
internal override int Update()
{
var output = new BerMemoryOutput();
var arrayLength = Value.Length;
var tagImplicit = new BerTag(BerType.OctetString);
var implicitLength = (arrayLength + BerEncoding.GetHeaderLength(tagImplicit, arrayLength));
BerEncoding.EncodeTag(output, Tag.ToContainer());
BerEncoding.EncodeLength(output, implicitLength);
BerEncoding.EncodeTag(output, tagImplicit);
BerEncoding.EncodeLength(output, arrayLength);
Encoded = output.ToArray();
EncodedLength = arrayLength + Encoded.Length;
return(EncodedLength);
}
void AssertCodecSanity(EmberNode ember)
{
var originalXml = GetXml(ember);
var output = new BerMemoryOutput();
ember.Encode(output);
var input = new BerMemoryInput(output.Memory);
var reader = new EmberReader(input);
var decoded = EmberNode.Decode(reader, new GlowApplicationInterface());
var decodedXml = GetXml(decoded);
if (originalXml != decodedXml)
{
throw new Exception("Codec error!");
}
}
/// <summary>
/// Pre-encodes the BER header and returns the byte length of the encoded node.
/// </summary>
/// <returns>The length of the encoded node.</returns>
internal override int Update()
{
var output = new BerMemoryOutput();
var stringLength = BerEncoding.GetUtf8StringLength(Value);
var tagImplicit = new BerTag(BerType.UTF8String);
var implicitLength = (stringLength + BerEncoding.GetHeaderLength(tagImplicit, stringLength));
BerEncoding.EncodeTag(output, Tag.ToContainer());
BerEncoding.EncodeLength(output, implicitLength);
BerEncoding.EncodeTag(output, tagImplicit);
BerEncoding.EncodeLength(output, stringLength);
Encoded = output.ToArray();
EncodedLength = stringLength + Encoded.Length;
return(EncodedLength);
}
/// <summary>
/// Pre-encodes the BER header and returns the byte length of the encoded node.
/// Overriden to encode the entire TLTLV
/// </summary>
/// <returns>The length of the encoded node.</returns>
internal override int Update()
{
var output = new BerMemoryOutput();
var tagImplicit = new BerTag(BerType.RelativeOid);
var valueLength = BerEncoding.GetRelativeOidLength(Value);
var implicitLength = valueLength + BerEncoding.GetHeaderLength(tagImplicit, valueLength);
BerEncoding.EncodeTag(output, Tag.ToContainer());
BerEncoding.EncodeLength(output, implicitLength);
BerEncoding.EncodeTag(output, tagImplicit);
BerEncoding.EncodeLength(output, valueLength);
Encoded = output.ToArray();
EncodedLength = valueLength + Encoded.Length;
return(EncodedLength);
}
/// <summary>
/// Writes a byte of ember data to the output.
/// </summary>
/// <param name="b">Byte to write</param>
public void WriteByte(byte b)
{
if (_buffer == null)
{
_buffer = new BerMemoryOutput();
}
if (_buffer.Length >= MaximumPackageLength)
{
OnPackageReady(isLastPackage: false);
}
if (_dataLength == 0)
{
WriteHeader();
}
_buffer.WriteByte(b);
_dataLength++;
}
/// <summary>
/// Pre-encodes the BER header and returns the byte length of the encoded node.
/// Overriden to encode the entire TLTLV
/// </summary>
/// <returns>The length of the encoded node.</returns>
internal override int Update()
{
var output = new BerMemoryOutput();
int tagLength, innerLength = 0, valueLength;
tagLength = BerEncoding.EncodeTag(output, Tag.ToContainer());
BerEncoding.EncodeLength(output, 0);
innerLength += BerEncoding.EncodeTag(output, new BerTag(BerType.Real));
innerLength += BerEncoding.EncodeLength(output, 0);
innerLength += valueLength = BerEncoding.EncodeReal(output, Value);
Encoded = output.ToArray();
EncodedLength = Encoded.Length;
Encoded[tagLength] = (byte)innerLength; // fix outer length
Encoded[tagLength + 2] = (byte)valueLength; // fix inner length
return(EncodedLength);
}
private void AssertEqual <T>(
Action <EmberLib.EmberWriter, BerTag, T> write, Func <EmberReader, T> read, T value, Action <T, T> assertEqual)
{
var number = this.Random.Next();
var outerId = EmberId.CreateApplication(number);
var tag = new BerTag(BerClass.Application, (uint)number);
var output = new BerMemoryOutput();
var writer = new EmberLib.EmberWriter(output);
write(writer, tag, value);
using (var input = new MemoryStream(output.ToArray()))
using (var reader = new EmberReader(input, 1))
{
Assert.IsTrue(reader.Read());
Assert.AreEqual(outerId, reader.OuterId);
assertEqual(value, read(reader));
}
}
void Test_ReaderWriter()
{
var output = new BerMemoryOutput();
var writer = new EmberWriter(output);
writer.WriteFrameBegin();
writer.WriteSequenceBegin(new BerTag(DefaultClass, 1));
for (uint index = 0; index <= 100; index++)
{
writer.Write(new BerTag(DefaultClass, index + 111122), index);
}
writer.WriteContainerEnd();
writer.WriteContainerEnd();
Console.WriteLine("\r\n------------------------ Reader, Writer");
var asyncReader = new AsyncDomReader(null);
asyncReader.ReadBytes(output.Memory);
DumpXml(asyncReader.DetachRoot());
//var input = new BerMemoryInput(output.Memory);
//var reader = new EmberReader(input);
//var xmlBuffer = new StringBuilder();
//var xmlSettings = new XmlWriterSettings
//{
// OmitXmlDeclaration = true,
//};
//using(var xmlWriter = XmlWriter.Create(xmlBuffer, xmlSettings))
// EmberToXml(reader, xmlWriter);
//Console.WriteLine(xmlBuffer.ToString());
}
void Test_DOM()
{
Console.WriteLine("\r\n------------------------ DOM");
EmberContainer container1;
EmberContainer frame = new EmberFrame();
container1 = new EmberSet(new BerTag(DefaultClass, 0));
container1.Insert(new BerTag(DefaultClass, 0), -1);
container1.Insert(new BerTag(DefaultClass, 1), 128);
container1.Insert(new BerTag(DefaultClass, 2), -128);
container1.Insert(new BerTag(DefaultClass, 3), 255);
container1.Insert(new BerTag(DefaultClass, 4), -255);
container1.Insert(new BerTag(DefaultClass, 5), 12345);
container1.Insert(new BerTag(DefaultClass, 6), -12345);
container1.Insert(new BerTag(DefaultClass, 7), 16384);
container1.Insert(new BerTag(DefaultClass, 8), -16384);
container1.Insert(new BerTag(DefaultClass, 9), 65535);
container1.Insert(new BerTag(DefaultClass, 10), -65535);
container1.Insert(new BerTag(DefaultClass, 11), 0);
container1.Insert(new BerTag(DefaultClass, 12), 127);
container1.Insert(new BerTag(DefaultClass, 13), -127);
container1.Insert(new BerTag(DefaultClass, 1111222), 0xFFFFFFFF);
container1.InsertOid(new BerTag(DefaultClass, 14), new int[] { 1, 3, 6, 0 });
container1.InsertOid(new BerTag(DefaultClass, 15), new int[] { 1 });
container1.InsertRelativeOid(new BerTag(DefaultClass, 16), new int[] { 1, 2, 3, 4, 5, 6 });
frame.Insert(container1);
container1 = new EmberSequence(new BerTag(DefaultClass, 1));
container1.Insert(new BerTag(DefaultClass, 3), -0.54321);
container1.Insert(new BerTag(DefaultClass, 5), "Wuppdich");
var appDefined = EmberApplicationInterface.CreateApplicationDefinedSequence(new BerTag(BerClass.Application, 889), 2, container1);
appDefined.Insert(new BerTag(DefaultClass, 100), true);
frame.Insert(container1);
var xml1 = GetXml(frame);
var output = new BerMemoryOutput();
frame.Encode(output);
var memory = output.ToArray();
using (var stream = new FileStream(@"N:\Temp\test.ber", FileMode.Create, FileAccess.Write))
stream.Write(memory, 0, memory.Length);
var input = new BerMemoryInput(memory);
var stopwatch = new Stopwatch();
stopwatch.Start();
var asyncReader = new AsyncFrameReader(this);
asyncReader.ReadBytes(output.Memory);
var loadedFrame = asyncReader.DetachRoot();
stopwatch.Stop();
Console.WriteLine("load tree: {0}ms", stopwatch.ElapsedMilliseconds);
var xml2 = GetXml(loadedFrame);
Console.WriteLine(xml1);
Console.WriteLine(xml2);
Debug.Assert(xml1 == xml2);
}
