chilon Code

#ifndef CHILON_ITERATOR_RANGE_HPP
#define CHILON_ITERATOR_RANGE_HPP

#include <chilon/meta/return.hpp>

// allow boost to hash these ranges
#include <boost/functional/hash/hash.hpp>

#include <iostream>
#include <iterator>
#include <string>

namespace chilon {

template <class T>
static inline auto begin(T&& t) CHILON_RETURN(std::forward<T>(t).begin())

template <class T>
static inline auto end(T&& t) CHILON_RETURN(std::forward<T>(t).end())

static inline char const * const begin(char const *str) {
    return str;
}

static inline char const * end(char const *str) {
    while ('\0' != *str) ++str;
    return str;
}

static inline char * end(char *str) {
    while ('\0' != *str) ++str;
    return str;
}

/**
 * @brief This class represents an iterator_range much like boost::iterator_range.
 * @detailed This iterator_range provides all of the functionality of boost::iterator_range
 *           but in addition allows easier modification of the range through
 *           references for begin/end in addition to .assign
 * @tparam   Iterator type for iterators to begin/end of range.
 */
template <class Iterator>
struct iterator_range {
    typedef typename std::iterator_traits<Iterator>::value_type          value_type;
    typedef typename std::iterator_traits<Iterator>::reference           reference;
    typedef typename std::iterator_traits<Iterator>::difference_type     difference_type;
    typedef typename std::iterator_traits<Iterator>::pointer             pointer;
    typedef typename std::iterator_traits<Iterator>::iterator_category   iterator_category;
    typedef Iterator    iterator;
    typedef Iterator    const_iterator;

    void assign(iterator const& begin, iterator const& end) {
        begin_ = begin;
        end_ = end;
    }

    std::size_t size()  const { return end_ - begin_; }
    bool        empty() const { return begin_ >= end_; }
    void        advance()               { ++begin_; }
    void        advance(int const size) { begin_ += size; }
    bool        same(char const * const ptr) const { return begin_ = ptr; }
    bool        end(iterator const candidate) const { return candidate == end_; }

    iterator    begin() const { return begin_; }
    iterator    end()   const { return end_; }
    iterator&   begin()       { return begin_; }
    iterator&   end()         { return end_; }
    reference   front() const { return *begin_; }
    reference   back()  const { return *(end_ - 1); }

    template <class T>
    friend std::ostream& operator<<(std::ostream &os, iterator_range<T> const& self);

    template <class T>
    bool operator==(T const& rhs) const {
        return size() == rhs.size() && std::equal(begin_, end_, rhs.begin());
    }

    bool operator==(char const * const str) const {
        return std::equal(begin_, end_, str) && str[end_ - begin_] == '\0';
    }

    bool operator==(std::string const &str) const {
        return size() == str.size() && std::equal(begin_, end_, str.begin());
    }

    template <class T>
    bool operator<(T const& rhs) const {
        auto it = begin();
        auto rhs_it = chilon::begin(rhs);
        auto rhs_end = chilon::end(rhs);

        for (;;) {
            if (*it < *rhs_it) return true;
            else if (*it != *rhs_it) return false;
            else if (++rhs_it == rhs_end) return false;
            else if (++it == end()) return true;
        }
    }

    template <class T>
    bool operator!=(T const& rhs) const {
        return ! (*this == rhs);
    }

    template <class T>
    void operator=(T const& rhs) {
        begin_ = rhs.begin();
        end_ = rhs.end();
    }

    reference operator[](difference_type const idx) const {
        return begin_[idx];
    }

    // iterator_range can be converted into a string
    operator std::string() const {
        return std::string(begin_, end_);
    }

    iterator_range(iterator const& begin, iterator const& end) : begin_(begin), end_(end) {}
    iterator_range(iterator const& end) : begin_(end), end_(end) {}
    iterator_range(std::string const& str) : begin_(str.begin()), end_(str.end()) {}
    // TODO: find default null type
    iterator_range() : begin_(0), end_(0) {}
  protected:
    iterator  begin_;
    iterator  end_;
};

template <class T>
std::ostream& operator<<(std::ostream &os, iterator_range<T> const& self) {
    std::copy(self.begin_, self.end_,
              std::ostream_iterator<typename iterator_range<T>::value_type>(os));
    return os;
}

template <class T>
bool operator==(std::string const &str, iterator_range<T> const& self) {
    return ! str.compare(0, str.size(), self.begin(), 0, self.size());
}

////////////////////////////////////////////////////////////////////////////////
typedef iterator_range<char const *>                range;
typedef iterator_range<std::string::const_iterator> string_range;
typedef iterator_range<std::string::iterator>       mutable_string_range;

static inline range to_range(char const * const str) {
    return range(str, end(str));
    return str;
}

template <class T>
std::size_t inline hash_value(chilon::iterator_range<T> const& arg) {
    return boost::hash_range(arg.begin(), arg.end());
}

}

namespace std {
    template <class T>
    struct hash<chilon::iterator_range<T>> {
        std::size_t operator()(chilon::iterator_range<T> const& arg) const {
            return chilon::hash_value(arg);
        }
    };
}

#endif