range.hpp

Go to the documentation of this file.

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use these files except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Copyright 2012 - Gonzalo Iglesias, Adrià de Gispert, William Byrne

#ifndef RANGEIMPLEMENTATIONS_HPP
#define RANGEIMPLEMENTATIONS_HPP

namespace HifstConstants {
const std::string kRange = "range";
const std::string kRangeOne = "one";
const std::string kRangeInfinite = "infinite";
}

namespace ucam {
namespace util {

template<typename NumberType>
inline void getRange ( const std::string& range, std::vector<NumberType>& x ) {
  std::vector<std::string> aux;
  boost::algorithm::split ( aux, range, boost::algorithm::is_any_of ( "," ) );
  for ( uint i = 0; i < aux.size(); ++i ) {
    std::string& s = aux[i];
    if ( !exists ( s, ":" ) ) {
      x.push_back ( toNumber<NumberType> ( s ) );
      continue;
    }
    std::vector<std::string> range_aux;
    boost::algorithm::split ( range_aux, s, boost::algorithm::is_any_of ( ":" ) );
    USER_CHECK ( range_aux.size()
                 && range_aux.size() <= 3, "string range incorrectly defined!" );
    NumberType jump = 1;
    if ( range_aux.size() == 3 ) jump = toNumber<NumberType> ( range_aux[1] );
    NumberType start = toNumber<NumberType> ( range_aux[0] );
    NumberType  end = toNumber<NumberType> ( range_aux[range_aux.size() - 1] );
    for ( NumberType k = start; k <= end; k += jump ) {
      x.push_back ( k );
    }
  }
};

template<class NumberType>
class NumberRangeInterface {
 public:
  virtual void next ( void ) = 0;
  virtual bool done ( void ) = 0;
  virtual void start ( void ) = 0;
  virtual NumberType get ( void ) = 0;
  virtual ~NumberRangeInterface() {};
};

template<class NumberType = uint>
class NumberRange : public NumberRangeInterface<NumberType> {
 private:
  std::vector<NumberType> range_;
  uint k_;
 public:
  NumberRange ( const std::vector<NumberType>& r ) : range_ ( r ), k_ ( 0 ) {};

  NumberRange ( const RegistryPO& rg ,
                const std::string& rangekey = HifstConstants::kRange) : k_ ( 0 ) {
    getRange ( rg.get<std::string> ( rangekey ), range_ );
  };

  NumberRange ( const std::string& range) : k_ ( 0 ) {
    getRange ( range , range_ );
  };

  inline void start ( void ) {
    k_ = 0;
  };
  inline void next ( void ) {
    if ( !done() ) ++k_;
  };
  inline bool done ( void ) {
    return k_ >= range_.size();
  };
  inline NumberType get ( void ) {
    return range_.at ( k_ );
  };
  inline NumberType operator() ( void ) {
    return range_.at ( k_ );
  };

 private:

  DISALLOW_COPY_AND_ASSIGN ( NumberRange );

};

template <typename NumberType>
class OneRange : public NumberRangeInterface<NumberType> {
 private:
  NumberType sid_;
  bool state_;
 public:
  OneRange ( const NumberType u = 0 ) : sid_ ( u ) , state_ ( false ) {};
  inline void start ( void ) {
    state_ = false;
  };
  inline void next ( void ) {
    state_ = true;
  };

  inline bool done ( void ) {
    return state_;
  };
  inline NumberType get ( void ) {
    return sid_;
  };

 private:
  DISALLOW_COPY_AND_ASSIGN ( OneRange );

};

template<typename NumberType = uint >
class InfiniteRange : public NumberRangeInterface<NumberType> {
 private:
  NumberType sid_;
 public:
  InfiniteRange ( const NumberType u = 1 ) : sid_ ( u ) {};
  inline void start ( void ) {};
  inline void next ( void ) {
    ++sid_;
  };

  inline bool done ( void ) {
    return false;
  };
  inline NumberType get ( void ) {
    return sid_;
  };

 private:
  DISALLOW_COPY_AND_ASSIGN ( InfiniteRange );

};

template<typename NumberType>
NumberRangeInterface<NumberType>* RangeInitFactory ( const RegistryPO& rg ,
    const std::string& option = HifstConstants::kRangeInfinite ) {
  if ( !rg.exists ( HifstConstants::kRange ) )
    if ( option == HifstConstants::kRangeInfinite )
      return new InfiniteRange<NumberType>();
  //this range will never break
    else if ( option == HifstConstants::kRangeOne )
      return new OneRange<NumberType>();
  //Just run once if range not specified
  return new NumberRange<NumberType> ( rg );
};

#define IntRangeFactory RangeInitFactory<unsigned>
typedef boost::scoped_ptr < NumberRangeInterface<unsigned> > IntRangePtr;

}
}  // end namespaces

#endif