Struct AssetPath 

pub struct AssetPath<'a> { /* private fields */ }

A path identifier for assets.

AssetPath represents the path used to load an asset, supporting both owned and borrowed string data. It provides utility methods for working with asset paths.

Path Format

Asset paths use forward slashes as separators, regardless of platform:

• textures/player.png
• audio/music/theme.ogg
• shaders/basic.vert

FFI Considerations

For FFI, convert to a C string using as_str() and standard FFI string handling. The path does not include a null terminator by default.

Example

use goud_engine::assets::AssetPath;

let path = AssetPath::new("textures/player.png");

assert_eq!(path.as_str(), "textures/player.png");
assert_eq!(path.file_name(), Some("player.png"));
assert_eq!(path.extension(), Some("png"));
assert_eq!(path.directory(), Some("textures"));

// From owned string
let owned = AssetPath::from_string("audio/sfx/jump.wav".to_string());
assert_eq!(owned.extension(), Some("wav"));

Implementations

impl<'a> AssetPath<'a>

pub fn new(path: &'a str) -> Self

Creates a new asset path from a string slice.

Example

use goud_engine::assets::AssetPath;

let path = AssetPath::new("textures/player.png");
assert_eq!(path.as_str(), "textures/player.png");

pub fn from_string(path: String) -> AssetPath<'static>

Creates a new asset path from an owned string.

Example

use goud_engine::assets::AssetPath;

let path = AssetPath::from_string("textures/player.png".to_string());
assert_eq!(path.as_str(), "textures/player.png");

pub fn as_str(&self) -> &str

Returns the path as a string slice.

pub fn is_empty(&self) -> bool

Returns true if the path is empty.

pub fn len(&self) -> usize

Returns the length of the path in bytes.

pub fn file_name(&self) -> Option<&str>

Returns the file name component of the path.

Example

use goud_engine::assets::AssetPath;

assert_eq!(AssetPath::new("textures/player.png").file_name(), Some("player.png"));
assert_eq!(AssetPath::new("player.png").file_name(), Some("player.png"));
assert_eq!(AssetPath::new("textures/").file_name(), None);

pub fn extension(&self) -> Option<&str>

Returns the file extension, if any.

Example

use goud_engine::assets::AssetPath;

assert_eq!(AssetPath::new("player.png").extension(), Some("png"));
assert_eq!(AssetPath::new("textures/player.png").extension(), Some("png"));
assert_eq!(AssetPath::new("Makefile").extension(), None);
assert_eq!(AssetPath::new(".gitignore").extension(), None);

pub fn directory(&self) -> Option<&str>

Returns the directory component of the path.

Example

use goud_engine::assets::AssetPath;

assert_eq!(AssetPath::new("textures/player.png").directory(), Some("textures"));
assert_eq!(AssetPath::new("a/b/c/file.txt").directory(), Some("a/b/c"));
assert_eq!(AssetPath::new("file.txt").directory(), None);

pub fn stem(&self) -> Option<&str>

Returns the file stem (file name without extension).

Example

use goud_engine::assets::AssetPath;

assert_eq!(AssetPath::new("player.png").stem(), Some("player"));
assert_eq!(AssetPath::new("textures/player.png").stem(), Some("player"));
assert_eq!(AssetPath::new("archive.tar.gz").stem(), Some("archive.tar"));
assert_eq!(AssetPath::new(".gitignore").stem(), Some(".gitignore"));

pub fn into_owned(self) -> AssetPath<'static>

Converts this path to an owned AssetPath<'static>.

If the path is already owned, this is a no-op. If borrowed, the string is cloned.

pub fn from_path(path: &Path) -> AssetPath<'static>

Creates an AssetPath from a std::path::Path.

Converts backslashes to forward slashes for platform consistency.

Example

use goud_engine::assets::AssetPath;
use std::path::Path;

let path = AssetPath::from_path(Path::new("textures/player.png"));
assert_eq!(path.as_str(), "textures/player.png");

pub fn join(&self, other: &str) -> AssetPath<'static>

Joins this path with another path component.

Example

use goud_engine::assets::AssetPath;

let base = AssetPath::new("textures");
let full = base.join("player.png");
assert_eq!(full.as_str(), "textures/player.png");

// Handles trailing slashes
let base = AssetPath::new("textures/");
let full = base.join("player.png");
assert_eq!(full.as_str(), "textures/player.png");

pub fn with_extension(&self, ext: &str) -> AssetPath<'static>

Returns the path with a different extension.

Example

use goud_engine::assets::AssetPath;

let path = AssetPath::new("textures/player.png");
let new_path = path.with_extension("jpg");
assert_eq!(new_path.as_str(), "textures/player.jpg");

// Add extension to file without one
let path = AssetPath::new("Makefile");
let new_path = path.with_extension("bak");
assert_eq!(new_path.as_str(), "Makefile.bak");

Trait Implementations

impl<'a> AsRef<str> for AssetPath<'a>

fn as_ref(&self) -> &str

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

impl<'a> Clone for AssetPath<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for AssetPath<'a>

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

Formats the value using the given formatter.

impl<'a> Display for AssetPath<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for AssetPath<'a>

fn from(s: &'a str) -> Self

Converts to this type from the input type.

impl From<String> for AssetPath<'static>

fn from(s: String) -> Self

Converts to this type from the input type.

impl<'a> Hash for AssetPath<'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<'a> PartialEq<&str> for AssetPath<'a>

fn eq(&self, other: &&str) -> 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<'a> PartialEq<str> for AssetPath<'a>

fn eq(&self, other: &str) -> 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<'a> PartialEq for AssetPath<'a>

fn eq(&self, other: &AssetPath<'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<'a> Eq for AssetPath<'a>

impl<'a> StructuralPartialEq for AssetPath<'a>