sbFraction.h

Go to the documentation of this file.

/*
 *=BEGIN SONGBIRD GPL
 *
 * This file is part of the Songbird web player.
 *
 * Copyright(c) 2005-2009 POTI, Inc.
 * http://www.songbirdnest.com
 *
 * This file may be licensed under the terms of of the
 * GNU General Public License Version 2 (the ``GPL'').
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the GPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the GPL along with this
 * program. If not, go to http://www.gnu.org/licenses/gpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *=END SONGBIRD GPL
 */

#ifndef SBFRACTION_H_
#define SBFRACTION_H_

#include <nsStringAPI.h>

class sbFraction
{
public:
  sbFraction() : mNumerator(0),
                 mDenominator(1) {}

  sbFraction(PRUint32 aNumerator, PRUint32 aDenominator = 1) :
    mNumerator(aNumerator),
    mDenominator(aDenominator) {}

  sbFraction(PRUint32 aWholeNumber,
             PRUint32 aNumerator,
             PRUint32 aDenominator) :
               mNumerator(aNumerator + aDenominator * aWholeNumber),
               mDenominator(aDenominator) {}

  bool IsEqual(sbFraction const & aOther) const
  {
    return ((mNumerator == aOther.mNumerator &&
             mDenominator == aOther.mDenominator) ||
            (mNumerator * aOther.mDenominator ==
             mDenominator * aOther.mNumerator));
  }

  bool IsLessThan(sbFraction const & aOther) const
  {
    return *this < aOther;
  }

  operator double() const
  {
    return static_cast<double>(mNumerator) / static_cast<double>(mDenominator);
  }

  PRBool operator > (const sbFraction & aFraction)
  {
    return (PRInt64)mNumerator * aFraction.mDenominator >
           (PRInt64)aFraction.mNumerator * mDenominator;
  }

  PRBool operator < (const sbFraction & aFraction)
  {
    return (PRInt64)mNumerator * aFraction.mDenominator <
           (PRInt64)aFraction.mNumerator * mDenominator;
  }

  PRBool operator >= (const sbFraction & aFraction)
  {
    return (PRInt64)mNumerator * aFraction.mDenominator >=
           (PRInt64)aFraction.mNumerator * mDenominator;
  }

  PRBool operator <= (const sbFraction & aFraction)
  {
    return (PRInt64)mNumerator * aFraction.mDenominator <=
           (PRInt64)aFraction.mNumerator * mDenominator;
  }

  PRUint32 Numerator() const
  {
    return mNumerator;
  }

  PRUint32 Denominator() const
  {
    return mDenominator;
  }

  void GetProperFraction(PRUint32& aWhole,
                         PRUint32& aNumerator,
                         PRUint32& aDenominator) const
  {
    aWhole = mNumerator / mDenominator;
    aNumerator = mNumerator - (aWhole * aDenominator);
    aDenominator = mDenominator;
  }
private:
  PRUint32 mNumerator;
  PRUint32 mDenominator;
};

inline
bool operator ==(sbFraction const & aLeft, sbFraction const & aRight)
{
  return aLeft.IsEqual(aRight);
}

inline
bool operator !=(sbFraction const & aLeft, sbFraction const & aRight)
{
  return !aLeft.IsEqual(aRight);
}

inline
bool operator <(sbFraction const & aLeft, sbFraction const & aRight)
{
  return aLeft.IsLessThan(aRight);
}

inline
bool operator >(sbFraction const & aLeft, sbFraction const & aRight)
{
  return aLeft != aRight && !aLeft.IsLessThan(aRight);
}

inline
bool operator >=(sbFraction const & aLeft, sbFraction const & aRight)
{
  return aLeft == aRight || aLeft > aRight;
}

inline
bool operator <=(sbFraction const & aLeft, sbFraction const & aRight)
{
  return aLeft == aRight || aLeft < aRight;
}

inline
nsString sbFractionToString(sbFraction const & aFraction)
{
  nsString result;

  result.AppendInt(aFraction.Numerator(), 10);
  if (aFraction.Denominator() > 1) {
    result.Append(NS_LITERAL_STRING("/"));
    result.AppendInt(aFraction.Denominator(), 10);
  }

  return result;
}

inline
nsresult sbFractionParsePart(nsAString const & aString,
                             PRInt32 aStart,
                             PRInt32 aLength,
                             PRUint32 * aValue)
{
  nsresult rv;

  nsDependentSubstring part(aString, aStart, aLength);
  PRInt32 temp = part.ToInteger(&rv, 10);
  NS_ENSURE_SUCCESS(rv, rv);
  NS_ENSURE_TRUE(temp >= 0, NS_ERROR_FAILURE);

  *aValue = temp;

  return NS_OK;
}

inline
nsresult sbFractionFromString(nsAString const & aString,
                              sbFraction & aFraction)
{
  nsresult rv;

  PRUint32 whole = 0;
  PRUint32 numerator = 0;
  PRUint32 denominator = 1;

  PRInt32 const space = aString.Find(NS_LITERAL_STRING(" "));
  PRInt32 const slash = aString.Find(NS_LITERAL_STRING("/"));

  // Whole number
  if (space == -1) {
    if (slash == -1) {
      numerator = aString.ToInteger(&rv, 10);
      aFraction = sbFraction(numerator);
    }
    else {
      rv = sbFractionParsePart(aString, 0, slash, &numerator);
      NS_ENSURE_SUCCESS(rv, rv);
      rv = sbFractionParsePart(aString,
                               slash + 1,
                               aString.Length() - slash - 1,
                               &denominator);
      NS_ENSURE_SUCCESS(rv, rv);

      aFraction = sbFraction(numerator, denominator);
    }
    return NS_OK;
  }
  // Bad format, no slash
  if (slash == -1) {
    return NS_ERROR_FAILURE;
  }

  rv = sbFractionParsePart(aString, 0, space, &whole);
  NS_ENSURE_SUCCESS(rv, rv);

  rv = sbFractionParsePart(aString, space + 1, slash - space - 1, &numerator);
  NS_ENSURE_SUCCESS(rv, rv);

  rv = sbFractionParsePart(aString,
                           slash + 1,
                           aString.Length() - slash - 1,
                           &denominator);
  NS_ENSURE_SUCCESS(rv, rv);

  aFraction = sbFraction(whole, numerator, denominator);

  return NS_OK;
}
inline
nsresult sbFractionFromString(nsACString const & aString,
                              sbFraction & aFraction)
{
  return sbFractionFromString(NS_ConvertASCIItoUTF16(aString), aFraction);
}
inline
nsresult sbFractionFromString(const char* aString,
                              sbFraction & aFraction)
{
  return sbFractionFromString(NS_ConvertASCIItoUTF16(nsDependentCString(aString)),
                              aFraction);
}

#endif /* SBFRACTION_H_ */