ComparatorUtils.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-2020.
//
// 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: $
// --------------------------------------------------------------------------
 
 
#pragma once
 
#include <functional>
 
namespace OpenMS
{
 
  template <class Cmp>
  struct PointerComparator :
    public std::binary_function<typename Cmp::first_argument_type *, typename Cmp::second_argument_type *, typename Cmp::result_type>
  {
    PointerComparator(PointerComparator const & pCmp) :
      cmp_(pCmp.cmp_)
    {}
    PointerComparator(Cmp const & cmp = Cmp()) :
      cmp_(cmp)
    {}
 
    template <typename T1, typename T2>
    typename Cmp::result_type
    operator()(T1 left, T2 right) const
    {
      return cmp_(*left, *right);          // T must have operator* defined
    }
 
protected:
    Cmp const & cmp_;
  };
 
  template <class Cmp>
  PointerComparator<Cmp> pointerComparator(Cmp const & cmp)
  {
    return PointerComparator<Cmp>(cmp);
  }
 
  template <class Cmp>
  struct ReverseComparator :
    std::binary_function<typename Cmp::second_argument_type, typename Cmp::first_argument_type, typename Cmp::result_type>
    // (Note that here we must reverse the order of template args!)
  {
    ReverseComparator(ReverseComparator const & cmp) :
      cmp_(cmp.cmp_) {}
 
    ReverseComparator(Cmp const & cmp = Cmp()) :
      cmp_(cmp) {}
 
    template <typename T1, typename T2>
    typename Cmp::result_type
    operator()(T1 left, T2 right) const
    {
      return cmp_(right, left);          // the other way round
    }
 
protected:
    Cmp const & cmp_;
  };
 
  template <class Cmp>
  ReverseComparator<Cmp> reverseComparator(Cmp const & cmp)
  {
    return ReverseComparator<Cmp>(cmp);
  }
 
  template <typename Cmp1, typename Cmp2>
  struct LexicographicComparator :
    std::binary_function<typename Cmp1::first_argument_type, typename Cmp1::second_argument_type, bool>
  {
    LexicographicComparator(Cmp1 const & cmp1 = Cmp1(), Cmp2 const & cmp2 = Cmp2()) :
      cmp1_(cmp1), cmp2_(cmp2) {}
 
    template <typename T1, typename T2>
    bool
    operator()(T1 left, T2 right) const
    {
      if (cmp1_(left, right))
      {
        return true;
      }
      else
      {
        if (cmp1_(right, left))
        {
          return false;
        }
        else
        {
          return cmp2_(left, right);
        }
      }
    }
 
protected:
    Cmp1 const & cmp1_;
    Cmp2 const & cmp2_;
  };
 
  template <typename Cmp1, typename Cmp2>
  LexicographicComparator<Cmp1, Cmp2> lexicographicComparator(Cmp1 const & cmp1, Cmp2 const & cmp2)
  {
    return LexicographicComparator<Cmp1, Cmp2>(cmp1, cmp2);
  }
 
  template <typename PairType>
  struct PairComparatorFirstElement :
    std::binary_function<PairType, PairType, bool>
  {
    bool operator()(const PairType & left, const PairType & right) const
    {
      return left.first < right.first;
    }
 
  };
 
  template <typename PairType>
  struct PairComparatorSecondElement :
    std::binary_function<PairType, PairType, bool>
  {
    bool operator()(const PairType & left, const PairType & right) const
    {
      return left.second < right.second;
    }
 
  };
 
  template <typename PairType>
  struct PairComparatorFirstElementMore :
    std::binary_function<PairType, PairType, bool>
  {
    bool operator()(const PairType & left, const PairType & right) const
    {
      return left.first > right.first;
    }
 
  };
 
  template <typename PairType>
  struct PairComparatorSecondElementMore :
    std::binary_function<PairType, PairType, bool>
  {
    bool operator()(const PairType & left, const PairType & right) const
    {
      return left.second > right.second;
    }
 
  };
 
  template <typename PairType>
  struct PairMatcherFirstElement :
    std::binary_function<PairType, PairType, bool>
  {
    bool operator()(const PairType & left, const PairType & right) const
    {
      return left.first == right.first;
    }
 
  };
 
  template <typename PairType>
  struct PairMatcherSecondElement :
    std::binary_function<PairType, PairType, bool>
  {
    bool operator()(const PairType & left, const PairType & right) const
    {
      return left.second == right.second;
    }
 
  };
 
  template <typename CompareType>
  struct EqualInTolerance :
    public std::binary_function<CompareType, CompareType, bool>
  {
    CompareType & tolerance;
 
    explicit EqualInTolerance(CompareType & c) :
      tolerance(c)
    {}
 
    bool operator()(CompareType i, CompareType j)
    {
      CompareType diff = fabs(i - j);
      return diff <= tolerance;
    }
 
  };
}