1
0
mirror of https://github.com/fafhrd91/actix-net synced 2024-12-22 21:13:24 +01:00
actix-net/router/src/path.rs

223 lines
5.3 KiB
Rust
Raw Permalink Normal View History

2019-01-05 22:19:25 +01:00
use std::ops::Index;
2019-01-16 04:25:49 +01:00
use serde::de;
use crate::de::PathDeserializer;
2019-03-04 21:41:39 +01:00
use crate::{Resource, ResourcePath};
2019-01-05 22:19:25 +01:00
#[derive(Debug, Clone, Copy)]
pub(crate) enum PathItem {
Static(&'static str),
Segment(u16, u16),
}
/// Resource path match information
///
/// If resource path contains variable patterns, `Path` stores them.
2019-01-06 07:00:38 +01:00
#[derive(Debug)]
2019-01-05 22:19:25 +01:00
pub struct Path<T> {
path: T,
pub(crate) skip: u16,
2019-12-31 07:04:35 +01:00
pub(crate) segments: Vec<(&'static str, PathItem)>,
2019-01-05 22:19:25 +01:00
}
impl<T: Default> Default for Path<T> {
fn default() -> Self {
Path {
path: T::default(),
skip: 0,
segments: Vec::new(),
}
}
}
2019-01-06 07:00:38 +01:00
impl<T: Clone> Clone for Path<T> {
fn clone(&self) -> Self {
Path {
path: self.path.clone(),
skip: self.skip,
segments: self.segments.clone(),
}
}
}
impl<T: ResourcePath> Path<T> {
2019-01-05 22:19:25 +01:00
pub fn new(path: T) -> Path<T> {
Path {
path,
skip: 0,
segments: Vec::new(),
}
}
#[inline]
2019-01-06 07:00:38 +01:00
/// Get reference to inner path instance
pub fn get_ref(&self) -> &T {
&self.path
}
#[inline]
2019-01-06 07:00:38 +01:00
/// Get mutable reference to inner path instance
pub fn get_mut(&mut self) -> &mut T {
&mut self.path
}
#[inline]
2019-01-06 17:12:51 +01:00
/// Path
2019-01-05 22:19:25 +01:00
pub fn path(&self) -> &str {
let skip = self.skip as usize;
let path = self.path.path();
if skip <= path.len() {
&path[skip..]
} else {
""
}
}
#[inline]
/// Set new path
2019-01-06 17:12:51 +01:00
pub fn set(&mut self, path: T) {
2019-01-05 22:19:25 +01:00
self.skip = 0;
self.path = path;
self.segments.clear();
}
#[inline]
/// Reset state
pub fn reset(&mut self) {
self.skip = 0;
self.segments.clear();
}
#[inline]
2019-01-05 22:19:25 +01:00
/// Skip first `n` chars in path
pub fn skip(&mut self, n: u16) {
self.skip += n;
2019-01-05 22:19:25 +01:00
}
2019-12-31 07:04:35 +01:00
pub(crate) fn add(&mut self, name: &'static str, value: PathItem) {
2019-01-05 22:19:25 +01:00
match value {
PathItem::Static(s) => self.segments.push((name, PathItem::Static(s))),
PathItem::Segment(begin, end) => self
.segments
.push((name, PathItem::Segment(self.skip + begin, self.skip + end))),
}
}
2019-01-06 07:00:38 +01:00
#[doc(hidden)]
2019-12-31 07:04:35 +01:00
pub fn add_static(&mut self, name: &'static str, value: &'static str) {
self.segments.push((name, PathItem::Static(value)));
2019-01-05 22:19:25 +01:00
}
#[inline]
2019-01-05 22:19:25 +01:00
/// Check if there are any matched patterns
pub fn is_empty(&self) -> bool {
self.segments.is_empty()
}
#[inline]
2019-01-05 22:19:25 +01:00
/// Check number of extracted parameters
pub fn len(&self) -> usize {
self.segments.len()
}
/// Get matched parameter by name without type conversion
pub fn get(&self, key: &str) -> Option<&str> {
for item in self.segments.iter() {
2019-12-31 07:04:35 +01:00
if key == item.0 {
2019-01-05 22:19:25 +01:00
return match item.1 {
PathItem::Static(ref s) => Some(&s),
PathItem::Segment(s, e) => {
Some(&self.path.path()[(s as usize)..(e as usize)])
}
};
}
}
if key == "tail" {
Some(&self.path.path()[(self.skip as usize)..])
} else {
None
}
}
2019-01-06 17:12:51 +01:00
/// Get unprocessed part of the path
2019-01-05 22:19:25 +01:00
pub fn unprocessed(&self) -> &str {
&self.path.path()[(self.skip as usize)..]
}
/// Get matched parameter by name.
///
/// If keyed parameter is not available empty string is used as default
/// value.
pub fn query(&self, key: &str) -> &str {
if let Some(s) = self.get(key) {
s
} else {
""
}
}
/// Return iterator to items in parameter container
pub fn iter(&self) -> PathIter<T> {
PathIter {
idx: 0,
params: self,
}
}
2019-01-16 04:25:49 +01:00
/// Try to deserialize matching parameters to a specified type `U`
pub fn load<'de, U: serde::Deserialize<'de>>(&'de self) -> Result<U, de::value::Error> {
de::Deserialize::deserialize(PathDeserializer::new(self))
}
2019-01-05 22:19:25 +01:00
}
#[derive(Debug)]
pub struct PathIter<'a, T> {
idx: usize,
params: &'a Path<T>,
}
impl<'a, T: ResourcePath> Iterator for PathIter<'a, T> {
2019-01-05 22:19:25 +01:00
type Item = (&'a str, &'a str);
#[inline]
fn next(&mut self) -> Option<(&'a str, &'a str)> {
if self.idx < self.params.len() {
let idx = self.idx;
let res = match self.params.segments[idx].1 {
PathItem::Static(ref s) => &s,
PathItem::Segment(s, e) => &self.params.path.path()[(s as usize)..(e as usize)],
};
self.idx += 1;
return Some((&self.params.segments[idx].0, res));
}
None
}
}
impl<'a, T: ResourcePath> Index<&'a str> for Path<T> {
2019-01-05 22:19:25 +01:00
type Output = str;
fn index(&self, name: &'a str) -> &str {
self.get(name)
.expect("Value for parameter is not available")
}
}
impl<T: ResourcePath> Index<usize> for Path<T> {
2019-01-05 22:19:25 +01:00
type Output = str;
fn index(&self, idx: usize) -> &str {
match self.segments[idx].1 {
PathItem::Static(ref s) => &s,
PathItem::Segment(s, e) => &self.path.path()[(s as usize)..(e as usize)],
}
}
}
2019-03-04 21:41:39 +01:00
impl<T: ResourcePath> Resource<T> for Path<T> {
fn resource_path(&mut self) -> &mut Self {
self
}
}