// Equals verifies whether two endpoint objects are equal
540624
func (a *ApplicationEndpoint) Equals(b *ApplicationEndpoint) bool {
	if a.ServiceID != b.ServiceID {
		return false
	}
	if a.InstanceID != b.InstanceID {
		return false
	}
	if a.Application != b.Application {
		return false
	}
	if a.Purpose != b.Purpose {
		return false
	}
	if a.HostID != b.HostID {
		return false
	}
	if a.HostIP != b.HostIP {
		return false
	}
	if a.HostPort != b.HostPort {
		return false
	}
	if a.ContainerID != b.ContainerID {
		return false
	}
	if a.ContainerIP != b.ContainerIP {
		return false
	}
	if a.ContainerPort != b.ContainerPort {
		return false
	}
	if a.Protocol != b.Protocol {
		return false
	}
	if a.VirtualAddress != b.VirtualAddress {
		return false
	}
	return true
}
982306
func (v *EmptyStruct) Equals(rhs *EmptyStruct) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}
755878
func (id *DeviceIdTuple) Equals(o *DeviceIdTuple) bool {
	if id == nil && o == nil {
		return true
	} else if id == nil || o == nil {
		return false
	}

	return o.Vendor == id.Vendor && o.Type == id.Type && o.Name == id.Name
}
675235
func (v *GenerateServiceResponse) Equals(rhs *GenerateServiceResponse) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Files == nil && rhs.Files == nil) || (v.Files != nil && rhs.Files != nil && _Map_String_Binary_Equals(v.Files, rhs.Files))) {
		return false
	}

	return true
}
315656
func endpointsEquivalent(a, b *object.Endpoints) bool {

	if len(a.Subsets) != len(b.Subsets) {
		return false
	}

	// we should be able to rely on
	// these being sorted and able to be compared
	// they are supposed to be in a canonical format
	for i, sa := range a.Subsets {
		sb := b.Subsets[i]
		if !subsetsEquivalent(sa, sb) {
			return false
		}
	}
	return true
}
88973
func (d *ResourceDevices) Equals(o *ResourceDevices) bool {
	if d == o {
		return true
	}
	if d == nil || o == nil {
		return false
	}
	if len(*d) != len(*o) {
		return false
	}
	m := make(map[string]*RequestedDevice, len(*d))
	for _, e := range *d {
		m[e.Name] = e
	}
	for _, oe := range *o {
		de, ok := m[oe.Name]
		if !ok || !de.Equals(oe) {
			return false
		}
	}
	return true
}
792650
func (e *Endpoints) DeepEquals(o *Endpoints) bool {
	switch {
	case (e == nil) != (o == nil):
		return false
	case (e == nil) && (o == nil):
		return true
	}

	if len(e.Backends) != len(o.Backends) {
		return false
	}

	for ip1, ports1 := range e.Backends {
		ports2, ok := o.Backends[ip1]
		if !ok {
			return false
		}

		if !ports1.DeepEquals(ports2) {
			return false
		}
	}

	return true
}
90108
func (a Line) Equals(other core.DxfElement) bool {
	if otherLine, ok := other.(*Line); ok {
		return a.BaseEntity.Equals(otherLine.BaseEntity) &&
			core.FloatEquals(a.Thickness, otherLine.Thickness) &&
			a.Start.Equals(otherLine.Start) &&
			a.End.Equals(otherLine.End) &&
			a.ExtrusionDirection.Equals(otherLine.ExtrusionDirection)
	}
	return false
}
36539
func (v *Service) Equals(rhs *Service) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Name == rhs.Name) {
		return false
	}
	if !(v.ThriftName == rhs.ThriftName) {
		return false
	}
	if !_ServiceID_EqualsPtr(v.ParentID, rhs.ParentID) {
		return false
	}
	if !_List_Function_Equals(v.Functions, rhs.Functions) {
		return false
	}
	if !(v.ModuleID == rhs.ModuleID) {
		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
}
98697
func (ps PointSet) Equals(pointSet *PointSet) bool {
	if (ps).Length() != (*pointSet).Length() {
		return false
	}

	for i, v := range ps {
		if !v.Equals((*pointSet).GetAt(i)) {
			return false
		}
	}

	return true
}
1025538
func (v *SinkRequest) Equals(rhs *SinkRequest) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Message == rhs.Message) {
		return false
	}

	return true
}
96408
func (a *NetAddr) Equals(other NetAddr) bool {
	return a.Addr == other.Addr && a.AddrNetwork == other.AddrNetwork && a.Path == other.Path
}
24644
func Equals(point1, other geom.Coord) bool {
	return (point1[0] == other[0]) && (point1[1] == other[1]) &&
		((point1[2] == other[2]) ||
			(math.IsNaN(point1[2]) && math.IsNaN(other[2])))
}
1306912
func (v *Oneway_Echo_Args) Equals(rhs *Oneway_Echo_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_String_EqualsPtr(v.Token, rhs.Token) {
		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
}
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
	}
}
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
}