JLimit.hh

Go to the documentation of this file.

#ifndef __JSUPPORT__JLIMIT__
#define __JSUPPORT__JLIMIT__
 
#include <limits>
#include <string>
#include <istream>
#include <ostream>
#include <sstream>
 
#include "JROOT/JCounter.hh"
 
#include "JTools/JRange.hh"
#include "JLang/JComparable.hh"
 
 
/**
 * \file
 * Auxiliaries for defining the range of iterations of objects.
 * \author mdejong
 */
namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }
 
namespace JSUPPORT {
 
  using JTOOLS::JRange;
  using JLANG::JComparable;
  using JROOT::counter_type;
  
  
  /**
   * Auxiliary class for defining the range of iterations of objects.
   *
   * Possible input syntax:
   * <pre>
   *     <begin of iteration>:<number of iterations>
   *     <number of iterations>
   * </pre>
   * where the iteration starts at 0.
   */
  struct JLimit :
    public JRange<counter_type>,
    public JComparable<JLimit>,
    public JComparable<JLimit, counter_type>
  {
 
    typedef JRange<counter_type>            range_type;
 
    
    /**
     * Default constructor.
     */
    JLimit() :
      JRange<counter_type>(JLimit::min(), JLimit::max())
    {}
 
 
    /**
     * Constructor.
     *
     * \param  counter      number of entries
     */
    JLimit(const counter_type counter) :
      JRange<counter_type>(JLimit::min(), counter)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  lower        lower limit
     * \param  upper        upper limit
     */
    JLimit(const counter_type lower, const counter_type upper) :
      JRange<counter_type>(lower, upper)
    {}
 
 
    /**
     * Get limit.
     *
     * \return              this limit
     */
    const JLimit& getLimit() const
    { 
      return static_cast<const JLimit&>(*this);
    }
 
 
    /**
     * Get limit.
     *
     * \return              this limit
     */
    JLimit& getLimit()
    {
      return static_cast<JLimit&>(*this);
    }
 
 
    /**
     * Set limit.
     *
     * \param  limit        limit
     */
    void setLimit(const JLimit& limit)
    {
      static_cast<JLimit&>(*this) = limit;
    }
 
 
    /**
     * Get minimum counter value.
     *
     * \return              value
     */
    static counter_type min()
    {
      return 0;
    }
 
 
    /**
     * Get maximum counter value.
     *
     * \return              value
     */
    static counter_type max()
    {
      return std::numeric_limits<counter_type>::max();
    }
 
 
    /**
     * Compare limit.
     *
     * \param  limit        limit
     * \return              true if this upper limit is less then given upper limit; else false
     */
    bool less(const JLimit& limit) const
    { 
      return getUpperLimit() < limit.getUpperLimit();
    }
 
 
    /**
     * Compare counter.
     *
     * \param  counter      counter
     * \return              true if this upper limit is less than counter; else false
     */
    bool less(const counter_type counter) const
    { 
      return getUpperLimit() < counter;
    }
 
 
    /**
     * Compare counter.
     *
     * \param  counter      counter
     * \return              true if this upper limit is more than counter; else false
     */
    bool more(const counter_type counter) const
    { 
      return getUpperLimit() > counter;
    }
 
 
    /**
     * Read limit from input.
     *
     * Note that input <tt>n</tt> will set the begin and end of the iteration to <tt>0</tt> and <tt>n</tt>, respectively;
     * and input <tt>i:n</tt> will set the begin and end of the iteration to <tt>i</tt> and <tt>i+n</tt>, respectively.
     *
     * \param  in            input stream
     * \param  limit         limit
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JLimit& limit)
    {
      using namespace std;
 
      limit.setLowerLimit(JLimit::min());
      limit.setUpperLimit(JLimit::max());
 
      string buffer;
 
      if (in >> buffer) {
 
        string::size_type pos = buffer.find(SEPARATOR);
 
        if (pos != string::npos) {
          
          buffer[pos] = ' ';
 
          istringstream is(buffer);
          
          if (is >> static_cast<range_type&>(limit)) {
            limit.setUpperLimit(limit.getLowerLimit() + limit.getUpperLimit());
          }
 
        } else {
 
          counter_type value;
          
          istringstream is(buffer);
 
          is >> value;
 
          limit.setUpperLimit(value);
        }
      }
 
      return in;
    }
 
    
    static const char SEPARATOR = ':';    //!< separator between values
  };
 
 
  /**
   * Type definition of limit.
   */
  typedef JLimit                    JLimit_t;
}
 
#endif