public void SaveToFile(string pOutputDir) { string functions = GenerateFunctionCodeBlock(); string properties = GeneratePropertiesCodeBlock(); string internals = GenerateInternalsCodeBlock(); string specifics = GenerateSpecificCodeBlock(); string constructors = ConstructorsTemplate.GetConstructorsString(Name); string ns = CSharpGenerator.BaseNs; if (!Namespace.Equals("")) { ns += "." + Namespace; } string nsPath = ns.Replace('.', '/'); Directory.CreateDirectory(pOutputDir + "/" + nsPath); StreamWriter SW = new StreamWriter(pOutputDir + "/" + nsPath + "/" + Name + ".cs"); List <string> parentList = Name != "SimObject" ? ParentList : null; string code = SimObjectTemplate.GetClassString(ns, Name, parentList, constructors, internals, properties, functions, specifics); if (Name.Equals("SimObject")) { code = code.Replace(" : base(pId)", "") .Replace(" : base(pObjPtr)", "") .Replace(" : base(pName)", "") .Replace(" : base(pObjPtr)", ""); } SW.Write(code); SW.Close(); }
/// <summary> /// Sobre escritura del método equals /// </summary> /// <param name="obj">Objeto a comparar</param> /// <returns></returns> public override bool Equals(object obj) { if (!(obj is Measure) || obj == null) { return(false); } if (this == obj) { return(true); } Measure measureAComparar = (Measure)obj; if (Namespace == null && measureAComparar.Namespace == null && LocalName == null && measureAComparar.LocalName == null) { return(true); } if ((Namespace == null && measureAComparar.Namespace != null) || (Namespace != null && measureAComparar.Namespace == null)) { return(false); } if ((LocalName == null && measureAComparar.LocalName != null) || (LocalName != null && measureAComparar.LocalName == null)) { return(false); } return(Namespace.Equals(measureAComparar.Namespace) && LocalName.Equals(measureAComparar.LocalName)); }
/// <summary> /// Check the equivalence of this object and the argument object. /// </summary> /// <param name="obj">Target object.</param> /// <returns>It returns True if equivalent, False otherwise.</returns> public override bool Equals(object obj) { if (obj == null || GetType() != obj.GetType()) { return(false); } var element = (Element)obj; var boolcollector = new BoolCollector(); boolcollector.ChangeBool("Accessibility", Accessibility == element.Accessibility); boolcollector.ChangeBool("Id", Id.Equals(element.Id)); boolcollector.ChangeBool("Inheritance", InheritanceList.SequenceEqual(element.InheritanceList)); boolcollector.ChangeBool("IsAbstract", IsAbstract == element.IsAbstract); boolcollector.ChangeBool("IsSealed", IsSealed == element.IsSealed); boolcollector.ChangeBool("IsStatic", IsStatic == element.IsStatic); boolcollector.ChangeBool("Members", Members.SequenceEqual(element.Members)); boolcollector.ChangeBool("Name", Name.Equals(element.Name)); boolcollector.ChangeBool("Namespace", Namespace.Equals(element.Namespace)); boolcollector.ChangeBool("Namespaces", Namespaces.SequenceEqual(element.Namespaces)); boolcollector.ChangeBool("Type", Type == element.Type); boolcollector.ChangeBool("Value", Value.Equals(element.Value)); return(boolcollector.Value); }
/// <summary> /// Determines if this package ID equals the provided one /// </summary> /// <returns>True if both IDs are equal, false otherwise</returns> public bool Match(PackageId id) { return ( Scope.Equals(id.scope) && Owner.Equals(id.Owner) && Namespace.Equals(id.Namespace) && Name.Equals(id.Name) ); }
public override bool Equals(object obj) { MessageDeliveryContextKey key = obj as MessageDeliveryContextKey; if (key != null) { return(Name.Equals(key.Name) && Namespace.Equals(key.Namespace)); } return(false); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// <c>true</c> if the current object is equal to the other parameter; otherwise, <c>false</c>. /// </returns> public bool Equals(AttributeKey other) { return(other != null && FriendlyName.Equals(other.FriendlyName, StringComparison.Ordinal) && Name.Equals(other.Name, StringComparison.Ordinal) && NameFormat.Equals(other.NameFormat, StringComparison.Ordinal) && Namespace.Equals(other.Namespace, StringComparison.Ordinal) && OriginalIssuer.Equals(other.OriginalIssuer, StringComparison.Ordinal) && ValueType.Equals(other.ValueType, StringComparison.Ordinal)); }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// <c>true</c> if the current object is equal to the other parameter; otherwise, <c>false</c>. /// </returns> public bool Equals(AttributeKey other) { return(other != null && FriendlyName.Equals(other.FriendlyName) && Name.Equals(other.Name) && NameFormat.Equals(other.NameFormat) && Namespace.Equals(other.Namespace) && OriginalIssuer.Equals(other.OriginalIssuer) && ValueType.Equals(other.ValueType)); }
public override bool Equals(object obj) { var other = obj as CustomField; if (other == null) { return(false); } return(Namespace.Equals(other.Namespace) && Name.Equals(other.Name) && Event.Equals(other.Event)); }
internal object Encode() { try { if (IsJson) { StringBuilder Builder = new StringBuilder(); if (Type != SocketIOPacketType.UNKNOWN) { Builder.Append((int)Type); } if (Type == SocketIOPacketType.BINARY_EVENT || Type == SocketIOPacketType.BINARY_ACK) { Builder.Append(Attachments.Count); Builder.Append('-'); } if (!string.IsNullOrEmpty(Namespace) && !Namespace.Equals("/")) { Builder.Append(Namespace); Builder.Append(','); } if (ID > -1) { Builder.Append(ID); } return(Builder.Append(JsonData?.ToString(Formatting.None) ?? string.Empty).ToString()); } else { if (Type != SocketIOPacketType.UNKNOWN) { List <byte> Buffer = new List <byte>() { (byte)Type }; Buffer.AddRange(RawData); return(Buffer.ToArray()); } else { return(RawData); } } } catch (Exception Exception) { throw new SocketIOException("Packet encoding failed. " + this, Exception); } }
public override bool Equals(object obj) { if (obj is PackageId) { PackageId id = (PackageId)obj; return(Owner.Equals(id.Owner) && Namespace.Equals(id.Namespace) && Name.Equals(id.Name)); } else { return(false); } }
/// <summary> /// Equals method comparing <see cref="Name"/>, <see cref="Namespace"/>, <see cref="Type"/> and <see cref="HashCode"/>. /// </summary> /// <param name="obj">Object to compare to.</param> /// <returns></returns> public override bool Equals(object obj) { if (!(obj is FrameworkElementSmall)) { return(false); } var comp = (FrameworkElementSmall)obj; if (!String.IsNullOrEmpty(Name)) { if (!Name.Equals(comp.Name)) { return(false); } } else if (!String.IsNullOrEmpty(comp.Name)) { return(false); } if (!String.IsNullOrEmpty(Namespace)) { if (!Namespace.Equals(comp.Namespace)) { return(false); } } if (Type != null) { if (!Type.Equals(comp.Type)) { return(false); } } else if (comp.Type != null) { return(false); } if (HashCode != comp.HashCode) { return(false); } return(true); }
public override bool Equals(object obj) { // If parameter is null return false. // ReSharper disable once RedundantNameQualifier if (object.Equals(obj, null)) { return(false); } // If parameter cannot be cast to Point return false. var x = obj as EntityType; // ReSharper disable once RedundantNameQualifier if (object.Equals(x, null)) { return(false); } // Return true if the fields match: return(Name.Equals(x.Name, StringComparison.OrdinalIgnoreCase) && (Namespace.Equals(x.Namespace, StringComparison.OrdinalIgnoreCase))); }
/// <summary> /// Determines whether this instance of <see cref="TypeId" /> refers to the same type as <paramref name="other"/>. /// </summary> public virtual bool Equals(TypeId?other) { if (ReferenceEquals(this, other)) { return(true); } if (other == null) { return(false); } if (IsNestedType) { return(DeclaringType !.Equals(other.DeclaringType) && StringComparer.Ordinal.Equals(Name, other.Name)); } else { return(Namespace.Equals(other.Namespace) && StringComparer.Ordinal.Equals(Name, other.Name)); } }
/// <summary> /// Check the equivalence of this object and the argument object. /// </summary> /// <param name="obj">Target object.</param> /// <returns>It returns True if equivalent, False otherwise.</returns> public override bool Equals(object obj) { if (obj == null || GetType() != obj.GetType()) { return(false); } var member = (Member)obj; var boolcollector = new BoolCollector(); boolcollector.ChangeBool("Accessibility", Accessibility == member.Accessibility); boolcollector.ChangeBool("Id", Id.Equals(member.Id)); boolcollector.ChangeBool("Name", Name.Equals(member.Name)); boolcollector.ChangeBool("Namespace", Namespace.Equals(member.Namespace)); boolcollector.ChangeBool("Parameters", ParameterNames.SequenceEqual(member.ParameterNames)); boolcollector.ChangeBool("ParameterTypes", ParameterTypes.SequenceEqual(member.ParameterTypes)); boolcollector.ChangeBool("ReturnComment", ReturnComment.Equals(member.ReturnComment)); boolcollector.ChangeBool("ReturnType", ReturnType.Equals(member.ReturnType)); boolcollector.ChangeBool("Type", Type == member.Type); boolcollector.ChangeBool("Value", Value.Equals(member.Value)); return(boolcollector.Value); }
/// <summary> /// Returns true if Identifier instances are equal /// </summary> /// <param name="other">Instance of Identifier to be compared</param> /// <returns>Boolean</returns> public bool Equals(Identifier other) { if (other is null) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return (( Namespace == other.Namespace || Namespace != null && Namespace.Equals(other.Namespace) ) && ( Id == other.Id || Id != null && Id.Equals(other.Id) )); }
bool IEquatable <IAsyncStream <T> > .Equals(IAsyncStream <T> other) => ProviderName.Equals(other.ProviderName) && Namespace.Equals(other.Namespace) && Guid.Equals(other.Guid);
public bool Equals(Identifier other) => !ReferenceEquals(other, null) && Name.Equals(other.Name, StringComparison.OrdinalIgnoreCase) && (Namespace == null && other.Namespace == null || Namespace.Equals(other.Namespace));