public bool Equals(COperand stat)
{
if (!Kind.Equals(stat.Kind))
{
return(false);
}
switch (Kind)
{
case OperandKinds.AddressPointer:
return(Offset == stat.Offset);
case OperandKinds.BaseBasePointer:
return(Base == stat.Base && Base2 == stat.Base2);
case OperandKinds.BaseOffsetPointer:
return(Base == stat.Base && Offset == stat.Offset);
case OperandKinds.Constant:
return(Value == stat.Value);
case OperandKinds.Variable:
return(Name == stat.Name);
default:
throw new Exception("Unable to compare exprs");
}
}
public override bool Equals(object o)
{
if (o == this)
{
return(true);
}
if (!(o is ZipkinSpan))
{
return(false);
}
ZipkinSpan that = (ZipkinSpan)o;
return(TraceId.Equals(that.TraceId) &&
((ParentId == null) ? (that.ParentId == null) : ParentId.Equals(that.ParentId)) &&
Id.Equals(that.Id) &&
Kind.Equals(that.Kind) &&
((Name == null) ? (that.Name == null) : Name.Equals(that.Name)) &&
(Timestamp == that.Timestamp) &&
(Duration == that.Duration) &&
((LocalEndpoint == null) ? (that.LocalEndpoint == null) : LocalEndpoint.Equals(that.LocalEndpoint)) &&
((RemoteEndpoint == null) ? (that.RemoteEndpoint == null) : RemoteEndpoint.Equals(that.RemoteEndpoint)) &&
Annotations.SequenceEqual(that.Annotations) &&
Tags.SequenceEqual(that.Tags) &&
(Debug == that.Debug) &&
(Shared == that.Shared));
}
/// <summary>
/// Returns true if ProfileTypeDTO instances are equal
/// </summary>
/// <param name="input">Instance of ProfileTypeDTO to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ProfileTypeDTO input)
{
if (input == null)
{
return(false);
}
return
((
Uid == input.Uid ||
(Uid != null &&
Uid.Equals(input.Uid))
) &&
(
Label == input.Label ||
(Label != null &&
Label.Equals(input.Label))
) &&
(
Kind == input.Kind ||
(Kind != null &&
Kind.Equals(input.Kind))
) &&
(
SupportedItemTypes == input.SupportedItemTypes ||
SupportedItemTypes != null &&
SupportedItemTypes.SequenceEqual(input.SupportedItemTypes)
));
}
/// <summary>
/// Returns true if ChannelDTO instances are equal
/// </summary>
/// <param name="input">Instance of ChannelDTO to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ChannelDTO input)
{
if (input == null)
{
return(false);
}
return
((
Uid == input.Uid ||
(Uid != null &&
Uid.Equals(input.Uid))
) &&
(
Id == input.Id ||
(Id != null &&
Id.Equals(input.Id))
) &&
(
ChannelTypeUID == input.ChannelTypeUID ||
(ChannelTypeUID != null &&
ChannelTypeUID.Equals(input.ChannelTypeUID))
) &&
(
ItemType == input.ItemType ||
(ItemType != null &&
ItemType.Equals(input.ItemType))
) &&
(
Kind == input.Kind ||
(Kind != null &&
Kind.Equals(input.Kind))
) &&
(
Label == input.Label ||
(Label != null &&
Label.Equals(input.Label))
) &&
(
Description == input.Description ||
(Description != null &&
Description.Equals(input.Description))
) &&
(
DefaultTags == input.DefaultTags ||
DefaultTags != null &&
DefaultTags.SequenceEqual(input.DefaultTags)
) &&
(
Properties == input.Properties ||
Properties != null &&
Properties.SequenceEqual(input.Properties)
) &&
(
Configuration == input.Configuration ||
Configuration != null &&
Configuration.SequenceEqual(input.Configuration)
));
}
public override bool Equals(object obj)
{
return(obj is Span other &&
Kind.Equals(other.Kind) &&
EditHandler.Equals(other.EditHandler) &&
ChunkGenerator.Equals(other.ChunkGenerator) &&
Tokens.SequenceEqual(other.Tokens, SyntaxTokenComparer.Default));
}
/// <summary>
/// Checks that the specified span is equivalent to the other in that it has the same start point and content.
/// </summary>
public override bool EquivalentTo(SyntaxTreeNode node)
{
return(node is Span other &&
Kind.Equals(other.Kind) &&
Start.Equals(other.Start) &&
EditHandler.Equals(other.EditHandler) &&
string.Equals(other.Content, Content, StringComparison.Ordinal));
}
/// <inheritdoc />
public bool Equals(Boundary <T> other)
{
if (other == null)
{
return(false);
}
return(Location.Equals(other.Location) && Kind.Equals(other.Kind));
}
public override bool Equals(object obj)
{
var other = obj as Span;
return(other != null &&
Kind.Equals(other.Kind) &&
EditHandler.Equals(other.EditHandler) &&
ChunkGenerator.Equals(other.ChunkGenerator) &&
Tokens.SequenceEqual(other.Tokens));
}
/// <inheritdoc />
public override bool Equals(object obj)
{
var other = obj as Span;
return(other != null &&
Kind.Equals(other.Kind) &&
Start.Equals(other.Start) &&
Collapsed.Equals(other.Collapsed) &&
Symbols.SequenceEqual(other.Symbols));
}
/// <inheritdoc />
public override bool EquivalentTo(SyntaxTreeNode node)
{
var other = node as Span;
return(other != null &&
Kind.Equals(other.Kind) &&
Start.Equals(other.Start) &&
Collapsed.Equals(other.Collapsed) &&
string.Equals(Content, other.Content, StringComparison.Ordinal));
}
public override bool Equals(object obj)
{
Span other = obj as Span;
return(other != null &&
Kind.Equals(other.Kind) &&
EditHandler.Equals(other.EditHandler) &&
CodeGenerator.Equals(other.CodeGenerator) &&
Symbols.SequenceEqual(other.Symbols));
}
public override bool Equals(object obj)
{
var item = obj as Box;
if (item == null)
{
return(false);
}
return(Position.Equals(item.Position) && Kind.Equals(item.Kind));
}
public bool Equals(Money other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Kind.Equals(other.Kind) && Amount == other.Amount);
}
/// <summary>
/// Returns true if ModelFlowChartMeta instances are equal
/// </summary>
/// <param name="other">Instance of ModelFlowChartMeta to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ModelFlowChartMeta other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Id == other.Id ||
Id != null &&
Id.Equals(other.Id)
) &&
(
Kind == other.Kind ||
Kind != null &&
Kind.Equals(other.Kind)
) &&
(
CreatedTime == other.CreatedTime ||
CreatedTime != null &&
CreatedTime.Equals(other.CreatedTime)
) &&
(
LastModifiedTime == other.LastModifiedTime ||
LastModifiedTime != null &&
LastModifiedTime.Equals(other.LastModifiedTime)
) &&
(
Author == other.Author ||
Author != null &&
Author.Equals(other.Author)
) &&
(
EditMode == other.EditMode ||
EditMode != null &&
EditMode.Equals(other.EditMode)
) &&
(
Config == other.Config ||
Config != null &&
Config.Equals(other.Config)
) &&
(
Comments == other.Comments ||
Comments != null &&
Comments.Equals(other.Comments)
));
}
/// <summary>
/// Returns true if ModelFlowChartEdgeMeta instances are equal
/// </summary>
/// <param name="other">Instance of ModelFlowChartEdgeMeta to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ModelFlowChartEdgeMeta other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Id == other.Id ||
Id != null &&
Id.Equals(other.Id)
) &&
(
Kind == other.Kind ||
Kind != null &&
Kind.Equals(other.Kind)
) &&
(
CreatedTime == other.CreatedTime ||
CreatedTime != null &&
CreatedTime.Equals(other.CreatedTime)
) &&
(
ModifiedTime == other.ModifiedTime ||
ModifiedTime != null &&
ModifiedTime.Equals(other.ModifiedTime)
) &&
(
Author == other.Author ||
Author != null &&
Author.Equals(other.Author)
) &&
(
Comments == other.Comments ||
Comments != null &&
Comments.Equals(other.Comments)
));
}
public override bool Equals(object obj)
{
Animals animal = (Animals)obj;
return(Name.Equals(animal.Name) & Kind.Equals(animal.Kind) & Weight == animal.Weight);
}
/// <summary>
/// Returns true if ChannelTypeDTO instances are equal
/// </summary>
/// <param name="input">Instance of ChannelTypeDTO to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ChannelTypeDTO input)
{
if (input == null)
{
return(false);
}
return
((
Parameters == input.Parameters ||
Parameters != null &&
Parameters.SequenceEqual(input.Parameters)
) &&
(
ParameterGroups == input.ParameterGroups ||
ParameterGroups != null &&
ParameterGroups.SequenceEqual(input.ParameterGroups)
) &&
(
Description == input.Description ||
(Description != null &&
Description.Equals(input.Description))
) &&
(
Label == input.Label ||
(Label != null &&
Label.Equals(input.Label))
) &&
(
Category == input.Category ||
(Category != null &&
Category.Equals(input.Category))
) &&
(
ItemType == input.ItemType ||
(ItemType != null &&
ItemType.Equals(input.ItemType))
) &&
(
Kind == input.Kind ||
(Kind != null &&
Kind.Equals(input.Kind))
) &&
(
StateDescription == input.StateDescription ||
(StateDescription != null &&
StateDescription.Equals(input.StateDescription))
) &&
(
Tags == input.Tags ||
Tags != null &&
Tags.SequenceEqual(input.Tags)
) &&
(
UID == input.UID ||
(UID != null &&
UID.Equals(input.UID))
) &&
(
Advanced == input.Advanced ||
(Advanced != null &&
Advanced.Equals(input.Advanced))
) &&
(
CommandDescription == input.CommandDescription ||
(CommandDescription != null &&
CommandDescription.Equals(input.CommandDescription))
));
}
public bool IsOfKind(string tokenType) => Kind.Equals(tokenType, StringComparison.Ordinal);
/// <summary>
/// Returns true if Instrument instances are equal
/// </summary>
/// <param name="other">Instance of Instrument to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(Instrument other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
QuoteCurrency == other.QuoteCurrency ||
QuoteCurrency.Equals(other.QuoteCurrency)
) &&
(
Kind == other.Kind ||
Kind.Equals(other.Kind)
) &&
(
TickSize == other.TickSize ||
TickSize != null &&
TickSize.Equals(other.TickSize)
) &&
(
ContractSize == other.ContractSize ||
ContractSize != null &&
ContractSize.Equals(other.ContractSize)
) &&
(
IsActive == other.IsActive ||
IsActive != null &&
IsActive.Equals(other.IsActive)
) &&
(
OptionType == other.OptionType ||
OptionType.Equals(other.OptionType)
) &&
(
MinTradeAmount == other.MinTradeAmount ||
MinTradeAmount != null &&
MinTradeAmount.Equals(other.MinTradeAmount)
) &&
(
InstrumentName == other.InstrumentName ||
InstrumentName != null &&
InstrumentName.Equals(other.InstrumentName)
) &&
(
SettlementPeriod == other.SettlementPeriod ||
SettlementPeriod.Equals(other.SettlementPeriod)
) &&
(
Strike == other.Strike ||
Strike != null &&
Strike.Equals(other.Strike)
) &&
(
BaseCurrency == other.BaseCurrency ||
BaseCurrency.Equals(other.BaseCurrency)
) &&
(
CreationTimestamp == other.CreationTimestamp ||
CreationTimestamp != null &&
CreationTimestamp.Equals(other.CreationTimestamp)
) &&
(
ExpirationTimestamp == other.ExpirationTimestamp ||
ExpirationTimestamp != null &&
ExpirationTimestamp.Equals(other.ExpirationTimestamp)
));
}
public override bool Equals(object obj)
{
Artiodactyls animal = (Artiodactyls)obj;
return(Name.Equals(animal.Name) & Kind.Equals(animal.Kind) & Weight == animal.Weight & Size == animal.Size & HoofSize == animal.HoofSize);
}
public void GetAllClass()
{
XmlNode lnkXmlNode = GetLink(ID);
if (lnkXmlNode != null)
{
if ((lnkXmlNode["extendedProperties"] != null) &&
(lnkXmlNode["extendedProperties"].Attributes["associationclass"] != null))
{
AssociationClass = Program.ProjectData.GetClassByID(lnkXmlNode["extendedProperties"].Attributes["associationclass"].Value);
AssociationClass.AssociationClass = true;
}
if ((lnkXmlNode["properties"] != null) && (lnkXmlNode["properties"].Attributes["direction"] != null))
{
Direction = lnkXmlNode["properties"].Attributes["direction"].Value.ToLower();
}
ClassStart = Program.ProjectData.GetClassByID(ClassStartID);
if (lnkXmlNode["target"]["role"].Attributes["name"] != null)
{
PropertyEndID = lnkXmlNode["target"]["role"].Attributes["name"].Value;
PropertyEnd = ClassStart.GetProperty(PropertyEndID);
if (Kind.Equals(KindLink.Aggregate))
{
if (lnkXmlNode["target"]["type"].Attributes["aggregation"].Value.Equals("composite"))
{
Kind = KindLink.Compose;
}
}
if (lnkXmlNode["target"]["type"].Attributes["multiplicity"] != null)
{
MultiplicityEnd = lnkXmlNode["target"]["type"].Attributes["multiplicity"].Value;
}
}
ClassEnd = Program.ProjectData.GetClassByID(ClassEndID);
if (lnkXmlNode["source"]["role"].Attributes["name"] != null)
{
PropertyStartID = lnkXmlNode["source"]["role"].Attributes["name"].Value;
PropertyStart = ClassEnd.GetProperty(PropertyStartID);
if (lnkXmlNode["source"]["type"].Attributes["multiplicity"] != null)
{
MultiplicityStart = lnkXmlNode["source"]["type"].Attributes["multiplicity"].Value;
}
}
if (!Kind.Equals(KindLink.Generalize))
{
if ((PropertyEnd == null) && (PropertyStart == null))
{
MessageBox.Show("Erreur: Lien incorrect entre les classes " + ClassStart.Name + " et " + ClassEnd.Name);
Application.Exit();
}
if (PropertyStart != null)
{
PropertyStart.LinkData = this;
}
if (PropertyEnd != null)
{
PropertyEnd.LinkData = this;
}
}
else
{
//
}
switch (Kind)
{
case KindLink.Aggregate:
{
//PropertyEnd.LinkData = this;
//PropertyEnd.LinkData = this;
break;
}
case KindLink.Compose:
{
//PropertyEnd.LinkData = this;
break;
}
case KindLink.Generalize:
{
break;
}
case KindLink.Associate:
{
//PropertyStart.LinkData = this;
break;
}
}
}
}
/// <summary>
/// Returns true if Span instances are equal
/// </summary>
/// <param name="other">Instance of Span to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(Span other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
TraceId == other.TraceId ||
TraceId != null &&
TraceId.Equals(other.TraceId)
) &&
(
Name == other.Name ||
Name != null &&
Name.Equals(other.Name)
) &&
(
ParentId == other.ParentId ||
ParentId != null &&
ParentId.Equals(other.ParentId)
) &&
(
Id == other.Id ||
Id != null &&
Id.Equals(other.Id)
) &&
(
Kind == other.Kind ||
Kind != null &&
Kind.Equals(other.Kind)
) &&
(
Timestamp == other.Timestamp ||
Timestamp != null &&
Timestamp.Equals(other.Timestamp)
) &&
(
Duration == other.Duration ||
Duration != null &&
Duration.Equals(other.Duration)
) &&
(
Debug == other.Debug ||
Debug != null &&
Debug.Equals(other.Debug)
) &&
(
Shared == other.Shared ||
Shared != null &&
Shared.Equals(other.Shared)
) &&
(
LocalEndpoint == other.LocalEndpoint ||
LocalEndpoint != null &&
LocalEndpoint.Equals(other.LocalEndpoint)
) &&
(
RemoteEndpoint == other.RemoteEndpoint ||
RemoteEndpoint != null &&
RemoteEndpoint.Equals(other.RemoteEndpoint)
) &&
(
Annotations == other.Annotations ||
Annotations != null &&
Annotations.SequenceEqual(other.Annotations)
) &&
(
Tags == other.Tags ||
Tags != null &&
Tags.Equals(other.Tags)
));
}
/// <summary>
/// Returns true if Position instances are equal
/// </summary>
/// <param name="other">Instance of Position to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(Position other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Direction == other.Direction ||
Direction.Equals(other.Direction)
) &&
(
AveragePriceUsd == other.AveragePriceUsd ||
AveragePriceUsd != null &&
AveragePriceUsd.Equals(other.AveragePriceUsd)
) &&
(
EstimatedLiquidationPrice == other.EstimatedLiquidationPrice ||
EstimatedLiquidationPrice != null &&
EstimatedLiquidationPrice.Equals(other.EstimatedLiquidationPrice)
) &&
(
FloatingProfitLoss == other.FloatingProfitLoss ||
FloatingProfitLoss != null &&
FloatingProfitLoss.Equals(other.FloatingProfitLoss)
) &&
(
FloatingProfitLossUsd == other.FloatingProfitLossUsd ||
FloatingProfitLossUsd != null &&
FloatingProfitLossUsd.Equals(other.FloatingProfitLossUsd)
) &&
(
OpenOrdersMargin == other.OpenOrdersMargin ||
OpenOrdersMargin != null &&
OpenOrdersMargin.Equals(other.OpenOrdersMargin)
) &&
(
TotalProfitLoss == other.TotalProfitLoss ||
TotalProfitLoss != null &&
TotalProfitLoss.Equals(other.TotalProfitLoss)
) &&
(
RealizedProfitLoss == other.RealizedProfitLoss ||
RealizedProfitLoss != null &&
RealizedProfitLoss.Equals(other.RealizedProfitLoss)
) &&
(
Delta == other.Delta ||
Delta != null &&
Delta.Equals(other.Delta)
) &&
(
InitialMargin == other.InitialMargin ||
InitialMargin != null &&
InitialMargin.Equals(other.InitialMargin)
) &&
(
Size == other.Size ||
Size != null &&
Size.Equals(other.Size)
) &&
(
MaintenanceMargin == other.MaintenanceMargin ||
MaintenanceMargin != null &&
MaintenanceMargin.Equals(other.MaintenanceMargin)
) &&
(
Kind == other.Kind ||
Kind.Equals(other.Kind)
) &&
(
MarkPrice == other.MarkPrice ||
MarkPrice != null &&
MarkPrice.Equals(other.MarkPrice)
) &&
(
AveragePrice == other.AveragePrice ||
AveragePrice != null &&
AveragePrice.Equals(other.AveragePrice)
) &&
(
SettlementPrice == other.SettlementPrice ||
SettlementPrice != null &&
SettlementPrice.Equals(other.SettlementPrice)
) &&
(
IndexPrice == other.IndexPrice ||
IndexPrice != null &&
IndexPrice.Equals(other.IndexPrice)
) &&
(
InstrumentName == other.InstrumentName ||
InstrumentName != null &&
InstrumentName.Equals(other.InstrumentName)
) &&
(
SizeCurrency == other.SizeCurrency ||
SizeCurrency != null &&
SizeCurrency.Equals(other.SizeCurrency)
));
}
public override bool Equals(object obj)
{
Mammals animal = (Mammals)obj;
return(Name.Equals(animal.Name) & Kind.Equals(animal.Kind) & Weight == animal.Weight & Size == animal.Size);
}
public override bool Equals(object obj)
{
Birds animal = (Birds)obj;
return(Name.Equals(animal.Name) & Kind.Equals(animal.Kind) & Weight == animal.Weight & BeakSize == animal.BeakSize);
}
/// <summary>Tests if this TypeSpecifier is considered equal to another.</summary>
/// <param name="other">The type specifier to compare to this object.</param>
/// <returns>True if the objects are considered equal, false if they are not.</returns>
public bool Equals(TypeSpecifier other)
{
return(Kind.Equals(other.Kind) && ArrayRank.Equals(other.ArrayRank));
}
public bool Equals(DataType other)
{
return(m_oKind.Equals(other.m_oKind));
}