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-2017.
//
// 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: Timo Sachsenberg $
// $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/StringListUtils.h>

#include <iosfwd>
#include <map>

#ifdef OPENMS_HAS_STREAM_EXTRACTION_BUG
#include <boost/lexical_cast.hpp>
#endif // OPENMS_HAS_STREAM_EXTRACTION_BUG

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;

    void setAcceptableRelative(const double rhs);

    const double & getAcceptableAbsolute() const;

    void setAcceptableAbsolute(const double rhs);

    const StringList & getWhitelist() const;

    StringList & getWhitelist();

    void setWhitelist(const StringList & rhs);

    void setMatchedWhitelist(const std::vector< std::pair<std::string, std::string> >& rhs); 

    const std::vector< std::pair<std::string, std::string> >& getMatchedWhitelist() const; 

    const int & getVerboseLevel() const;

    void setVerboseLevel(const int rhs);

    const int & getTabWidth() const;

    void setTabWidth(const int rhs);

    const int & getFirstColumn() const;

    void setFirstColumn(const int rhs);

    std::ostream & getLogDestination() const;

    void setLogDestination(std::ostream & 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();

      void setToString(const std::string & s);

      void updatePosition();

      void seekGToSavedPosition();

      bool ok() const;
    };

    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_();

      void reset();
#ifdef OPENMS_HAS_STREAM_EXTRACTION_BUG

      bool readdigits(InputLine & input_line, std::string & target_buffer, char & c_buffer);

      bool tryExtractDouble(InputLine & input_line, double & target);
#endif
      void fillFromInputLine(InputLine & input_line);
    };

    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_);
    };

    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_;

    std::vector< std::pair<std::string, std::string> > matched_whitelist_; 
  }; // class FuzzyStringComparator

} //namespace OpenMS

#endif //OPENMS_CONCEPT_FUZZYSTRINGCOMPARATOR_H