vendor/url-1.6.0/src/slicing.rs

   1 // Copyright 2016 The rust-url developers.
   2 //
   3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   6 // option. This file may not be copied, modified, or distributed
   7 // except according to those terms.
   8
   9 use std::ops::{Range, RangeFrom, RangeTo, RangeFull, Index};
  10 use Url;
  11
  12 impl Index<RangeFull> for Url {
  13     type Output = str;
  14     fn index(&self, _: RangeFull) -> &str {
  15         &self.serialization
  16     }
  17 }
  18
  19 impl Index<RangeFrom<Position>> for Url {
  20     type Output = str;
  21     fn index(&self, range: RangeFrom<Position>) -> &str {
  22         &self.serialization[self.index(range.start)..]
  23     }
  24 }
  25
  26 impl Index<RangeTo<Position>> for Url {
  27     type Output = str;
  28     fn index(&self, range: RangeTo<Position>) -> &str {
  29         &self.serialization[..self.index(range.end)]
  30     }
  31 }
  32
  33 impl Index<Range<Position>> for Url {
  34     type Output = str;
  35     fn index(&self, range: Range<Position>) -> &str {
  36         &self.serialization[self.index(range.start)..self.index(range.end)]
  37     }
  38 }
  39
  40 /// Indicates a position within a URL based on its components.
  41 ///
  42 /// A range of positions can be used for slicing `Url`:
  43 ///
  44 /// ```rust
  45 /// # use url::{Url, Position};
  46 /// # fn something(some_url: Url) {
  47 /// let serialization: &str = &some_url[..];
  48 /// let serialization_without_fragment: &str = &some_url[..Position::AfterQuery];
  49 /// let authority: &str = &some_url[Position::BeforeUsername..Position::AfterPort];
  50 /// let data_url_payload: &str = &some_url[Position::BeforePath..Position::AfterQuery];
  51 /// let scheme_relative: &str = &some_url[Position::BeforeUsername..];
  52 /// # }
  53 /// ```
  54 ///
  55 /// In a pseudo-grammar (where `[`…`]?` makes a sub-sequence optional),
  56 /// URL components and delimiters that separate them are:
  57 ///
  58 /// ```notrust
  59 /// url =
  60 ///     scheme ":"
  61 ///     [ "//" [ username [ ":" password ]? "@" ]? host [ ":" port ]? ]?
  62 ///     path [ "?" query ]? [ "#" fragment ]?
  63 /// ```
  64 ///
  65 /// When a given component is not present,
  66 /// its "before" and "after" position are the same
  67 /// (so that `&some_url[BeforeFoo..AfterFoo]` is the empty string)
  68 /// and component ordering is preserved
  69 /// (so that a missing query "is between" a path and a fragment).
  70 ///
  71 /// The end of a component and the start of the next are either the same or separate
  72 /// by a delimiter.
  73 /// (Not that the initial `/` of a path is considered part of the path here, not a delimiter.)
  74 /// For example, `&url[..BeforeFragment]` would include a `#` delimiter (if present in `url`),
  75 /// so `&url[..AfterQuery]` might be desired instead.
  76 ///
  77 /// `BeforeScheme` and `AfterFragment` are always the start and end of the entire URL,
  78 /// so `&url[BeforeScheme..X]` is the same as `&url[..X]`
  79 /// and `&url[X..AfterFragment]` is the same as `&url[X..]`.
  80 #[derive(Copy, Clone, Debug)]
  81 pub enum Position {
  82     BeforeScheme,
  83     AfterScheme,
  84     BeforeUsername,
  85     AfterUsername,
  86     BeforePassword,
  87     AfterPassword,
  88     BeforeHost,
  89     AfterHost,
  90     BeforePort,
  91     AfterPort,
  92     BeforePath,
  93     AfterPath,
  94     BeforeQuery,
  95     AfterQuery,
  96     BeforeFragment,
  97     AfterFragment
  98 }
  99
 100 impl Url {
 101     #[inline]
 102     fn index(&self, position: Position) -> usize {
 103         match position {
 104             Position::BeforeScheme => 0,
 105
 106             Position::AfterScheme => self.scheme_end as usize,
 107
 108             Position::BeforeUsername => if self.has_authority() {
 109                 self.scheme_end as usize + "://".len()
 110             } else {
 111                 debug_assert!(self.byte_at(self.scheme_end) == b':');
 112                 debug_assert!(self.scheme_end + ":".len() as u32 == self.username_end);
 113                 self.scheme_end as usize + ":".len()
 114             },
 115
 116             Position::AfterUsername => self.username_end as usize,
 117
 118             Position::BeforePassword => if self.has_authority() &&
 119                                            self.byte_at(self.username_end) == b':' {
 120                 self.username_end as usize + ":".len()
 121             } else {
 122                 debug_assert!(self.username_end == self.host_start);
 123                 self.username_end as usize
 124             },
 125
 126             Position::AfterPassword => if self.has_authority() &&
 127                                           self.byte_at(self.username_end) == b':' {
 128                 debug_assert!(self.byte_at(self.host_start - "@".len() as u32) == b'@');
 129                 self.host_start as usize - "@".len()
 130             } else {
 131                 debug_assert!(self.username_end == self.host_start);
 132                 self.host_start as usize
 133             },
 134
 135             Position::BeforeHost => self.host_start as usize,
 136
 137             Position::AfterHost => self.host_end as usize,
 138
 139             Position::BeforePort => if self.port.is_some() {
 140                 debug_assert!(self.byte_at(self.host_end) == b':');
 141                 self.host_end as usize + ":".len()
 142             } else {
 143                 self.host_end as usize
 144             },
 145
 146             Position::AfterPort => self.path_start as usize,
 147
 148             Position::BeforePath => self.path_start as usize,
 149
 150             Position::AfterPath => match (self.query_start, self.fragment_start) {
 151                 (Some(q), _) => q as usize,
 152                 (None, Some(f)) => f as usize,
 153                 (None, None) => self.serialization.len(),
 154             },
 155
 156             Position::BeforeQuery => match (self.query_start, self.fragment_start) {
 157                 (Some(q), _) => {
 158                     debug_assert!(self.byte_at(q) == b'?');
 159                     q as usize + "?".len()
 160                 }
 161                 (None, Some(f)) => f as usize,
 162                 (None, None) => self.serialization.len(),
 163             },
 164
 165             Position::AfterQuery => match self.fragment_start {
 166                 None => self.serialization.len(),
 167                 Some(f) => f as usize,
 168             },
 169
 170             Position::BeforeFragment => match self.fragment_start {
 171                 Some(f) => {
 172                     debug_assert!(self.byte_at(f) == b'#');
 173                     f as usize + "#".len()
 174                 }
 175                 None => self.serialization.len(),
 176             },
 177
 178             Position::AfterFragment => self.serialization.len(),
 179         }
 180     }
 181 }
 182