// Equals returns true if all the fields of this LargeDeltas match the
// provided LargeDeltas.
//
// This function performs a deep comparison.
779736
func (v *LargeDeltas) Equals(rhs *LargeDeltas) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.B1 == nil && rhs.B1 == nil) || (v.B1 != nil && rhs.B1 != nil && v.B1.Equals(rhs.B1))) {
		return false
	}
	if !((v.B10 == nil && rhs.B10 == nil) || (v.B10 != nil && rhs.B10 != nil && v.B10.Equals(rhs.B10))) {
		return false
	}
	if !((v.B100 == nil && rhs.B100 == nil) || (v.B100 != nil && rhs.B100 != nil && v.B100.Equals(rhs.B100))) {
		return false
	}
	if !_Bool_EqualsPtr(v.CheckTrue, rhs.CheckTrue) {
		return false
	}
	if !((v.B1000 == nil && rhs.B1000 == nil) || (v.B1000 != nil && rhs.B1000 != nil && v.B1000.Equals(rhs.B1000))) {
		return false
	}
	if !_Bool_EqualsPtr(v.CheckFalse, rhs.CheckFalse) {
		return false
	}
	if !((v.Vertwo2000 == nil && rhs.Vertwo2000 == nil) || (v.Vertwo2000 != nil && rhs.Vertwo2000 != nil && v.Vertwo2000.Equals(rhs.Vertwo2000))) {
		return false
	}
	if !((v.ASet2500 == nil && rhs.ASet2500 == nil) || (v.ASet2500 != nil && rhs.ASet2500 != nil && _Set_String_Equals(v.ASet2500, rhs.ASet2500))) {
		return false
	}
	if !((v.Vertwo3000 == nil && rhs.Vertwo3000 == nil) || (v.Vertwo3000 != nil && rhs.Vertwo3000 != nil && v.Vertwo3000.Equals(rhs.Vertwo3000))) {
		return false
	}
	if !((v.BigNumbers == nil && rhs.BigNumbers == nil) || (v.BigNumbers != nil && rhs.BigNumbers != nil && _List_I32_Equals(v.BigNumbers, rhs.BigNumbers))) {
		return false
	}

	return true
}
557388
func (tag Tag) Equals(other DxfElement) bool {
	if otherTag, ok := other.(*Tag); ok {
		return tag.Code == otherTag.Code && tag.Value.Equals(otherTag.Value)
	}
	return false
}
630095
func (e LineElement) Equals(other LineElement) bool {
	return core.FloatEquals(e.Length, other.Length) &&
		e.AbsoluteRotation == other.AbsoluteRotation &&
		e.IsTextString == other.IsTextString &&
		e.IsShape == other.IsShape &&
		e.ShapeNumber == other.ShapeNumber &&
		core.FloatEquals(e.Scale, other.Scale) &&
		core.FloatEquals(e.RotationAngle, other.RotationAngle) &&
		core.FloatEquals(e.XOffset, other.XOffset) &&
		core.FloatEquals(e.YOffset, other.YOffset) &&
		e.Text == other.Text
}
286244
func Equals(a interface{}, b interface{}) BoolPredicate {
	return func() bool {
		switch aval := a.(type) {
		case string:
			bval, ok := b.(string)
			return ok && aval == bval
		case []string:
			bval, ok := b.([]string)
			if !ok {
				return false
			}
			if len(aval) != len(bval) {
				return false
			}
			for i := range aval {
				if aval[i] != bval[i] {
					return false
				}
			}
			return true
		default:
			return false
		}
	}
}
961499
func (e Text) Equals(other core.DxfElement) bool {
	if otherText, ok := other.(*Text); ok {
		return e.BaseEntity.Equals(otherText.BaseEntity) &&
			core.FloatEquals(e.Thickness, otherText.Thickness) &&
			e.FirstAlignmentPoint.Equals(otherText.FirstAlignmentPoint) &&
			core.FloatEquals(e.Height, otherText.Height) &&
			e.Value == otherText.Value &&
			core.FloatEquals(e.Rotation, otherText.Rotation) &&
			core.FloatEquals(e.RelativeXScale, otherText.RelativeXScale) &&
			core.FloatEquals(e.ObliqueAngle, otherText.ObliqueAngle) &&
			e.StyleName == otherText.StyleName &&
			e.MirroredX == otherText.MirroredX &&
			e.MirroredY == otherText.MirroredY &&
			e.HorizontalJustification == otherText.HorizontalJustification &&
			e.SecondAlignmentPoint.Equals(otherText.SecondAlignmentPoint) &&
			e.ExtrusionDirection.Equals(otherText.ExtrusionDirection) &&
			e.VerticalJustification == otherText.VerticalJustification
	}
	return false
}
494182
func (a *LogFilter) Equals(b *LogFilter) bool {
	if a.Name != b.Name {
		return false
	}
	if a.Version != b.Version {
		return false
	}
	if a.Filter != b.Filter {
		return false
	}
	return true
}
503033
func equals(v1, v2 interface{}) bool {
	v1Type := jsonType(v1)
	if v1Type != jsonType(v2) {
		return false
	}
	switch v1Type {
	case "array":
		arr1, arr2 := v1.([]interface{}), v2.([]interface{})
		if len(arr1) != len(arr2) {
			return false
		}
		for i := range arr1 {
			if !equals(arr1[i], arr2[i]) {
				return false
			}
		}
		return true
	case "object":
		obj1, obj2 := v1.(map[string]interface{}), v2.(map[string]interface{})
		if len(obj1) != len(obj2) {
			return false
		}
		for k, v1 := range obj1 {
			if v2, ok := obj2[k]; ok {
				if !equals(v1, v2) {
					return false
				}
			} else {
				return false
			}
		}
		return true
	case "number":
		num1, _ := new(big.Float).SetString(string(v1.(json.Number)))
		num2, _ := new(big.Float).SetString(string(v2.(json.Number)))
		return num1.Cmp(num2) == 0
	default:
		return v1 == v2
	}
}
270676
func Equals(tb testing.TB, got, want interface{}) {
	if !reflect.DeepEqual(got, want) {
		_, file, line, _ := runtime.Caller(1)
		fmt.Printf("\033[31m%s:%d:\n\n\tgot: %#v\n\n\twant: %#v\033[39m\n\n", filepath.Base(file), line, got, want)
		tb.FailNow()
	}
}
205846
func (b *BinaryAttribute) Equals(other Attribute) bool {
	if a, ok := other.(*BinaryAttribute); !ok {
		return false
	} else {
		return a.Name == b.Name
	}
}
1015381
func (cm *ChanMode) Equals(other *ChanMode) bool {
	return reflect.DeepEqual(cm, other)
}
1249449
func (v *ServiceGenerator_Generate_Result) Equals(rhs *ServiceGenerator_Generate_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
		return false
	}

	return true
}
42319
func (s StringSet) Equals(t StringSet) bool {
	if len(s) != len(t) {
		return false
	}

	k1 := s.Array()
	k2 := t.Array()

	sort.Sort(AlphaOrder(k1))
	sort.Sort(AlphaOrder(k2))

	for i := range k1 {
		if k1[i] != k2[i] {
			return false
		}
	}
	return true
}
959466
func (c *Card) Equals(o *Card) bool {
	if c.Suit == o.Suit && c.Value == o.Value {
		return true
	}
	return false
}
763503
func (point *DataPoint) Equals(that *DataPoint) bool {
	return reflect.DeepEqual(point, that)
}
157024
func (r *Rule) Equals(other Rule) bool {
	if !utils.StringSlicesEqual(r.Resources, other.Resources) {
		return false
	}
	if !utils.StringSlicesEqual(r.Verbs, other.Verbs) {
		return false
	}
	if !utils.StringSlicesEqual(r.Actions, other.Actions) {
		return false
	}
	if r.Where != other.Where {
		return false
	}
	return true
}
669532
func (v *KeyValue_GetValue_Args) Equals(rhs *KeyValue_GetValue_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_String_EqualsPtr(v.Key, rhs.Key) {
		return false
	}

	return true
}
736022
func (a *Affinity) Equals(o *Affinity) bool {
	return a == o ||
		a.LTarget == o.LTarget &&
			a.RTarget == o.RTarget &&
			a.Operand == o.Operand &&
			a.Weight == o.Weight
}