FuzzyStringComparator.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2012.
//
// This software is released under a three-clause BSD license:
//  * 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 copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Stephan Aiche $
// $Authors: Clemens Groepl, Stephan Aiche $
// --------------------------------------------------------------------------

#ifndef OPENMS_CONCEPT_FUZZYSTRINGCOMPARATOR_H
#define OPENMS_CONCEPT_FUZZYSTRINGCOMPARATOR_H

#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/DATASTRUCTURES/String.h>
#include <OpenMS/DATASTRUCTURES/StringList.h>

#include <cstdlib> // for strtod()
#include <fstream>
#include <iostream>
#include <cctype> // for isspace()
#include <limits> // for NaN
#include <sstream>
#include <map>

namespace OpenMS
{
  namespace Internal
  {
    namespace ClassTest
    {
      void OPENMS_DLLAPI
      testStringSimilar(const char * file, int line,
                        const std::string & string_1,
                        const char * string_1_stringified,
                        const std::string & string_2,
                        const char * string_2_stringified);
      bool OPENMS_DLLAPI
      isFileSimilar(const std::string &, const std::string &);
    }
  }

  class OPENMS_DLLAPI FuzzyStringComparator
  {

    friend void OPENMS_DLLAPI
    Internal::ClassTest::testStringSimilar(
      const char * file,
      int line,
      const std::string & string_1,
      const char * string_1_stringified,
      const std::string & string_2,
      const char * string_2_stringified);
    friend bool OPENMS_DLLAPI
    Internal::ClassTest::isFileSimilar(const std::string &,
                                       const std::string &);

    struct AbortComparison
    {
    };

public:



    FuzzyStringComparator();

    virtual
    ~FuzzyStringComparator();

    FuzzyStringComparator(const FuzzyStringComparator & rhs);

    FuzzyStringComparator &
    operator=(const FuzzyStringComparator & rhs);


    const double &
    getAcceptableRelative() const
    {
      return ratio_max_allowed_;
    }

    void
    setAcceptableRelative(const double rhs)
    {
      this->ratio_max_allowed_ = rhs;
      if (ratio_max_allowed_ < 1.0)
        ratio_max_allowed_ = 1
                             / ratio_max_allowed_;

    }

    const double &
    getAcceptableAbsolute() const
    {
      return absdiff_max_allowed_;
    }

    void
    setAcceptableAbsolute(const double rhs)
    {
      this->absdiff_max_allowed_ = rhs;
      if (absdiff_max_allowed_ < 0.0)
        absdiff_max_allowed_
          = -absdiff_max_allowed_;
    }

    const StringList &
    getWhitelist() const
    {
      return whitelist_;
    }

    StringList &
    getWhitelist()
    {
      return whitelist_;
    }

    void
    setWhitelist(const StringList & rhs)
    {
      whitelist_ = rhs;
    }

    const int &
    getVerboseLevel() const
    {
      return verbose_level_;
    }

    void
    setVerboseLevel(const int rhs)
    {
      this->verbose_level_ = rhs;
    }

    const int &
    getTabWidth() const
    {
      return tab_width_;
    }

    void
    setTabWidth(const int rhs)
    {
      this->tab_width_ = rhs;
    }

    const int &
    getFirstColumn() const
    {
      return first_column_;
    }

    void
    setFirstColumn(const int rhs)
    {
      this->first_column_ = rhs;
    }

    std::ostream &
    getLogDestination() const
    {
      return *log_dest_;
    }

    void
    setLogDestination(std::ostream & rhs)
    {
      this->log_dest_ = &rhs;
    }

    bool
    compareStrings(std::string const & lhs, std::string const & rhs);

    bool
    compareStreams(std::istream & input_1, std::istream & input_2);

    bool
    compareFiles(const std::string & filename_1,
                 const std::string & filename_2);

protected:

    bool
    compareLines_(std::string const & line_str_1,
                  std::string const & line_str_2);

    void
    reportSuccess_() const;

    void
    reportFailure_(char const * const message) const;

    void writeWhitelistCases_(const std::string & prefix) const;

    void readNextLine_(std::istream & input_stream, std::string & line_string, int & line_number) const;

    bool openInputFileStream_(const std::string & filename, std::ifstream & input_stream) const;

    std::ostream * log_dest_;

    std::string input_1_name_;
    std::string input_2_name_;

    struct InputLine
    {
      std::stringstream line_;
      std::ios::pos_type line_position_;

      InputLine() :
        line_()
      {
      }

      void setToString(const std::string & s)
      {
        line_.str(s);
        line_.seekp(0);
        line_.clear();
        line_.unsetf(std::ios::skipws);

        line_position_ = line_.tellg();
      }

      void updatePosition()
      {
        line_position_ = (Int(line_.tellg()) != -1 ? line_.tellg() : std::ios::pos_type(line_.str().length()));             // save current reading position
      }

      void seekGToSavedPosition()
      {
        line_.clear();             // reset status
        line_.seekg(line_position_);             // rewind to saved position
      }

      operator void *() const
      {
        return line_.operator void *();
      }
    };

    InputLine input_line_1_;
    InputLine input_line_2_;

    int line_num_1_;
    int line_num_2_;

    int line_num_1_max_;
    int line_num_2_max_;

    std::string line_str_1_max_;
    std::string line_str_2_max_;

    double ratio_max_allowed_;

    double ratio_max_;

    double absdiff_max_allowed_;

    double absdiff_max_;

    struct StreamElement_
    {
      double number;
      unsigned char letter;
      bool is_number;
      bool is_space;

      StreamElement_() :
        number(0),
        letter(0),
        is_number(false),
        is_space(false)
      {}

      void reset()
      {
        is_number = false;
        is_space = false;
        letter = '\0';
        number = std::numeric_limits<double>::quiet_NaN();
      }

      void fillFromInputLine(InputLine & input_line)
      {
        // first reset all internal variables so we do not mess with
        // old values
        reset();

        input_line.updatePosition();
        input_line.line_ >> letter;             // read letter
        if ((is_space = (isspace(letter) != 0)))               // is whitespace?
        {
          input_line.line_ >> std::ws;               // skip over further whitespace
        }
        else
        {
          input_line.seekGToSavedPosition();
          if ((is_number = ((input_line.line_ >> number) != 0)))                    // is a number?
          {
          }
          else
          {
            input_line.seekGToSavedPosition();
            input_line.line_ >> letter;                 // read letter
          }
        }
      }

    };

    StreamElement_ element_1_;
    StreamElement_ element_2_;

    struct PrefixInfo_
    {
      OpenMS::String prefix;
      OpenMS::String prefix_whitespaces;
      int line_column;

      PrefixInfo_(const InputLine & input_line, const int tab_width_, const int first_column_) :
        prefix(input_line.line_.str()), line_column(0)
      {
        prefix = prefix.prefix(size_t(input_line.line_position_));
        prefix_whitespaces = prefix;
        for (String::iterator iter = prefix_whitespaces.begin(); iter != prefix_whitespaces.end(); ++iter)
        {
          if (*iter != '\t')
          {
            * iter = ' ';
            ++line_column;
          }
          else
          {
            line_column = (line_column / tab_width_ + 1) * tab_width_;
          }
        }
        line_column += first_column_;
      }

    };

    bool is_absdiff_small_;

    int verbose_level_;
    int tab_width_;
    int first_column_;

    bool is_status_success_;

    bool use_prefix_;

    StringList whitelist_;
    std::map<String, UInt> whitelist_cases_;

  }; // class FuzzyStringComparator

} //namespace OpenMS

#endif //OPENMS_CONCEPT_FUZZYSTRINGCOMPARATOR_H