Line data Source code
1 : //
2 : // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
3 : //
4 : // Distributed under the Boost Software License, Version 1.0. (See accompanying
5 : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 : //
7 : // Official repository: https://github.com/boostorg/url
8 : //
9 :
10 : #ifndef BOOST_URL_GRAMMAR_RANGE_RULE_HPP
11 : #define BOOST_URL_GRAMMAR_RANGE_RULE_HPP
12 :
13 : #include <boost/url/detail/config.hpp>
14 : #include <boost/url/error.hpp>
15 : #include <boost/core/detail/string_view.hpp>
16 : #include <boost/url/grammar/parse.hpp>
17 : #include <boost/url/grammar/type_traits.hpp>
18 : #include <boost/url/grammar/detail/range_rule.hpp>
19 : #include <boost/core/detail/static_assert.hpp>
20 : #include <cstddef>
21 : #include <iterator>
22 : #include <type_traits>
23 : #include <utility>
24 : #include <stddef.h> // ::max_align_t
25 :
26 : namespace boost {
27 : namespace urls {
28 : namespace grammar {
29 : namespace implementation_defined {
30 : template<class R0, class R1>
31 : struct range_rule_t;
32 : } // implementation_defined
33 :
34 : namespace implementation_defined
35 : {
36 : template<class RangeRule, class = void>
37 : struct range_value_type
38 : {
39 : using type = void;
40 : };
41 :
42 : template<class RangeRule>
43 : struct range_value_type<
44 : RangeRule,
45 : urls::void_t<typename RangeRule::value_type>>
46 : {
47 : using type = typename RangeRule::value_type;
48 : };
49 :
50 : template<class RangeRule, class ValueType, class = void>
51 : struct is_range_rule : std::false_type
52 : {
53 : };
54 :
55 : template<class RangeRule, class ValueType>
56 : struct is_range_rule<
57 : RangeRule,
58 : ValueType,
59 : urls::void_t<
60 : decltype(std::declval<RangeRule const&>().first(
61 : std::declval<char const*&>(),
62 : std::declval<char const*>())),
63 : decltype(std::declval<RangeRule const&>().next(
64 : std::declval<char const*&>(),
65 : std::declval<char const*>()))>>
66 : : std::integral_constant<bool,
67 : std::is_same<
68 : decltype(std::declval<RangeRule const&>().first(
69 : std::declval<char const*&>(),
70 : std::declval<char const*>())),
71 : system::result<ValueType>>::value &&
72 : std::is_same<
73 : decltype(std::declval<RangeRule const&>().next(
74 : std::declval<char const*&>(),
75 : std::declval<char const*>())),
76 : system::result<ValueType>>::value>
77 : {
78 : };
79 : }
80 :
81 : template<class RangeRule>
82 : using is_range_rule = implementation_defined::is_range_rule<
83 : RangeRule,
84 : typename implementation_defined::range_value_type<
85 : RangeRule>::type>;
86 :
87 : #ifdef BOOST_URL_HAS_CONCEPTS
88 : template <class T>
89 : concept RangeRule =
90 : requires (T r, char const*& it, char const* end)
91 : {
92 : typename T::value_type;
93 : { r.first(it, end) } -> std::same_as<system::result<typename T::value_type>>;
94 : { r.next(it, end) } -> std::same_as<system::result<typename T::value_type>>;
95 : };
96 : #endif
97 :
98 : template<class T>
99 : class any_rule;
100 :
101 : template<class T>
102 : class any_rule
103 : {
104 : public:
105 : using value_type = T;
106 :
107 : any_rule() noexcept;
108 : any_rule(any_rule const&) noexcept;
109 : any_rule(any_rule&&) noexcept;
110 : any_rule& operator=(any_rule const&) noexcept;
111 : any_rule& operator=(any_rule&&) noexcept;
112 : ~any_rule();
113 :
114 : template<class R>
115 : explicit
116 : any_rule(R const& next);
117 :
118 : template<class R0, class R1>
119 : any_rule(
120 : R0 const& first,
121 : R1 const& next);
122 :
123 : system::result<T>
124 : first(
125 : char const*& it,
126 : char const* end) const noexcept;
127 :
128 : system::result<T>
129 : next(
130 : char const*& it,
131 : char const* end) const noexcept;
132 :
133 : private:
134 : static constexpr
135 : std::size_t BufferSize = 128;
136 :
137 : struct small_buffer
138 : {
139 : alignas(alignof(::max_align_t))
140 : unsigned char buf[BufferSize];
141 :
142 711 : void const* addr() const noexcept
143 : {
144 711 : return buf;
145 : }
146 :
147 2820 : void* addr() noexcept
148 : {
149 2820 : return buf;
150 : }
151 : };
152 :
153 : struct impl_base;
154 :
155 : template<class R, bool>
156 : struct impl1;
157 :
158 : template<
159 : class R0, class R1, bool>
160 : struct impl2;
161 :
162 : impl_base&
163 : get() noexcept;
164 :
165 : impl_base const&
166 : get() const noexcept;
167 :
168 : small_buffer sb_;
169 : };
170 :
171 : /** A forward range of parsed elements
172 :
173 : Objects of this type are forward ranges
174 : returned when parsing using the
175 : @ref range_rule.
176 : Iteration is performed by re-parsing the
177 : underlying character buffer. Ownership
178 : of the buffer is not transferred; the
179 : caller is responsible for ensuring that
180 : the lifetime of the buffer extends until
181 : it is no longer referenced by the range.
182 :
183 : @note
184 :
185 : The implementation may type-erase the
186 : rule responsible for iterating the
187 : underlying character buffer. Objects
188 : of type `range` are intended to be used
189 : ephemerally. That is, for short durations
190 : such as within a function scope. If it is
191 : necessary to store the range for a long
192 : period of time or with static storage
193 : duration, it is necessary to copy the
194 : contents to an object of a different type.
195 :
196 : @tparam T The value type of the range
197 : @tparam RangeRule The implementation used to
198 : iterate the range. The default is a
199 : type-erased rule.
200 :
201 : @see
202 : @ref parse,
203 : @ref range_rule.
204 : */
205 : template<
206 : class T,
207 : class RangeRule = any_rule<T>>
208 : class range
209 : : private detail::range_base_storage<
210 : RangeRule>
211 : {
212 : private:
213 : #ifdef BOOST_URL_HAS_CONCEPTS
214 : static_assert(
215 : ::boost::urls::grammar::RangeRule<RangeRule>,
216 : "RangeRule requirements not met");
217 : #else
218 : static_assert(
219 : ::boost::urls::grammar::is_range_rule<RangeRule>::value,
220 : "RangeRule requirements not met");
221 : #endif
222 :
223 : static_assert(
224 : std::is_class<
225 : detail::range_base_storage<
226 : RangeRule>>::value,
227 : "range_base_storage requirements not met");
228 :
229 : using storage_type =
230 : detail::range_base_storage<
231 : RangeRule>;
232 :
233 : using storage_type::rule;
234 :
235 : core::string_view s_;
236 : std::size_t n_ = 0;
237 :
238 : template<
239 : class R0, class R1>
240 : friend struct implementation_defined::range_rule_t;
241 :
242 : range(
243 : core::string_view s,
244 : std::size_t n,
245 : RangeRule const& rule) noexcept;
246 :
247 : range(
248 : core::string_view s,
249 : std::size_t n,
250 : RangeRule&& rule) noexcept;
251 :
252 : public:
253 : /** The type of each element of the range
254 : */
255 : using value_type = T;
256 :
257 : /** The type of each element of the range
258 : */
259 : using reference = T const&;
260 :
261 : /** The type of each element of the range
262 : */
263 : using const_reference = T const&;
264 :
265 : /** Provided for compatibility, unused
266 : */
267 : using pointer = void const*;
268 :
269 : /** The type used to represent unsigned integers
270 : */
271 : using size_type = std::size_t;
272 :
273 : /** The type used to represent signed integers
274 : */
275 : using difference_type = std::ptrdiff_t;
276 :
277 : /** A constant, forward iterator to elements of the range
278 : */
279 : class iterator;
280 :
281 : /** A constant, forward iterator to elements of the range
282 : */
283 : using const_iterator = iterator;
284 :
285 : /** Destructor
286 : */
287 : ~range();
288 :
289 : /** Constructor
290 :
291 : Default-constructed ranges have
292 : zero elements.
293 :
294 : @par Exception Safety
295 : Throws nothing.
296 : */
297 : range() noexcept;
298 :
299 : /** Constructor
300 :
301 : The new range references the
302 : same underlying character buffer.
303 : Ownership is not transferred; the
304 : caller is responsible for ensuring
305 : that the lifetime of the buffer
306 : extends until it is no longer
307 : referenced. The moved-from object
308 : becomes as if default-constructed.
309 :
310 : @par Exception Safety
311 : Throws nothing.
312 : */
313 : range(range&&) noexcept;
314 :
315 : /** Constructor
316 :
317 : The copy references the same
318 : underlying character buffer.
319 : Ownership is not transferred; the
320 : caller is responsible for ensuring
321 : that the lifetime of the buffer
322 : extends until it is no longer
323 : referenced.
324 :
325 : @par Exception Safety
326 : Throws nothing.
327 : */
328 : range(range const&) noexcept;
329 :
330 : /** Assignment
331 :
332 : After the move, this references the
333 : same underlying character buffer. Ownership
334 : is not transferred; the caller is responsible
335 : for ensuring that the lifetime of the buffer
336 : extends until it is no longer referenced.
337 : The moved-from object becomes as if
338 : default-constructed.
339 :
340 : @par Exception Safety
341 : Throws nothing.
342 :
343 : @return `*this`
344 : */
345 : range&
346 : operator=(range&&) noexcept;
347 :
348 : /** Assignment
349 :
350 : The copy references the same
351 : underlying character buffer.
352 : Ownership is not transferred; the
353 : caller is responsible for ensuring
354 : that the lifetime of the buffer
355 : extends until it is no longer
356 : referenced.
357 :
358 : @par Exception Safety
359 : Throws nothing.
360 :
361 : @return `*this`
362 : */
363 : range&
364 : operator=(range const&) noexcept;
365 :
366 : /** Return an iterator to the beginning
367 :
368 : @return An iterator to the first element
369 : */
370 : iterator begin() const noexcept;
371 :
372 : /** Return an iterator to the end
373 :
374 : @return An iterator to one past the last element
375 : */
376 : iterator end() const noexcept;
377 :
378 : /** Return true if the range is empty
379 :
380 : @return `true` if the range is empty
381 : */
382 : bool
383 12 : empty() const noexcept
384 : {
385 12 : return n_ == 0;
386 : }
387 :
388 : /** Return the number of elements in the range
389 :
390 : @return The number of elements
391 : */
392 : std::size_t
393 42 : size() const noexcept
394 : {
395 42 : return n_;
396 : }
397 :
398 : /** Return the matching part of the string
399 :
400 : @return A string view representing the range
401 : */
402 : core::string_view
403 19 : string() const noexcept
404 : {
405 19 : return s_;
406 : }
407 : };
408 :
409 : //------------------------------------------------
410 :
411 : namespace implementation_defined {
412 : template<
413 : class R0,
414 : class R1 = void>
415 : struct range_rule_t;
416 : }
417 :
418 : //------------------------------------------------
419 :
420 : namespace implementation_defined {
421 : template<class R>
422 : struct range_rule_t<R>
423 : {
424 : using value_type =
425 : range<typename R::value_type>;
426 :
427 : system::result<value_type>
428 : parse(
429 : char const*& it,
430 : char const* end) const;
431 :
432 : constexpr
433 18 : range_rule_t(
434 : R const& next,
435 : std::size_t N,
436 : std::size_t M) noexcept
437 18 : : next_(next)
438 18 : , N_(N)
439 18 : , M_(M)
440 : {
441 18 : }
442 :
443 : private:
444 : R const next_;
445 : std::size_t N_;
446 : std::size_t M_;
447 : };
448 : } // implementation_defined
449 :
450 : /** Match a repeating number of elements
451 :
452 : Elements are matched using the passed rule.
453 : <br>
454 : Normally when the rule returns an error,
455 : the range ends and the input is rewound to
456 : one past the last character that matched
457 : successfully. However, if the rule returns
458 : the special value @ref error::end_of_range, the
459 : input is not rewound. This allows for rules
460 : which consume input without producing
461 : elements in the range. For example, to
462 : relax the grammar for a comma-delimited
463 : list by allowing extra commas in between
464 : elements.
465 :
466 : @par Value Type
467 : @code
468 : using value_type = range< typename Rule::value_type >;
469 : @endcode
470 :
471 : @par Example
472 : Rules are used with the function @ref parse.
473 : @code
474 : // range = 1*( ";" token )
475 :
476 : system::result< range<core::string_view> > rv = parse( ";alpha;xray;charlie",
477 : range_rule(
478 : tuple_rule(
479 : squelch( delim_rule( ';' ) ),
480 : token_rule( alpha_chars ) ),
481 : 1 ) );
482 : @endcode
483 :
484 : @par BNF
485 : @code
486 : range = <N>*<M>next
487 : @endcode
488 :
489 : @par Specification
490 : @li <a href="https://datatracker.ietf.org/doc/html/rfc5234#section-3.6"
491 : >3.6. Variable Repetition (rfc5234)</a>
492 :
493 : @param next The rule to use for matching
494 : each element. The range extends until this
495 : rule returns an error.
496 :
497 : @param N The minimum number of elements for
498 : the range to be valid. If omitted, this
499 : defaults to zero.
500 :
501 : @param M The maximum number of elements for
502 : the range to be valid. If omitted, this
503 : defaults to unlimited.
504 :
505 : @return A rule that matches the range.
506 :
507 : @see
508 : @ref alpha_chars,
509 : @ref delim_rule,
510 : @ref error::end_of_range,
511 : @ref parse,
512 : @ref range,
513 : @ref tuple_rule,
514 : @ref squelch.
515 : */
516 : template<BOOST_URL_CONSTRAINT(Rule) R>
517 : constexpr
518 : implementation_defined::range_rule_t<R>
519 18 : range_rule(
520 : R const& next,
521 : std::size_t N = 0,
522 : std::size_t M =
523 : std::size_t(-1)) noexcept
524 : {
525 : // If you get a compile error here it
526 : // means that your rule does not meet
527 : // the type requirements. Please check
528 : // the documentation.
529 : static_assert(
530 : is_rule<R>::value,
531 : "Rule requirements not met");
532 :
533 : return implementation_defined::range_rule_t<R>{
534 18 : next, N, M};
535 : }
536 :
537 : //------------------------------------------------
538 :
539 : namespace implementation_defined {
540 : template<class R0, class R1>
541 : struct range_rule_t
542 : {
543 : using value_type =
544 : range<typename R0::value_type>;
545 :
546 : system::result<value_type>
547 : parse(
548 : char const*& it,
549 : char const* end) const;
550 :
551 : constexpr
552 1 : range_rule_t(
553 : R0 const& first,
554 : R1 const& next,
555 : std::size_t N,
556 : std::size_t M) noexcept
557 1 : : first_(first)
558 1 : , next_(next)
559 1 : , N_(N)
560 1 : , M_(M)
561 : {
562 1 : }
563 :
564 : private:
565 : R0 const first_;
566 : R1 const next_;
567 : std::size_t N_;
568 : std::size_t M_;
569 : };
570 : } // implementation_defined
571 :
572 : /** Match a repeating number of elements
573 :
574 : Two rules are used for match. The rule
575 : `first` is used for matching the first
576 : element, while the `next` rule is used
577 : to match every subsequent element.
578 : <br>
579 : Normally when the rule returns an error,
580 : the range ends and the input is rewound to
581 : one past the last character that matched
582 : successfully. However, if the rule returns
583 : the special value @ref error::end_of_range, the
584 : input is not rewound. This allows for rules
585 : which consume input without producing
586 : elements in the range. For example, to
587 : relax the grammar for a comma-delimited
588 : list by allowing extra commas in between
589 : elements.
590 :
591 : @par Value Type
592 : @code
593 : using value_type = range< typename Rule::value_type >;
594 : @endcode
595 :
596 : @par Example
597 : Rules are used with the function @ref parse.
598 : @code
599 : // range = [ token ] *( "," token )
600 :
601 : system::result< range< core::string_view > > rv = parse( "whiskey,tango,foxtrot",
602 : range_rule(
603 : token_rule( alpha_chars ), // first
604 : tuple_rule( // next
605 : squelch( delim_rule(',') ),
606 : token_rule( alpha_chars ) ) ) );
607 : @endcode
608 :
609 : @par BNF
610 : @code
611 : range = <1>*<1>first
612 : / first <N-1>*<M-1>next
613 : @endcode
614 :
615 : @par Specification
616 : @li <a href="https://datatracker.ietf.org/doc/html/rfc5234#section-3.6"
617 : >3.6. Variable Repetition (rfc5234)</a>
618 :
619 : @param first The rule to use for matching
620 : the first element. If this rule returns
621 : an error, the range is empty.
622 :
623 : @param next The rule to use for matching
624 : each subsequent element. The range extends
625 : until this rule returns an error.
626 :
627 : @param N The minimum number of elements for
628 : the range to be valid. If omitted, this
629 : defaults to zero.
630 :
631 : @param M The maximum number of elements for
632 : the range to be valid. If omitted, this
633 : defaults to unlimited.
634 :
635 : @return A rule that matches the range.
636 :
637 : @see
638 : @ref alpha_chars,
639 : @ref delim_rule,
640 : @ref error::end_of_range,
641 : @ref parse,
642 : @ref range,
643 : @ref tuple_rule,
644 : @ref squelch.
645 : */
646 : template<
647 : BOOST_URL_CONSTRAINT(Rule) R1,
648 : BOOST_URL_CONSTRAINT(Rule) R2>
649 : constexpr
650 : auto
651 1 : range_rule(
652 : R1 const& first,
653 : R2 const& next,
654 : std::size_t N = 0,
655 : std::size_t M =
656 : std::size_t(-1)) noexcept ->
657 : #if 1
658 : typename std::enable_if<
659 : ! std::is_integral<R2>::value,
660 : implementation_defined::range_rule_t<R1, R2>>::type
661 : #else
662 : range_rule_t<R1, R2>
663 : #endif
664 : {
665 : // If you get a compile error here it
666 : // means that your rule does not meet
667 : // the type requirements. Please check
668 : // the documentation.
669 : static_assert(
670 : is_rule<R1>::value,
671 : "Rule requirements not met");
672 : static_assert(
673 : is_rule<R2>::value,
674 : "Rule requirements not met");
675 :
676 : // If you get a compile error here it
677 : // means that your rules do not have
678 : // the exact same value_type. Please
679 : // check the documentation.
680 : static_assert(
681 : std::is_same<
682 : typename R1::value_type,
683 : typename R2::value_type>::value,
684 : "Rule requirements not met");
685 :
686 : return implementation_defined::range_rule_t<R1, R2>{
687 1 : first, next, N, M};
688 : }
689 :
690 : } // grammar
691 : } // urls
692 : } // boost
693 :
694 : #include <boost/url/grammar/impl/range_rule.hpp>
695 :
696 : #endif
|
