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)); }