include/boost/url/impl/url_base.hpp

99.5% Lines (1552/1560) 100.0% List of functions (81/81)

[ ] prev/next file n p prev/next uncovered line

url_base.hpp

f(x) Functions (81)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
3		// Copyright (c) 2022 Alan de Freitas (alandefreitas@gmail.com)
4		//
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)
7		//
8		// Official repository: https://github.com/boostorg/url
9		//
10
11		#ifndef BOOST_URL_IMPL_URL_BASE_HPP
12		#define BOOST_URL_IMPL_URL_BASE_HPP
13
14		#include <boost/url/encode.hpp>
15		#include <boost/url/error.hpp>
16		#include <boost/url/host_type.hpp>
17		#include <boost/url/scheme.hpp>
18		#include <boost/url/url_view.hpp>
19		#include <boost/url/detail/any_params_iter.hpp>
20		#include <boost/url/detail/any_segments_iter.hpp>
21		#include <boost/url/detail/decode.hpp>
22		#include <boost/url/detail/encode.hpp>
23		#include <boost/url/detail/except.hpp>
24		#include <boost/url/detail/normalize.hpp>
25		#include <boost/url/detail/path.hpp>
26		#include <boost/url/detail/print.hpp>
27		#include <boost/url/grammar/ci_string.hpp>
28		#include <boost/url/rfc/authority_rule.hpp>
29		#include <boost/url/rfc/query_rule.hpp>
30		#include <boost/url/rfc/ipv6_address_rule.hpp>
31		#include <boost/url/rfc/detail/charsets.hpp>
32		#include <boost/url/rfc/detail/host_rule.hpp>
33		#include <boost/url/rfc/detail/ipvfuture_rule.hpp>
34		#include <boost/url/rfc/detail/path_rules.hpp>
35		#include <boost/url/rfc/detail/port_rule.hpp>
36		#include <boost/url/rfc/detail/scheme_rule.hpp>
37		#include <boost/url/rfc/detail/userinfo_rule.hpp>
38		#include <boost/url/grammar/parse.hpp>
39		#include <boost/url/detail/move_chars.hpp>
40		#include <cstring>
41		#include <iostream>
42		#include <stdexcept>
43		#include <utility>
44
45		namespace boost {
46		namespace urls {
47
48		//------------------------------------------------
49
50		// these objects help handle the cases
51		// where the user passes in strings that
52		// come from inside the url buffer.
53
54		inline
55	18290x	url_base::
56		op_t::
57		~op_t()
58		{
59	18290x	if(old)
60	2561x	u.cleanup(*this);
61	18290x	u.check_invariants();
62	18290x	}
63
64		inline
65	18290x	url_base::
66		op_t::
67		op_t(
68		url_base& impl_,
69		core::string_view* s0_,
70	18290x	core::string_view* s1_) noexcept
71	18290x	: u(impl_)
72	18290x	, s0(s0_)
73	18290x	, s1(s1_)
74		{
75	18290x	u.check_invariants();
76	18290x	}
77
78		inline
79		void
80	9366x	url_base::
81		op_t::
82		move(
83		char* dest,
84		char const* src,
85		std::size_t n) noexcept
86		{
87	9366x	if(! n)
88	2519x	return;
89	6847x	if(s0)
90		{
91	4885x	if(s1)
92	654x	return detail::move_chars(
93	654x	dest, src, n, s0, s1);
94	4231x	return detail::move_chars(
95	4231x	dest, src, n, *s0);
96		}
97	1962x	detail::move_chars(
98		dest, src, n);
99		}
100
101		//------------------------------------------------
102
103		// construct reference
104		inline
105	1647x	url_base::
106		url_base(
107	1647x	detail::url_impl const& impl) noexcept
108	1647x	: url_view_base(impl)
109		{
110	1647x	}
111
112		inline
113		void
114	305x	url_base::
115		reserve_impl(std::size_t n)
116		{
117	305x	op_t op(*this);
118	305x	reserve_impl(n, op);
119	304x	if(s_)
120	302x	s_[size()] = '\0';
121	305x	}
122
123		// make a copy of u
124		inline
125		void
126	5227x	url_base::
127		copy(url_view_base const& u)
128		{
129	5227x	if (this == &u)
130	140x	return;
131	5213x	op_t op(*this);
132	5213x	if(u.size() == 0)
133		{
134	126x	clear();
135	126x	return;
136		}
137	5087x	reserve_impl(
138		u.size(), op);
139	5084x	impl_ = u.impl();
140	5084x	impl_.cs_ = s_;
141	5084x	impl_.from_ = {from::url};
142	5084x	std::memcpy(s_,
143	5084x	u.data(), u.size());
144	5084x	s_[size()] = '\0';
145	5213x	}
146
147		//------------------------------------------------
148		//
149		// Scheme
150		//
151		//------------------------------------------------
152
153		inline
154		url_base&
155	376x	url_base::
156		set_scheme(core::string_view s)
157		{
158	376x	set_scheme_impl(
159		s, string_to_scheme(s));
160	359x	return *this;
161		}
162
163		inline
164		url_base&
165	182x	url_base::
166		set_scheme_id(urls::scheme id)
167		{
168	182x	if(id == urls::scheme::unknown)
169	14x	detail::throw_invalid_argument();
170	168x	if(id == urls::scheme::none)
171	18x	return remove_scheme();
172	150x	set_scheme_impl(to_string(id), id);
173	119x	return *this;
174		}
175
176		inline
177		url_base&
178	53x	url_base::
179		remove_scheme()
180		{
181	53x	op_t op(*this);
182	53x	auto const sn = impl_.len(id_scheme);
183	53x	if(sn == 0)
184	15x	return *this;
185	38x	auto const po = impl_.offset(id_path);
186	38x	auto fseg = first_segment();
187		bool const encode_colon =
188	38x	!has_authority() &&
189	21x	impl_.nseg_ > 0 &&
190	70x	s_[po] != '/' &&
191	11x	fseg.contains(':');
192	38x	if(!encode_colon)
193		{
194		// just remove the scheme
195	29x	resize_impl(id_scheme, 0, op);
196	29x	impl_.scheme_ = urls::scheme::none;
197	29x	check_invariants();
198	29x	return *this;
199		}
200		// encode any ":" in the first path segment
201	9x	BOOST_ASSERT(sn >= 2);
202	9x	auto pn = impl_.len(id_path);
203	9x	std::size_t cn = 0;
204	46x	for (char c: fseg)
205	37x	cn += c == ':';
206		std::size_t new_size =
207	9x	size() - sn + 2 * cn;
208	9x	bool need_resize = new_size > size();
209	9x	if (need_resize)
210		{
211	1x	resize_impl(
212	1x	id_path, pn + 2 * cn, op);
213		}
214		// move [id_scheme, id_path) left
215	9x	op.move(
216		s_,
217	9x	s_ + sn,
218		po - sn);
219		// move [id_path, id_query) left
220	9x	auto qo = impl_.offset(id_query);
221	9x	op.move(
222	9x	s_ + po - sn,
223	9x	s_ + po,
224		qo - po);
225		// move [id_query, id_end) left
226	9x	op.move(
227	9x	s_ + qo - sn + 2 * cn,
228	9x	s_ + qo,
229	9x	impl_.offset(id_end) - qo);
230
231		// adjust part offsets.
232		// (po and qo are invalidated)
233	9x	if (need_resize)
234		{
235	1x	impl_.adjust_left(id_user, id_end, sn);
236		}
237		else
238		{
239	8x	impl_.adjust_left(id_user, id_path, sn);
240	8x	impl_.adjust_left(id_query, id_end, sn - 2 * cn);
241		}
242	9x	if (encode_colon)
243		{
244		// move the 2nd, 3rd, ... segments
245	9x	auto begin = s_ + impl_.offset(id_path);
246	9x	auto it = begin;
247	9x	auto end = begin + pn;
248	46x	while (it != end &&
249	40x	*it != '/')
250	37x	++it;
251		// we don't need op here because this is
252		// an internal operation
253	9x	std::memmove(it + (2 * cn), it, end - it);
254
255		// move 1st segment
256	9x	auto src = s_ + impl_.offset(id_path) + pn;
257	9x	auto dest = s_ + impl_.offset(id_query);
258	9x	src -= end - it;
259	9x	dest -= end - it;
260	9x	pn -= end - it;
261		do {
262	37x	--src;
263	37x	--dest;
264	37x	if (*src != ':')
265		{
266	25x	dest = src;
267		}
268		else
269		{
270		// use uppercase as required by
271		// syntax-based normalization
272	12x	*dest-- = 'A';
273	12x	*dest-- = '3';
274	12x	*dest = '%';
275		}
276	37x	--pn;
277	37x	} while (pn);
278		}
279	9x	s_[size()] = '\0';
280	9x	impl_.scheme_ = urls::scheme::none;
281	9x	return *this;
282	53x	}
283
284		//------------------------------------------------
285		//
286		// Authority
287		//
288		//------------------------------------------------
289
290		inline
291		url_base&
292	120x	url_base::
293		set_encoded_authority(
294		pct_string_view s)
295		{
296	120x	op_t op(*this, &detail::ref(s));
297	122x	authority_view a = grammar::parse(
298		s, authority_rule
299	120x	).value(BOOST_URL_POS);
300	119x	auto n = s.size() + 2;
301		auto const need_slash =
302	141x	! is_path_absolute() &&
303	22x	impl_.len(id_path) > 0;
304	119x	if(need_slash)
305	2x	++n;
306	119x	auto dest = resize_impl(
307		id_user, id_path, n, op);
308	119x	dest[0] = '/';
309	119x	dest[1] = '/';
310	119x	std::memcpy(dest + 2,
311	119x	s.data(), s.size());
312	119x	if(need_slash)
313	2x	dest[n - 1] = '/';
314	119x	impl_.apply_authority(a.u_);
315	119x	if(need_slash)
316	2x	impl_.adjust_right(
317		id_query, id_end, 1);
318	119x	return *this;
319	120x	}
320
321		inline
322		url_base&
323	259x	url_base::
324		remove_authority()
325		{
326	259x	if(! has_authority())
327	70x	return *this;
328
329	189x	op_t op(*this);
330	189x	auto path = impl_.get(id_path);
331	189x	bool const need_dot = path.starts_with("//");
332	189x	if(need_dot)
333		{
334		// prepend "/.", can't throw
335	5x	auto p = resize_impl(
336		id_user, id_path, 2, op);
337	5x	p[0] = '/';
338	5x	p[1] = '.';
339	5x	impl_.split(id_user, 0);
340	5x	impl_.split(id_pass, 0);
341	5x	impl_.split(id_host, 0);
342	5x	impl_.split(id_port, 0);
343		}
344		else
345		{
346	184x	resize_impl(
347		id_user, id_path, 0, op);
348		}
349	189x	impl_.host_type_ =
350		urls::host_type::none;
351	189x	return *this;
352	189x	}
353
354		//------------------------------------------------
355		//
356		// Userinfo
357		//
358		//------------------------------------------------
359
360		inline
361		url_base&
362	225x	url_base::
363		set_userinfo(
364		core::string_view s)
365		{
366	225x	op_t op(*this, &s);
367	225x	encoding_opts opt;
368	225x	auto const n = encoded_size(
369		s, detail::userinfo_chars, opt);
370	225x	auto dest = set_userinfo_impl(n, op);
371	225x	encode(
372		dest,
373		n,
374		s,
375		detail::userinfo_chars,
376		opt);
377	225x	auto const pos = impl_.get(
378		id_user, id_host
379	225x	).find_first_of(':');
380	225x	if(pos != core::string_view::npos)
381		{
382	22x	impl_.split(id_user, pos);
383		// find ':' in plain string
384		auto const pos2 =
385	22x	s.find_first_of(':');
386	22x	if(pos2 != core::string_view::npos)
387		{
388		// pos2 is the ':' index in plain input (user[:pass])
389		// decoded user is [0, pos2), decoded pass is (pos2, end].
390	22x	impl_.decoded_[id_user] =
391	22x	detail::to_size_type(pos2);
392	22x	impl_.decoded_[id_pass] =
393	22x	detail::to_size_type(s.size() - pos2 - 1);
394		}
395		else
396		{
397	✗	impl_.decoded_[id_user] =
398	✗	detail::to_size_type(s.size());
399	✗	impl_.decoded_[id_pass] = 0;
400		}
401		}
402		else
403		{
404	203x	impl_.decoded_[id_user] =
405	203x	detail::to_size_type(s.size());
406	203x	impl_.decoded_[id_pass] = 0;
407		}
408	225x	return *this;
409	225x	}
410
411		inline
412		url_base&
413	52x	url_base::
414		set_encoded_userinfo(
415		pct_string_view s)
416		{
417	52x	op_t op(*this, &detail::ref(s));
418	52x	auto const pos = s.find_first_of(':');
419	52x	if(pos != core::string_view::npos)
420		{
421		// user:pass
422	7x	auto const s0 = s.substr(0, pos);
423	7x	auto const s1 = s.substr(pos + 1);
424		auto const n0 =
425	7x	detail::re_encoded_size_unsafe(
426		s0,
427		detail::user_chars);
428		auto const n1 =
429	7x	detail::re_encoded_size_unsafe(s1,
430		detail::password_chars);
431		auto dest =
432	7x	set_userinfo_impl(n0 + n1 + 1, op);
433	7x	impl_.decoded_[id_user] =
434	7x	detail::to_size_type(detail::re_encode_unsafe(
435		dest,
436	7x	dest + n0,
437		s0,
438		detail::user_chars));
439	7x	*dest++ = ':';
440	7x	impl_.decoded_[id_pass] =
441	7x	detail::to_size_type(detail::re_encode_unsafe(
442		dest,
443	7x	dest + n1,
444		s1,
445		detail::password_chars));
446	7x	impl_.split(id_user, 2 + n0);
447		}
448		else
449		{
450		// user
451		auto const n =
452	45x	detail::re_encoded_size_unsafe(
453		s, detail::user_chars);
454	45x	auto dest = set_userinfo_impl(n, op);
455	45x	impl_.decoded_[id_user] =
456	90x	detail::to_size_type(detail::re_encode_unsafe(
457		dest,
458	45x	dest + n,
459		s,
460		detail::user_chars));
461	45x	impl_.split(id_user, 2 + n);
462	45x	impl_.decoded_[id_pass] = 0;
463		}
464	52x	return *this;
465	52x	}
466
467		inline
468		url_base&
469	214x	url_base::
470		remove_userinfo() noexcept
471		{
472	214x	if(impl_.len(id_pass) == 0)
473	138x	return *this; // no userinfo
474
475	76x	op_t op(*this);
476		// keep authority '//'
477	76x	resize_impl(
478		id_user, id_host, 2, op);
479	76x	impl_.decoded_[id_user] = 0;
480	76x	impl_.decoded_[id_pass] = 0;
481	76x	return *this;
482	76x	}
483
484		//------------------------------------------------
485
486		inline
487		url_base&
488	241x	url_base::
489		set_user(core::string_view s)
490		{
491	241x	op_t op(*this, &s);
492	241x	encoding_opts opt;
493	241x	auto const n = encoded_size(
494		s, detail::user_chars, opt);
495	241x	auto dest = set_user_impl(n, op);
496	241x	encode_unsafe(
497		dest,
498		n,
499		s,
500		detail::user_chars,
501		opt);
502	241x	impl_.decoded_[id_user] =
503	241x	detail::to_size_type(s.size());
504	241x	return *this;
505	241x	}
506
507		inline
508		url_base&
509	147x	url_base::
510		set_encoded_user(
511		pct_string_view s)
512		{
513	147x	op_t op(*this, &detail::ref(s));
514		auto const n =
515	147x	detail::re_encoded_size_unsafe(
516		s, detail::user_chars);
517	147x	auto dest = set_user_impl(n, op);
518	147x	impl_.decoded_[id_user] =
519	294x	detail::to_size_type(detail::re_encode_unsafe(
520		dest,
521	147x	dest + n,
522		s,
523		detail::user_chars));
524	147x	BOOST_ASSERT(
525		impl_.decoded_[id_user] ==
526		s.decoded_size());
527	147x	return *this;
528	147x	}
529
530		//------------------------------------------------
531
532		inline
533		url_base&
534	231x	url_base::
535		set_password(core::string_view s)
536		{
537	231x	op_t op(*this, &s);
538	231x	encoding_opts opt;
539	231x	auto const n = encoded_size(
540		s, detail::password_chars, opt);
541	231x	auto dest = set_password_impl(n, op);
542	231x	encode_unsafe(
543		dest,
544		n,
545		s,
546		detail::password_chars,
547		opt);
548	231x	impl_.decoded_[id_pass] =
549	231x	detail::to_size_type(s.size());
550	231x	return *this;
551	231x	}
552
553		inline
554		url_base&
555	140x	url_base::
556		set_encoded_password(
557		pct_string_view s)
558		{
559	140x	op_t op(*this, &detail::ref(s));
560		auto const n =
561	140x	detail::re_encoded_size_unsafe(
562		s,
563		detail::password_chars);
564	140x	auto dest = set_password_impl(n, op);
565	140x	impl_.decoded_[id_pass] =
566	280x	detail::to_size_type(detail::re_encode_unsafe(
567		dest,
568	140x	dest + n,
569		s,
570		detail::password_chars));
571	140x	BOOST_ASSERT(
572		impl_.decoded_[id_pass] ==
573		s.decoded_size());
574	140x	return *this;
575	140x	}
576
577		inline
578		url_base&
579	19x	url_base::
580		remove_password() noexcept
581		{
582	19x	auto const n = impl_.len(id_pass);
583	19x	if(n < 2)
584	12x	return *this; // no password
585
586	7x	op_t op(*this);
587		// clear password, retain '@'
588		auto dest =
589	7x	resize_impl(id_pass, 1, op);
590	7x	dest[0] = '@';
591	7x	impl_.decoded_[id_pass] = 0;
592	7x	return *this;
593	7x	}
594
595		//------------------------------------------------
596		//
597		// Host
598		//
599		//------------------------------------------------
600		/*
601		host_type host_type() // ipv4, ipv6, ipvfuture, name
602
603		std::string host() // return encoded_host().decode()
604		pct_string_view encoded_host() // return host part, as-is
605		std::string host_address() // return encoded_host_address().decode()
606		pct_string_view encoded_host_address() // ipv4, ipv6, ipvfut, or encoded name, no brackets
607
608		ipv4_address host_ipv4_address() // return ipv4_address or {}
609		ipv6_address host_ipv6_address() // return ipv6_address or {}
610		core::string_view host_ipvfuture() // return ipvfuture or {}
611		std::string host_name() // return decoded name or ""
612		pct_string_view encoded_host_name() // return encoded host name or ""
613
614		--------------------------------------------------
615
616		set_host( core::string_view ) // set host part from plain text
617		set_encoded_host( pct_string_view ) // set host part from encoded text
618		set_host_address( core::string_view ) // set host from ipv4, ipv6, ipvfut, or plain reg-name string
619		set_encoded_host_address( pct_string_view ) // set host from ipv4, ipv6, ipvfut, or encoded reg-name string
620
621		set_host_ipv4( ipv4_address ) // set ipv4
622		set_host_ipv6( ipv6_address ) // set ipv6
623		set_host_ipvfuture( core::string_view ) // set ipvfuture
624		set_host_name( core::string_view ) // set name from plain
625		set_encoded_host_name( pct_string_view ) // set name from encoded
626		*/
627
628		// set host part from plain text
629		inline
630		url_base&
631	401x	url_base::
632		set_host(
633		core::string_view s)
634		{
635	401x	if( s.size() > 2 &&
636	450x	s.front() == '[' &&
637	49x	s.back() == ']')
638		{
639		// IP-literal
640	49x	if (s[1] != 'v')
641		{
642		// IPv6-address
643	48x	auto innersv = s.substr(1, s.size() - 2);
644	48x	auto innerit = innersv.begin();
645	48x	auto endit = innersv.end();
646	48x	auto rv = grammar::parse(
647		innerit,
648		endit,
649		ipv6_address_rule);
650	48x	if(rv)
651		{
652	48x	if (innerit == endit)
653		{
654	47x	set_host_ipv6_and_encoded_zone_id(*rv, {});
655	48x	return *this;
656		}
657		// IPv6addrz: https://datatracker.ietf.org/doc/html/rfc6874
658	1x	auto chars_left = endit - innerit;
659	2x	if (chars_left >= 2 &&
660	1x	*innerit++ == '%')
661		{
662	1x	core::string_view zone_id_str = {&*innerit, std::size_t(chars_left - 1)};
663	1x	set_host_ipv6_and_zone_id(*rv, zone_id_str);
664	1x	return *this;
665		}
666		}
667		}
668		else
669		{
670		// IPvFuture
671	1x	auto rv = grammar::parse(
672	1x	s.substr(1, s.size() - 2),
673		detail::ipvfuture_rule);
674	1x	if(rv)
675	1x	return set_host_ipvfuture(rv->str);
676		}
677		}
678	352x	else if(s.size() >= 7) // "0.0.0.0"
679		{
680		// IPv4-address
681	348x	auto rv = parse_ipv4_address(s);
682	348x	if(rv)
683	189x	return set_host_ipv4(*rv);
684		}
685
686		// reg-name
687	163x	op_t op(*this, &s);
688	163x	encoding_opts opt;
689	163x	auto const n = encoded_size(
690		s, detail::host_chars, opt);
691	163x	auto dest = set_host_impl(n, op);
692	163x	encode(
693		dest,
694	163x	impl_.get(id_path).data() - dest,
695		s,
696		detail::host_chars,
697		opt);
698	163x	impl_.decoded_[id_host] =
699	163x	detail::to_size_type(s.size());
700	163x	impl_.host_type_ =
701		urls::host_type::name;
702	163x	return *this;
703	163x	}
704
705		// set host part from encoded text
706		inline
707		url_base&
708	218x	url_base::
709		set_encoded_host(
710		pct_string_view s)
711		{
712	218x	if( s.size() > 2 &&
713	235x	s.front() == '[' &&
714	17x	s.back() == ']')
715		{
716		// IP-literal
717	17x	if (s[1] != 'v')
718		{
719		// IPv6-address
720	16x	auto innersv = s.substr(1, s.size() - 2);
721	16x	auto innerit = innersv.begin();
722	16x	auto endit = innersv.end();
723	16x	auto rv = grammar::parse(
724		innerit,
725		endit,
726		ipv6_address_rule);
727	16x	if(rv)
728		{
729	8x	if (innerit == endit)
730		{
731	5x	set_host_ipv6_and_encoded_zone_id(*rv, {});
732	6x	return *this;
733		}
734		// IPv6addrz: https://datatracker.ietf.org/doc/html/rfc6874
735	3x	auto chars_left = endit - innerit;
736	4x	if (chars_left >= 3 &&
737	1x	*innerit++ == '%' &&
738	5x	*innerit++ == '2' &&
739	1x	*innerit++ == '5')
740		{
741	1x	auto const nz = std::size_t(chars_left - 3);
742	1x	core::string_view zone_id_str = {&*innerit, std::size_t(chars_left - 3)};
743	1x	std::size_t dnz = detail::decode_bytes_unsafe(zone_id_str);
744	1x	pct_string_view zone_id_pct = make_pct_string_view_unsafe(innerit, nz, dnz);
745	1x	set_host_ipv6_and_encoded_zone_id(*rv, zone_id_pct);
746	1x	return *this;
747		}
748		}
749		}
750		else
751		{
752		// IPvFuture
753	1x	auto rv = grammar::parse(
754	1x	s.substr(1, s.size() - 2),
755		detail::ipvfuture_rule);
756	1x	if(rv)
757	1x	return set_host_ipvfuture(rv->str);
758		}
759		}
760	201x	else if(s.size() >= 7) // "0.0.0.0"
761		{
762		// IPv4-address
763	74x	auto rv = parse_ipv4_address(s);
764	74x	if(rv)
765	5x	return set_host_ipv4(*rv);
766		}
767
768		// reg-name
769	206x	op_t op(*this, &detail::ref(s));
770	206x	auto const n = detail::re_encoded_size_unsafe(
771		s, detail::host_chars);
772	206x	auto dest = set_host_impl(n, op);
773	206x	impl_.decoded_[id_host] =
774	412x	detail::to_size_type(detail::re_encode_unsafe(
775		dest,
776	206x	impl_.get(id_path).data(),
777		s,
778		detail::host_chars));
779	206x	BOOST_ASSERT(impl_.decoded_[id_host] ==
780		s.decoded_size());
781	206x	impl_.host_type_ =
782		urls::host_type::name;
783	206x	return *this;
784	206x	}
785
786		inline
787		url_base&
788	10x	url_base::
789		set_host_address(
790		core::string_view s)
791		{
792	10x	if (!s.empty())
793		{
794		// IP-literal
795	9x	if (s[0] != 'v')
796		{
797		// IPv6-address
798	8x	auto innerit = s.begin();
799	8x	auto endit = s.end();
800	8x	auto rv = grammar::parse(
801		innerit,
802		endit,
803		ipv6_address_rule);
804	8x	if(rv)
805		{
806	2x	if (innerit == endit)
807		{
808	1x	set_host_ipv6_and_encoded_zone_id(*rv, {});
809	2x	return *this;
810		}
811		// IPv6addrz: https://datatracker.ietf.org/doc/html/rfc6874
812	1x	auto chars_left = endit - innerit;
813	2x	if (chars_left >= 2 &&
814	1x	*innerit++ == '%')
815		{
816	1x	core::string_view zone_id_str = {&*innerit, std::size_t(chars_left - 1)};
817	1x	set_host_ipv6_and_zone_id(*rv, zone_id_str);
818	1x	return *this;
819		}
820		}
821		}
822
823		// IPvFuture
824	7x	auto rv = grammar::parse(s, detail::ipvfuture_rule);
825	7x	if(rv)
826	1x	return set_host_ipvfuture(rv->str);
827
828	6x	if(s.size() >= 7) // "0.0.0.0"
829		{
830		// IPv4-address
831	5x	auto rv2 = parse_ipv4_address(s);
832	5x	if(rv2)
833	2x	return set_host_ipv4(*rv2);
834		}
835		}
836
837		// reg-name
838	5x	op_t op(*this, &s);
839	5x	encoding_opts opt;
840	5x	auto const n = encoded_size(
841		s, detail::host_chars, opt);
842	5x	auto dest = set_host_impl(n, op);
843	5x	encode(
844		dest,
845	5x	impl_.get(id_path).data() - dest,
846		s,
847		detail::host_chars,
848		opt);
849	5x	impl_.decoded_[id_host] =
850	5x	detail::to_size_type(s.size());
851	5x	impl_.host_type_ =
852		urls::host_type::name;
853	5x	return *this;
854	5x	}
855
856		inline
857		url_base&
858	8x	url_base::
859		set_encoded_host_address(
860		pct_string_view s)
861		{
862	8x	if( !s.empty() )
863		{
864		// IP-literal
865	7x	if (s[0] != 'v')
866		{
867		// IPv6-address
868	6x	auto innerit = s.begin();
869	6x	auto endit = s.end();
870	6x	auto rv = grammar::parse(
871		innerit,
872		endit,
873		ipv6_address_rule);
874	6x	if(rv)
875		{
876	2x	if (innerit == endit)
877		{
878	1x	set_host_ipv6_and_encoded_zone_id(*rv, {});
879	3x	return *this;
880		}
881		// IPv6addrz: https://datatracker.ietf.org/doc/html/rfc6874
882	1x	auto chars_left = endit - innerit;
883	2x	if (chars_left >= 3 &&
884	1x	*innerit++ == '%' &&
885	3x	*innerit++ == '2' &&
886	1x	*innerit++ == '5')
887		{
888	1x	auto const nz = std::size_t(chars_left - 3);
889	1x	core::string_view zone_id_str = {&*innerit, std::size_t(chars_left - 3)};
890	1x	std::size_t dnz = detail::decode_bytes_unsafe(zone_id_str);
891	1x	pct_string_view zone_id_pct = make_pct_string_view_unsafe(innerit, nz, dnz);
892	1x	set_host_ipv6_and_encoded_zone_id(*rv, zone_id_pct);
893	1x	return *this;
894		}
895		}
896
897	4x	if(s.size() >= 7) // "0.0.0.0"
898		{
899		// IPv4-address
900	3x	auto rv2 = parse_ipv4_address(s);
901	3x	if(rv2)
902	1x	return set_host_ipv4(*rv2);
903		}
904		}
905		else
906		{
907		// IPvFuture
908	1x	auto rv = grammar::parse(
909		s, detail::ipvfuture_rule);
910	1x	if(rv)
911	1x	return set_host_ipvfuture(rv->str);
912		}
913		}
914
915		// reg-name
916	4x	op_t op(*this, &detail::ref(s));
917	4x	auto const n = detail::re_encoded_size_unsafe(
918		s, detail::host_chars);
919	4x	auto dest = set_host_impl(n, op);
920	4x	impl_.decoded_[id_host] =
921	8x	detail::to_size_type(detail::re_encode_unsafe(
922		dest,
923	4x	impl_.get(id_path).data(),
924		s,
925		detail::host_chars));
926	4x	BOOST_ASSERT(impl_.decoded_[id_host] ==
927		s.decoded_size());
928	4x	impl_.host_type_ =
929		urls::host_type::name;
930	4x	return *this;
931	4x	}
932
933		inline
934		url_base&
935	203x	url_base::
936		set_host_ipv4(
937		ipv4_address const& addr)
938		{
939	203x	op_t op(*this);
940		char buf[urls::ipv4_address::max_str_len];
941	203x	auto s = addr.to_buffer(buf, sizeof(buf));
942	203x	auto dest = set_host_impl(s.size(), op);
943	203x	std::memcpy(dest, s.data(), s.size());
944	203x	impl_.decoded_[id_host] =
945	203x	detail::to_size_type(impl_.len(id_host));
946	203x	impl_.host_type_ = urls::host_type::ipv4;
947	203x	auto bytes = addr.to_bytes();
948	203x	std::memcpy(
949	203x	impl_.ip_addr_,
950	203x	bytes.data(),
951		bytes.size());
952	203x	return *this;
953	203x	}
954
955		inline
956		url_base&
957	5x	url_base::
958		set_host_ipv6(
959		ipv6_address const& addr)
960		{
961	5x	set_host_ipv6_and_encoded_zone_id(addr, encoded_zone_id());
962	5x	return *this;
963		}
964
965		inline
966		url_base&
967	3x	url_base::
968		set_zone_id(core::string_view s)
969		{
970	3x	set_host_ipv6_and_zone_id(host_ipv6_address(), s);
971	3x	return *this;
972		}
973
974		inline
975		url_base&
976	3x	url_base::
977		set_encoded_zone_id(pct_string_view s)
978		{
979	3x	set_host_ipv6_and_encoded_zone_id(host_ipv6_address(), s);
980	3x	return *this;
981		}
982
983		inline
984		void
985	5x	url_base::
986		set_host_ipv6_and_zone_id(
987		ipv6_address const& addr,
988		core::string_view zone_id)
989		{
990	5x	op_t op(*this, &zone_id);
991		char ipv6_str_buf[urls::ipv6_address::max_str_len];
992	5x	auto ipv6_str = addr.to_buffer(ipv6_str_buf, sizeof(ipv6_str_buf));
993	5x	bool const has_zone_id = !zone_id.empty();
994	5x	encoding_opts opt;
995	5x	auto const ipn = ipv6_str.size();
996	5x	auto const zn = encoded_size(zone_id, unreserved_chars, opt);
997	5x	auto const n = ipn + 2 + has_zone_id * (3 + zn);
998	5x	auto dest = set_host_impl(n, op);
999	5x	*dest++ = '[';
1000	5x	std::memcpy(dest, ipv6_str.data(), ipn);
1001	5x	dest += ipn;
1002	5x	if (has_zone_id)
1003		{
1004	5x	*dest++ = '%';
1005	5x	*dest++ = '2';
1006	5x	*dest++ = '5';
1007	5x	encode(dest, zn, zone_id, unreserved_chars, opt);
1008	5x	dest += zn;
1009		}
1010	5x	*dest++ = ']';
1011		// ipn + \|"["\| + \|"]"\| + (has_zone_id ? \|"%"\| + zn : 0)
1012	10x	impl_.decoded_[id_host] = detail::to_size_type(
1013	5x	ipn + 2 + has_zone_id * (1 + zone_id.size()));
1014	5x	impl_.host_type_ = urls::host_type::ipv6;
1015	5x	auto bytes = addr.to_bytes();
1016	5x	std::memcpy(
1017	5x	impl_.ip_addr_,
1018	5x	bytes.data(),
1019		bytes.size());
1020	5x	}
1021
1022		inline
1023		void
1024	64x	url_base::
1025		set_host_ipv6_and_encoded_zone_id(
1026		ipv6_address const& addr,
1027		pct_string_view zone_id)
1028		{
1029	64x	op_t op(*this, &detail::ref(zone_id));
1030		char ipv6_str_buf[urls::ipv6_address::max_str_len];
1031	64x	auto ipv6_str = addr.to_buffer(ipv6_str_buf, sizeof(ipv6_str_buf));
1032	64x	bool const has_zone_id = !zone_id.empty();
1033	64x	auto const ipn = ipv6_str.size();
1034	64x	auto const zn = detail::re_encoded_size_unsafe(zone_id, unreserved_chars);
1035	64x	auto const n = ipn + 2 + has_zone_id * (3 + zn);
1036	64x	auto dest = set_host_impl(n, op);
1037	64x	*dest++ = '[';
1038	64x	std::memcpy(dest, ipv6_str.data(), ipn);
1039	64x	dest += ipn;
1040	64x	std::size_t dzn = 0;
1041	64x	if (has_zone_id)
1042		{
1043	6x	*dest++ = '%';
1044	6x	*dest++ = '2';
1045	6x	*dest++ = '5';
1046	6x	dzn = detail::re_encode_unsafe(dest, dest + zn, zone_id, unreserved_chars);
1047		}
1048	64x	*dest++ = ']';
1049		// ipn + \|"["\| + \|"]"\| + (has_zone_id ? \|"%"\| + zn : 0)
1050	128x	impl_.decoded_[id_host] = detail::to_size_type(
1051	64x	ipn + 2 + has_zone_id * (1 + dzn));
1052	64x	impl_.host_type_ = urls::host_type::ipv6;
1053	64x	auto bytes = addr.to_bytes();
1054	64x	std::memcpy(
1055	64x	impl_.ip_addr_,
1056	64x	bytes.data(),
1057		bytes.size());
1058	64x	}
1059
1060		inline
1061		url_base&
1062	7x	url_base::
1063		set_host_ipvfuture(
1064		core::string_view s)
1065		{
1066	7x	op_t op(*this, &s);
1067		// validate
1068	8x	grammar::parse(s,
1069		detail::ipvfuture_rule
1070	8x	).value(BOOST_URL_POS);
1071	6x	auto dest = set_host_impl(
1072	6x	s.size() + 2, op);
1073	6x	*dest++ = '[';
1074	6x	dest += s.copy(dest, s.size());
1075	6x	*dest = ']';
1076	6x	impl_.host_type_ =
1077		urls::host_type::ipvfuture;
1078	6x	impl_.decoded_[id_host] =
1079	6x	detail::to_size_type(s.size() + 2);
1080	6x	return *this;
1081	7x	}
1082
1083		inline
1084		url_base&
1085	4x	url_base::
1086		set_host_name(
1087		core::string_view s)
1088		{
1089	4x	bool is_ipv4 = false;
1090	4x	if(s.size() >= 7) // "0.0.0.0"
1091		{
1092		// IPv4-address
1093	3x	if(parse_ipv4_address(s).has_value())
1094	1x	is_ipv4 = true;
1095		}
1096	4x	auto allowed = detail::host_chars;
1097	4x	if(is_ipv4)
1098	1x	allowed = allowed - '.';
1099
1100	4x	op_t op(*this, &s);
1101	4x	encoding_opts opt;
1102	4x	auto const n = encoded_size(
1103		s, allowed, opt);
1104	4x	auto dest = set_host_impl(n, op);
1105	4x	encode_unsafe(
1106		dest,
1107		n,
1108		s,
1109		allowed,
1110		opt);
1111	4x	impl_.host_type_ =
1112		urls::host_type::name;
1113	4x	impl_.decoded_[id_host] =
1114	4x	detail::to_size_type(s.size());
1115	4x	return *this;
1116	4x	}
1117
1118		inline
1119		url_base&
1120	4x	url_base::
1121		set_encoded_host_name(
1122		pct_string_view s)
1123		{
1124	4x	bool is_ipv4 = false;
1125	4x	if(s.size() >= 7) // "0.0.0.0"
1126		{
1127		// IPv4-address
1128	3x	if(parse_ipv4_address(s).has_value())
1129	1x	is_ipv4 = true;
1130		}
1131	4x	auto allowed = detail::host_chars;
1132	4x	if(is_ipv4)
1133	1x	allowed = allowed - '.';
1134
1135	4x	op_t op(*this, &detail::ref(s));
1136	4x	auto const n = detail::re_encoded_size_unsafe(
1137		s, allowed);
1138	4x	auto dest = set_host_impl(n, op);
1139	4x	impl_.decoded_[id_host] =
1140	8x	detail::to_size_type(detail::re_encode_unsafe(
1141		dest,
1142	4x	dest + n,
1143		s,
1144		allowed));
1145	4x	BOOST_ASSERT(
1146		impl_.decoded_[id_host] ==
1147		s.decoded_size());
1148	4x	impl_.host_type_ =
1149		urls::host_type::name;
1150	4x	return *this;
1151	4x	}
1152
1153		//------------------------------------------------
1154
1155		inline
1156		url_base&
1157	215x	url_base::
1158		set_port_number(
1159		std::uint16_t n)
1160		{
1161	215x	op_t op(*this);
1162		auto s =
1163	215x	detail::make_printed(n);
1164	215x	auto dest = set_port_impl(
1165	215x	s.string().size(), op);
1166	215x	std::memcpy(
1167	215x	dest, s.string().data(),
1168	215x	s.string().size());
1169	215x	impl_.port_number_ = n;
1170	215x	return *this;
1171	215x	}
1172
1173		inline
1174		url_base&
1175	389x	url_base::
1176		set_port(
1177		core::string_view s)
1178		{
1179	389x	op_t op(*this, &s);
1180	410x	auto t = grammar::parse(s,
1181	21x	detail::port_rule{}
1182	389x	).value(BOOST_URL_POS);
1183		auto dest =
1184	368x	set_port_impl(t.str.size(), op);
1185	368x	std::memcpy(dest,
1186	368x	t.str.data(), t.str.size());
1187	368x	if(t.has_number)
1188	208x	impl_.port_number_ = t.number;
1189		else
1190	160x	impl_.port_number_ = 0;
1191	368x	return *this;
1192	389x	}
1193
1194		inline
1195		url_base&
1196	206x	url_base::
1197		remove_port() noexcept
1198		{
1199	206x	op_t op(*this);
1200	206x	resize_impl(id_port, 0, op);
1201	206x	impl_.port_number_ = 0;
1202	412x	return *this;
1203	206x	}
1204
1205		//------------------------------------------------
1206		//
1207		// Compound Fields
1208		//
1209		//------------------------------------------------
1210
1211		inline
1212		url_base&
1213	14x	url_base::
1214		remove_origin()
1215		{
1216		// these two calls perform 2 memmoves instead of 1
1217	14x	remove_authority();
1218	14x	remove_scheme();
1219	14x	return *this;
1220		}
1221
1222		//------------------------------------------------
1223		//
1224		// Path
1225		//
1226		//------------------------------------------------
1227
1228		inline
1229		bool
1230	52x	url_base::
1231		set_path_absolute(
1232		bool absolute)
1233		{
1234	52x	op_t op(*this);
1235
1236		// check if path empty
1237	52x	if(impl_.len(id_path) == 0)
1238		{
1239	40x	if(! absolute)
1240		{
1241		// already not absolute
1242	34x	return true;
1243		}
1244
1245		// add '/'
1246	6x	auto dest = resize_impl(
1247		id_path, 1, op);
1248	6x	*dest = '/';
1249	6x	++impl_.decoded_[id_path];
1250	6x	return true;
1251		}
1252
1253		// check if path absolute
1254	12x	if(s_[impl_.offset(id_path)] == '/')
1255		{
1256	9x	if(absolute)
1257		{
1258		// already absolute
1259	2x	return true;
1260		}
1261
1262	11x	if( has_authority() &&
1263	4x	impl_.len(id_path) > 1)
1264		{
1265		// can't do it, paths are always
1266		// absolute when authority present!
1267	2x	return false;
1268		}
1269
1270	5x	auto p = encoded_path();
1271	5x	auto pos = p.find_first_of(":/", 1);
1272	6x	if (pos != core::string_view::npos &&
1273	1x	p[pos] == ':')
1274		{
1275		// prepend with .
1276	1x	auto n = impl_.len(id_path);
1277	1x	resize_impl(id_path, n + 1, op);
1278	1x	std::memmove(
1279	2x	s_ + impl_.offset(id_path) + 1,
1280	1x	s_ + impl_.offset(id_path), n);
1281	1x	*(s_ + impl_.offset(id_path)) = '.';
1282	1x	++impl_.decoded_[id_path];
1283	1x	return true;
1284		}
1285
1286		// remove '/'
1287	4x	auto n = impl_.len(id_port);
1288	4x	impl_.split(id_port, n + 1);
1289	4x	resize_impl(id_port, n, op);
1290	4x	--impl_.decoded_[id_path];
1291	4x	return true;
1292		}
1293
1294	3x	if(! absolute)
1295		{
1296		// already not absolute
1297	1x	return true;
1298		}
1299
1300		// add '/'
1301	2x	auto n = impl_.len(id_port);
1302	2x	auto dest = resize_impl(
1303	2x	id_port, n + 1, op) + n;
1304	2x	impl_.split(id_port, n);
1305	2x	*dest = '/';
1306	2x	++impl_.decoded_[id_path];
1307	2x	return true;
1308	52x	}
1309
1310		inline
1311		url_base&
1312	298x	url_base::
1313		set_path(
1314		core::string_view s)
1315		{
1316	298x	op_t op(*this, &s);
1317	298x	encoding_opts opt;
1318
1319		//------------------------------------------------
1320		//
1321		// Calculate encoded size
1322		//
1323		// - "/"s are not encoded
1324		// - "%2F"s are not encoded
1325		//
1326		// - reserved path chars are re-encoded
1327		// - colons in first segment might need to be re-encoded
1328		// - the path might need to receive a prefix
1329	298x	auto const n = encoded_size(
1330		s, detail::path_chars, opt);
1331	298x	std::size_t n_reencode_colons = 0;
1332	298x	core::string_view first_seg;
1333	298x	if (!has_scheme() &&
1334	337x	!has_authority() &&
1335	39x	!s.starts_with('/'))
1336		{
1337		// the first segment with unencoded colons would look
1338		// like the scheme
1339	6x	first_seg = detail::to_sv(s);
1340	6x	std::size_t p = s.find('/');
1341	6x	if (p != core::string_view::npos)
1342	2x	first_seg = s.substr(0, p);
1343	6x	n_reencode_colons = std::count(
1344	12x	first_seg.begin(), first_seg.end(), ':');
1345		}
1346		// the authority can only be followed by an empty or relative path
1347		// if we have an authority and the path is a non-empty relative path, we
1348		// add the "/" prefix to make it valid.
1349		bool make_absolute =
1350	298x	has_authority() &&
1351	305x	!s.starts_with('/') &&
1352	7x	!s.empty();
1353		// a path starting with "//" might look like the authority.
1354		// we add a "/." prefix to prevent that
1355		bool add_dot_segment =
1356	592x	!make_absolute &&
1357	294x	s.starts_with("//");
1358
1359		//------------------------------------------------
1360		//
1361		// Re-encode data
1362		//
1363	596x	auto dest = set_path_impl(
1364	298x	n + make_absolute + 2 * n_reencode_colons + 2 * add_dot_segment, op);
1365	298x	impl_.decoded_[id_path] = 0;
1366	298x	if (!dest)
1367		{
1368	3x	impl_.nseg_ = 0;
1369	3x	return *this;
1370		}
1371	295x	if (make_absolute)
1372		{
1373	4x	*dest++ = '/';
1374	4x	impl_.decoded_[id_path] += 1;
1375		}
1376	291x	else if (add_dot_segment)
1377		{
1378	12x	*dest++ = '/';
1379	12x	*dest++ = '.';
1380	12x	impl_.decoded_[id_path] += 2;
1381		}
1382	590x	dest += encode_unsafe(
1383		dest,
1384	295x	impl_.get(id_query).data() - dest,
1385		first_seg,
1386	295x	detail::segment_chars - ':',
1387		opt);
1388	295x	dest += encode_unsafe(
1389		dest,
1390	295x	impl_.get(id_query).data() - dest,
1391		s.substr(first_seg.size()),
1392		detail::path_chars,
1393		opt);
1394	295x	impl_.decoded_[id_path] +=
1395	295x	detail::to_size_type(s.size());
1396	295x	BOOST_ASSERT(!dest \|\| dest == impl_.get(id_query).data());
1397	295x	BOOST_ASSERT(
1398		impl_.decoded_[id_path] ==
1399		s.size() + make_absolute + 2 * add_dot_segment);
1400
1401		//------------------------------------------------
1402		//
1403		// Update path parameters
1404		//
1405		// get the encoded_path with the replacements we applied
1406	295x	if (s == "/")
1407		{
1408		// "/" maps to sequence {}
1409	144x	impl_.nseg_ = 0;
1410		}
1411	151x	else if (!s.empty())
1412		{
1413	146x	if (s.starts_with("/./"))
1414	1x	s = s.substr(2);
1415		// count segments as number of '/'s + 1
1416	292x	impl_.nseg_ = detail::to_size_type(
1417	146x	std::count(
1418	292x	s.begin() + 1, s.end(), '/') + 1);
1419		}
1420		else
1421		{
1422		// an empty relative path maps to sequence {}
1423	5x	impl_.nseg_ = 0;
1424		}
1425
1426	295x	check_invariants();
1427	295x	return *this;
1428	298x	}
1429
1430		inline
1431		url_base&
1432	299x	url_base::
1433		set_encoded_path(
1434		pct_string_view s)
1435		{
1436	299x	op_t op(*this, &detail::ref(s));
1437
1438		//------------------------------------------------
1439		//
1440		// Calculate re-encoded output size
1441		//
1442		// - reserved path chars are re-encoded
1443		// - colons in first segment might need to be re-encoded
1444		// - the path might need to receive a prefix
1445	299x	auto const n = detail::re_encoded_size_unsafe(
1446		s, detail::path_chars);
1447	299x	std::size_t n_reencode_colons = 0;
1448	299x	core::string_view first_seg;
1449	299x	if (!has_scheme() &&
1450	332x	!has_authority() &&
1451	33x	!s.starts_with('/'))
1452		{
1453		// the first segment with unencoded colons would look
1454		// like the scheme
1455	26x	first_seg = detail::to_sv(s);
1456	26x	std::size_t p = s.find('/');
1457	26x	if (p != core::string_view::npos)
1458	9x	first_seg = s.substr(0, p);
1459	26x	n_reencode_colons = std::count(
1460	52x	first_seg.begin(), first_seg.end(), ':');
1461		}
1462		// the authority can only be followed by an empty or relative path
1463		// if we have an authority and the path is a non-empty relative path, we
1464		// add the "/" prefix to make it valid.
1465		bool make_absolute =
1466	299x	has_authority() &&
1467	443x	!s.starts_with('/') &&
1468	144x	!s.empty();
1469		// a path starting with "//" might look like the authority
1470		// we add a "/." prefix to prevent that
1471		bool add_dot_segment =
1472	502x	!make_absolute &&
1473	362x	!has_authority() &&
1474	63x	s.starts_with("//");
1475
1476		//------------------------------------------------
1477		//
1478		// Re-encode data
1479		//
1480	598x	auto dest = set_path_impl(
1481	299x	n + make_absolute + 2 * n_reencode_colons + 2 * add_dot_segment, op);
1482	299x	impl_.decoded_[id_path] = 0;
1483	299x	if (!dest)
1484		{
1485	2x	impl_.nseg_ = 0;
1486	2x	return *this;
1487		}
1488	297x	if (make_absolute)
1489		{
1490	96x	*dest++ = '/';
1491	96x	impl_.decoded_[id_path] += 1;
1492		}
1493	201x	else if (add_dot_segment)
1494		{
1495	5x	*dest++ = '/';
1496	5x	*dest++ = '.';
1497	5x	impl_.decoded_[id_path] += 2;
1498		}
1499	297x	impl_.decoded_[id_path] +=
1500	297x	detail::to_size_type(detail::re_encode_unsafe(
1501		dest,
1502	297x	impl_.get(id_query).data(),
1503		first_seg,
1504	297x	detail::segment_chars - ':'));
1505	297x	impl_.decoded_[id_path] +=
1506	594x	detail::to_size_type(detail::re_encode_unsafe(
1507		dest,
1508	297x	impl_.get(id_query).data(),
1509		s.substr(first_seg.size()),
1510		detail::path_chars));
1511	297x	BOOST_ASSERT(dest == impl_.get(id_query).data());
1512	297x	BOOST_ASSERT(
1513		impl_.decoded_[id_path] ==
1514		s.decoded_size() + make_absolute + 2 * add_dot_segment);
1515
1516		//------------------------------------------------
1517		//
1518		// Update path parameters
1519		//
1520		// get the encoded_path with the replacements we applied
1521	297x	if (s == "/")
1522		{
1523		// "/" maps to sequence {}
1524	19x	impl_.nseg_ = 0;
1525		}
1526	278x	else if (!s.empty())
1527		{
1528	227x	if (s.starts_with("/./"))
1529	7x	s = s.substr(2);
1530		// count segments as number of '/'s + 1
1531	454x	impl_.nseg_ = detail::to_size_type(
1532	227x	std::count(
1533	454x	s.begin() + 1, s.end(), '/') + 1);
1534		}
1535		else
1536		{
1537		// an empty relative path maps to sequence {}
1538	51x	impl_.nseg_ = 0;
1539		}
1540
1541	297x	check_invariants();
1542	297x	return *this;
1543	299x	}
1544
1545		inline
1546		segments_ref
1547	1146x	url_base::
1548		segments() noexcept
1549		{
1550	1146x	return {*this};
1551		}
1552
1553		inline
1554		segments_encoded_ref
1555	497x	url_base::
1556		encoded_segments() noexcept
1557		{
1558	497x	return {*this};
1559		}
1560
1561		//------------------------------------------------
1562		//
1563		// Query
1564		//
1565		//------------------------------------------------
1566
1567		inline
1568		url_base&
1569	169x	url_base::
1570		set_query(
1571		core::string_view s)
1572		{
1573	169x	edit_params(
1574	169x	detail::params_iter_impl(impl_),
1575	169x	detail::params_iter_impl(impl_, 0),
1576	338x	detail::query_string_iter(s, true));
1577	169x	return *this;
1578		}
1579
1580		inline
1581		url_base&
1582	179x	url_base::
1583		set_encoded_query(
1584		pct_string_view s)
1585		{
1586	179x	op_t op(*this);
1587	179x	std::size_t n = 0; // encoded size
1588	179x	std::size_t nparam = 1; // param count
1589	179x	auto const end = s.end();
1590	179x	auto p = s.begin();
1591
1592		// measure
1593	742x	while(p != end)
1594		{
1595	563x	if(*p == '&')
1596		{
1597	4x	++p;
1598	4x	++n;
1599	4x	++nparam;
1600		}
1601	559x	else if(*p != '%')
1602		{
1603	533x	if(detail::query_chars(*p))
1604	518x	n += 1; // allowed
1605		else
1606	15x	n += 3; // escaped
1607	533x	++p;
1608		}
1609		else
1610		{
1611		// escape
1612	26x	n += 3;
1613	26x	p += 3;
1614		}
1615		}
1616
1617		// resize
1618	179x	auto dest = resize_impl(
1619	179x	id_query, n + 1, op);
1620	179x	*dest++ = '?';
1621
1622		// encode
1623	179x	impl_.decoded_[id_query] =
1624	358x	detail::to_size_type(detail::re_encode_unsafe(
1625		dest,
1626	179x	dest + n,
1627		s,
1628		detail::query_chars));
1629	179x	BOOST_ASSERT(
1630		impl_.decoded_[id_query] ==
1631		s.decoded_size());
1632	179x	impl_.nparam_ =
1633	179x	detail::to_size_type(nparam);
1634	179x	return *this;
1635	179x	}
1636
1637		inline
1638		params_ref
1639	977x	url_base::
1640		params() noexcept
1641		{
1642		return params_ref(
1643		*this,
1644		encoding_opts{
1645	977x	true, false, false});
1646		}
1647
1648		inline
1649		params_ref
1650	4x	url_base::
1651		params(encoding_opts opt) noexcept
1652		{
1653	4x	return {*this, opt};
1654		}
1655
1656		inline
1657		params_encoded_ref
1658	77x	url_base::
1659		encoded_params() noexcept
1660		{
1661	77x	return {*this};
1662		}
1663
1664		inline
1665		url_base&
1666	1x	url_base::
1667		set_params(
1668		std::initializer_list<param_view> ps,
1669		encoding_opts opts) noexcept
1670		{
1671	1x	params(opts).assign(ps);
1672	1x	return *this;
1673		}
1674
1675		inline
1676		url_base&
1677	1x	url_base::
1678		set_encoded_params( std::initializer_list< param_pct_view > ps ) noexcept
1679		{
1680	1x	encoded_params().assign(ps);
1681	1x	return *this;
1682		}
1683
1684		inline
1685		url_base&
1686	990x	url_base::
1687		remove_query() noexcept
1688		{
1689	990x	op_t op(*this);
1690	990x	resize_impl(id_query, 0, op);
1691	990x	impl_.nparam_ = 0;
1692	990x	impl_.decoded_[id_query] = 0;
1693	1980x	return *this;
1694	990x	}
1695
1696		//------------------------------------------------
1697		//
1698		// Fragment
1699		//
1700		//------------------------------------------------
1701
1702		inline
1703		url_base&
1704	407x	url_base::
1705		remove_fragment() noexcept
1706		{
1707	407x	op_t op(*this);
1708	407x	resize_impl(id_frag, 0, op);
1709	407x	impl_.decoded_[id_frag] = 0;
1710	814x	return *this;
1711	407x	}
1712
1713		inline
1714		url_base&
1715	151x	url_base::
1716		set_fragment(core::string_view s)
1717		{
1718	151x	op_t op(*this, &s);
1719	151x	encoding_opts opt;
1720	151x	auto const n = encoded_size(
1721		s,
1722		detail::fragment_chars,
1723		opt);
1724	151x	auto dest = resize_impl(
1725		id_frag, n + 1, op);
1726	151x	*dest++ = '#';
1727	151x	encode_unsafe(
1728		dest,
1729		n,
1730		s,
1731		detail::fragment_chars,
1732		opt);
1733	151x	impl_.decoded_[id_frag] =
1734	151x	detail::to_size_type(s.size());
1735	151x	return *this;
1736	151x	}
1737
1738		inline
1739		url_base&
1740	183x	url_base::
1741		set_encoded_fragment(
1742		pct_string_view s)
1743		{
1744	183x	op_t op(*this, &detail::ref(s));
1745		auto const n =
1746	183x	detail::re_encoded_size_unsafe(
1747		s,
1748		detail::fragment_chars);
1749	183x	auto dest = resize_impl(
1750	183x	id_frag, n + 1, op);
1751	183x	*dest++ = '#';
1752	183x	impl_.decoded_[id_frag] =
1753	366x	detail::to_size_type(detail::re_encode_unsafe(
1754		dest,
1755	183x	dest + n,
1756		s,
1757		detail::fragment_chars));
1758	183x	BOOST_ASSERT(
1759		impl_.decoded_[id_frag] ==
1760		s.decoded_size());
1761	183x	return *this;
1762	183x	}
1763
1764		//------------------------------------------------
1765		//
1766		// Resolution
1767		//
1768		//------------------------------------------------
1769
1770		inline
1771		system::result<void>
1772	516x	url_base::
1773		resolve(
1774		url_view_base const& ref)
1775		{
1776	516x	if(! has_scheme())
1777		{
1778	2x	BOOST_URL_RETURN_EC(error::not_a_base);
1779		}
1780
1781	514x	if (this == &ref)
1782		{
1783	2x	normalize_path();
1784	2x	return {};
1785		}
1786
1787	512x	op_t op(*this);
1788
1789		//
1790		// 5.2.2. Transform References
1791		// https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.2
1792		//
1793
1794	782x	if( ref.has_scheme() &&
1795	270x	ref.scheme() != scheme())
1796		{
1797	202x	reserve_impl(ref.size(), op);
1798	202x	copy(ref);
1799	202x	normalize_path();
1800	202x	return {};
1801		}
1802	310x	if(ref.has_authority())
1803		{
1804	78x	reserve_impl(
1805	78x	impl_.offset(id_user) + ref.size(), op);
1806	78x	set_encoded_authority(
1807		ref.encoded_authority());
1808	78x	set_encoded_path(
1809		ref.encoded_path());
1810	78x	if (ref.encoded_path().empty())
1811	33x	set_path_absolute(false);
1812		else
1813	45x	normalize_path();
1814	78x	if(ref.has_query())
1815	8x	set_encoded_query(
1816		ref.encoded_query());
1817		else
1818	70x	remove_query();
1819	78x	if(ref.has_fragment())
1820	7x	set_encoded_fragment(
1821		ref.encoded_fragment());
1822		else
1823	71x	remove_fragment();
1824	78x	return {};
1825		}
1826	232x	if(ref.encoded_path().empty())
1827		{
1828	43x	reserve_impl(
1829	43x	impl_.offset(id_query) +
1830	43x	ref.size(), op);
1831	43x	normalize_path();
1832	43x	if(ref.has_query())
1833		{
1834	12x	set_encoded_query(
1835		ref.encoded_query());
1836		}
1837	43x	if(ref.has_fragment())
1838	20x	set_encoded_fragment(
1839		ref.encoded_fragment());
1840		else
1841	23x	remove_fragment();
1842	43x	return {};
1843		}
1844	189x	if(ref.is_path_absolute())
1845		{
1846	41x	reserve_impl(
1847	41x	impl_.offset(id_path) +
1848	41x	ref.size(), op);
1849	41x	set_encoded_path(
1850		ref.encoded_path());
1851	41x	normalize_path();
1852	41x	if(ref.has_query())
1853	4x	set_encoded_query(
1854		ref.encoded_query());
1855		else
1856	37x	remove_query();
1857	41x	if(ref.has_fragment())
1858	2x	set_encoded_fragment(
1859		ref.encoded_fragment());
1860		else
1861	39x	remove_fragment();
1862	41x	return {};
1863		}
1864		// General case: ref is relative path
1865	148x	reserve_impl(
1866	148x	impl_.offset(id_query) +
1867	148x	ref.size(), op);
1868		// 5.2.3. Merge Paths
1869	148x	auto es = encoded_segments();
1870	148x	if(es.size() > 0)
1871		{
1872	141x	es.pop_back();
1873		}
1874	296x	es.insert(es.end(),
1875	148x	ref.encoded_segments().begin(),
1876	148x	ref.encoded_segments().end());
1877	148x	normalize_path();
1878	148x	if(ref.has_query())
1879	10x	set_encoded_query(
1880		ref.encoded_query());
1881		else
1882	138x	remove_query();
1883	148x	if(ref.has_fragment())
1884	13x	set_encoded_fragment(
1885		ref.encoded_fragment());
1886		else
1887	135x	remove_fragment();
1888	148x	return {};
1889	512x	}
1890
1891		//------------------------------------------------
1892		//
1893		// Normalization
1894		//
1895		//------------------------------------------------
1896
1897		template <
1898		class AllowedCharset,
1899		class IgnoredCharset>
1900		void
1901	2975x	url_base::
1902		normalize_octets_impl(
1903		int id,
1904		AllowedCharset const& allowed,
1905		IgnoredCharset const& ignored,
1906		op_t& op) noexcept
1907		{
1908	2975x	char* it = s_ + impl_.offset(id);
1909	2975x	char* end = s_ + impl_.offset(id + 1);
1910	2975x	char d = 0;
1911	2975x	char* dest = it;
1912	16442x	while (it < end)
1913		{
1914	13467x	if (*it != '%')
1915		{
1916	13249x	dest = it;
1917	13249x	++it;
1918	13249x	++dest;
1919	13249x	continue;
1920		}
1921	218x	BOOST_ASSERT(end - it >= 3);
1922
1923		// decode unreserved octets
1924	218x	d = detail::decode_one(it + 1);
1925	314x	if (allowed(d) &&
1926	96x	!ignored(d))
1927		{
1928	87x	*dest = d;
1929	87x	it += 3;
1930	87x	++dest;
1931	87x	continue;
1932		}
1933
1934		// uppercase percent-encoding triplets
1935	131x	*dest++ = '%';
1936	131x	++it;
1937	131x	dest++ = grammar::to_upper(it++);
1938	131x	dest++ = grammar::to_upper(it++);
1939		}
1940	2975x	if (it != dest)
1941		{
1942	35x	auto diff = it - dest;
1943	35x	auto n = impl_.len(id) - diff;
1944	35x	shrink_impl(id, n, op);
1945	35x	s_[size()] = '\0';
1946		}
1947	2975x	}
1948
1949		template<class CharSet>
1950		void
1951	2757x	url_base::
1952		normalize_octets_impl(
1953		int idx,
1954		CharSet const& allowed,
1955		op_t& op) noexcept
1956		{
1957	2757x	return normalize_octets_impl(
1958	2757x	idx, allowed, detail::empty_chars, op);
1959		}
1960
1961		inline
1962		url_base&
1963	217x	url_base::
1964		normalize_scheme()
1965		{
1966	217x	to_lower_impl(id_scheme);
1967	217x	return *this;
1968		}
1969
1970		inline
1971		url_base&
1972	563x	url_base::
1973		normalize_authority()
1974		{
1975	563x	op_t op(*this);
1976
1977		// normalize host
1978	563x	if (host_type() == urls::host_type::name)
1979		{
1980	351x	normalize_octets_impl(
1981		id_host,
1982		detail::reg_name_chars, op);
1983		}
1984	563x	decoded_to_lower_impl(id_host);
1985
1986		// normalize password
1987	563x	normalize_octets_impl(id_pass, detail::password_chars, op);
1988
1989		// normalize user
1990	563x	normalize_octets_impl(id_user, detail::user_chars, op);
1991	1126x	return *this;
1992	563x	}
1993
1994		inline
1995		url_base&
1996	1065x	url_base::
1997		normalize_path()
1998		{
1999	1065x	op_t op(*this);
2000
2001		//
2002		// Step 1: Percent-encoding normalization
2003		//
2004		// Decode percent-encoded characters that are
2005		// valid unencoded in path segments (pchar),
2006		// and uppercase remaining hex digits.
2007		//
2008		// This can introduce:
2009		// - New '.' from %2E (dot is unreserved)
2010		// - New ':' from %3A (colon is a pchar)
2011		// This cannot introduce:
2012		// - New '/' (%2F stays encoded, '/' is not
2013		// a segment character)
2014		//
2015		// These new '.' and ':' characters can create
2016		// ambiguities that Steps 2 and 3 must handle.
2017		//
2018	1065x	normalize_octets_impl(id_path, detail::segment_chars, op);
2019	1065x	core::string_view p = impl_.get(id_path);
2020	1065x	char* p_dest = s_ + impl_.offset(id_path);
2021	1065x	char* p_end = s_ + impl_.offset(id_path + 1);
2022	1065x	auto pn = p.size();
2023
2024		//
2025		// Step 2: Preserve existing path shields
2026		//
2027		// If the URL has no authority, a path starting
2028		// with "//" would be misinterpreted as an
2029		// authority when serialized and re-parsed.
2030		// Some paths already have a dot prefix ("/."
2031		// or "./") that shields against this. We
2032		// preserve them so remove_dot_segments (Step 3)
2033		// does not strip them. Step 1 can also reveal
2034		// new shields by decoding %2E to '.'.
2035		//
2036		// This is an optimization. Step 4 would create
2037		// a new shield anyway if remove_dot_segments
2038		// produces a problematic output, but preserving
2039		// an existing shield avoids the memmove in
2040		// Step 4.
2041		//
2042		// path_shield_len: number of leading bytes
2043		// to skip during remove_dot_segments.
2044		// Always 0 (no shield) or 2 ("/." or "./").
2045		//
2046	1065x	auto path_shield_len = 0;
2047	1065x	if (!has_authority())
2048		{
2049	313x	if (p.starts_with("/./"))
2050		{
2051		// (a) Absolute path with "/." prefix.
2052		//
2053		// Check if "/." shields a "//"
2054		// underneath (possibly through
2055		// multiple "/./" layers like "/././/").
2056		// If so, preserve the first 2 chars.
2057		//
2058		// /.//evil -> /.//evil (preserved)
2059		// Without it: //evil (ambiguous).
2060		// /././/evil -> /.//evil (same idea)
2061		//
2062		// Requires no authority (with authority,
2063		// "//" in the path is unambiguous):
2064		// http://h/.//x -> http://h//x (OK)
2065		// Scheme is irrelevant (absolute paths
2066		// can't be confused with a scheme):
2067		// scheme:/.//x and /.//x both need it.
2068		//
2069	18x	path_shield_len = 2;
2070	19x	while (p.substr(path_shield_len, 3).starts_with("/./"))
2071		{
2072	1x	path_shield_len += 2;
2073		}
2074	18x	if (p.substr(path_shield_len).starts_with("//"))
2075		{
2076	15x	path_shield_len = 2;
2077		}
2078		else
2079		{
2080	3x	path_shield_len = 0;
2081		}
2082		}
2083	295x	else if (
2084	349x	!has_scheme() &&
2085	54x	p.starts_with("./"))
2086		{
2087		// (b) Relative path with "./" prefix,
2088		// no scheme.
2089		//
2090		// Check if "./" shields a "//"
2091		// underneath. If so, preserve it.
2092		//
2093		// .//evil -> .//evil (preserved)
2094		// Without it: //evil (ambiguous).
2095		// ././/evil -> .//evil (same idea)
2096		//
2097		// Requires no authority (with authority,
2098		// "//" in the path is unambiguous):
2099		// //h/.//x -> //h//x (OK)
2100		// Requires no scheme: with a scheme,
2101		// remove_dot_segments would strip "./"
2102		// and Step 4 handles any resulting "//".
2103		//
2104	12x	path_shield_len = 1;
2105	16x	while (p.substr(path_shield_len, 3).starts_with("/./"))
2106		{
2107	4x	path_shield_len += 2;
2108		}
2109	12x	if (p.substr(path_shield_len).starts_with("//"))
2110		{
2111	4x	path_shield_len = 2;
2112		}
2113		else
2114		{
2115	8x	path_shield_len = 0;
2116		}
2117		}
2118		}
2119
2120		//
2121		// Step 3: Remove "." and ".." segments
2122		//
2123		// RFC 3986 Section 5.2.4.
2124		//
2125		// If path_shield_len > 0, the first
2126		// path_shield_len characters are an existing
2127		// path shield ("/." or "./") that must
2128		// be preserved (see Step 2), we tell
2129		// remove_dot_segments to start after that
2130		// prefix.
2131		//
2132		// Note: remove_dot_segments only recognizes
2133		// literal '.' and '..', not encoded forms like
2134		// '%2E'. This is correct here because Step 1
2135		// already decoded %2E to '.'. If this function
2136		// were called without Step 1, encoded dots
2137		// would be missed.
2138		//
2139	1065x	bool was_absolute = is_path_absolute();
2140	1065x	p.remove_prefix(path_shield_len);
2141	1065x	p_dest += path_shield_len;
2142	1065x	auto n = detail::remove_dot_segments(
2143	1065x	p_dest, p_end, p);
2144
2145		//
2146		// Step 4: Create path shield if needed,
2147		// then shrink path to final size
2148		//
2149		// remove_dot_segments can produce output that
2150		// needs a 2-byte shield prefix, as explained
2151		// in step 2. The memmove below writes within
2152		// the original path region (before shrink_impl)
2153		// and always has room because ".." cancellation
2154		// consumes >= 5 bytes but we only need 2 for the
2155		// shield.
2156		//
2157	3195x	bool needs_shield = [&]()
2158		{
2159	1065x	if (path_shield_len)
2160		{
2161		// Step 2 already preserved a shield.
2162	19x	return false;
2163		}
2164	1046x	if (has_authority())
2165		{
2166		// With an authority, "//" in the path
2167		// is unambiguous and the path is always
2168		// absolute (path-abempty).
2169	752x	return false;
2170		}
2171	294x	if (n == 0)
2172		{
2173		// Empty output. Nothing to shield.
2174	28x	return false;
2175		}
2176	266x	if (p_dest[0] != '/')
2177		{
2178		// Output doesn't start with '/'.
2179		// No authority ambiguity, and if it
2180		// was relative, it stayed relative.
2181	129x	return false;
2182		}
2183	137x	if (n >= 2 && p_dest[1] == '/')
2184		{
2185		// Output starts with "//": would be
2186		// misinterpreted as authority.
2187		// /a/..//evil -> //evil
2188		// so we need a shield
2189		// /a/..//evil -> /.//evil
2190	7x	return true;
2191		}
2192	130x	if (!was_absolute)
2193		{
2194		// Relative path became absolute: ".."
2195		// canceled all leading segments and
2196		// the remaining input started with "/"
2197		// because of how remove_dot_segments is
2198		// defined.
2199		// a/..//evil -> /evil -> .//evil
2200		// a/b/../..//evil -> /evil -> .//evil
2201	5x	return true;
2202		}
2203	125x	return false;
2204	1065x	}();
2205	1065x	if (needs_shield)
2206		{
2207	12x	BOOST_ASSERT(n + 2 <= pn);
2208	12x	std::memmove(p_dest + 2, p_dest, n);
2209	12x	if (was_absolute)
2210		{
2211		// "/." keeps the path absolute.
2212	7x	p_dest[0] = '/';
2213	7x	p_dest[1] = '.';
2214		}
2215		else
2216		{
2217		// "./" keeps the path relative.
2218	5x	p_dest[0] = '.';
2219	5x	p_dest[1] = '/';
2220		}
2221	12x	path_shield_len = 2;
2222		}
2223	1065x	if (n != pn)
2224		{
2225	163x	BOOST_ASSERT(n < pn);
2226	163x	shrink_impl(id_path, n + path_shield_len, op);
2227		}
2228
2229		//
2230		// Step 5: Encode colons in first segment
2231		//
2232		// If the URL has no scheme and no authority,
2233		// a colon in the first path segment would be
2234		// misinterpreted as a scheme delimiter when
2235		// serialized and re-parsed.
2236		//
2237		// Colons can appear in the first segment either
2238		// because they were already there (decoded from
2239		// %3A in Step 1), or because remove_dot_segments
2240		// (Step 3) canceled preceding segments via ".."
2241		// and exposed a colon that was deeper in the path.
2242		//
2243		// Example (pre-existing):
2244		// my%3Asharona -> Step 1: my:sharona
2245		// -> Step 5: my%3Asharona
2246		// Example (exposed by dot removal):
2247		// a/../b:c -> Step 3: b:c
2248		// -> Step 5: b%3Ac
2249		//
2250		// ALL colons in the first segment must be
2251		// encoded, not just the first one. In a
2252		// schemeless relative-reference, the first
2253		// segment must be segment-nz-nc (RFC 3986
2254		// Section 4.2), which does not allow ':':
2255		// path-noscheme = segment-nz-nc *( "/" segment )
2256		// segment-nz-nc = 1*( unreserved / pct-encoded
2257		// / sub-delims / "@" )
2258		// So "b%3Ac:d" would fail to re-parse.
2259		// All colons must go: "b%3Ac%3Ad".
2260		//
2261		// Requires no scheme (with a scheme, colons
2262		// in the path are unambiguous):
2263		// scheme:a:b -> scheme:a:b (OK)
2264		// Requires no authority (with authority,
2265		// path starts with "/" so the first segment
2266		// is empty, no colon issue).
2267		//
2268	1142x	if (!has_scheme() &&
2269	77x	!has_authority())
2270		{
2271	58x	p = impl_.get(id_path);
2272	58x	core::string_view first_seg = p;
2273	58x	auto i = first_seg.find('/');
2274	58x	if (i != core::string_view::npos)
2275		{
2276	28x	first_seg = p.substr(0, i);
2277		}
2278	58x	if (first_seg.contains(':'))
2279		{
2280	13x	pn = p.size();
2281		auto cn =
2282	13x	std::count(
2283		first_seg.begin(),
2284		first_seg.end(),
2285	13x	':');
2286	13x	resize_impl(
2287	13x	id_path, pn + (2 * cn), op);
2288	13x	auto begin = s_ + impl_.offset(id_path);
2289	13x	auto it = begin;
2290	13x	auto end = begin + pn;
2291	103x	while (it != end &&
2292	91x	*it != '/')
2293		{
2294	90x	++it;
2295		}
2296	13x	std::memmove(it + (2 * cn), it, end - it);
2297	13x	auto src = s_ + impl_.offset(id_path) + pn;
2298	13x	auto dest = s_ + impl_.offset(id_query);
2299	13x	src -= end - it;
2300	13x	dest -= end - it;
2301	13x	pn -= end - it;
2302		do {
2303	90x	--src;
2304	90x	--dest;
2305	90x	if (*src != ':')
2306		{
2307	65x	dest = src;
2308		}
2309		else
2310		{
2311	25x	*dest-- = 'A';
2312	25x	*dest-- = '3';
2313	25x	*dest = '%';
2314		}
2315	90x	--pn;
2316	90x	} while (pn);
2317		}
2318		}
2319
2320		//
2321		// Step 6: Update path parameters
2322		//
2323		{
2324	1065x	p = encoded_path();
2325	1065x	if (p == "/")
2326		{
2327	126x	impl_.nseg_ = 0;
2328		}
2329	939x	else if (!p.empty())
2330		{
2331	1622x	impl_.nseg_ = detail::to_size_type(
2332	811x	std::count(
2333	1622x	p.begin() + 1, p.end(), '/') + 1);
2334		}
2335		else
2336		{
2337	128x	impl_.nseg_ = 0;
2338		}
2339	1065x	impl_.decoded_[id_path] =
2340	1065x	detail::to_size_type(detail::decode_bytes_unsafe(
2341		impl_.get(id_path)));
2342		}
2343	1065x	return *this;
2344	1065x	}
2345
2346		inline
2347		url_base&
2348	218x	url_base::
2349		normalize_query()
2350		{
2351	218x	op_t op(*this);
2352	218x	normalize_octets_impl(
2353		id_query,
2354		detail::query_chars,
2355		detail::query_ignore_chars,
2356		op);
2357	436x	return *this;
2358	218x	}
2359
2360		inline
2361		url_base&
2362	215x	url_base::
2363		normalize_fragment()
2364		{
2365	215x	op_t op(*this);
2366	215x	normalize_octets_impl(
2367		id_frag, detail::fragment_chars, op);
2368	430x	return *this;
2369	215x	}
2370
2371		inline
2372		url_base&
2373	214x	url_base::
2374		normalize()
2375		{
2376	214x	normalize_fragment();
2377	214x	normalize_query();
2378	214x	normalize_path();
2379	214x	normalize_authority();
2380	214x	normalize_scheme();
2381	214x	return *this;
2382		}
2383
2384		//------------------------------------------------
2385		//
2386		// Implementation
2387		//
2388		//------------------------------------------------
2389
2390		inline
2391		void
2392	43552x	url_base::
2393		check_invariants() const noexcept
2394		{
2395	43552x	BOOST_ASSERT(
2396		impl_.len(id_scheme) == 0 \|\|
2397		impl_.get(id_scheme).ends_with(':'));
2398	43552x	BOOST_ASSERT(
2399		impl_.len(id_user) == 0 \|\|
2400		impl_.get(id_user).starts_with("//"));
2401	43552x	BOOST_ASSERT(
2402		impl_.len(id_pass) == 0 \|\|
2403		impl_.get(id_user).starts_with("//"));
2404	43552x	BOOST_ASSERT(
2405		impl_.len(id_pass) == 0 \|\|
2406		(impl_.len(id_pass) == 1 &&
2407		impl_.get(id_pass) == "@") \|\|
2408		(impl_.len(id_pass) > 1 &&
2409		impl_.get(id_pass).starts_with(':') &&
2410		impl_.get(id_pass).ends_with('@')));
2411	43552x	BOOST_ASSERT(
2412		impl_.len(id_user, id_path) == 0 \|\|
2413		impl_.get(id_user).starts_with("//"));
2414	43552x	BOOST_ASSERT(impl_.decoded_[id_path] >=
2415		((impl_.len(id_path) + 2) / 3));
2416	43552x	BOOST_ASSERT(
2417		impl_.len(id_port) == 0 \|\|
2418		impl_.get(id_port).starts_with(':'));
2419	43552x	BOOST_ASSERT(
2420		impl_.len(id_query) == 0 \|\|
2421		impl_.get(id_query).starts_with('?'));
2422	43552x	BOOST_ASSERT(
2423		(impl_.len(id_query) == 0 && impl_.nparam_ == 0) \|\|
2424		(impl_.len(id_query) > 0 && impl_.nparam_ > 0));
2425	43552x	BOOST_ASSERT(
2426		impl_.len(id_frag) == 0 \|\|
2427		impl_.get(id_frag).starts_with('#'));
2428	43552x	BOOST_ASSERT(c_str()[size()] == '\0');
2429	43552x	}
2430
2431		inline
2432		char*
2433	5500x	url_base::
2434		resize_impl(
2435		int id,
2436		std::size_t new_size,
2437		op_t& op)
2438		{
2439	5500x	return resize_impl(
2440	5500x	id, id + 1, new_size, op);
2441		}
2442
2443		inline
2444		char*
2445	6225x	url_base::
2446		resize_impl(
2447		int first,
2448		int last,
2449		std::size_t new_len,
2450		op_t& op)
2451		{
2452	6225x	auto const n0 = impl_.len(first, last);
2453	6225x	if(new_len == 0 && n0 == 0)
2454	1090x	return s_ + impl_.offset(first);
2455	5135x	if(new_len <= n0)
2456	2193x	return shrink_impl(
2457	2193x	first, last, new_len, op);
2458
2459		// growing
2460	2942x	std::size_t n = new_len - n0;
2461	2942x	reserve_impl(size() + n, op);
2462		auto const pos =
2463	2942x	impl_.offset(last);
2464		// adjust chars
2465	2942x	op.move(
2466	2942x	s_ + pos + n,
2467	2942x	s_ + pos,
2468	2942x	impl_.offset(id_end) -
2469		pos + 1);
2470		// collapse (first, last)
2471	2942x	impl_.collapse(first, last,
2472	2942x	impl_.offset(last) + n);
2473		// shift (last, end) right
2474	2942x	impl_.adjust_right(last, id_end, n);
2475	2942x	s_[size()] = '\0';
2476	2942x	return s_ + impl_.offset(first);
2477		}
2478
2479		inline
2480		char*
2481	198x	url_base::
2482		shrink_impl(
2483		int id,
2484		std::size_t new_size,
2485		op_t& op)
2486		{
2487	198x	return shrink_impl(
2488	198x	id, id + 1, new_size, op);
2489		}
2490
2491		inline
2492		char*
2493	2391x	url_base::
2494		shrink_impl(
2495		int first,
2496		int last,
2497		std::size_t new_len,
2498		op_t& op)
2499		{
2500		// shrinking
2501	2391x	auto const n0 = impl_.len(first, last);
2502	2391x	BOOST_ASSERT(new_len <= n0);
2503	2391x	std::size_t n = n0 - new_len;
2504		auto const pos =
2505	2391x	impl_.offset(last);
2506		// adjust chars
2507	2391x	op.move(
2508	2391x	s_ + pos - n,
2509	2391x	s_ + pos,
2510	2391x	impl_.offset(
2511	2391x	id_end) - pos + 1);
2512		// collapse (first, last)
2513	2391x	impl_.collapse(first, last,
2514	2391x	impl_.offset(last) - n);
2515		// shift (last, end) left
2516	2391x	impl_.adjust_left(last, id_end, n);
2517	2391x	s_[size()] = '\0';
2518	2391x	return s_ + impl_.offset(first);
2519		}
2520
2521		//------------------------------------------------
2522
2523		inline
2524		void
2525	526x	url_base::
2526		set_scheme_impl(
2527		core::string_view s,
2528		urls::scheme id)
2529		{
2530	526x	op_t op(*this, &s);
2531	526x	check_invariants();
2532	574x	grammar::parse(
2533	48x	s, detail::scheme_rule()
2534	574x	).value(BOOST_URL_POS);
2535	478x	auto const n = s.size();
2536	478x	auto const p = impl_.offset(id_path);
2537
2538		// check for "./" prefix
2539		bool const has_dot =
2540	1434x	[this, p]
2541		{
2542	478x	if(impl_.nseg_ == 0)
2543	213x	return false;
2544	265x	if(first_segment().size() < 2)
2545	42x	return false;
2546	223x	auto const src = s_ + p;
2547	223x	if(src[0] != '.')
2548	220x	return false;
2549	3x	if(src[1] != '/')
2550	✗	return false;
2551	3x	return true;
2552	478x	}();
2553
2554		// Remove "./"
2555	478x	if(has_dot)
2556		{
2557		// do this first, for
2558		// strong exception safety
2559	6x	reserve_impl(
2560	3x	size() + n + 1 - 2, op);
2561	3x	op.move(
2562	3x	s_ + p,
2563	3x	s_ + p + 2,
2564	3x	size() + 1 -
2565		(p + 2));
2566	3x	impl_.set_size(
2567		id_path,
2568	3x	impl_.len(id_path) - 2);
2569	3x	s_[size()] = '\0';
2570		}
2571
2572	478x	auto dest = resize_impl(
2573		id_scheme, n + 1, op);
2574	478x	s.copy(dest, n);
2575	478x	dest[n] = ':';
2576	478x	impl_.scheme_ = id;
2577	478x	check_invariants();
2578	526x	}
2579
2580		inline
2581		char*
2582	396x	url_base::
2583		set_user_impl(
2584		std::size_t n,
2585		op_t& op)
2586		{
2587	396x	check_invariants();
2588	396x	if(impl_.len(id_pass) != 0)
2589		{
2590		// keep "//"
2591	147x	auto dest = resize_impl(
2592		id_user, 2 + n, op);
2593	147x	check_invariants();
2594	147x	return dest + 2;
2595		}
2596		// add authority
2597		bool const make_absolute =
2598	333x	!is_path_absolute() &&
2599	84x	!impl_.get(id_path).empty();
2600	498x	auto dest = resize_impl(
2601	249x	id_user, 2 + n + 1 + make_absolute, op);
2602	249x	impl_.split(id_user, 2 + n);
2603	249x	dest[0] = '/';
2604	249x	dest[1] = '/';
2605	249x	dest[2 + n] = '@';
2606	249x	if (make_absolute)
2607		{
2608	6x	impl_.split(id_pass, 1);
2609	6x	impl_.split(id_host, 0);
2610	6x	impl_.split(id_port, 0);
2611	6x	dest[3 + n] = '/';
2612		}
2613	249x	check_invariants();
2614	249x	return dest + 2;
2615		}
2616
2617		inline
2618		char*
2619	377x	url_base::
2620		set_password_impl(
2621		std::size_t n,
2622		op_t& op)
2623		{
2624	377x	check_invariants();
2625	377x	if(impl_.len(id_user) != 0)
2626		{
2627		// already have authority
2628	313x	auto const dest = resize_impl(
2629		id_pass, 1 + n + 1, op);
2630	313x	dest[0] = ':';
2631	313x	dest[n + 1] = '@';
2632	313x	check_invariants();
2633	313x	return dest + 1;
2634		}
2635		// add authority
2636		bool const make_absolute =
2637	104x	!is_path_absolute() &&
2638	40x	!impl_.get(id_path).empty();
2639		auto const dest =
2640	128x	resize_impl(
2641		id_user, id_host,
2642	64x	2 + 1 + n + 1 + make_absolute, op);
2643	64x	impl_.split(id_user, 2);
2644	64x	dest[0] = '/';
2645	64x	dest[1] = '/';
2646	64x	dest[2] = ':';
2647	64x	dest[2 + n + 1] = '@';
2648	64x	if (make_absolute)
2649		{
2650	7x	impl_.split(id_pass, 2 + n);
2651	7x	impl_.split(id_host, 0);
2652	7x	impl_.split(id_port, 0);
2653	7x	dest[4 + n] = '/';
2654		}
2655	64x	check_invariants();
2656	64x	return dest + 3;
2657		}
2658
2659		inline
2660		char*
2661	277x	url_base::
2662		set_userinfo_impl(
2663		std::size_t n,
2664		op_t& op)
2665		{
2666		// "//" {dest} "@"
2667	277x	check_invariants();
2668		bool const make_absolute =
2669	406x	!is_path_absolute() &&
2670	129x	!impl_.get(id_path).empty();
2671	554x	auto dest = resize_impl(
2672	277x	id_user, id_host, n + 3 + make_absolute, op);
2673	277x	impl_.split(id_user, n + 2);
2674	277x	dest[0] = '/';
2675	277x	dest[1] = '/';
2676	277x	dest[n + 2] = '@';
2677	277x	if (make_absolute)
2678		{
2679	3x	impl_.split(id_pass, 1);
2680	3x	impl_.split(id_host, 0);
2681	3x	impl_.split(id_port, 0);
2682	3x	dest[3 + n] = '/';
2683		}
2684	277x	check_invariants();
2685	277x	return dest + 2;
2686		}
2687
2688		inline
2689		char*
2690	721x	url_base::
2691		set_host_impl(
2692		std::size_t n,
2693		op_t& op)
2694		{
2695	721x	check_invariants();
2696	721x	if(impl_.len(id_user) == 0)
2697		{
2698		// add authority
2699		bool make_absolute =
2700	320x	!is_path_absolute() &&
2701	147x	impl_.len(id_path) != 0;
2702	173x	auto pn = impl_.len(id_path);
2703	346x	auto dest = resize_impl(
2704	173x	id_user, n + 2 + make_absolute, op);
2705	173x	impl_.split(id_user, 2);
2706	173x	impl_.split(id_pass, 0);
2707	173x	impl_.split(id_host, n);
2708	173x	impl_.split(id_port, 0);
2709	173x	impl_.split(id_path, pn + make_absolute);
2710	173x	if (make_absolute)
2711		{
2712	9x	dest[n + 2] = '/';
2713	9x	++impl_.decoded_[id_path];
2714		}
2715	173x	dest[0] = '/';
2716	173x	dest[1] = '/';
2717	173x	check_invariants();
2718	173x	return dest + 2;
2719		}
2720		// already have authority
2721	548x	auto const dest = resize_impl(
2722		id_host, n, op);
2723	548x	check_invariants();
2724	548x	return dest;
2725		}
2726
2727		inline
2728		char*
2729	604x	url_base::
2730		set_port_impl(
2731		std::size_t n,
2732		op_t& op)
2733		{
2734	604x	check_invariants();
2735	604x	if(impl_.len(id_user) != 0)
2736		{
2737		// authority exists
2738	503x	auto dest = resize_impl(
2739		id_port, n + 1, op);
2740	503x	dest[0] = ':';
2741	503x	check_invariants();
2742	503x	return dest + 1;
2743		}
2744		bool make_absolute =
2745	174x	!is_path_absolute() &&
2746	73x	impl_.len(id_path) != 0;
2747	202x	auto dest = resize_impl(
2748	101x	id_user, 3 + n + make_absolute, op);
2749	101x	impl_.split(id_user, 2);
2750	101x	impl_.split(id_pass, 0);
2751	101x	impl_.split(id_host, 0);
2752	101x	dest[0] = '/';
2753	101x	dest[1] = '/';
2754	101x	dest[2] = ':';
2755	101x	if (make_absolute)
2756		{
2757	8x	impl_.split(id_port, n + 1);
2758	8x	dest[n + 3] = '/';
2759	8x	++impl_.decoded_[id_path];
2760		}
2761	101x	check_invariants();
2762	101x	return dest + 3;
2763		}
2764
2765		inline
2766		char*
2767	597x	url_base::
2768		set_path_impl(
2769		std::size_t n,
2770		op_t& op)
2771		{
2772	597x	check_invariants();
2773	597x	auto const dest = resize_impl(
2774		id_path, n, op);
2775	597x	return dest;
2776		}
2777
2778
2779		//------------------------------------------------
2780
2781		// return the first segment of the path.
2782		// this is needed for some algorithms.
2783		inline
2784		core::string_view
2785	303x	url_base::
2786		first_segment() const noexcept
2787		{
2788	303x	if(impl_.nseg_ == 0)
2789	9x	return {};
2790	294x	auto const p0 = impl_.cs_ +
2791	294x	impl_.offset(id_path) +
2792	294x	detail::path_prefix(
2793	294x	impl_.get(id_path));
2794	294x	auto const end = impl_.cs_ +
2795	294x	impl_.offset(id_query);
2796	294x	if(impl_.nseg_ == 1)
2797	182x	return core::string_view(
2798	91x	p0, end - p0);
2799	203x	auto p = p0;
2800	910x	while(*p != '/')
2801		{
2802	707x	BOOST_ASSERT(p < end);
2803	707x	++p;
2804		}
2805	203x	return core::string_view(p0, p - p0);
2806		}
2807
2808		inline
2809		detail::segments_iter_impl
2810	2315x	url_base::
2811		edit_segments(
2812		detail::segments_iter_impl const& it0,
2813		detail::segments_iter_impl const& it1,
2814		detail::any_segments_iter&& src,
2815		// -1 = preserve
2816		// 0 = make relative (can fail)
2817		// 1 = make absolute
2818		int absolute)
2819		{
2820		// Iterator doesn't belong to this url
2821	2315x	BOOST_ASSERT(it0.ref.alias_of(impl_));
2822
2823		// Iterator doesn't belong to this url
2824	2315x	BOOST_ASSERT(it1.ref.alias_of(impl_));
2825
2826		// Iterator is in the wrong order
2827	2315x	BOOST_ASSERT(it0.index <= it1.index);
2828
2829		// Iterator is out of range
2830	2315x	BOOST_ASSERT(it0.index <= impl_.nseg_);
2831	2315x	BOOST_ASSERT(it0.pos <= impl_.len(id_path));
2832
2833		// Iterator is out of range
2834	2315x	BOOST_ASSERT(it1.index <= impl_.nseg_);
2835	2315x	BOOST_ASSERT(it1.pos <= impl_.len(id_path));
2836
2837		//------------------------------------------------
2838		//
2839		// Calculate output prefix
2840		//
2841		// 0 = ""
2842		// 1 = "/"
2843		// 2 = "./"
2844		// 3 = "/./"
2845		//
2846	2315x	bool const is_abs = is_path_absolute();
2847	2315x	if(has_authority())
2848		{
2849		// Check if the new
2850		// path would be empty
2851	1855x	if( src.fast_nseg == 0 &&
2852	911x	it0.index == 0 &&
2853	655x	it1.index == impl_.nseg_)
2854		{
2855		// VFALCO we don't have
2856		// access to nchar this early
2857		//
2858		//BOOST_ASSERT(nchar == 0);
2859	627x	absolute = 0;
2860		}
2861		else
2862		{
2863		// prefix "/" required
2864	1228x	absolute = 1;
2865		}
2866		}
2867	460x	else if(absolute < 0)
2868		{
2869	460x	absolute = is_abs; // preserve
2870		}
2871	2315x	auto const path_pos = impl_.offset(id_path);
2872
2873	2315x	std::size_t nchar = 0;
2874	2315x	std::size_t prefix = 0;
2875	2315x	bool encode_colons = false;
2876	2315x	bool cp_src_prefix = false;
2877	2315x	if(it0.index > 0)
2878		{
2879		// first segment unchanged
2880	870x	prefix = src.fast_nseg > 0;
2881		}
2882	1445x	else if(src.fast_nseg > 0)
2883		{
2884		// first segment from src
2885	718x	if(! src.front.empty())
2886		{
2887	640x	if( src.front == "." &&
2888	7x	src.fast_nseg > 1)
2889	4x	if (src.s.empty())
2890		{
2891		// if front is ".", we need the extra "." in the prefix
2892		// which will maintain the invariant that segments represent
2893		// {"."}
2894	4x	prefix = 2 + absolute;
2895		}
2896		else
2897		{
2898		// if the "." prefix is explicitly required from set_path
2899		// we do not include an extra "." segment
2900	✗	prefix = absolute;
2901	✗	cp_src_prefix = true;
2902		}
2903	629x	else if(absolute)
2904	542x	prefix = 1;
2905	166x	else if(has_scheme() \|\|
2906	79x	! src.front.contains(':'))
2907	82x	prefix = 0;
2908		else
2909		{
2910	5x	prefix = 0;
2911	5x	encode_colons = true;
2912		}
2913		}
2914		else
2915		{
2916	85x	prefix = 2 + absolute;
2917		}
2918		}
2919		else
2920		{
2921		// first segment from it1
2922	727x	auto const p =
2923	727x	impl_.cs_ + path_pos + it1.pos;
2924	1454x	switch(impl_.cs_ +
2925	727x	impl_.offset(id_query) - p)
2926		{
2927	680x	case 0:
2928		// points to end
2929	680x	prefix = absolute;
2930	680x	break;
2931	36x	default:
2932	36x	BOOST_ASSERT(*p == '/');
2933	36x	if(p[1] != '/')
2934		{
2935	35x	if(absolute)
2936	29x	prefix = 1;
2937	11x	else if(has_scheme() \|\|
2938	11x	! it1.dereference().contains(':'))
2939	5x	prefix = 0;
2940		else
2941	1x	prefix = 2;
2942	35x	break;
2943		}
2944		// empty
2945		BOOST_FALLTHROUGH;
2946		case 1:
2947		// empty
2948	12x	BOOST_ASSERT(*p == '/');
2949	12x	prefix = 2 + absolute;
2950	12x	break;
2951		}
2952		}
2953
2954		// append '/' to new segs
2955		// if inserting at front.
2956	2315x	std::size_t const suffix =
2957	3234x	it1.index == 0 &&
2958	2494x	impl_.nseg_ > 0 &&
2959	179x	src.fast_nseg > 0;
2960
2961		//------------------------------------------------
2962		//
2963		// Measure the number of encoded characters
2964		// of output, and the number of inserted
2965		// segments including internal separators.
2966		//
2967	2315x	src.encode_colons = encode_colons;
2968	2315x	std::size_t nseg = 0;
2969	2315x	if(src.measure(nchar))
2970		{
2971	1279x	src.encode_colons = false;
2972		for(;;)
2973		{
2974	1605x	++nseg;
2975	1605x	if(! src.measure(nchar))
2976	1277x	break;
2977	326x	++nchar;
2978		}
2979		}
2980
2981	2313x	switch(src.fast_nseg)
2982		{
2983	1036x	case 0:
2984	1036x	BOOST_ASSERT(nseg == 0);
2985	1036x	break;
2986	1089x	case 1:
2987	1089x	BOOST_ASSERT(nseg == 1);
2988	1089x	break;
2989	188x	case 2:
2990	188x	BOOST_ASSERT(nseg >= 2);
2991	188x	break;
2992		}
2993
2994		//------------------------------------------------
2995		//
2996		// Calculate [pos0, pos1) to remove
2997		//
2998	2313x	auto pos0 = it0.pos;
2999	2313x	if(it0.index == 0)
3000		{
3001		// patch pos for prefix
3002	1443x	pos0 = 0;
3003		}
3004	2313x	auto pos1 = it1.pos;
3005	2313x	if(it1.index == 0)
3006		{
3007		// patch pos for prefix
3008	919x	pos1 = detail::path_prefix(
3009		impl_.get(id_path));
3010		}
3011	1394x	else if(
3012	1394x	it0.index == 0 &&
3013	524x	it1.index < impl_.nseg_ &&
3014		nseg == 0)
3015		{
3016		// Remove the slash from segment it1
3017		// if it is becoming the new first
3018		// segment.
3019	47x	++pos1;
3020		}
3021		// calc decoded size of old range
3022		auto const dn0 =
3023	2313x	detail::decode_bytes_unsafe(
3024		core::string_view(
3025	2313x	impl_.cs_ +
3026	2313x	impl_.offset(id_path) +
3027		pos0,
3028		pos1 - pos0));
3029
3030		//------------------------------------------------
3031		//
3032		// Resize
3033		//
3034	4626x	op_t op(*this, &src.s);
3035		char* dest;
3036		char const* end;
3037		{
3038	2313x	auto const nremove = pos1 - pos0;
3039		// check overflow
3040	4626x	if( nchar <= max_size() && (
3041	2313x	prefix + suffix <=
3042	2313x	max_size() - nchar))
3043		{
3044	2313x	nchar = prefix + nchar + suffix;
3045	3484x	if( nchar <= nremove \|\|
3046	1171x	nchar - nremove <=
3047	1171x	max_size() - size())
3048	2313x	goto ok;
3049		}
3050		// too large
3051	✗	detail::throw_length_error();
3052	2313x	ok:
3053		auto const new_size =
3054	2313x	size() + nchar - nremove;
3055	2313x	reserve_impl(new_size, op);
3056	2313x	dest = s_ + path_pos + pos0;
3057	2313x	op.move(
3058	2313x	dest + nchar,
3059	2313x	s_ + path_pos + pos1,
3060	2313x	size() - path_pos - pos1);
3061	4626x	impl_.set_size(
3062		id_path,
3063	2313x	impl_.len(id_path) + nchar - nremove);
3064	2313x	BOOST_ASSERT(size() == new_size);
3065	2313x	end = dest + nchar;
3066	2313x	auto const nseg1 =
3067	2313x	static_cast<std::ptrdiff_t>(impl_.nseg_) +
3068	2313x	static_cast<std::ptrdiff_t>(nseg) -
3069	2313x	static_cast<std::ptrdiff_t>(it1.index) +
3070	2313x	static_cast<std::ptrdiff_t>(it0.index) -
3071		static_cast<std::ptrdiff_t>(cp_src_prefix);
3072	2313x	BOOST_ASSERT(nseg1 >= 0);
3073	2313x	impl_.nseg_ = detail::to_size_type(nseg1);
3074	2313x	if(s_)
3075	2306x	s_[size()] = '\0';
3076		}
3077
3078		//------------------------------------------------
3079		//
3080		// Output segments and internal separators:
3081		//
3082		// prefix [ segment [ '/' segment ] ] suffix
3083		//
3084	2313x	auto const dest0 = dest;
3085	2313x	switch(prefix)
3086		{
3087	60x	case 3:
3088	60x	*dest++ = '/';
3089	60x	*dest++ = '.';
3090	60x	*dest++ = '/';
3091	60x	break;
3092	42x	case 2:
3093	42x	*dest++ = '.';
3094		BOOST_FALLTHROUGH;
3095	1193x	case 1:
3096	1193x	*dest++ = '/';
3097	1193x	break;
3098	1060x	default:
3099	1060x	break;
3100		}
3101	2313x	src.rewind();
3102	2313x	if(nseg > 0)
3103		{
3104	1277x	src.encode_colons = encode_colons;
3105		for(;;)
3106		{
3107	1603x	src.copy(dest, end);
3108	1603x	if(--nseg == 0)
3109	1277x	break;
3110	326x	*dest++ = '/';
3111	326x	src.encode_colons = false;
3112		}
3113	1277x	if(suffix)
3114	179x	*dest++ = '/';
3115		}
3116	2313x	BOOST_ASSERT(dest == dest0 + nchar);
3117
3118		// calc decoded size of new range,
3119		auto const dn =
3120	2313x	detail::decode_bytes_unsafe(
3121	2313x	core::string_view(dest0, dest - dest0));
3122	2313x	if(dn >= dn0)
3123	1401x	impl_.decoded_[id_path] +=
3124	1401x	detail::to_size_type(dn - dn0);
3125		else
3126	912x	impl_.decoded_[id_path] -=
3127	912x	detail::to_size_type(dn0 - dn);
3128
3129		return detail::segments_iter_impl(
3130	4626x	impl_, pos0, it0.index);
3131		}
3132
3133		//------------------------------------------------
3134
3135		inline
3136		auto
3137	1695x	url_base::
3138		edit_params(
3139		detail::params_iter_impl const& it0,
3140		detail::params_iter_impl const& it1,
3141		detail::any_params_iter&& src) ->
3142		detail::params_iter_impl
3143		{
3144	1695x	auto pos0 = impl_.offset(id_query);
3145	1695x	auto pos1 = pos0 + it1.pos;
3146	1695x	pos0 = pos0 + it0.pos;
3147
3148		// Iterators belong to this url
3149	1695x	BOOST_ASSERT(it0.ref.alias_of(impl_));
3150	1695x	BOOST_ASSERT(it1.ref.alias_of(impl_));
3151
3152		// Iterators is in the right order
3153	1695x	BOOST_ASSERT(it0.index <= it1.index);
3154
3155		// Iterators are within range
3156	1695x	BOOST_ASSERT(it0.index <= impl_.nparam_);
3157	1695x	BOOST_ASSERT(pos0 <= impl_.offset(id_frag));
3158	1695x	BOOST_ASSERT(it1.index <= impl_.nparam_);
3159	1695x	BOOST_ASSERT(pos1 <= impl_.offset(id_frag));
3160
3161		// calc decoded size of old range,
3162		// minus one if '?' or '&' prefixed
3163		auto dn0 =
3164		static_cast<std::ptrdiff_t>(
3165	1695x	detail::decode_bytes_unsafe(
3166		core::string_view(
3167	1695x	impl_.cs_ + pos0,
3168	1695x	pos1 - pos0)));
3169	1695x	if(impl_.len(id_query) > 0)
3170	1157x	dn0 -= 1;
3171	1695x	if(dn0 < 0)
3172	552x	dn0 = 0;
3173
3174		//------------------------------------------------
3175		//
3176		// Measure the number of encoded characters
3177		// of output, and the number of inserted
3178		// segments including internal separators.
3179		//
3180
3181	1695x	std::size_t nchar = 0;
3182	1695x	std::size_t nparam = 0;
3183	1695x	if(src.measure(nchar))
3184		{
3185	1430x	++nchar; // for '?' or '&'
3186		for(;;)
3187		{
3188	1652x	++nparam;
3189	1652x	if(! src.measure(nchar))
3190	1430x	break;
3191	222x	++nchar; // for '&'
3192		}
3193		}
3194
3195		//------------------------------------------------
3196		//
3197		// Resize
3198		//
3199	1690x	op_t op(*this, &src.s0, &src.s1);
3200		char* dest;
3201		char const* end;
3202		{
3203	1690x	auto const nremove = pos1 - pos0;
3204		// check overflow
3205	2995x	if( nchar > nremove &&
3206	1305x	nchar - nremove >
3207	1305x	max_size() - size())
3208		{
3209		// too large
3210	✗	detail::throw_length_error();
3211		}
3212	1690x	auto const nparam1 =
3213	1690x	static_cast<std::ptrdiff_t>(impl_.nparam_) +
3214	1690x	static_cast<std::ptrdiff_t>(nparam) -
3215	1690x	static_cast<std::ptrdiff_t>(it1.index) +
3216	1690x	static_cast<std::ptrdiff_t>(it0.index);
3217	1690x	BOOST_ASSERT(nparam1 >= 0);
3218	1690x	reserve_impl(size() + nchar - nremove, op);
3219	1690x	dest = s_ + pos0;
3220	1690x	end = dest + nchar;
3221	1690x	if(impl_.nparam_ > 0)
3222		{
3223		// needed when we move
3224		// the beginning of the query
3225	1152x	s_[impl_.offset(id_query)] = '&';
3226		}
3227	1690x	op.move(
3228	1690x	dest + nchar,
3229	1690x	impl_.cs_ + pos1,
3230	1690x	size() - pos1);
3231	3380x	impl_.set_size(
3232		id_query,
3233	1690x	impl_.len(id_query) +
3234		nchar - nremove);
3235	1690x	impl_.nparam_ =
3236	1690x	detail::to_size_type(nparam1);
3237	1690x	if(nparam1 > 0)
3238		{
3239		// needed when we erase
3240		// the beginning of the query
3241	1587x	s_[impl_.offset(id_query)] = '?';
3242		}
3243	1690x	if(s_)
3244	1690x	s_[size()] = '\0';
3245		}
3246	1690x	auto const dest0 = dest;
3247
3248		//------------------------------------------------
3249		//
3250		// Output params and internal separators:
3251		//
3252		// [ '?' param ] [ '&' param ]
3253		//
3254	1690x	if(nparam > 0)
3255		{
3256	1430x	if(it0.index == 0)
3257	887x	*dest++ = '?';
3258		else
3259	543x	*dest++ = '&';
3260	1430x	src.rewind();
3261		for(;;)
3262		{
3263	1652x	src.copy(dest, end);
3264	1652x	if(--nparam == 0)
3265	1430x	break;
3266	222x	*dest++ = '&';
3267		}
3268		}
3269
3270		// calc decoded size of new range,
3271		// minus one if '?' or '&' prefixed
3272		auto dn =
3273		static_cast<std::ptrdiff_t>(
3274	1690x	detail::decode_bytes_unsafe(
3275	1690x	core::string_view(dest0, dest - dest0)));
3276	1690x	if(impl_.len(id_query) > 0)
3277	1587x	dn -= 1;
3278	1690x	if(dn < 0)
3279	157x	dn = 0;
3280
3281	1690x	if(dn >= dn0)
3282	1310x	impl_.decoded_[id_query] +=
3283	1310x	detail::to_size_type(dn - dn0);
3284		else
3285	380x	impl_.decoded_[id_query] -=
3286	380x	detail::to_size_type(dn0 - dn);
3287
3288		return detail::params_iter_impl(
3289	1690x	impl_,
3290	1690x	pos0 - impl_.offset_[id_query],
3291	3380x	it0.index);
3292	1690x	}
3293
3294		//------------------------------------------------
3295
3296		inline
3297		void
3298	563x	url_base::
3299		decoded_to_lower_impl(int id) noexcept
3300		{
3301	563x	char* it = s_ + impl_.offset(id);
3302	563x	char const* const end = s_ + impl_.offset(id + 1);
3303	3559x	while(it < end)
3304		{
3305	2996x	if (*it != '%')
3306		{
3307	5962x	*it = grammar::to_lower(
3308	2981x	*it);
3309	2981x	++it;
3310	2981x	continue;
3311		}
3312	15x	it += 3;
3313		}
3314	563x	}
3315
3316		inline
3317		void
3318	217x	url_base::
3319		to_lower_impl(int id) noexcept
3320		{
3321	217x	char* it = s_ + impl_.offset(id);
3322	217x	char const* const end = s_ + impl_.offset(id + 1);
3323	1088x	while(it < end)
3324		{
3325	1742x	*it = grammar::to_lower(
3326	871x	*it);
3327	871x	++it;
3328		}
3329	217x	}
3330
3331		} // urls
3332		} // boost
3333
3334		#endif
3335