// LessThanOrEqual filter with value.
190799
func (p *TodoQueryProperty) LessThanOrEqual(value interface{}) *TodoQueryBuilder {
	p.bldr.q = p.bldr.q.Filter(p.name+" <=", value)
	if p.bldr.plugin != nil {
		p.bldr.plugin.Filter(p.name, "<=", value)
	}
	return p.bldr
}
690789
func (v *Validator) Less(field string, value float64) *ValidationResult {
	return v.inequality(field, value, less, "less than")
}
961502
func (o *ReplaceSynonymsInHighlightOption) Equal(o2 *ReplaceSynonymsInHighlightOption) bool {
	if o2 == nil {
		return o.value == true
	}
	return o.value == o2.value
}
761553
func (n *serviceNodeSorter) Less(i, j int) bool {
	return n.Vec[i] < n.Vec[j]
}
110208
func (p *UserQueryProperty) LessThanOrEqual(value interface{}) *UserQueryBuilder {
	p.bldr.q = p.bldr.q.Filter(p.name+" <=", value)
	if p.bldr.plugin != nil {
		p.bldr.plugin.Filter(p.name, "<=", value)
	}
	return p.bldr
}
1360492
func AnchoringEqual(o1, o2 *AnchoringOption) bool {
	if o1 != nil {
		return o1.Equal(o2)
	}
	if o2 != nil {
		return o2.Equal(o1)
	}
	return true
}
921058
func (v *Version) Less(other *Version) bool {
	switch {
	case v.Major < other.Major:
		return true
	case v.Major > other.Major:
		return false
	case v.Minor < other.Minor:
		return true
	case v.Minor > other.Minor:
		return false
	default:
		return (v.Patch < other.Patch)
	}
}
1259805
func (c *Condition) OrEqual(column string, value interface{}) *Condition {
	expr := column + " = ?"
	c.Or(expr, value)
	return c
}
859412
func (b *Sortable) Less(i, j int) bool {
	for _, c := range b.Comparators {
		if c(i, j) {
			return true
		} else if c(j, i) {
			return false
		}
	}
	return false
}
787231
func (this *state) isBetterThanOrEqualTo(other *state) bool {
	mySize := this.bitCount + (latchTable[this.mode][other.mode] >> 16)

	if other.bShiftByteCount > 0 && (this.bShiftByteCount == 0 || this.bShiftByteCount > other.bShiftByteCount) {
		mySize += 10 // Cost of entering Binary Shift mode.
	}
	return mySize <= other.bitCount
}
365160
func NewEqualFilter(binName string, value interface{}) *Filter {
	val := NewValue(value)
	return newFilter(binName, ICT_DEFAULT, val.GetType(), val, val)
}
988151
func (o *NumericFiltersOption) Equal(o2 *NumericFiltersOption) bool {
	return o.comp.Equal(&o2.comp)
}
1137108
func (v Value) LessThanEq(w Value) bool {
	if v == w {
		return true
	}
	return v.LessThan(w)
}
1248193
func RankingEqual(o1, o2 *RankingOption) bool {
	if o1 != nil {
		return o1.Equal(o2)
	}
	if o2 != nil {
		return o2.Equal(o1)
	}
	return true
}
1097558
func (i Interval) Less(other Interval) bool {
	return i.latest.Sub(other.earliest) < 0
}
624931
func LimitEqual(o1, o2 *LimitOption) bool {
	if o1 != nil {
		return o1.Equal(o2)
	}
	if o2 != nil {
		return o2.Equal(o1)
	}
	return true
}
791269
func (s *i18nSorter) Less(i, j int) bool {

	iValue := strings.ToLower(s.getComparisonValueFunc(s.toBeSorted[i]))
	jValue := strings.ToLower(s.getComparisonValueFunc(s.toBeSorted[j]))

	// if it's a local sort, use the collator
	if s.collator != nil {
		return s.collator.CompareString(iValue, jValue) == -1
	}

	// for universal sorts, normalize the unicode to sort
	normalizer := norm.NFKD
	iValue = normalizer.String(iValue)
	jValue = normalizer.String(jValue)

	return bytes.Compare([]byte(iValue), []byte(jValue)) == -1
}