// Equals tests equality against another Polyline.
354085
func (p Polyline) Equals(other core.DxfElement) bool {
	if otherPolyline, ok := other.(*Polyline); ok {
		return p.BaseEntity.Equals(otherPolyline.BaseEntity) &&
			core.FloatEquals(p.Elevation, otherPolyline.Elevation) &&
			core.FloatEquals(p.Thickness, otherPolyline.Thickness) &&
			p.Closed == otherPolyline.Closed &&
			p.CurveFitVerticesAdded == otherPolyline.CurveFitVerticesAdded &&
			p.SplineFitVerticesAdded == otherPolyline.SplineFitVerticesAdded &&
			p.Is3dPolyline == otherPolyline.Is3dPolyline &&
			p.Is3dPolygonMesh == otherPolyline.Is3dPolygonMesh &&
			p.PolygonMeshClosedNDir == otherPolyline.PolygonMeshClosedNDir &&
			p.IsPolyfaceMesh == otherPolyline.IsPolyfaceMesh &&
			p.LineTypeParentAround == otherPolyline.LineTypeParentAround &&
			core.FloatEquals(p.DefaultStartWidth, otherPolyline.DefaultStartWidth) &&
			core.FloatEquals(p.DefaultEndWidth, otherPolyline.DefaultEndWidth) &&
			p.VertexCountM == otherPolyline.VertexCountM &&
			p.VertexCountN == otherPolyline.VertexCountN &&
			p.SmoothDensityM == otherPolyline.SmoothDensityM &&
			p.SmoothDensityN == otherPolyline.SmoothDensityN &&
			p.SmoothSurface == otherPolyline.SmoothSurface &&
			p.ExtrusionDirection.Equals(otherPolyline.ExtrusionDirection) &&
			p.Vertices.Equals(otherPolyline.Vertices)
	}
	return false
}
91483
func (c *Constraint) Equals(o *Constraint) bool {
	return c == o ||
		c.LTarget == o.LTarget &&
			c.RTarget == o.RTarget &&
			c.Operand == o.Operand
}
1010775
func (t TablesSection) Equals(other core.DxfElement) bool {
	if otherTable, ok := other.(*TablesSection); ok {
		return t.Layers.Equals(otherTable.Layers) &&
			t.Styles.Equals(otherTable.Styles) &&
			t.LineTypes.Equals(otherTable.LineTypes)
	}

	return false
}
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
}
296101
func (p *Point) Equals(point *Point) bool {
	if p[0] == point[0] && p[1] == point[1] {
		return true
	}

	return false
}
1107885
func (e Ellipse) Equals(other core.DxfElement) bool {
	if otherEllipse, ok := other.(*Ellipse); ok {
		return e.BaseEntity.Equals(otherEllipse.BaseEntity) &&
			e.Center.Equals(otherEllipse.Center) &&
			e.MajorAxisEnd.Equals(otherEllipse.MajorAxisEnd) &&
			e.ExtrusionDirection.Equals(otherEllipse.ExtrusionDirection) &&
			core.FloatEquals(e.MinorToMajorAxisRatio, otherEllipse.MinorToMajorAxisRatio) &&
			core.FloatEquals(e.StartParameter, otherEllipse.StartParameter) &&
			core.FloatEquals(e.EndParameter, otherEllipse.EndParameter)
	}
	return false
}
122628
func (v *CrazyNesting) Equals(rhs *CrazyNesting) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_String_EqualsPtr(v.StringField, rhs.StringField) {
		return false
	}
	if !((v.SetField == nil && rhs.SetField == nil) || (v.SetField != nil && rhs.SetField != nil && _Set_Insanity_Equals(v.SetField, rhs.SetField))) {
		return false
	}
	if !_List_Map_Set_I32_Map_I32_Set_List_Map_Insanity_String_Equals(v.ListField, rhs.ListField) {
		return false
	}
	if !((v.BinaryField == nil && rhs.BinaryField == nil) || (v.BinaryField != nil && rhs.BinaryField != nil && bytes.Equal(v.BinaryField, rhs.BinaryField))) {
		return false
	}

	return true
}
435741
func (v *Xception) Equals(rhs *Xception) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_I32_EqualsPtr(v.ErrorCode, rhs.ErrorCode) {
		return false
	}
	if !_String_EqualsPtr(v.Message, rhs.Message) {
		return false
	}

	return true
}
754539
func Equals(left, right Expr) EqualsExpr {
	return EqualsExpr{Left: left, Right: right}
}
1123141
func (s String) Equals(other DxfElement) bool {
	if sStr, ok := other.(*String); ok {
		return s.value == sStr.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
}
309956
func (c *Color) Equals(c2 *Color) bool {
	if len(c.params) != len(c2.params) {
		return false
	}

	for _, attr := range c.params {
		if !c2.attrExists(attr) {
			return false
		}
	}

	return true
}
937012
func (g *Geometry) Equals(other *Geometry) (bool, error) {
	return g.binaryPred("Equals", cGEOSEquals, other)
}
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
}
780577
func (v *NestedListsI32x2) Equals(rhs *NestedListsI32x2) 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_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
}
1307623
func (c Color) Equals(other Color) bool {
	return c.R == other.R &&
		c.G == other.G &&
		c.B == other.B &&
		c.A == other.A
}