void EmberToXml(EmberReader reader, XmlWriter writer)
{
if (reader.Read())
{
EmberToXml_ProcessNode(reader, writer, 0);
}
}
private void ReadResult(EmberReader reader)
{
int index;
for (index = 0; reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer);)
{
if (reader.GetContextSpecificOuterNumber() == GlowTuple.Value.OuterNumber)
{
if (index >= this.valueReaders.Length)
{
throw this.CreateSignatureMismatchException();
}
this.valueReaders[index].ReadValue(reader);
++index;
}
else
{
reader.Skip();
}
}
if (index < this.valueReaders.Length)
{
throw this.CreateSignatureMismatchException();
}
}
internal override RetrievalState ReadContents(EmberReader reader, ElementType actualType)
{
this.AssertElementType(ElementType.Node, actualType);
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
switch (reader.GetContextSpecificOuterNumber())
{
case GlowNodeContents.Description.OuterNumber:
this.Description = reader.AssertAndReadContentsAsString();
break;
case GlowNodeContents.IsRoot.OuterNumber:
this.IsRoot = reader.AssertAndReadContentsAsBoolean();
break;
case GlowNodeContents.IsOnline.OuterNumber:
this.IsOnline = reader.AssertAndReadContentsAsBoolean();
this.RetrievalState &= RetrievalState.Complete;
break;
case GlowNodeContents.SchemaIdentifiers.OuterNumber:
this.ReadSchemaIdentifiers(reader);
break;
default:
reader.Skip();
break;
}
}
return(this.RetrievalState);
}
internal virtual Element ReadNewChildContents(
EmberReader reader, ElementType actualType, Context context, out RetrievalState childRetrievalState)
{
reader.SkipToEndContainer();
childRetrievalState = RetrievalState.Complete;
return(null);
}
internal void Read(
EmberReader reader,
IDictionary <int, IInvocationResult> pendingInvocations,
IReadOnlyDictionary <int, IEnumerable <IStreamedParameter> > streamedParameters)
{
reader.ReadAndAssertOuter(GlowGlobal.Root.OuterId);
switch (reader.InnerNumber)
{
case GlowRootElementCollection.InnerNumber:
this.ReadChildren(reader);
break;
case GlowInvocationResult.InnerNumber:
ReadInvocationResult(reader, pendingInvocations);
break;
case GlowStreamCollection.InnerNumber:
ReadStreamCollection(reader, streamedParameters);
break;
default:
reader.Skip();
break;
}
}
internal sealed override object ReadValue(EmberReader reader, out ParameterType?parameterType)
{
switch (reader.InnerNumber)
{
case InnerNumber.Boolean:
parameterType = ParameterType.Boolean;
return(reader.ReadContentsAsBoolean());
case InnerNumber.Integer:
parameterType = ParameterType.Integer;
return(reader.ReadContentsAsInt64());
case InnerNumber.Octetstring:
parameterType = ParameterType.Octets;
return(reader.ReadContentsAsByteArray());
case InnerNumber.Real:
parameterType = ParameterType.Real;
return(reader.ReadContentsAsDouble());
default:
parameterType = ParameterType.String;
return(reader.AssertAndReadContentsAsString());
}
}
void EmberToXml_Recurse(EmberReader reader, XmlWriter writer, int indent)
{
while (reader.Read())
{
EmberToXml_ProcessNode(reader, writer, indent);
}
}
internal static TMostDerived ReadContents(
EmberReader reader, ElementType actualType, Context context, out RetrievalState retrievalState)
{
var result = Construct(context);
retrievalState = result.ReadContents(reader, actualType);
return(result);
}
internal virtual RetrievalState ReadQualifiedChild(
EmberReader reader, ElementType actualType, int[] path, int index)
{
const string Format =
"The path of a qualified element attempts to address a direct or indirect child of the element with the path {0}.";
throw new ModelException(string.Format(CultureInfo.InvariantCulture, Format, this.GetPath()));
}
internal sealed override KeyValuePair <string, ParameterType>[] ReadTupleDescription(
EmberReader reader, KeyValuePair <string, ParameterType>[] expectedTypes)
{
var descriptions = new List <KeyValuePair <string, ParameterType> >();
this.ReadTupleDescription(reader, expectedTypes, (i, d) => descriptions.Add(d));
return(descriptions.ToArray());
}
internal sealed override Element ReadNewChildContents(
EmberReader reader, ElementType actualType, Context context, out RetrievalState childRetrievalState)
{
MetaElement metaChild;
return(MetaChildren.TryGetValue(context.Identifier, out metaChild) ?
metaChild.ReadContents(reader, actualType, context, out childRetrievalState) :
this.ReadNewDynamicChildContents(reader, actualType, context, out childRetrievalState));
}
internal sealed override RetrievalState ReadChildren(EmberReader reader)
{
if (this.ReadChildrenCore(reader))
{
this.RetrievalState = RetrievalState.Complete;
}
return(this.RetrievalState);
}
internal sealed override bool ReadChildrenCore(EmberReader reader)
{
var isEmpty = true;
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
switch (reader.InnerNumber)
{
case GlowParameter.InnerNumber:
isEmpty = false;
this.ReadChild(reader, ElementType.Parameter);
break;
case GlowNode.InnerNumber:
isEmpty = false;
this.ReadChild(reader, ElementType.Node);
break;
case GlowFunction.InnerNumber:
isEmpty = false;
this.ReadChild(reader, ElementType.Function);
break;
case GlowMatrix.InnerNumber:
isEmpty = false;
this.ReadChild(reader, ElementType.Matrix);
break;
case GlowQualifiedParameter.InnerNumber:
isEmpty = false;
this.ReadQualifiedChild(reader, ElementType.Parameter);
break;
case GlowQualifiedNode.InnerNumber:
isEmpty = false;
this.ReadQualifiedChild(reader, ElementType.Node);
break;
case GlowQualifiedFunction.InnerNumber:
isEmpty = false;
this.ReadQualifiedChild(reader, ElementType.Function);
break;
case GlowQualifiedMatrix.InnerNumber:
isEmpty = false;
this.ReadQualifiedChild(reader, ElementType.Matrix);
break;
default:
reader.Skip();
break;
}
}
return(isEmpty);
}
internal static void AssertInnerNumber(this EmberReader reader, int expectedInnerNumber)
{
if (reader.InnerNumber != expectedInnerNumber)
{
const string Format =
"Found actual inner number {0} while expecting {1} on a container with the outer identifier {2}.";
throw new ModelException(string.Format(
CultureInfo.InvariantCulture, Format, reader.InnerNumber, expectedInnerNumber, reader.OuterId));
}
}
internal sealed override KeyValuePair <string, ParameterType>[] ReadTupleDescription(
EmberReader reader, KeyValuePair <string, ParameterType>[] expectedTypes)
{
var descriptionCount = this.ReadTupleDescription(reader, expectedTypes, (i, d) => expectedTypes[i] = d);
if (descriptionCount < expectedTypes.Length)
{
throw this.CreateSignatureMismatchException();
}
return(expectedTypes);
}
internal override RetrievalState ReadContents(EmberReader reader, ElementType actualType)
{
var result = base.ReadContents(reader, actualType);
if (this.GetValue() == null)
{
const string Format = "No value field is available for the non-nullable parameter with the path {0}.";
throw new ModelException(string.Format(CultureInfo.InvariantCulture, Format, this.GetPath()));
}
return(result);
}
private void ReadQualifiedChild(EmberReader reader, ElementType actualType)
{
reader.ReadAndAssertOuter(GlowQualifiedNode.Path.OuterId);
var path = reader.AssertAndReadContentsAsInt32Array();
if (path.Length == 0)
{
throw new ModelException("Invalid path for a qualified element.");
}
this.ReadQualifiedChild(reader, actualType, path, 0);
}
internal sealed override Element ReadNewDynamicChildContents(
EmberReader reader, ElementType actualType, Context context, out RetrievalState childRetrievalState)
{
if (ReadContentsCallback == null)
{
const string Format = "The type argument passed to CollectionNode<TElement> with the path {0} is neither " +
"an Element<TMostDerived> subclass nor IParameter nor INode nor IFunction.";
throw new ModelException(string.Format(CultureInfo.InvariantCulture, Format, this.GetPath()));
}
return(ReadContentsCallback(reader, actualType, context, out childRetrievalState));
}
internal static int GetContextSpecificOuterNumber(this EmberReader reader)
{
var outerId = reader.OuterId;
if (outerId.Class != Class.ContextSpecific)
{
const string Format = "Found actual outer identifier {0} while expecting a context-specific one.";
throw new ModelException(string.Format(CultureInfo.InvariantCulture, Format, outerId));
}
return(outerId.Number);
}
internal static int AssertAndReadContentsAsInt32(this EmberReader reader)
{
var result = AssertAndReadContentsAsInt64(reader);
if ((result < int.MinValue) || (result > int.MaxValue))
{
const string Format = "Found actual integer {0} while expecting to read a 32-bit integer.";
throw new ModelException(string.Format(CultureInfo.InvariantCulture, Format, result));
}
return((int)result);
}
private void ReadChildContents(
EmberReader reader,
ElementType actualType,
int number,
ref Element child,
out RetrievalState childRetrievalState)
{
reader.AssertInnerNumber(InnerNumber.Set);
if (child != null)
{
childRetrievalState = child.ReadContents(reader, actualType);
}
else
{
using (var stream = new MemoryStream())
using (var writer = new EmberWriter(stream))
{
// Since EmberReader checks that every end of a container is matched by a start, we need to write
// this dummy here.
writer.WriteStartSet(GlowNode.Contents.OuterId);
var identifier = reader.CopyToEndContainer(writer, GlowNodeContents.Identifier.OuterId) as string;
if (identifier != null)
{
writer.Flush();
stream.Position = 0;
using (var contentsReader = new EmberReader(stream))
{
contentsReader.Read(); // Read what we have written with WriteStartSet above
var newPolicy = this.childrenRetrievalPolicy == ChildrenRetrievalPolicy.All ?
ChildrenRetrievalPolicy.All : ChildrenRetrievalPolicy.None;
var context = new Context(this, number, identifier, newPolicy);
child = this.ReadNewChildContents(contentsReader, actualType, context, out childRetrievalState);
if (child != null)
{
this.children.Add(number, child);
}
}
}
else
{
childRetrievalState = RetrievalState.Complete;
child = null;
}
}
}
}
void Run(string path)
{
using (var stream = File.OpenRead(path))
{
var reader = new EmberReader(new BerStreamInput(stream));
var app = new GlowApplicationInterface();
_glow = (GlowContainer)EmberNode.Decode(reader, app);
}
//var settings = new XmlWriterSettings
//{
// Indent = true,
// IndentChars = " ",
// OmitXmlDeclaration = true,
//};
//using(var writer = XmlWriter.Create(Console.Out, settings))
// XmlExport.Export(_glow, writer);
//var children = _glow[GlowTags.CollectionItem][GlowTags.Node.Children];
//for(int index = 0; index < 2000; index++)
//{
// var node = new GlowNode(5 + index)
// {
// Identifier = "abc" + index,
// Description = "Hallo ich bin Node " + index,
// };
// children.Insert(node);
//}
//using(var output = new BerStreamOutput(File.Create("big.ember")))
// _glow.Encode(output);
var listener = new TcpListener(IPAddress.Any, 9097);
listener.Start();
listener.BeginAcceptSocket(AcceptCallback, listener);
Console.WriteLine("Press Enter to quit...");
Console.ReadLine();
lock (_sync)
{
foreach (var client in _clients)
{
client.Close();
}
}
listener.Stop();
}
internal int ReadInt(EmberReader reader, string fieldName)
{
try
{
return(reader.AssertAndReadContentsAsInt32());
}
catch (ModelException ex)
{
const string Format =
"The value of the field {0} is out of the allowed range for the element with the path {1}.";
throw new ModelException(
string.Format(CultureInfo.InvariantCulture, Format, fieldName, this.GetPath()), ex);
}
}
private int[] ReadParametersLocation(EmberReader reader)
{
if (reader.InnerNumber == InnerNumber.RelativeObjectIdentifier)
{
return(reader.ReadContentsAsInt32Array());
}
else
{
var path = new int[this.NumberPath.Length + 1];
Array.Copy(this.NumberPath, path, this.NumberPath.Length);
path[this.NumberPath.Length] = this.ReadInt(reader, GlowMatrixContents.ParametersLocation.Name);
return(path);
}
}
private static T AssertAndReadContents <T>(EmberReader reader, Func <EmberReader, T> read)
{
try
{
return(read(reader));
}
catch (InvalidOperationException ex)
{
const string Format =
"Found actual inner number {0} while expecting to read a {1} data value with outer identifier {2}.";
throw new ModelException(
string.Format(CultureInfo.InvariantCulture, Format, reader.InnerNumber, typeof(T), reader.OuterId),
ex);
}
}
void Test_InteropDom()
{
Console.WriteLine("\r\n------------------------ Interop DOM");
var testFilePath = @"N:\Temp\test.ber";
using (var stream = File.OpenRead(testFilePath))
{
var input = new BerStreamInput(stream);
var reader = new EmberReader(input);
var root = EmberNode.Decode(reader, this);
Console.WriteLine(GetXml(root));
}
}
internal sealed override RetrievalState ReadAdditionalField(EmberReader reader, int contextSpecificOuterNumber)
{
this.isProviderChangeInProgress = true;
try
{
switch (contextSpecificOuterNumber)
{
case GlowMatrix.Targets.OuterNumber:
reader.AssertInnerNumber(GlowTargetCollection.InnerNumber);
this.Targets = this.ReadSignals(
reader,
this.Targets,
GlowTargetCollection.Target.OuterNumber,
GlowTarget.InnerNumber,
GlowTarget.Number.OuterNumber,
GlowTarget.Number.Name);
break;
case GlowMatrix.Sources.OuterNumber:
reader.AssertInnerNumber(GlowSourceCollection.InnerNumber);
this.Sources = this.ReadSignals(
reader,
this.Sources,
GlowSourceCollection.Source.OuterNumber,
GlowSource.InnerNumber,
GlowSource.Number.OuterNumber,
GlowSource.Number.Name);
break;
case GlowMatrix.Connections.OuterNumber:
this.ReadConnections(reader);
this.connectionsRead = true;
break;
default:
reader.Skip();
break;
}
}
finally
{
this.isProviderChangeInProgress = false;
}
return(this.RetrievalState);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private static IReadOnlyList <MatrixLabel> ReadLabels(EmberReader reader)
{
reader.AssertInnerNumber(GlowLabelCollection.InnerNumber);
var result = new List <MatrixLabel>();
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
switch (reader.GetContextSpecificOuterNumber())
{
case GlowLabelCollection.Label.OuterNumber:
reader.AssertInnerNumber(GlowLabel.InnerNumber);
int[] basePath = null;
string description = null;
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
switch (reader.GetContextSpecificOuterNumber())
{
case GlowLabel.BasePath.OuterNumber:
basePath = reader.AssertAndReadContentsAsInt32Array();
break;
case GlowLabel.Description.OuterNumber:
description = reader.AssertAndReadContentsAsString();
break;
default:
reader.Skip();
break;
}
}
if ((basePath != null) && (description != null))
{
result.Add(new MatrixLabel(basePath, description));
}
break;
default:
reader.Skip();
break;
}
}
return(result);
}
internal static Element ReadDynamicChildContents(
EmberReader reader,
ElementType actualType,
Context context,
out RetrievalState childRetrievalState)
{
switch (actualType)
{
case ElementType.Parameter:
return DynamicParameter.ReadContents(reader, actualType, context, out childRetrievalState);
case ElementType.Node:
return DynamicNode.ReadContents(reader, actualType, context, out childRetrievalState);
default:
return DynamicFunction.ReadContents(reader, actualType, context, out childRetrievalState);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private static void AssertRead(EmberReader reader, EmberId?expectedOuter)
{
try
{
if (!reader.Read())
{
const string Format = "Encountered end of stream while expecting outer identifier{0}.";
throw new ModelException(string.Format(CultureInfo.InvariantCulture, Format, GetId(expectedOuter)));
}
}
catch (EmberException ex)
{
const string Format = "Encountered invalid EmBER data while expecting outer identifier{0}.";
throw new ModelException(string.Format(CultureInfo.InvariantCulture, Format, GetId(expectedOuter)), ex);
}
}
private StreamDescription ReadStreamDescriptor(EmberReader reader)
{
reader.AssertInnerNumber(GlowStreamDescription.InnerNumber);
reader.ReadAndAssertOuter(GlowStreamDescription.Format.OuterId);
var streamFormat = this.ReadEnum <StreamFormat>(reader, GlowStreamDescription.Format.Name);
reader.ReadAndAssertOuter(GlowStreamDescription.Offset.OuterId);
var offset = this.ReadInt(reader, GlowStreamDescription.Offset.Name);
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
reader.Skip();
}
return(new StreamDescription(streamFormat, offset));
}
