EIC code displayed by LXR master/​include/​boost/​spirit/​home/​support/​iterators/​line_pos_iterator.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-19 09:47:51

 /*==============================================================================
     Copyright (c) 2001-2011 Joel de Guzman
     Copyright (c) 2010      Bryce Lelbach
     Copyright (c) 2014      Tomoki Imai
     Copyright (c) 2023      Kniazev Nikita
     Copyright (c) 2023      Tobias Loew
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
 #if !defined(BOOST_SPIRIT_SUPPORT_LINE_POS_ITERATOR)
 #define BOOST_SPIRIT_SUPPORT_LINE_POS_ITERATOR
 
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/range/iterator_range_core.hpp>
 #include <iterator>
 
 namespace boost { namespace spirit
 {
     //[line_pos_iterator_class
     /*`The `line_pos_iterator` is a lightweight line position iterator.
        This iterator adapter only stores the current line number, nothing else.
        Unlike __classic__'s `position_iterator`, it does not store the
        column number and does not need an end iterator. The current column can
        be computed, if needed.
        NOTE: line counting considers position inside multicharacter line-breaks
        (such as CRLF and LFCR) as being on the next line already. */
     //`[heading Class Reference]
     template <class Iterator>
     class line_pos_iterator : public boost::iterator_adaptor<
         line_pos_iterator<Iterator>  // Derived
       , Iterator                     // Base
       , boost::use_default           // Value
       , boost::forward_traversal_tag // CategoryOrTraversal
     > {
     public:
         line_pos_iterator();
 
         explicit line_pos_iterator(Iterator, std::size_t line_start = 1);
 
         std::size_t position() const;
 
     private:
         friend class boost::iterator_core_access;
 
         void increment();
 
         std::size_t line; // The line position.
         bool prev_n;
         bool prev_r;
     };
     //]
 
     template <class Iterator>
     line_pos_iterator<Iterator>::line_pos_iterator() :
         line_pos_iterator::iterator_adaptor_(), line(1), prev_n(), prev_r() { }
 
     template <class Iterator>
     line_pos_iterator<Iterator>::line_pos_iterator(Iterator base, std::size_t line_start /* = 1 */ ) :
         line_pos_iterator::iterator_adaptor_(base), line(line_start), prev_n(), prev_r() { }
 
     template <class Iterator>
     std::size_t line_pos_iterator<Iterator>::position() const
     {
         return line;
     }
  
     template<class Iterator>
     void line_pos_iterator<Iterator>::increment()
     {
         typename std::iterator_traits<Iterator>::reference
           ch = *(this->base());
       
         int newline = ((ch == '\n') & !prev_r) | ((ch == '\r') & !prev_n);
         line += newline;
         prev_r = (ch == '\r') & newline;
         prev_n = (ch == '\n') & newline;
 
         ++this->base_reference();
     }
 
     //[line_pos_iterator_utilities
     //`[heading get_line]
     template <class Iterator>
     inline std::size_t get_line(Iterator);
     /*`Get the line position. Returns -1 if Iterator is not a
        `line_pos_iterator`. */
 
     //`[heading get_line_start]
     template <class Iterator>
     inline Iterator get_line_start(Iterator lower_bound, Iterator current); 
     /*`Get an iterator to the beginning of the line. Applicable to any
        iterator. */
 
     //`[heading get_line_end]
     template <class Iterator>
     inline Iterator get_line_end(Iterator current, Iterator upper_bound);
     /*`Get an iterator to the end of the line. Applicable to any
        iterator. */
 
     //`[heading get_current_line]
     template <class Iterator>
     inline iterator_range<Iterator>
     get_current_line(Iterator lower_bound, Iterator current,
                      Iterator upper_bound); 
     /*`Get an `iterator_range` containing the current line. Applicable to any
        iterator. */ 
 
     //`[heading get_column]
     template <class Iterator>
     inline std::size_t get_column(Iterator lower_bound, Iterator current,
                                   std::size_t tabs = 4); 
     /*`Get the current column. Applicable to any iterator. */ 
     //]
 
     template <class Iterator>
     inline std::size_t get_line(Iterator)
     {
         return -1;
     }
     
     template <class Iterator>
     inline std::size_t get_line(line_pos_iterator<Iterator> i)
     {
         return i.position();
     }
 
     namespace detail {
         // get_line_start for forward iterators: forward linear search starting from lower-bound
         // complexity: linear in length of [lower_bound, current)
         template <class Iterator>
         inline Iterator get_line_start(Iterator lower_bound,
                                        Iterator current, 
                                        std::forward_iterator_tag)
         {
             Iterator latest = lower_bound;
             for (Iterator it = lower_bound; it != current; ) {
                 if ((*it == '\r') || (*it == '\n')) {
                     latest = ++it;
                 }
                 else {
                     ++it;
                 }
             }
             return latest;
         }
 
         // get_line_start for forward iterators: backward linear search starting from current
         // complexity: linear in avarage line-length
         template <class Iterator>
         inline Iterator get_line_start(Iterator lower_bound,
                                        Iterator current,
                                        std::bidirectional_iterator_tag)
         {
             while (current != lower_bound) {
                 --current;
                 if ((*current == '\r') || (*current == '\n')) {
                     return ++current;
                 }
             }
             return current;
         }
     }
 
     template <class Iterator>
     inline Iterator get_line_start(Iterator lower_bound, Iterator current)
     {
         return detail::get_line_start(
             lower_bound,
             current,
             typename std::iterator_traits<Iterator>::iterator_category()
         );
     }
 
     template <class Iterator>
     inline line_pos_iterator<Iterator>
     get_line_start(line_pos_iterator<Iterator> lower_bound,
                    line_pos_iterator<Iterator> current)
     {
         // No need in line number counting because it will be the same
         Iterator it = get_line_start(lower_bound.base(), current.base());
         return line_pos_iterator<Iterator>(it, current.position());
     }
 
     template <class Iterator>
     inline Iterator get_line_end(Iterator current, Iterator upper_bound)
     {
         for (Iterator i = current; i != upper_bound; ++i) {
             if ((*i == '\n') || (*i == '\r')) {
                 return i;
             }
         }
         return upper_bound;
     }
 
     template <class Iterator>
     inline line_pos_iterator<Iterator>
     get_line_end(line_pos_iterator<Iterator> current,
                  line_pos_iterator<Iterator> upper_bound)
     {
         // No need in line number counting because it will be the same
         Iterator it = get_line_end(current.base(), upper_bound.base());
         return line_pos_iterator<Iterator>(it, current.position());
     }
     
     template <class Iterator>
     inline iterator_range<Iterator>
     get_current_line(Iterator lower_bound,
                      Iterator current,
                      Iterator upper_bound)
     {
         Iterator first = get_line_start(lower_bound, current);
         Iterator last = get_line_end(current, upper_bound);
         return iterator_range<Iterator>(first, last);
     }
 
     template <class Iterator>
     inline std::size_t get_column(Iterator lower_bound,
                                   Iterator current,
                                   std::size_t tabs)
     {
         std::size_t column = 1;
         Iterator first = get_line_start(lower_bound, current);
       
         for (Iterator i = first; i != current; ++i) {
           switch (*i) {
             case '\t':
               column += tabs - (column - 1) % tabs;
               break;
             default:
               ++column;
           }
         }
       
         return column;
     }
 
     template <class Iterator>
     inline std::size_t get_column(line_pos_iterator<Iterator> lower_bound,
                                   line_pos_iterator<Iterator> current,
                                   std::size_t tabs = 4)
     {
         return get_column(lower_bound.base(), current.base(), tabs);
     }
 
 }}
 
 #endif // BOOST_SPIRIT_SUPPORT_LINE_POS_ITERATOR
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team