// Equals returns true if all the fields of this NestedListsI32x3 match the
// provided NestedListsI32x3.
//
// This function performs a deep comparison.
491429
func (v *NestedListsI32x3) Equals(rhs *NestedListsI32x3) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Integerlist == nil && rhs.Integerlist == nil) || (v.Integerlist != nil && rhs.Integerlist != nil && _List_List_List_I32_Equals(v.Integerlist, rhs.Integerlist))) {
		return false
	}

	return true
}
1271212
func (style Style) Equals(other core.DxfElement) bool {
	if otherStyle, ok := other.(*Style); ok {
		return style.Name == otherStyle.Name &&
			core.FloatEquals(style.Height, otherStyle.Height) &&
			core.FloatEquals(style.Width, otherStyle.Width) &&
			core.FloatEquals(style.Oblique, otherStyle.Oblique) &&
			style.IsBackwards == otherStyle.IsBackwards &&
			style.IsUpsideDown == otherStyle.IsUpsideDown &&
			style.IsShape == otherStyle.IsShape &&
			style.IsVerticalText == otherStyle.IsVerticalText &&
			style.Font == otherStyle.Font &&
			style.BigFont == otherStyle.BigFont
	}
	return false
}
1249709
func (slice TagSlice) Equals(other DxfElement) bool {
	if otherSlice, ok := other.(TagSlice); ok {
		if len(slice) != len(otherSlice) {
			return false
		}

		for index, tag := range slice {
			otherTag := otherSlice[index]

			if !tag.Equals(otherTag) {
				return false
			}
		}
		return true
	}
	return false
}
1134165
func (bb BoundingBox) Equals(test BoundingBox) bool {
	bblen := len(bb)
	testlen := len(test)
	if (bblen == 0) && (testlen == 0) {
		return true
	}
	if (bblen == 0) || (testlen == 0) || (bblen != testlen) {
		return false
	}
	for inx := 0; inx < bblen; inx++ {
		if bb[inx] != test[inx] {
			return false
		}
	}
	return true
}
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
}
462048
func (i Insert) Equals(other core.DxfElement) bool {
	if otherInsert, ok := other.(*Insert); ok {
		return i.BaseEntity.Equals(otherInsert.BaseEntity) &&
			i.BlockName == otherInsert.BlockName &&
			i.InsertionPoint.Equals(otherInsert.InsertionPoint) &&
			core.FloatEquals(i.ScaleFactorX, otherInsert.ScaleFactorX) &&
			core.FloatEquals(i.ScaleFactorY, otherInsert.ScaleFactorY) &&
			core.FloatEquals(i.ScaleFactorZ, otherInsert.ScaleFactorZ) &&
			core.FloatEquals(i.RotationAngle, otherInsert.RotationAngle) &&
			i.ColumnCount == otherInsert.ColumnCount &&
			i.RowCount == otherInsert.RowCount &&
			core.FloatEquals(i.ColumnSpacing, otherInsert.ColumnSpacing) &&
			core.FloatEquals(i.RowSpacing, otherInsert.RowSpacing) &&
			i.AttributesFollow == otherInsert.AttributesFollow &&
			i.Entities.Equals(otherInsert.Entities) &&
			i.ExtrusionDirection.Equals(otherInsert.ExtrusionDirection)
	}
	return false
}
1006389
func (c *Config) Equals(other *Config) bool {
	if (c.Blocks != nil || len(c.Blocks) != 0) || (other.Blocks != nil || len(other.Blocks) != 0) {
		if !reflect.DeepEqual(c.Blocks, other.Blocks) {
			return false
		}
	}
	if (c.variables != nil || len(c.variables) != 0) || (other.variables != nil || len(other.variables) != 0) {
		if !reflect.DeepEqual(c.variables, other.variables) {
			return false
		}
	}
	return true
}
1015381
func (cm *ChanMode) Equals(other *ChanMode) bool {
	return reflect.DeepEqual(cm, other)
}
1065287
func (xs *Affinities) Equals(ys *Affinities) bool {
	if xs == ys {
		return true
	}
	if xs == nil || ys == nil {
		return false
	}
	if len(*xs) != len(*ys) {
		return false
	}
SETEQUALS:
	for _, x := range *xs {
		for _, y := range *ys {
			if x.Equals(y) {
				continue SETEQUALS
			}
		}
		return false
	}
	return true
}
820241
func (r *Resources) Equals(o *Resources) bool {
	if r == o {
		return true
	}
	if r == nil || o == nil {
		return false
	}
	return r.CPU == o.CPU &&
		r.MemoryMB == o.MemoryMB &&
		r.DiskMB == o.DiskMB &&
		r.IOPS == o.IOPS &&
		r.Networks.Equals(&o.Networks) &&
		r.Devices.Equals(&o.Devices)
}
1247444
func equals(a, b interface{}) bool {
	sameType := reflect.TypeOf(a) == reflect.TypeOf(b)
	if _, ok := a.([]byte); ok {
		if _, ok := b.([]byte); !ok {
			// panic(fmt.Sprintf("incomparable type: %v vs %v", a, b))
			return false
		}
		b1 := a.([]byte)
		b2 := b.([]byte)
		if len(b1) != len(b2) {
			return false
		}
		for i := 0; i < len(b1) && i < len(b2); i++ {
			if b1[i] != b2[i] {
				return false
			}
		}
		return true
	} else if _, ok := a.(int64); ok {
		if _, ok := b.(int64); !ok {
			// panic(fmt.Sprintf("incomparable type: %v vs %v", a, b))
			return false
		}
		return a.(int64) == b.(int64)
	} else if a == nil && b == nil {
		return true
	} else if sameType && a == b {
		return true
	}
	return false
}
1365234
func (config *QueryConfig) Equals(that *QueryConfig) bool {
	return reflect.DeepEqual(config, that)
}
421021
func (config *ThresholdConfig) Equals(that *ThresholdConfig) bool {
	return reflect.DeepEqual(config, that)
}
114606
func (m *Matrix) Equals(other *Matrix) bool {
	if other == nil && m != nil {
		return false
	} else if other == nil {
		return true
	}

	if m.stride != other.stride {
		return false
	}

	msize := len(m.elements)
	m2size := len(other.elements)

	if msize != m2size {
		return false
	}

	for i := 0; i < msize; i++ {
		if m.elements[i] != other.elements[i] {
			return false
		}
	}
	return true
}
966038
func (v *VersioningTestV1) Equals(rhs *VersioningTestV1) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_I32_EqualsPtr(v.BeginInBoth, rhs.BeginInBoth) {
		return false
	}
	if !_String_EqualsPtr(v.OldString, rhs.OldString) {
		return false
	}
	if !_I32_EqualsPtr(v.EndInBoth, rhs.EndInBoth) {
		return false
	}

	return true
}
673092
func (v *GuessProtocolStruct) Equals(rhs *GuessProtocolStruct) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.MapField == nil && rhs.MapField == nil) || (v.MapField != nil && rhs.MapField != nil && _Map_String_String_Equals(v.MapField, rhs.MapField))) {
		return false
	}

	return true
}
630197
func (lhs ModuleID) Equals(rhs ModuleID) bool {
	return ((int32)(lhs) == (int32)(rhs))
}