Struct ObjectDir

pub struct ObjectDir<'a>(/* private fields */);

OSS Object 对象路径的前缀目录 不带前缀 /, 且必须以 / 结尾

Implementations

impl<'a> ObjectDir<'a>

pub fn new<'b: 'a>( val: impl Into<Cow<'b, str>>, ) -> Result<Self, InvalidObjectDir>

Creates a new ObjectPath from the given string.

assert!(ObjectDir::new("abc/").is_ok());
assert!(ObjectDir::new("abc/def/").is_ok());
assert!(ObjectDir::new("/").is_err());
assert!(ObjectDir::new("/abc/").is_err());
assert!(ObjectDir::new(".abc/").is_err());
assert!(ObjectDir::new("../abc/").is_err());
assert!(ObjectDir::new(r"aaa\abc/").is_err());

pub const unsafe fn from_static(secret: &'a str) -> Self

Safety

Const function that creates a new ObjectPath from a static str.

let path = unsafe { ObjectDir::from_static("abc/") };
assert!(path == "abc/");

Trait Implementations

impl<'dir1, 'dir2: 'dir1> Add<ObjectDir<'dir2>> for ObjectDir<'dir1>

fn add(self, rhs: ObjectDir<'dir2>) -> Self::Output

支持 ObjectDir 相加运算

let dir1 = ObjectDir::new("dir1/").unwrap();
let dir2 = ObjectDir::new("dir2/").unwrap();
let full_dir = ObjectDir::new("dir1/dir2/").unwrap();

assert_eq!(dir1 + dir2, full_dir);

type Output = ObjectDir<'dir1>

The resulting type after applying the + operator.

impl<'file, 'dir: 'file> Add<ObjectPathInner<'file>> for ObjectDir<'dir>

fn add(self, rhs: ObjectPathInner<'file>) -> Self::Output

支持 ObjectDir 与 ObjectPath 相加运算

let dir1 = ObjectDir::new("dir1/").unwrap();
let file1 = ObjectPath::new("img1.png").unwrap();
let full_file = ObjectPath::new("dir1/img1.png").unwrap();

assert_eq!(dir1 + file1, full_file);

type Output = ObjectPathInner<'file>

The resulting type after applying the + operator.

impl<'dir1, 'dir2: 'dir1> AddAssign<ObjectDir<'dir2>> for ObjectDir<'dir1>

fn add_assign(&mut self, rhs: ObjectDir<'dir2>)

支持 ObjectDir 相加运算

let mut dir1 = ObjectDir::new("dir1/").unwrap();
let dir2 = ObjectDir::new("dir2/").unwrap();
let full_dir = ObjectDir::new("dir1/dir2/").unwrap();

dir1 += dir2;
assert_eq!(dir1, full_dir);

impl AsMut<String> for ObjectDir<'_>

fn as_mut(&mut self) -> &mut String

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<str> for ObjectDir<'_>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for ObjectDir<'a>

fn clone(&self) -> ObjectDir<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ObjectDir<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ObjectDir<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for ObjectDir<'_>

fn from_str(s: &str) -> Result<Self, Self::Err>

use std::str::FromStr;
let path: ObjectDir = "path1/".parse().unwrap();
assert!(path == "path1/");
assert!(ObjectDir::from_str("abc/").is_ok());
assert!(ObjectDir::from_str("abc/def/").is_ok());
assert!(ObjectDir::from_str("/").is_err());
assert!(ObjectDir::from_str("/abc/").is_err());
assert!(ObjectDir::from_str(".abc/").is_err());
assert!(ObjectDir::from_str("../abc/").is_err());
assert!(ObjectDir::from_str(r"aaa\abc/").is_err());

type Err = InvalidObjectDir

The associated error which can be returned from parsing.

impl<'a> Hash for ObjectDir<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<&str> for ObjectDir<'_>

fn eq(&self, other: &&str) -> bool

相等比较

let path = ObjectDir::new("abc/").unwrap();
assert!(path == "abc/");

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<ObjectDir<'_>> for &str

fn eq(&self, other: &ObjectDir<'_>) -> bool

相等比较

let path = ObjectDir::new("abc/").unwrap();
assert!("abc/" == path);

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<ObjectDir<'_>> for String

fn eq(&self, other: &ObjectDir<'_>) -> bool

相等比较

let path = ObjectDir::new("abc/").unwrap();
assert!("abc/".to_string() == path);

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<String> for ObjectDir<'_>

fn eq(&self, other: &String) -> bool

相等比较

let path = ObjectDir::new("abc/").unwrap();
assert!(path == "abc/".to_string());

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq for ObjectDir<'a>

fn eq(&self, other: &ObjectDir<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&Path> for ObjectDir<'_>

type Error = InvalidObjectDir

The type returned in the event of a conversion error.

fn try_from(value: &Path) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a: 'b, 'b> TryFrom<&'a str> for ObjectDir<'b>

type Error = InvalidObjectDir

The type returned in the event of a conversion error.

fn try_from(val: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for ObjectDir<'_>

fn try_from(val: String) -> Result<Self, Self::Error>

let path: ObjectDir = String::from("abc/").try_into().unwrap();
assert!(path == "abc/");

type Error = InvalidObjectDir

The type returned in the event of a conversion error.

impl<'a> Eq for ObjectDir<'a>

impl<'a> StructuralPartialEq for ObjectDir<'a>