Rename enums/functions that collide in chromium style in platform/

third_party/WebKit/Source/platform/Decimal.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 69 matching lines @@
 SpecialValueHandler::SpecialValueHandler(const Decimal& lhs, const Decimal& rhs)
     : m_lhs(lhs), m_rhs(rhs), m_result(ResultIsUnknown)
 {
 }
 
 SpecialValueHandler::HandleResult SpecialValueHandler::handle()
 {
     if (m_lhs.isFinite() && m_rhs.isFinite())
         return BothFinite;
 
-    const Decimal::EncodedData::FormatClass lhsClass = m_lhs.value().formatClass();
-    const Decimal::EncodedData::FormatClass rhsClass = m_rhs.value().formatClass();
+    const Decimal::EncodedData::FormatClass lhsClass = m_lhs.value().getFormatClass();
+    const Decimal::EncodedData::FormatClass rhsClass = m_rhs.value().getFormatClass();
     if (lhsClass == Decimal::EncodedData::ClassNaN) {
         m_result = ResultIsLHS;
         return EitherNaN;
     }
 
     if (rhsClass == Decimal::EncodedData::ClassNaN) {
         m_result = ResultIsRHS;
         return EitherNaN;
     }
 
@@ skipping 223 matching lines @@
     m_data = (*this / other).m_data;
     return *this;
 }
 
 Decimal Decimal::operator-() const
 {
     if (isNaN())
         return *this;
 
     Decimal result(*this);
-    result.m_data.setSign(invertSign(m_data.sign()));
+    result.m_data.setSign(invertSign(m_data.getSign()));
     return result;
 }
 
 Decimal Decimal::operator+(const Decimal& rhs) const
 {
     const Decimal& lhs = *this;
-    const Sign lhsSign = lhs.sign();
-    const Sign rhsSign = rhs.sign();
+    const Sign lhsSign = lhs.getSign();
+    const Sign rhsSign = rhs.getSign();
 
     SpecialValueHandler handler(lhs, rhs);
     switch (handler.handle()) {
     case SpecialValueHandler::BothFinite:
         break;
 
     case SpecialValueHandler::BothInfinity:
         return lhsSign == rhsSign ? lhs : nan();
 
     case SpecialValueHandler::EitherNaN:
@@ skipping 16 matching lines @@
         return Decimal(Positive, alignedOperands.exponent, 0);
 
     return static_cast<int64_t>(result) >= 0
         ? Decimal(lhsSign, alignedOperands.exponent, result)
         : Decimal(invertSign(lhsSign), alignedOperands.exponent, -static_cast<int64_t>(result));
 }
 
 Decimal Decimal::operator-(const Decimal& rhs) const
 {
     const Decimal& lhs = *this;
-    const Sign lhsSign = lhs.sign();
-    const Sign rhsSign = rhs.sign();
+    const Sign lhsSign = lhs.getSign();
+    const Sign rhsSign = rhs.getSign();
 
     SpecialValueHandler handler(lhs, rhs);
     switch (handler.handle()) {
     case SpecialValueHandler::BothFinite:
         break;
 
     case SpecialValueHandler::BothInfinity:
         return lhsSign == rhsSign ? nan() : lhs;
 
     case SpecialValueHandler::EitherNaN:
@@ skipping 16 matching lines @@
         return Decimal(Positive, alignedOperands.exponent, 0);
 
     return static_cast<int64_t>(result) >= 0
         ? Decimal(lhsSign, alignedOperands.exponent, result)
         : Decimal(invertSign(lhsSign), alignedOperands.exponent, -static_cast<int64_t>(result));
 }
 
 Decimal Decimal::operator*(const Decimal& rhs) const
 {
     const Decimal& lhs = *this;
-    const Sign lhsSign = lhs.sign();
-    const Sign rhsSign = rhs.sign();
+    const Sign lhsSign = lhs.getSign();
+    const Sign rhsSign = rhs.getSign();
     const Sign resultSign = lhsSign == rhsSign ? Positive : Negative;
 
     SpecialValueHandler handler(lhs, rhs);
     switch (handler.handle()) {
     case SpecialValueHandler::BothFinite: {
         const uint64_t lhsCoefficient = lhs.m_data.coefficient();
         const uint64_t rhsCoefficient = rhs.m_data.coefficient();
         int resultExponent = lhs.exponent() + rhs.exponent();
         UInt128 work(UInt128::multiply(lhsCoefficient, rhsCoefficient));
         while (work.high()) {
@@ skipping 16 matching lines @@
         return lhs.isZero() ? nan() : infinity(resultSign);
     }
 
     ASSERT_NOT_REACHED();
     return nan();
 }
 
 Decimal Decimal::operator/(const Decimal& rhs) const
 {
     const Decimal& lhs = *this;
-    const Sign lhsSign = lhs.sign();
-    const Sign rhsSign = rhs.sign();
+    const Sign lhsSign = lhs.getSign();
+    const Sign rhsSign = rhs.getSign();
     const Sign resultSign = lhsSign == rhsSign ? Positive : Negative;
 
     SpecialValueHandler handler(lhs, rhs);
     switch (handler.handle()) {
     case SpecialValueHandler::BothFinite:
         break;
 
     case SpecialValueHandler::BothInfinity:
         return nan();
 
@@ skipping 165 matching lines @@
 
     uint64_t result = m_data.coefficient();
     const int numberOfDigits = countDigits(result);
     const int numberOfDropDigits = -exponent();
     if (numberOfDigits <= numberOfDropDigits)
         return isPositive() ? Decimal(1) : zero(Positive);
 
     result = scaleDown(result, numberOfDropDigits);
     if (isPositive() && !isMultiplePowersOfTen(m_data.coefficient(), numberOfDropDigits))
         ++result;
-    return Decimal(sign(), 0, result);
+    return Decimal(getSign(), 0, result);
 }
 
 Decimal Decimal::compareTo(const Decimal& rhs) const
 {
     const Decimal result(*this - rhs);
-    switch (result.m_data.formatClass()) {
+    switch (result.m_data.getFormatClass()) {
     case EncodedData::ClassInfinity:
         return result.isNegative() ? Decimal(-1) : Decimal(1);
 
     case EncodedData::ClassNaN:
     case EncodedData::ClassNormal:
         return result;
 
     case EncodedData::ClassZero:
         return zero(Positive);
 
@@ skipping 14 matching lines @@
 
     uint64_t result = m_data.coefficient();
     const int numberOfDigits = countDigits(result);
     const int numberOfDropDigits = -exponent();
     if (numberOfDigits < numberOfDropDigits)
         return isPositive() ? zero(Positive) : Decimal(-1);
 
     result = scaleDown(result, numberOfDropDigits);
     if (isNegative() && !isMultiplePowersOfTen(m_data.coefficient(), numberOfDropDigits))
         ++result;
-    return Decimal(sign(), 0, result);
+    return Decimal(getSign(), 0, result);
 }
 
 Decimal Decimal::fromDouble(double doubleValue)
 {
     if (std::isfinite(doubleValue))
         return fromString(String::numberToStringECMAScript(doubleValue));
 
     if (std::isinf(doubleValue))
         return infinity(doubleValue < 0 ? Negative : Positive);
 
@@ skipping 219 matching lines @@
     uint64_t result = m_data.coefficient();
     const int numberOfDigits = countDigits(result);
     const int numberOfDropDigits = -exponent();
     if (numberOfDigits < numberOfDropDigits)
         return zero(Positive);
 
     result = scaleDown(result, numberOfDropDigits - 1);
     if (result % 10 >= 5)
         result += 10;
     result /= 10;
-    return Decimal(sign(), 0, result);
+    return Decimal(getSign(), 0, result);
 }
 
 double Decimal::toDouble() const
 {
     if (isFinite()) {
         bool valid;
         const double doubleValue = toString().toDouble(&valid);
         return valid ? doubleValue : std::numeric_limits<double>::quiet_NaN();
     }
 
     if (isInfinity())
         return isNegative() ? -std::numeric_limits<double>::infinity() : std::numeric_limits<double>::infinity();
 
     return std::numeric_limits<double>::quiet_NaN();
 }
 
 String Decimal::toString() const
 {
-    switch (m_data.formatClass()) {
+    switch (m_data.getFormatClass()) {
     case EncodedData::ClassInfinity:
-        return sign() ? "-Infinity" : "Infinity";
+        return getSign() ? "-Infinity" : "Infinity";
 
     case EncodedData::ClassNaN:
         return "NaN";
 
     case EncodedData::ClassNormal:
     case EncodedData::ClassZero:
         break;
 
     default:
         ASSERT_NOT_REACHED();
         return "";
     }
 
     StringBuilder builder;
-    if (sign())
+    if (getSign())
         builder.append('-');
 
     int originalExponent = exponent();
     uint64_t coefficient = m_data.coefficient();
 
     if (originalExponent < 0) {
         const int maxDigits = DBL_DIG;
         uint64_t lastDigit = 0;
         while (countDigits(coefficient) > maxDigits) {
             lastDigit = coefficient % 10;
@@ skipping 51 matching lines @@
     }
     return builder.toString();
 }
 
 Decimal Decimal::zero(Sign sign)
 {
     return Decimal(EncodedData(sign, EncodedData::ClassZero));
 }
 
 } // namespace blink