summaryrefslogtreecommitdiffstats
path: root/contrib/src/boost/algorithm/string/concept.hpp
blob: efc8d0feb721d3ef74e37bc41d323607ae1a7f34 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
//  Boost string_algo library concept.hpp header file  ---------------------------//


//  Copyright Pavol Droba 2002-2003.

//

// 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)


//  See http://www.boost.org/ for updates, documentation, and revision history.


#ifndef BOOST_STRING_CONCEPT_HPP

#define BOOST_STRING_CONCEPT_HPP


#include <boost/concept_check.hpp>

#include <boost/range/iterator_range_core.hpp>

#include <boost/range/begin.hpp>

#include <boost/range/end.hpp>


/*! \file 

    Defines concepts used in string_algo library

*/

namespace boost {
    namespace algorithm {

        //! Finder concept

        /*!

            Defines the Finder concept. Finder is a functor which selects

            an arbitrary part of a string. Search is performed on

            the range specified by starting and ending iterators.



            Result of the find operation must be convertible to iterator_range.

        */
        template<typename FinderT, typename IteratorT>
        struct FinderConcept
        {
        private:
            typedef iterator_range<IteratorT> range;
        public:
            void constraints()
            {
                // Operation

                r=(*pF)(i,i);
            }
        private:
            range r;
            IteratorT i;
            FinderT* pF;    
        }; // Finder_concept


        
        //! Formatter concept

        /*!

            Defines the Formatter concept. Formatter is a functor, which

            takes a result from a finder operation and transforms it

            in a specific way.



            Result must be a container supported by container_traits, 

            or a reference to it.

        */
        template<typename FormatterT, typename FinderT, typename IteratorT>
        struct FormatterConcept
        {
        public:
            void constraints()
            {
                // Operation

                ::boost::begin((*pFo)( (*pF)(i,i) ));
                ::boost::end((*pFo)( (*pF)(i,i) ));
            }
        private:
            IteratorT i;
            FinderT* pF;
            FormatterT *pFo;
        }; // FormatterConcept;


    } // namespace algorithm

} // namespace boost





#endif  // BOOST_STRING_CONCEPT_HPP