DistanceErrorRule.hpp

Go to the documentation of this file.

#ifndef __OPENTREP_DISTANCEERRORRULE_HPP
#define __OPENTREP_DISTANCEERRORRULE_HPP
 
// //////////////////////////////////////////////////////////////////////
// Import section
// //////////////////////////////////////////////////////////////////////
// STL
#include <istream>
#include <ostream>
#include <sstream>
#include <string>
#include <map>
// Boost Array
#include <boost/array.hpp>
// OpenTrep
#include <opentrep/OPENTREP_Types.hpp>
#include <opentrep/OPENTREP_Abstract.hpp>
 
namespace OPENTREP {
 
  // ////////////////////////////////////////////////////////////////////
  static const DistanceErrorScaleArray_T K_DEFAULT_ERROR_SCALE =
    { {3, 6, 9, 14, 19} };
 
 
  // ///////////////////////////////////////////////////////////////
  struct DistanceErrorRule : public OPENTREP_Abstract {
  public:
    // ///////// Getters ////////
    const DistanceErrorScale_T& getDistanceErrorScale() const {
      return _scale;
    }
    
    
    // ///////// Setters //////////
 
    
  public:
    // ///////// Business methods ////////
    NbOfErrors_T getAllowedDistanceError (const NbOfLetters_T& iNbOfLetters) const {
      NbOfErrors_T oNbOfErrors_T = 0;
 
      DistanceErrorScale_T::const_iterator itError =
        _scale.lower_bound (iNbOfLetters);
 
      if (itError != _scale.end()) {
        oNbOfErrors_T = itError->second;
        
      } else {
        oNbOfErrors_T = iNbOfLetters / 4;
      }
      
      return oNbOfErrors_T;
    }
    
    
  public:
    // ///////// Display methods ////////
    void toStream (std::ostream& ioOut) const {
      ioOut << toString();
    }

    void fromStream (std::istream&) {
    }

    std::string toShortString() const {
      std::ostringstream oStr;
      NbOfLetters_T idx = 0;
      for (DistanceErrorScale_T::const_iterator itError = _scale.begin();
           itError != _scale.end(); ++itError, ++idx) {
        if (idx != 0) {
          oStr << ", ";
        }
        oStr << itError->second << ": " << itError->first;
      }
      return oStr.str();
    }
    
    std::string toString() const {
      std::ostringstream oStr;
      oStr << toShortString();
      return oStr.str();
    }
 
    
  public:
    DistanceErrorRule (const DistanceErrorScale_T& iScale)
      : _scale (iScale) {
    }

    DistanceErrorRule (const NbOfErrors_T iSize,
                       const NbOfLetters_T iScaleArray[]) {
      for (NbOfErrors_T idx = 0; idx != iSize; ++idx) {
        _scale.insert (DistanceErrorScale_T::value_type (iScaleArray[idx],
                                                         idx));
      }
    }

    DistanceErrorRule (const DistanceErrorScaleArray_T& iScaleArray) {
      for (NbOfErrors_T idx = 0; idx != iScaleArray.size(); ++idx) {
        _scale.insert (DistanceErrorScale_T::value_type (iScaleArray[idx],
                                                         idx));
      }
    }
 
  private:
    DistanceErrorRule ();

    DistanceErrorRule (const DistanceErrorRule&);
    
    virtual ~DistanceErrorRule() {}
 
    
  private:
    // /////// Attributes /////////
    DistanceErrorScale_T _scale;
  };
 
}
#endif // __OPENTREP_DISTANCEERRORRULE_HPP