public override string ToXml(int storeType) { if (TypeName == null || TypeName.Equals("")) { return(""); } StringBuilder str = new StringBuilder(String.Format("<{0}>", TypeName)); try { if (IsExist("Name")) { str.Append(String.Format("<Name>{0}</Name>", Name)); } str.Append(mProperty.ToXml("Name")); str.Append(GetExtXmlData()); } finally { str.Append(String.Format("</{0}>", TypeName)); } return(str.ToString()); }
public bool Equals(ItemType other) { return(TypeValuesEqual(TypeValues, other?.TypeValues) && TypeHeader.Equals(other?.TypeHeader) && TypeName.Equals(other?.TypeName) && SelectedItem.Equals(other?.SelectedItem)); }
/// <include file='doc\ToolboxItem.uex' path='docs/doc[@for="ToolboxItem.Equals"]/*' /> /// <internalonly/> public override bool Equals(object obj) { if (this == obj) { return(true); } if (obj == null) { return(false); } if (!(obj.GetType() == this.GetType())) { return(false); } ToolboxItem otherItem = (ToolboxItem)obj; if (TypeName != otherItem.TypeName) { if (TypeName == null || otherItem.TypeName == null) { return(false); } if (!TypeName.Equals(otherItem.TypeName)) { return(false); } } if (AssemblyName != otherItem.AssemblyName) { if (AssemblyName == null || otherItem.AssemblyName == null) { return(false); } if (!AssemblyName.FullName.Equals(otherItem.AssemblyName.FullName)) { return(false); } } if (DisplayName != otherItem.DisplayName) { if (DisplayName == null || otherItem.DisplayName == null) { return(false); } if (!DisplayName.Equals(otherItem.DisplayName)) { return(false); } } return(true); }
public override string ToXml(int storeType) { if (TypeName == null || TypeName.Equals("")) { return(""); } lock (mConfigs.SyncRoot) { StringBuilder str = new StringBuilder("<" + TypeName + ">"); try { foreach (IConfig config in mConfigs.Values) { if (config.StoreType <= storeType) { str.Append(config.ToXml()); } } } finally { str.Append("</" + TypeName + ">"); } return(str.ToString()); } }
/// <inheritdoc /> public bool MatchesType(Type type, string typeName) { var typeToMatch = new TypeName(type.AssemblyQualifiedName.Split(',')); var typeToCheck = new TypeName(typeName.Split(',')); return(typeToCheck.Equals(typeToMatch)); }
/// <summary> /// Returns true if EquipmentAttachment instances are equal /// </summary> /// <param name="other">Instance of EquipmentAttachment to be compared</param> /// <returns>Boolean</returns> public bool Equals(EquipmentAttachment other) { if (other is null) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return (( Id == other.Id || Id.Equals(other.Id) ) && ( Equipment == other.Equipment || Equipment != null && Equipment.Equals(other.Equipment) ) && ( TypeName == other.TypeName || TypeName != null && TypeName.Equals(other.TypeName) ) && ( Description == other.Description || Description != null && Description.Equals(other.Description) )); }
public override bool Equals(object obj) { if (obj as TypeReferenceDefinition == null) { return(false); } return(TypeName.Equals((obj as TypeReferenceDefinition).TypeName) && Reference.Equals((obj as TypeReferenceDefinition).Reference)); }
public bool Equals(CacheTokenPair other) { if (other != null && ReferenceEquals(this, other)) { return(true); } return(TypeName.Equals(other.TypeName, StringComparison.Ordinal) && Codename.Equals(other.Codename, StringComparison.Ordinal)); }
public override bool Equals(object obj) { if (obj == this) { return(true); } return(obj is ViewModelOid oid && TypeName.Equals(oid.TypeName) && Keys.SequenceEqual(oid.Keys)); }
public static void ImplementsInequalityCorrectly(string leftTypeName, string rightTypeName) { var left = new TypeName(leftTypeName); var right = new TypeName(rightTypeName); Assert.NotEqual(left, right); Assert.False(left.Equals(right)); Assert.False(left == right); Assert.True(left != right); }
public bool Equals(WebhookSubjectModel other) { if (other != null && ReferenceEquals(this, other)) { return(true); } return(Operation.Equals(other.Operation, StringComparison.Ordinal) && TypeName.Equals(other.TypeName, StringComparison.Ordinal) && Codename.Equals(other.Codename, StringComparison.Ordinal)); }
public bool MatchesType(Type type, string? typeName) { if (typeName == null) return false; var typeAssemblyQualifiedName = type.AssemblyQualifiedName ?? string.Empty; var typeToMatch = new TypeName(typeAssemblyQualifiedName.Split(',')); var typeToCheck = new TypeName(typeName.Split(',')); return typeToCheck.Equals(typeToMatch); }
/// <summary> /// Try and open the directory entry and return an actual NtObject handle. /// </summary> /// <param name="throw_on_error">True to throw on error.</param> /// <returns>The object opened.</returns> /// <exception cref="System.ArgumentException">Thrown if invalid typename.</exception> public virtual NtResult <NtObject> ToObject(bool throw_on_error) { AttributeFlags flags = AttributeFlags.CaseInsensitive; if (TypeName.Equals("key", StringComparison.OrdinalIgnoreCase)) { flags |= AttributeFlags.OpenLink; } return(NtObject.OpenWithType(TypeName, RelativePath, _root, flags, GenericAccessRights.MaximumAllowed, null, throw_on_error)); }
public override bool Equals(object obj) { if (obj is UaTypeMetadata typeMetadata) { return(TypeName.Equals(typeMetadata.TypeName) && RepositoryGroupName.Equals(typeMetadata.RepositoryGroupName)); } else { return(false); } }
public override bool Equals(object other) { bool result = false; if (other is FieldInfo) { FieldInfo info = other as FieldInfo; result = Name.Equals(info.Name); result &= TypeName.Equals(info.TypeName); } return(result); }
public override bool Equals(object obj) { AccountType type = obj as AccountType; if (type != null) { return(TypeName.Equals(type.TypeName) & PutWeights.Equals(type.PutWeights) & WithdrawWeights.Equals(type.WithdrawWeights)); } return(false); }
public override bool Equals(object obj) { if (obj == this) { return(true); } var oid = obj as EntityOid; if (oid != null) { return(TypeName.Equals(oid.TypeName) && Key.SequenceEqual(oid.Key)); } return(false); }
/// <summary> /// Processes the specified type creating kernel bindings. /// If the type is called typeName and implements interfaceType it will be bound to interfaceType /// </summary> /// <param name = "type">The type to process.</param> /// <param name = "scopeCallback">the scope callback.</param> /// <param name = "kernel">The kernel to configure.</param> public void Process(Type type, Func <IContext, object> scopeCallback, IKernel kernel) { if (type.IsInterface || type.IsAbstract) { return; } if (TypeName.Equals(type.Name) || TypeName.Equals(type.FullName)) { if (type.GetInterface(InterfaceType.FullName) != null) { kernel.Rebind(InterfaceType).To(type).InScope(scopeCallback); } } }
public void AddName(TypeName name) { if (name.Equals(TypeName.Empty)) { throw new ArgumentException("must not be TypeName.Empty", nameof(name)); } if (Name.Equals(TypeName.Empty)) { Name = name; } else { (nestedNames ?? (nestedNames = new List <TypeName> ())).Add(name); } }
protected override bool LoadFromXmlNode(XmlNode node) { try { if (node != null && !node.Name.Equals("#comment")) { if (TypeName.Equals("")) { TypeName = node.Name; } if (node.Name.Equals(TypeName)) { Clear(); foreach (XmlNode xSubNode in node.ChildNodes) { if (!xSubNode.Name.Equals("#comment")) { if (!SetExtXmlData(xSubNode)) { if (xSubNode.FirstChild != null && xSubNode.FirstChild.Value != null) { this.SetValue(xSubNode.Name, xSubNode.FirstChild.Value); } } } } if (IsExist("Name")) { Name = StrValue("Name"); } return(true); } } } catch (Exception e) { System.Console.Out.WriteLine("¼ÓÔØÅäÖÃÊý¾Ýʧ°Ü£º{0}", e); } return(false); }
public bool Equals(XunitTestTheoryTask other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } // Do not include base.Equals, so we don't try to compare Id or ParentId, // which will be different for each instance, and we're trying to act like // a value type return(ProjectId.Equals(other.ProjectId) && TypeName.Equals(other.TypeName) && MethodName.Equals(other.MethodName) && TheoryName.Equals(other.TheoryName)); }
public override bool Equals(object obj) { EnumerationType other = obj as EnumerationType; if (other != null && TypeName.Equals(other.TypeName) && other._legalValues.Count == _legalValues.Count) { for (int i = 0; i < _legalValues.Count; i++) { KeyValuePair <string, int> thisPair = _legalValues[i]; KeyValuePair <string, int> otherPair = other._legalValues[i]; if ((thisPair.Key != otherPair.Key || thisPair.Value != otherPair.Value)) { return(false); } } return(true); } return(false); }
private IConfig CreateConfigInstance(XmlNode node) { if (TypeName.Equals("Actions") || TypeName.Equals("Monitors") || TypeName.Equals("Schedulers") || TypeName.Equals("Tasks") || TypeName.Equals("VideoSources")) { string type = ""; foreach (XmlNode xSubNode in node.ChildNodes) { if (!xSubNode.Name.Equals("#comment") && xSubNode.Name.Equals("Type")) { type = xSubNode.FirstChild.Value; break; } } if (!type.Equals("")) { return(CreateConfigInstance(type)); } } return(CreateConfigInstance()); }
public bool Equals(XunitTestTheoryTask other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } // Don't include base.Equals, as RemoteTask.Equals includes RemoteTask.Id // in the calculation, and this is a new guid generated for each new instance // Using RemoteTask.Id in the Equals means collapsing the return values of // IUnitTestElement.GetTaskSequence into a tree will fail (as no assembly, // or class tasks will return true from Equals) return(AssemblyLocation.Equals(other.AssemblyLocation) && TypeName.Equals(other.TypeName) && MethodName.Equals(other.MethodName) && TheoryName.Equals(other.TheoryName)); }
public sealed override bool Equals(object obj) { TabularType other = obj as TabularType; if (other != null && TypeName.Equals(other.TypeName) && _rowType.Equals(other._rowType) && _indexNames.Count == other._indexNames.Count) { for (int i = 0; i < _indexNames.Count; i++) { if (_indexNames[i] != other._indexNames[i]) { return(false); } } return(true); } else { return(false); } }
public DocumentNode Rewrite(ISchemaInfo schema, DocumentNode document) { if (SchemaName.HasValue && !SchemaName.Value.Equals(schema.Name)) { return(document); } ITypeDefinitionNode?typeDefinition = document.Definitions .OfType <ITypeDefinitionNode>() .FirstOrDefault(t => TypeName.Equals(t.GetOriginalName(schema.Name))); if (typeDefinition is null) { return(document); } var definitions = new List <IDefinitionNode>(document.Definitions); definitions.Remove(typeDefinition); return(document.WithDefinitions(definitions)); }
public override bool Equals(object obj) { CType type = (obj as CType); if (type == null) { return(false); } bool equ = true; equ = equ && TypeClass == type.TypeClass; equ = equ && IsConst == type.IsConst; equ = equ && TypeName.Equals(type.TypeName); equ = equ && ArraySize == type.ArraySize; equ = equ && ContainedType == type.ContainedType; equ = equ && (EnumConstants == type.EnumConstants || (EnumConstants != null && type.EnumConstants != null && Enumerable.SequenceEqual(EnumConstants, type.EnumConstants))); equ = equ && (StructMembers == type.StructMembers || (StructMembers != null && type.StructMembers != null && Enumerable.SequenceEqual(StructMembers, type.StructMembers))); equ = equ && FunctionReturnType == type.FunctionReturnType; equ = equ && (FunctionArgumentTypes == type.FunctionArgumentTypes || (FunctionArgumentTypes != null && type.FunctionArgumentTypes != null && Enumerable.SequenceEqual(FunctionArgumentTypes, type.FunctionArgumentTypes))); return(equ); }
public sealed override bool Equals(object obj) { CompositeType other = obj as CompositeType; if (other != null && TypeName.Equals(other.TypeName) && other._members.Count == _members.Count) { foreach (string key in _members.Keys) { CompositeTypeMember thisMember = _members[key]; CompositeTypeMember otherMember; if (!other._members.TryGetValue(key, out otherMember)) { return(false); } if (!thisMember.Equals(otherMember)) { return(false); } } return(true); } return(false); }
private Func <ColumnVal, Node> GetColumnWriter(VariableDef c) { String TypeName; Boolean IsOptional; if (c.Type.OnTypeRef) { TypeName = c.Type.TypeRef.Value; IsOptional = false; } else if (c.Type.OnOptional) { TypeName = c.Type.Optional.Value; IsOptional = true; } else if (c.Type.OnList) { var ElementTypeName = c.Type.List.Value; if (!ElementTypeName.Equals("Byte", StringComparison.OrdinalIgnoreCase)) { throw new InvalidOperationException("InvalidColumnListType: List<{0}>".Formats(ElementTypeName)); } TypeName = "Binary"; IsOptional = false; } else { throw new InvalidOperationException(); } Dictionary <Int64, String> EnumWriter = null; if (EnumUnderlyingTypes.ContainsKey(TypeName)) { EnumWriter = EnumWriters[TypeName]; TypeName = EnumUnderlyingTypes[TypeName]; } Func <ColumnVal, Node> Writer; if (!IsOptional) { if (TypeName.Equals("Boolean", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnPrimitive) { throw new InvalidOperationException(); } var vv = v.Primitive; if (!vv.OnBooleanValue) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.BooleanValue.ToInvariantString()) } })); }; } else if (TypeName.Equals("String", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnPrimitive) { throw new InvalidOperationException(); } var vv = v.Primitive; if (!vv.OnStringValue) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.StringValue) } })); }; } else if (TypeName.Equals("Int", StringComparison.OrdinalIgnoreCase)) { if (EnumWriter != null) { Writer = v => { if (!v.OnPrimitive) { throw new InvalidOperationException(); } var vv = v.Primitive; if (!vv.OnIntValue) { throw new InvalidOperationException(); } if (EnumWriter.ContainsKey(vv.IntValue)) { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(EnumWriter[vv.IntValue]) } })); } else { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.IntValue.ToInvariantString()) } })); } }; } else { Writer = v => { if (!v.OnPrimitive) { throw new InvalidOperationException(); } var vv = v.Primitive; if (!vv.OnIntValue) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.IntValue.ToInvariantString()) } })); }; } } else if (TypeName.Equals("Int64", StringComparison.OrdinalIgnoreCase)) { if (EnumWriter != null) { Writer = v => { if (!v.OnPrimitive) { throw new InvalidOperationException(); } var vv = v.Primitive; if (!vv.OnInt64Value) { throw new InvalidOperationException(); } if (EnumWriter.ContainsKey(vv.Int64Value)) { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(EnumWriter[vv.Int64Value]) } })); } else { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.Int64Value.ToInvariantString()) } })); } }; } else { Writer = v => { if (!v.OnPrimitive) { throw new InvalidOperationException(); } var vv = v.Primitive; if (!vv.OnInt64Value) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.Int64Value.ToInvariantString()) } })); }; } } else if (TypeName.Equals("Real", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnPrimitive) { throw new InvalidOperationException(); } var vv = v.Primitive; if (!vv.OnRealValue) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.RealValue.ToInvariantString()) } })); }; } else if (TypeName.Equals("Binary", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnPrimitive) { throw new InvalidOperationException(); } var vv = v.Primitive; if (!vv.OnBinaryValue) { throw new InvalidOperationException(); } var ByteString = String.Join(" ", vv.BinaryValue.Select(b => b.ToString("X2", System.Globalization.CultureInfo.InvariantCulture)).ToArray()); return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(ByteString) } })); }; } else { throw new InvalidOperationException("InvalidType: {0}".Formats(TypeName)); } } else { if (TypeName.Equals("Boolean", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnOptional) { throw new InvalidOperationException(); } if (v.Optional.OnNone) { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateEmpty() } })); } var vv = v.Optional.Some; if (!vv.OnBooleanValue) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.BooleanValue.ToInvariantString()) } })); }; } else if (TypeName.Equals("String", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnOptional) { throw new InvalidOperationException(); } if (v.Optional.OnNone) { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateEmpty() } })); } var vv = v.Optional.Some; if (!vv.OnStringValue) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.StringValue) } })); }; } else if (TypeName.Equals("Int", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnOptional) { throw new InvalidOperationException(); } if (v.Optional.OnNone) { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateEmpty() } })); } var vv = v.Optional.Some; if (!vv.OnIntValue) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.IntValue.ToInvariantString()) } })); }; } else if (TypeName.Equals("Int64", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnOptional) { throw new InvalidOperationException(); } if (v.Optional.OnNone) { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateEmpty() } })); } var vv = v.Optional.Some; if (!vv.OnInt64Value) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.Int64Value.ToInvariantString()) } })); }; } else if (TypeName.Equals("Real", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnOptional) { throw new InvalidOperationException(); } if (v.Optional.OnNone) { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateEmpty() } })); } var vv = v.Optional.Some; if (!vv.OnRealValue) { throw new InvalidOperationException(); } return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(vv.RealValue.ToInvariantString()) } })); }; } else if (TypeName.Equals("Binary", StringComparison.OrdinalIgnoreCase)) { Writer = v => { if (!v.OnOptional) { throw new InvalidOperationException(); } if (v.Optional.OnNone) { return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateEmpty() } })); } var vv = v.Optional.Some; if (!vv.OnBinaryValue) { throw new InvalidOperationException(); } var ByteString = String.Join(" ", vv.BinaryValue.Select(b => b.ToString("X2", System.Globalization.CultureInfo.InvariantCulture)).ToArray()); return(Node.CreateStem(new Stem { Name = c.Name, Children = new List <Node> { Node.CreateLeaf(ByteString) } })); }; } else { throw new InvalidOperationException("InvalidType: {0}".Formats(TypeName)); } } return(Writer); }
private Func <Node, ColumnVal> GetColumnReader(EntityDef e, VariableDef c) { String TypeName; Boolean IsOptional; if (c.Type.OnTypeRef) { TypeName = c.Type.TypeRef.Value; IsOptional = false; } else if (c.Type.OnOptional) { TypeName = c.Type.Optional.Value; IsOptional = true; } else if (c.Type.OnList) { var ElementTypeName = c.Type.List.Value; if (!ElementTypeName.Equals("Byte", StringComparison.OrdinalIgnoreCase)) { throw new InvalidOperationException("InvalidColumnListType: List<{0}>".Formats(ElementTypeName)); } TypeName = "Binary"; IsOptional = false; } else { throw new InvalidOperationException(); } Dictionary <String, Int64> EnumParser = null; if (EnumUnderlyingTypes.ContainsKey(TypeName)) { EnumParser = EnumParsers[TypeName]; TypeName = EnumUnderlyingTypes[TypeName]; } Func <Node, ColumnVal> Reader; if (!IsOptional) { if (TypeName.Equals("Boolean", StringComparison.OrdinalIgnoreCase)) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; try { var v = Boolean.Parse(cv); return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateBooleanValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } else if (TypeName.Equals("String", StringComparison.OrdinalIgnoreCase)) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; var v = cv; return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateStringValue(v))); }; } else if (TypeName.Equals("Int", StringComparison.OrdinalIgnoreCase)) { if (EnumParser != null) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if (EnumParser.ContainsKey(cv)) { var v = (int)(EnumParser[cv]); return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateIntValue(v))); } else { try { var v = NumericStrings.InvariantParseInt32(cv); return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateIntValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } } }; } else { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; try { var v = NumericStrings.InvariantParseInt32(cv); return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateIntValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } } else if (TypeName.Equals("Int64", StringComparison.OrdinalIgnoreCase)) { if (EnumParser != null) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if (EnumParser.ContainsKey(cv)) { var v = (Int64)(EnumParser[cv]); return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateInt64Value(v))); } else { try { var v = NumericStrings.InvariantParseInt64(cv); return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateInt64Value(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } } }; } else { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; try { var v = NumericStrings.InvariantParseInt64(cv); return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateInt64Value(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } } else if (TypeName.Equals("Real", StringComparison.OrdinalIgnoreCase)) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; try { var v = NumericStrings.InvariantParseFloat64(cv); return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateRealValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } else if (TypeName.Equals("Binary", StringComparison.OrdinalIgnoreCase)) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; try { var v = Regex.Split(cv.Trim(" \t\r\n".ToCharArray()), "( |\t|\r|\n)+", RegexOptions.ExplicitCapture).Where(s => s != "").Select(s => Byte.Parse(s, System.Globalization.NumberStyles.HexNumber)).ToList(); return(ColumnVal.CreatePrimitive(PrimitiveVal.CreateBinaryValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } else { throw new InvalidOperationException("InvalidType: {0}".Formats(TypeName)); } } else { if (TypeName.Equals("Boolean", StringComparison.OrdinalIgnoreCase)) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if ((cv == null) || (cv == "-")) { return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty)); } try { var v = Boolean.Parse(cv); return(ColumnVal.CreateOptional(PrimitiveVal.CreateBooleanValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } else if (TypeName.Equals("String", StringComparison.OrdinalIgnoreCase)) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if ((cv == null) || (cv == "-")) { return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty)); } var v = cv; return(ColumnVal.CreateOptional(PrimitiveVal.CreateStringValue(v))); }; } else if (TypeName.Equals("Int", StringComparison.OrdinalIgnoreCase)) { if (EnumParser != null) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if ((cv == null) || (cv == "-")) { return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty)); } if (EnumParser.ContainsKey(cv)) { var v = (int)(EnumParser[cv]); return(ColumnVal.CreateOptional(PrimitiveVal.CreateIntValue(v))); } else { try { var v = NumericStrings.InvariantParseInt32(cv); return(ColumnVal.CreateOptional(PrimitiveVal.CreateIntValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } } }; } else { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if ((cv == null) || (cv == "-")) { return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty)); } try { var v = NumericStrings.InvariantParseInt32(cv); return(ColumnVal.CreateOptional(PrimitiveVal.CreateIntValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } } else if (TypeName.Equals("Int64", StringComparison.OrdinalIgnoreCase)) { if (EnumParser != null) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if ((cv == null) || (cv == "-")) { return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty)); } if (EnumParser.ContainsKey(cv)) { var v = (Int64)(EnumParser[cv]); return(ColumnVal.CreateOptional(PrimitiveVal.CreateInt64Value(v))); } else { try { var v = NumericStrings.InvariantParseInt64(cv); return(ColumnVal.CreateOptional(PrimitiveVal.CreateInt64Value(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } } }; } else { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if ((cv == null) || (cv == "-")) { return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty)); } try { var v = NumericStrings.InvariantParseInt64(cv); return(ColumnVal.CreateOptional(PrimitiveVal.CreateInt64Value(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } } else if (TypeName.Equals("Real", StringComparison.OrdinalIgnoreCase)) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if ((cv == null) || (cv == "-")) { return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty)); } try { var v = NumericStrings.InvariantParseFloat64(cv); return(ColumnVal.CreateOptional(PrimitiveVal.CreateRealValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } else if (TypeName.Equals("Binary", StringComparison.OrdinalIgnoreCase)) { Reader = TreeRow => { var cvs = TreeRow.Stem.Children.Where(col => col.OnStem && col.Stem.Name.Equals(c.Name, StringComparison.OrdinalIgnoreCase)).ToList(); if (cvs.Count != 1) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1}", e.Name, c.Name)); } var cv = cvs.Single().Stem.Children.Single().Leaf; if ((cv == null) || (cv == "-")) { return(ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty)); } try { var v = Regex.Split(cv.Trim(" \t\r\n".ToCharArray()), "( |\t|\r|\n)+", RegexOptions.ExplicitCapture).Select(s => Byte.Parse(s, System.Globalization.NumberStyles.HexNumber)).ToList(); return(ColumnVal.CreateOptional(PrimitiveVal.CreateBinaryValue(v))); } catch (FormatException) { throw new InvalidOperationException(String.Format("InvalidData: {0}.{1} '{2}'", e.Name, c.Name, cv)); } }; } else { throw new InvalidOperationException("InvalidType: {0}".Formats(TypeName)); } } return(Reader); }