113 lines
3.3 KiB
Rust
113 lines
3.3 KiB
Rust
use std::{slice, str};
|
|
|
|
use ffi;
|
|
use error::{Error, Result};
|
|
use util::{check_stack, StackGuard};
|
|
use types::LuaRef;
|
|
|
|
/// Handle to an internal Lua string.
|
|
///
|
|
/// Unlike Rust strings, Lua strings may not be valid UTF-8.
|
|
#[derive(Clone, Debug)]
|
|
pub struct String<'lua>(pub(crate) LuaRef<'lua>);
|
|
|
|
impl<'lua> String<'lua> {
|
|
/// Get a `&str` slice if the Lua string is valid UTF-8.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate rlua;
|
|
/// # use rlua::{Lua, String, Result};
|
|
/// # fn try_main() -> Result<()> {
|
|
/// let lua = Lua::new();
|
|
/// let globals = lua.globals();
|
|
///
|
|
/// let version: String = globals.get("_VERSION")?;
|
|
/// assert!(version.to_str().unwrap().contains("Lua"));
|
|
///
|
|
/// let non_utf8: String = lua.eval(r#" "test\xff" "#, None)?;
|
|
/// assert!(non_utf8.to_str().is_err());
|
|
/// # Ok(())
|
|
/// # }
|
|
/// # fn main() {
|
|
/// # try_main().unwrap();
|
|
/// # }
|
|
/// ```
|
|
pub fn to_str(&self) -> Result<&str> {
|
|
str::from_utf8(self.as_bytes()).map_err(|e| Error::FromLuaConversionError {
|
|
from: "string",
|
|
to: "&str",
|
|
message: Some(e.to_string()),
|
|
})
|
|
}
|
|
|
|
/// Get the bytes that make up this string.
|
|
///
|
|
/// The returned slice will not contain the terminating nul byte, but will contain any nul
|
|
/// bytes embedded into the Lua string.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate rlua;
|
|
/// # use rlua::{Lua, String};
|
|
/// # fn main() {
|
|
/// let lua = Lua::new();
|
|
///
|
|
/// let non_utf8: String = lua.eval(r#" "test\xff" "#, None).unwrap();
|
|
/// assert!(non_utf8.to_str().is_err()); // oh no :(
|
|
/// assert_eq!(non_utf8.as_bytes(), &b"test\xff"[..]);
|
|
/// # }
|
|
/// ```
|
|
pub fn as_bytes(&self) -> &[u8] {
|
|
let nulled = self.as_bytes_with_nul();
|
|
&nulled[..nulled.len() - 1]
|
|
}
|
|
|
|
/// Get the bytes that make up this string, including the trailing nul byte.
|
|
pub fn as_bytes_with_nul(&self) -> &[u8] {
|
|
let lua = self.0.lua;
|
|
unsafe {
|
|
let _sg = StackGuard::new(lua.state);
|
|
check_stack(lua.state, 1);
|
|
|
|
lua.push_ref(&self.0);
|
|
rlua_assert!(
|
|
ffi::lua_type(lua.state, -1) == ffi::LUA_TSTRING,
|
|
"string ref is not string type"
|
|
);
|
|
|
|
let mut size = 0;
|
|
// This will not trigger a 'm' error, because the reference is guaranteed to be of
|
|
// string type
|
|
let data = ffi::lua_tolstring(lua.state, -1, &mut size);
|
|
|
|
slice::from_raw_parts(data as *const u8, size + 1)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'lua> AsRef<[u8]> for String<'lua> {
|
|
fn as_ref(&self) -> &[u8] {
|
|
self.as_bytes()
|
|
}
|
|
}
|
|
|
|
// Lua strings are basically &[u8] slices, so implement PartialEq for anything resembling that.
|
|
//
|
|
// This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str`, `String` and `rlua::String`
|
|
// itself.
|
|
//
|
|
// The only downside is that this disallows a comparison with `Cow<str>`, as that only implements
|
|
// `AsRef<str>`, which collides with this impl. Requiring `AsRef<str>` would fix that, but limit us
|
|
// in other ways.
|
|
impl<'lua, T> PartialEq<T> for String<'lua>
|
|
where
|
|
T: AsRef<[u8]>,
|
|
{
|
|
fn eq(&self, other: &T) -> bool {
|
|
self.as_bytes() == other.as_ref()
|
|
}
|
|
}
|