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());
}
}
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);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private static List <KeyValuePair <string, int> > ReadEnumeration(EmberReader reader)
{
var entries = reader.AssertAndReadContentsAsString().Split('\n');
var result = new List <KeyValuePair <string, int> >();
for (int index = 0; index < entries.Length; ++index)
{
var entryString = entries[index];
if (!entryString.StartsWith("~", StringComparison.Ordinal))
{
result.Add(new KeyValuePair <string, int>(entryString, index));
}
}
return(result);
}
internal override RetrievalState ReadContents(EmberReader reader, ElementType actualType)
{
this.AssertElementType(ElementType.Function, actualType);
var isEmpty = true;
var argumentsRead = false;
var resultRead = false;
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
isEmpty = false;
switch (reader.GetContextSpecificOuterNumber())
{
case GlowFunctionContents.Description.OuterNumber:
this.Description = reader.AssertAndReadContentsAsString();
break;
case GlowFunctionContents.Arguments.OuterNumber:
this.arguments = this.ReadTupleDescription(reader, this.arguments);
argumentsRead = true;
break;
case GlowFunctionContents.Result.OuterNumber:
this.result = this.ReadTupleDescription(reader, this.result);
resultRead = true;
break;
default:
reader.Skip();
break;
}
}
if (!isEmpty &&
((!argumentsRead && (this.arguments.Length > 0)) || (!resultRead && (this.result.Length > 0))))
{
throw this.CreateSignatureMismatchException();
}
return(RetrievalState.Complete);
}
private List <KeyValuePair <string, int> > ReadEnumMap(EmberReader reader)
{
reader.AssertInnerNumber(GlowStringIntegerCollection.InnerNumber);
var result = new List <KeyValuePair <string, int> >();
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
reader.AssertInnerNumber(GlowStringIntegerPair.InnerNumber);
reader.ReadAndAssertOuter(GlowStringIntegerPair.EntryString.OuterId);
var entryString = reader.AssertAndReadContentsAsString();
reader.ReadAndAssertOuter(GlowStringIntegerPair.EntryInteger.OuterId);
var entryInteger = this.ReadInt(reader, GlowStringIntegerPair.EntryInteger.Name);
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
reader.Skip();
}
result.Add(new KeyValuePair <string, int>(entryString, entryInteger));
}
return(result);
}
internal virtual KeyValuePair <string, ParameterType> ReadTupleItemDescription(
EmberReader reader, KeyValuePair <string, ParameterType>[] expectedTypes, int index)
{
reader.AssertInnerNumber(GlowTupleItemDescription.InnerNumber);
reader.ReadAndAssertOuter(GlowTupleItemDescription.Type.OuterId);
var type = this.ReadEnum <ParameterType>(reader, GlowTupleItemDescription.Type.Name);
string name = null;
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
switch (reader.GetContextSpecificOuterNumber())
{
case GlowTupleItemDescription.TheName.OuterNumber:
name = reader.AssertAndReadContentsAsString();
break;
default:
reader.Skip();
break;
}
}
return(new KeyValuePair <string, ParameterType>(name, type));
}
internal override RetrievalState ReadContents(EmberReader reader, ElementType actualType)
{
this.AssertElementType(ElementType.Parameter, actualType);
ParameterType?valueType = null;
ParameterType?enumType = null;
ParameterType?typeType = null;
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
ParameterType?dummyType;
switch (reader.GetContextSpecificOuterNumber())
{
case GlowParameterContents.Description.OuterNumber:
this.Description = reader.AssertAndReadContentsAsString();
break;
case GlowParameterContents.Value.OuterNumber:
this.SetProviderValue(this.ReadValue(reader, out valueType));
break;
case GlowParameterContents.Minimum.OuterNumber:
this.SetMinimum(this.ReadValue(reader, out dummyType));
break;
case GlowParameterContents.Maximum.OuterNumber:
this.SetMaximum(this.ReadValue(reader, out dummyType));
break;
case GlowParameterContents.Access.OuterNumber:
this.Access = this.ReadEnum <ParameterAccess>(reader, GlowParameterContents.Access.Name);
break;
case GlowParameterContents.Format.OuterNumber:
this.Format = reader.AssertAndReadContentsAsString();
break;
case GlowParameterContents.Enumeration.OuterNumber:
this.EnumMapCore = ReadEnumeration(reader);
enumType = ParameterType.Enum;
break;
case GlowParameterContents.Factor.OuterNumber:
this.FactorCore = this.ReadInt(reader, GlowParameterContents.Factor.Name);
break;
case GlowParameterContents.IsOnline.OuterNumber:
this.IsOnline = reader.AssertAndReadContentsAsBoolean();
var send = (this.RetrieveDetailsChangeStatus == RetrieveDetailsChangeStatus.Changed) &&
this.RetrieveDetails && this.StreamIdentifier.HasValue;
this.RetrievalState &= send ? RetrievalState.None : RetrievalState.Complete;
break;
case GlowParameterContents.Formula.OuterNumber:
this.FormulaCore = reader.AssertAndReadContentsAsString();
break;
case GlowParameterContents.Step.OuterNumber:
this.ReadInt(reader, GlowParameterContents.Step.Name);
break;
case GlowParameterContents.Default.OuterNumber:
this.DefaultValue = this.ReadValue(reader, out dummyType);
break;
case GlowParameterContents.Type.OuterNumber:
typeType = this.ReadEnum <ParameterType>(reader, GlowParameterContents.Type.Name);
break;
case GlowParameterContents.StreamIdentifier.OuterNumber:
this.StreamIdentifier = this.ReadInt(reader, GlowParameterContents.StreamIdentifier.Name);
break;
case GlowParameterContents.EnumMap.OuterNumber:
this.EnumMapCore = this.ReadEnumMap(reader);
enumType = ParameterType.Enum;
break;
case GlowParameterContents.StreamDescriptor.OuterNumber:
this.StreamDescriptor = this.ReadStreamDescriptor(reader);
break;
case GlowParameterContents.SchemaIdentifiers.OuterNumber:
this.ReadSchemaIdentifiers(reader);
break;
default:
reader.Skip();
break;
}
}
this.SetFinalTytpe(valueType, enumType, typeType);
return(this.RetrievalState);
}
internal sealed override RetrievalState ReadContents(EmberReader reader, ElementType actualType)
{
this.AssertElementType(ElementType.Matrix, actualType);
var addressingMode = MatrixAddressingMode.Linear;
while (reader.Read() && (reader.InnerNumber != InnerNumber.EndContainer))
{
switch (reader.GetContextSpecificOuterNumber())
{
case GlowMatrixContents.Description.OuterNumber:
this.Description = reader.AssertAndReadContentsAsString();
break;
case GlowMatrixContents.Type.OuterNumber:
this.type = this.ReadEnum <MatrixType>(reader, GlowMatrixContents.Type.Name);
break;
case GlowMatrixContents.AddressingMode.OuterNumber:
addressingMode =
this.ReadEnum <MatrixAddressingMode>(reader, GlowMatrixContents.AddressingMode.Name);
break;
case GlowMatrixContents.TargetCount.OuterNumber:
this.Targets =
Enumerable.Range(0, this.ReadInt(reader, GlowMatrixContents.TargetCount.Name)).ToList();
break;
case GlowMatrixContents.SourceCount.OuterNumber:
this.Sources =
Enumerable.Range(0, this.ReadInt(reader, GlowMatrixContents.SourceCount.Name)).ToList();
break;
case GlowMatrixContents.MaximumTotalConnects.OuterNumber:
this.MaximumTotalConnects = this.ReadInt(reader, GlowMatrixContents.MaximumTotalConnects.Name);
break;
case GlowMatrixContents.MaximumConnectsPerTarget.OuterNumber:
this.MaximumConnectsPerTarget =
this.ReadInt(reader, GlowMatrixContents.MaximumConnectsPerTarget.Name);
break;
case GlowMatrixContents.ParametersLocation.OuterNumber:
this.ParametersLocation = this.ReadParametersLocation(reader);
break;
case GlowMatrixContents.GainParameterNumber.OuterNumber:
this.GainParameterNumber = this.ReadInt(reader, GlowMatrixContents.GainParameterNumber.Name);
break;
case GlowMatrixContents.Labels.OuterNumber:
this.Labels = ReadLabels(reader);
break;
case GlowMatrixContents.SchemaIdentifiers.OuterNumber:
this.ReadSchemaIdentifiers(reader);
break;
default:
reader.Skip();
break;
}
}
return(this.RetrievalState);
}
internal void ReadSchemaIdentifiers(EmberReader reader) =>
this.SchemaIdentifiers = reader.AssertAndReadContentsAsString().Split('\n');
internal sealed override string ReadValue(EmberReader reader, out ParameterType?parameterType)
{
parameterType = ParameterType.String;
return(reader.AssertAndReadContentsAsString());
}
