UnitLabel.cpp

#include "MantidKernel/UnitLabel.h"
#include <cstring>

namespace Mantid
{
  namespace Kernel
  {

    /**
     * @param ascii A plain-text label containing only ascii characters
     * @param unicode A label that can contain unicode characters
     * @param latex A text label containg the ascii characters with latex formatting
     */
    UnitLabel::UnitLabel(const AsciiString &ascii, const Utf8String &unicode, const AsciiString &latex)
        : m_ascii(ascii), m_utf8(unicode), m_latex(latex)
    {
    }

    /**
     * Use an ASCII string for the unicode variant too
     * @param ascii A plain-text label containing only ascii characters
     */
    UnitLabel::UnitLabel(const UnitLabel::AsciiString &ascii)
        : m_ascii(ascii), m_utf8(ascii.begin(), ascii.end()), m_latex(ascii)
    {
    }

    /**
     * Use an ASCII string for the unicode variant too, given
     * as a C-style string
     * @param ascii A plain-text label
     */
    UnitLabel::UnitLabel(const char *ascii)
        : m_ascii(ascii), m_utf8(m_ascii.begin(), m_ascii.end()),m_latex(ascii)
    {
    }

    /**
     * Test if two objects are considered equal
     * @param rhs A second label object
     * @return True if they are conisdered equal, false otherwise
     */
    bool UnitLabel::operator==(const UnitLabel &rhs) const
    {
      return (this->ascii() == rhs.ascii() &&
              this->utf8() == rhs.utf8());
    }

    /**
     * Test if this object is considered equal to another std::string.
     * It compares to result of ascii()
     * @param rhs A string to compare
     * @return True if they are conisdered equal, false otherwise
     */
    bool UnitLabel::operator==(const std::string &rhs) const
    {
      return (this->ascii() == rhs);
    }

    /**
     * Test if this object is considered equal to another c-style string.
     * It compares to result of ascii()
     * @param rhs A string to compare
     * @return True if they are conisdered equal, false otherwise
     */
    bool UnitLabel::operator==(const char *rhs) const
    {
      return (strcmp(ascii().c_str(), rhs) == 0);
    }

    /**
     * Test if this object is considered equal to another std::wstring.
     * It compares to result of utf8()
     * @param rhs A string to compare
     * @return True if they are conisdered equal, false otherwise
     */
    bool UnitLabel::operator==(const std::wstring &rhs) const
    {
      return (this->utf8() == rhs);
    }

    /**
     * Test if two objects are not considered equal
     * @param rhs A second label object
     * @return True if they are conisdered equal, false otherwise
     */
    bool UnitLabel::operator!=(const UnitLabel &rhs) const
    {
      return !(*this == rhs);
    }

    /**
     * Test if this object is not considered equal to another std::string.
     * It compares to result of ascii()
     * @param rhs A string to compare
     * @return True if they are conisdered equal, false otherwise
     */
    bool UnitLabel::operator!=(const std::string &rhs) const
    {
      return !(*this == rhs);
    }

    /**
     * Test if this object is not considered equal to another c-style string
     * It compares to result of ascii()
     * @param rhs A string to compare
     * @return True if they are conisdered equal, false otherwise
     */
    bool UnitLabel::operator!=(const char * rhs) const
    {
      return !(*this == rhs);
    }

    /**
     * Test if this object is not considered equal to another std::wstring.
     * It compares to result of utf8()
     * @param rhs A string to compare
     * @return True if they are conisdered equal, false otherwise
     */
    bool UnitLabel::operator!=(const std::wstring &rhs) const
    {
      return !(*this == rhs);
    }

    /**
     * @return A std::string containing the plain-text label
     */
    const UnitLabel::AsciiString & UnitLabel::ascii() const
    {
      return m_ascii;
    }

    /**
     * @return A UnitLabel::utf8string containing the unicode label
     */
    const UnitLabel::Utf8String & UnitLabel::utf8() const
    {
      return m_utf8;
    }

    /**
     * @return A std::string containing the latex label
     */
    const UnitLabel::AsciiString & UnitLabel::latex() const
    {
      return m_latex;
    }

    /**
     * Returns the results of the ascii() method
     */
    UnitLabel::operator std::string() const
    {
      return this->ascii();
    }

  } // namespace Kernel
} // namespace Mantid