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

	return true
}
198041
func (t *Quest_TemplateSpec) Equals(o *Quest_TemplateSpec) bool {
	return proto.Equal(t, o)
}
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
}
614623
func (f Float) Equals(other DxfElement) bool {
	if fValue, ok := other.(*Float); ok {
		return f.value == fValue.value
	}
	return false
}
307025
func (a *ProcNFSDExports) Equals(b *ProcNFSDExports) bool {
	if a.MountPoint != b.MountPoint {
		return false
	}
	if !reflect.DeepEqual(a.ClientOptions, b.ClientOptions) {
		return false
	}
	return true
}
694577
func Equals(labels1, labels2 map[string]string) bool {
	if len(labels1) != len(labels2) {
		return false
	}

	for k, v := range labels1 {
		value, ok := labels2[k]
		if !ok {
			return false
		}
		if value != v {
			return false
		}
	}
	return true
}
413494
func (c Vertex) Equals(other core.DxfElement) bool {
	if otherVertex, ok := other.(*Vertex); ok {
		return c.BaseEntity.Equals(otherVertex.BaseEntity) &&
			c.Location.Equals(otherVertex.Location) &&
			core.FloatEquals(c.StartingWidth, otherVertex.StartingWidth) &&
			core.FloatEquals(c.EndWidth, otherVertex.EndWidth) &&
			core.FloatEquals(c.Bulge, otherVertex.Bulge) &&
			c.CreatedByCurveFitting == otherVertex.CreatedByCurveFitting &&
			c.CurveFitTangentDefined == otherVertex.CurveFitTangentDefined &&
			c.SplineVertex == otherVertex.SplineVertex &&
			c.SplineFrameCtrlPoint == otherVertex.SplineFrameCtrlPoint &&
			c.Is3dPolylineVertex == otherVertex.Is3dPolylineVertex &&
			c.Is3dPolylineMesh == otherVertex.Is3dPolylineMesh &&
			c.IsPolyfaceMeshVertex == otherVertex.IsPolyfaceMeshVertex &&
			core.FloatEquals(c.CurveFitTangentDirection,
				otherVertex.CurveFitTangentDirection) &&
			c.Id == otherVertex.Id
	}
	return false
}
562789
func (v *Insanity) Equals(rhs *Insanity) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.UserMap == nil && rhs.UserMap == nil) || (v.UserMap != nil && rhs.UserMap != nil && _Map_Numberz_UserId_Equals(v.UserMap, rhs.UserMap))) {
		return false
	}
	if !((v.Xtructs == nil && rhs.Xtructs == nil) || (v.Xtructs != nil && rhs.Xtructs != nil && _List_Xtruct_Equals(v.Xtructs, rhs.Xtructs))) {
		return false
	}

	return true
}
513365
func (v *Plugin_Goodbye_Result) Equals(rhs *Plugin_Goodbye_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}
854744
func (v *ServiceGenerator_Generate_Args) Equals(rhs *ServiceGenerator_Generate_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Request == nil && rhs.Request == nil) || (v.Request != nil && rhs.Request != nil && v.Request.Equals(rhs.Request))) {
		return false
	}

	return true
}
149599
func (v *ResourceDoesNotExist) Equals(rhs *ResourceDoesNotExist) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Key == rhs.Key) {
		return false
	}
	if !_String_EqualsPtr(v.Message, rhs.Message) {
		return false
	}

	return true
}
1201820
func (v *StructA) Equals(rhs *StructA) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.S == rhs.S) {
		return false
	}

	return true
}
672217
func (p LWPolyline) Equals(other core.DxfElement) bool {
	if otherLWPolyline, ok := other.(*LWPolyline); ok {
		return p.BaseEntity.Equals(otherLWPolyline.BaseEntity) &&
			p.Closed == otherLWPolyline.Closed &&
			p.Plinegen == otherLWPolyline.Plinegen &&
			core.FloatEquals(p.ConstantWidth, otherLWPolyline.ConstantWidth) &&
			core.FloatEquals(p.Elevation, otherLWPolyline.Elevation) &&
			core.FloatEquals(p.Thickness, otherLWPolyline.Thickness) &&
			p.Points.Equals(otherLWPolyline.Points) &&
			p.ExtrusionDirection.Equals(otherLWPolyline.ExtrusionDirection)
	}
	return false
}
352211
func Equals(a, b error) bool {
	if a == nil && b == nil {
		// Both are nil.
		return true
	}

	if a == nil || b == nil {
		// One of the two is nil, since we know both are not nil.
		return false
	}

	return a.Error() == b.Error() && Code(a) == Code(b)
}
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
}
1162700
func (v *TypeReference) Equals(rhs *TypeReference) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Name == rhs.Name) {
		return false
	}
	if !(v.ImportPath == rhs.ImportPath) {
		return false
	}
	if !((v.Annotations == nil && rhs.Annotations == nil) || (v.Annotations != nil && rhs.Annotations != nil && _Map_String_String_Equals(v.Annotations, rhs.Annotations))) {
		return false
	}

	return true
}
1262349
func (v *NestedListsBonk) Equals(rhs *NestedListsBonk) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Bonk == nil && rhs.Bonk == nil) || (v.Bonk != nil && rhs.Bonk != nil && _List_List_List_Bonk_Equals(v.Bonk, rhs.Bonk))) {
		return false
	}

	return true
}