basic_view.hpp

Go to the documentation of this file.

/// \file jsonv/detail/basic_view.hpp
///
/// Copyright (c) 2014-2020 by Travis Gockel. All rights reserved.
///
/// This program is free software: you can redistribute it and/or modify it under the terms of the Apache License
/// as published by the Apache Software Foundation, either version 2 of the License, or (at your option) any later
/// version.
///
/// \author Travis Gockel (travis@gockelhut.com)
#pragma once
 
#include <jsonv/config.hpp>
 
#include <iterator>
#include <utility>
 
namespace jsonv::detail
{
 
/// A view template used for array and object views of a \c value. This class allows traversing a \c value with a range
/// based for loop.
///
/// \note
/// A view does nothing to preserve the lifetime of the underlying container, nor does it remain valid if the container
/// is modified.
template <typename TIterator,
          typename TConstIterator = TIterator
         >
class basic_view
{
public:
    typedef TIterator                                           iterator;
    typedef TConstIterator                                      const_iterator;
    typedef std::reverse_iterator<iterator>                     reverse_iterator;
    typedef std::reverse_iterator<const_iterator>               const_reverse_iterator;
    typedef typename std::iterator_traits<iterator>::value_type value_type;
    typedef typename std::iterator_traits<iterator>::reference  reference;
    typedef typename std::iterator_traits<iterator>::pointer    pointer;
 
public:
    basic_view(iterator begin_, iterator end_) :
            _begin(begin_),
            _end(end_)
    { }
 
    iterator       begin()       { return _begin; }
    const_iterator begin() const { return _begin; }
    iterator       end()         { return _end; }
    const_iterator end() const   { return _end; }
 
    const_iterator cbegin() const { return _begin; }
    const_iterator cend()   const { return _end; }
 
    reverse_iterator       rbegin()       { return reverse_iterator(end()); };
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    reverse_iterator       rend()         { return reverse_iterator(begin()); }
    const_reverse_iterator rend() const   { return reverse_iterator(begin()); }
 
    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator crend() const   { return reverse_iterator(begin()); }
 
private:
    iterator _begin;
    iterator _end;
};
 
/// Something that owns an object. Used in basic_owning_view to move the value somewhere fixed before getting the
/// itertors and constructing the base.
template <typename T>
class basic_owner
{
public:
    explicit basic_owner(T&& x) :
            _value(std::move(x))
    { }
 
protected:
    T _value;
};
 
/// A form of basic_view that owns the object it is iterating over.
template <typename TContainer,
          typename TIterator,
          typename TConstIterator = TIterator
         >
class basic_owning_view :
        private basic_owner<TContainer>,
        public basic_view<TIterator, TConstIterator>
{
    using basic_owner<TContainer>::_value;
 
public:
    template <typename FBegin, typename FEnd>
    basic_owning_view(TContainer&& container, FBegin begin, FEnd end) :
            basic_owner<TContainer>(std::move(container)),
            basic_view<TIterator, TConstIterator>(begin(_value), end(_value))
    { }
};
 
}