. /include/boost/url /grammar /delim_rule.hpp
100.00% Lines (16/16) 100.00% Functions (5/5)
[ ] prev/next file n p prev/next uncovered line
TLA Baseline Branch
Line Hits Code Line Hits Code
1   // 1   //
2   // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) 2   // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
3   // Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.com) 3   // Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.com)
4   // 4   //
5   // Distributed under the Boost Software License, Version 1.0. (See accompanying 5   // Distributed under the Boost Software License, Version 1.0. (See accompanying
6   // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6   // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7   // 7   //
8   // Official repository: https://github.com/boostorg/url 8   // Official repository: https://github.com/boostorg/url
9   // 9   //
10   10  
11   #ifndef BOOST_URL_GRAMMAR_DELIM_RULE_HPP 11   #ifndef BOOST_URL_GRAMMAR_DELIM_RULE_HPP
12   #define BOOST_URL_GRAMMAR_DELIM_RULE_HPP 12   #define BOOST_URL_GRAMMAR_DELIM_RULE_HPP
13   13  
14   #include <boost/url/detail/config.hpp> 14   #include <boost/url/detail/config.hpp>
15   #include <boost/core/detail/string_view.hpp> 15   #include <boost/core/detail/string_view.hpp>
16   #include <boost/url/grammar/charset.hpp> 16   #include <boost/url/grammar/charset.hpp>
17   #include <boost/url/grammar/error.hpp> 17   #include <boost/url/grammar/error.hpp>
18   #include <boost/url/grammar/type_traits.hpp> 18   #include <boost/url/grammar/type_traits.hpp>
19   #include <type_traits> 19   #include <type_traits>
20   20  
21   namespace boost { 21   namespace boost {
22   namespace urls { 22   namespace urls {
23   namespace grammar { 23   namespace grammar {
24   24  
25   namespace implementation_defined { 25   namespace implementation_defined {
26   struct ch_delim_rule 26   struct ch_delim_rule
27   { 27   {
28   using value_type = core::string_view; 28   using value_type = core::string_view;
29   29  
30   constexpr 30   constexpr
HITCBC 31   48364 ch_delim_rule(char ch) noexcept 31   48368 ch_delim_rule(char ch) noexcept
HITCBC 32   48364 : ch_(ch) 32   48368 : ch_(ch)
33   { 33   {
HITCBC 34   48364 } 34   48368 }
35   35  
36   BOOST_URL_CXX20_CONSTEXPR 36   BOOST_URL_CXX20_CONSTEXPR
37   system::result<value_type> 37   system::result<value_type>
38   parse( 38   parse(
39   char const*& it, 39   char const*& it,
40   char const* end) const noexcept; 40   char const* end) const noexcept;
41   41  
42   private: 42   private:
43   char ch_; 43   char ch_;
44   }; 44   };
45   } // implementation_defined 45   } // implementation_defined
46   46  
47   /** Match a character literal 47   /** Match a character literal
48   48  
49   This matches the specified character. 49   This matches the specified character.
50   The value is a reference to the character 50   The value is a reference to the character
51   in the underlying buffer, expressed as a 51   in the underlying buffer, expressed as a
52   `core::string_view`. The function @ref squelch 52   `core::string_view`. The function @ref squelch
53   may be used to turn this into `void` instead. 53   may be used to turn this into `void` instead.
54   If there is no more input, the error code 54   If there is no more input, the error code
55   @ref error::need_more is returned. 55   @ref error::need_more is returned.
56   56  
57   @par Value Type 57   @par Value Type
58   @code 58   @code
59   using value_type = core::string_view; 59   using value_type = core::string_view;
60   @endcode 60   @endcode
61   61  
62   @par Example 62   @par Example
63   Rules are used with the function @ref parse. 63   Rules are used with the function @ref parse.
64   @code 64   @code
65   system::result< core::string_view > rv = parse( ".", delim_rule('.') ); 65   system::result< core::string_view > rv = parse( ".", delim_rule('.') );
66   @endcode 66   @endcode
67   67  
68   @par BNF 68   @par BNF
69   @code 69   @code
70   char = %00-FF 70   char = %00-FF
71   @endcode 71   @endcode
72   72  
73   @param ch The character to match 73   @param ch The character to match
74   @return A rule which matches the character. 74   @return A rule which matches the character.
75   75  
76   @see 76   @see
77   @ref parse, 77   @ref parse,
78   @ref squelch. 78   @ref squelch.
79   */ 79   */
80   constexpr 80   constexpr
81   implementation_defined::ch_delim_rule 81   implementation_defined::ch_delim_rule
HITCBC 82   48364 delim_rule( char ch ) noexcept 82   48368 delim_rule( char ch ) noexcept
83   { 83   {
HITCBC 84   48364 return {ch}; 84   48368 return {ch};
85   } 85   }
86   86  
87   //------------------------------------------------ 87   //------------------------------------------------
88   88  
89   namespace implementation_defined { 89   namespace implementation_defined {
90   template<class CharSet> 90   template<class CharSet>
91   struct cs_delim_rule 91   struct cs_delim_rule
92   { 92   {
93   using value_type = core::string_view; 93   using value_type = core::string_view;
94   94  
95   constexpr 95   constexpr
HITCBC 96   3 cs_delim_rule( 96   3 cs_delim_rule(
97   CharSet const& cs) noexcept 97   CharSet const& cs) noexcept
98   : cs_(cs) 98   : cs_(cs)
99   { 99   {
HITCBC 100   3 } 100   3 }
101   101  
102   system::result<value_type> 102   system::result<value_type>
HITCBC 103   948 parse( 103   948 parse(
104   char const*& it, 104   char const*& it,
105   char const* end) const noexcept 105   char const* end) const noexcept
106   { 106   {
HITCBC 107   948 if(it == end) 107   948 if(it == end)
108   { 108   {
109   // end 109   // end
HITCBC 110   1 BOOST_URL_RETURN_EC( 110   1 BOOST_URL_RETURN_EC(
111   error::need_more); 111   error::need_more);
112   } 112   }
HITCBC 113   947 if(! cs_(*it)) 113   947 if(! cs_(*it))
114   { 114   {
115   // wrong character 115   // wrong character
HITCBC 116   398 BOOST_URL_RETURN_EC( 116   398 BOOST_URL_RETURN_EC(
117   error::mismatch); 117   error::mismatch);
118   } 118   }
HITCBC 119   1098 return core::string_view{ 119   1098 return core::string_view{
HITCBC 120   549 it++, 1 }; 120   549 it++, 1 };
121   } 121   }
122   122  
123   private: 123   private:
124   CharSet cs_; 124   CharSet cs_;
125   }; 125   };
126   } // implementation_defined 126   } // implementation_defined
127   127  
128   /** Match a single character from a character set 128   /** Match a single character from a character set
129   129  
130   This matches exactly one character which 130   This matches exactly one character which
131   belongs to the specified character set. 131   belongs to the specified character set.
132   The value is a reference to the character 132   The value is a reference to the character
133   in the underlying buffer, expressed as a 133   in the underlying buffer, expressed as a
134   `core::string_view`. The function @ref squelch 134   `core::string_view`. The function @ref squelch
135   may be used to turn this into `void` instead. 135   may be used to turn this into `void` instead.
136   If there is no more input, the error code 136   If there is no more input, the error code
137   @ref error::need_more is returned. 137   @ref error::need_more is returned.
138   138  
139   @par Value Type 139   @par Value Type
140   @code 140   @code
141   using value_type = core::string_view; 141   using value_type = core::string_view;
142   @endcode 142   @endcode
143   143  
144   @par Example 144   @par Example
145   Rules are used with the function @ref parse. 145   Rules are used with the function @ref parse.
146   @code 146   @code
147   system::result< core::string_view > rv = parse( "X", delim_rule( alpha_chars ) ); 147   system::result< core::string_view > rv = parse( "X", delim_rule( alpha_chars ) );
148   @endcode 148   @endcode
149   149  
150   @param cs The character set to use. 150   @param cs The character set to use.
151   @return A rule which matches a single character from the set. 151   @return A rule which matches a single character from the set.
152   152  
153   @see 153   @see
154   @ref alpha_chars, 154   @ref alpha_chars,
155   @ref parse, 155   @ref parse,
156   @ref squelch. 156   @ref squelch.
157   */ 157   */
158   template<BOOST_URL_CONSTRAINT(CharSet) CS> 158   template<BOOST_URL_CONSTRAINT(CharSet) CS>
159   constexpr 159   constexpr
160   typename std::enable_if< 160   typename std::enable_if<
161   ! std::is_convertible< 161   ! std::is_convertible<
162   CS, char>::value, 162   CS, char>::value,
163   implementation_defined::cs_delim_rule<CS>>::type 163   implementation_defined::cs_delim_rule<CS>>::type
HITCBC 164   3 delim_rule( 164   3 delim_rule(
165   CS const& cs) noexcept 165   CS const& cs) noexcept
166   { 166   {
167   // If you get a compile error here it 167   // If you get a compile error here it
168   // means that your type does not meet 168   // means that your type does not meet
169   // the requirements for a CharSet. 169   // the requirements for a CharSet.
170   // Please consult the documentation. 170   // Please consult the documentation.
171   static_assert( 171   static_assert(
172   is_charset<CS>::value, 172   is_charset<CS>::value,
173   "CharSet requirements not met"); 173   "CharSet requirements not met");
174   174  
HITCBC 175   3 return implementation_defined::cs_delim_rule<CS>(cs); 175   3 return implementation_defined::cs_delim_rule<CS>(cs);
176   } 176   }
177   177  
178   } // grammar 178   } // grammar
179   } // urls 179   } // urls
180   } // boost 180   } // boost
181   181  
182   #include <boost/url/grammar/impl/delim_rule.hpp> 182   #include <boost/url/grammar/impl/delim_rule.hpp>
183   183  
184   #endif 184   #endif