Check if a value is lower or equal to another before sending the request

@param string        $sValue1                  The first value to compare
@param string        $sValue2                  The second value to compare

@return Request
188227
public function ifle($sValue1, $sValue2)
    {
        $this->sCondition = '(' . Parameter::make($sValue1) . '<=' . Parameter::make($sValue2) . ')';
        return $this;
    }
75219
public function compare($priority1, $priority2)
    {
        $p1Count = count($priority1);
        $p2Count = count($priority2);

        $count = min($p1Count, $p2Count);

        foreach (range(1, $count) as $i) {
            $k = $i - 1;

            if ($priority1[$k] == $priority2[$k]) {
                continue;
            } elseif ($priority1[$k] > $priority2[$k]) {
                return 1;
            } else {
                return -1;
            }
        }

        return 0;
    }
678902
public function conditionalChecked($value_1 = null, $value_2 = null)
	{
		if (isset($value_1) && isset($value_2) && ($value_1 === $value_2)) {
			return $this->checked();
		} else {
			return $this;
		}
	}
414023
public static function smallerThan(Version $v1, Version $v2)
    {
        // If it's equal it can not be smaller
        if (self::equals($v1, $v2)) {
            return false;
        }

        // If it's not equal, and not greater, it must be smaller
        return !self::greaterThan($v1, $v2);
    }
746655
public static function compareElements($elem1, $elem2)
    {
        if (is_array($elem1)) {
            if (is_array($elem2)) {
                return strcmp(serialize($elem1), serialize($elem2));
            }

            return 1;
        }

        if (is_array($elem2)) {
            return -1;
        }

        if ((string)$elem1 === (string)$elem2) {
            return 0;
        }

        return ((string)$elem1 > (string)$elem2) ? 1 : -1;
    }
697010
public static function slowEquals($str1, $str2){
				
		$l1 = \strlen($str1);
		$l2 = \strlen($str2);
		$diff = $l1 ^ $l2;

		for($i = 0; $i < $l1 && $i < $l2; ++$i){
			$diff |= \ord($str1[$i]) ^ \ord($str2[$i]);
		}

		return $diff === 0;
		
	}
1086205
private function __convertStringToBool($sValue)
    {
        if(strcasecmp($sValue, 'true') == 0)
        {
            return true;
        }
        if(strcasecmp($sValue, 'false') == 0)
        {
            return false;
        }
        if(is_numeric($sValue))
        {
            if($sValue == 0)
            {
                return false;
            }
            return true;
        }
        return false;
    }
114816
private function valuesAreEqual( $firstValue, $secondValue ): bool {
		if ( $this->comparer === null ) {
			$this->comparer = new StrictComparer();
		}

		return $this->comparer->valuesAreEqual( $firstValue, $secondValue );
	}
311503
public static function compare($price1, $price2)
    {
        //====================================================================//
        // Check Both Prices are valid
        if (!self::isValid($price1) || !self::isValid($price2)) {
            Splash::log()->war(__FUNCTION__." : Given Prices are invalid");
            if (!self::isValid($price1)) {
                Splash::log()->www(__FUNCTION__." Price 1", $price1);
            }
            if (!self::isValid($price2)) {
                Splash::log()->www(__FUNCTION__." Price 2", $price2);
            }

            return false;
        }
        //====================================================================//
        // Compare Base Price
        if (((bool) $price1["base"]) != ((bool) $price2["base"])) {
            return false;
        }
        //====================================================================//
        // Compare Price
        return self::compareAmounts($price1, $price2);
    }
677980
public function Compare($other)
	{
	    switch ( $other->GetValueCode() )
	    {
	        case SByteProxyFactory::Code:
	            return 0;

	        case ByteProxyFactory::Code:
	        case UShortProxyFactory::Code:
	        case UIntProxyFactory::Code:
	        case ULongProxyFactory::Code:
	        case ShortProxyFactory::Code:
	        case IntProxyFactory::Code:
	        case LongProxyFactory::Code:
	        case IntegerProxyFactory::Code:
	        case DecimalProxyFactory::Code:
	        case FloatProxyFactory::Code:
	        case DoubleProxyFactory::Code:
	            return -1;

	        default:
	            return -2;
	    }
	}
308928
public function evalEquals( core_kernel_classes_Literal $first,  core_kernel_classes_Literal $second)
    {
        $returnValue = (bool) false;

        
        if($first instanceof core_kernel_classes_Literal && $second instanceof core_kernel_classes_Literal)  {
    		$returnValue = $first->literal == $second->literal;
        }
        

        return (bool) $returnValue;
    }
929084
public function join($str1 = null, $str2 = null)
    {
        if (is_null($str1)) {
            $str1 = $this->number();
        }
        if (is_null($str2)) {
            $str2 = $this->vn();
        }

        return $str1 . $this->vnSeparator . $str2;
    }
365657
public function equals($other) {
		if ($other instanceof UrlQuery) {
			return ($this->isEmpty() && $other->isEmpty()) || ($this->__toString() === $other->__toString() );
		}
		if (is_null($other)) {
			return $this->isEmpty();
		}
		return false;
	}
450901
public function GetAddFilterURL($sValue)
    {
        // @todo: the sorting is lost here (#29269)
        $oActiveListfilter = TdbPkgShopListfilter::GetActiveInstance();
        $aURLData = $oActiveListfilter->GetCurrentFilterAsArray();
        $aURLData[TdbPkgShopListfilterItem::URL_PARAMETER_FILTER_DATA][$this->id] = $sValue;
        $aURLData[TdbPkgShopListfilter::URL_PARAMETER_IS_NEW_REQUEST] = '1';

        return $this->getActivePageService()->getLinkToActivePageRelative($aURLData);
    }
303978
public static function compare($val1, $val2)
    {
        if(in_array(self::getQualifiedType($val1), array('int','boolean', 'float', 'NULL')) )
            return $val1 == $val2 ? 0 : (($val1 < $val2) ? -1 : 1);
        // if(self::getQualifiedType($val1) == 'string' )
            // return strcmp($val1, $val2);
        if(self::isSubclass($val1, 'Date'))
            return self::compare($val1->toUnix(), $val2->toUnix());

        return strcmp((string)$val1, (string)$val2);
    }
212549
public static function Compare ($string1, $string2, $encoding = Encoding::DEFAULT_ENCODING) {
		return strcmp(Encoding::Adjust($string1, $encoding), Encoding::Adjust($string2, $encoding));
	}
1136764
private static function callbackEquals( $callback1, $callback2 ) {

			if ( is_array( $callback1 ) && is_array( $callback2 ) ) {
				
				if ( count( $callback1 ) == count( $callback2 ) ) {
				
					for ( $i=0, $len = count( $callback1 ); $i<$len; $i++ ) {
						if ( $callback1[$i] != $callback2[$i] ) {
							return false;
						}
					}

					return true;

				} else {
					
					return false;
				
				}

			} else {

				return $callback1 == $callback2;

			}

		}