Struct rutie::RString [−][src]
pub struct RString { /* fields omitted */ }
Expand description
String
Implementations
👎 Deprecated since 0.3.2: please use new_usascii_unchecked
or new_utf8
instead
please use new_usascii_unchecked
or new_utf8
instead
Creates a new instance of Ruby String
containing given string
.
Examples
use rutie::{RString, VM};
let string = RString::new("Hello, World!");
assert_eq!(string.to_str(), "Hello, World!");
Ruby:
str = 'Hello, World!'
str == 'Hello, World!'
Creates a new instance of Ruby String
, with UTF8 encoding, containing
given string
.
Examples
use rutie::{RString, VM};
let string = RString::new_utf8("Hello, World!");
assert_eq!(string.to_string(), "Hello, World!".to_string());
Ruby:
str = 'Hello, World!'
str == 'Hello, World!'
Creates a new instance of Ruby String
containing given string
.
Examples
use rutie::{RString, VM};
let string = RString::new_usascii_unchecked("Hello, World!");
assert_eq!(string.to_str(), "Hello, World!");
Ruby:
str = 'Hello, World!'
str == 'Hello, World!'
Creates a new instance of Ruby String
from given byte
sequence with given Encoding
.
Examples
use rutie::{RString, Encoding, EncodingSupport, VM};
let bytes = [197, 130, 97, 197, 130];
let enc = Encoding::find("UTF-8").unwrap();
let string = RString::from_bytes(&bytes, &enc);
assert_eq!(string.to_str(), "łał");
VM::require("enc/encdb");
VM::require("enc/trans/transdb");
let result = string.encode(Encoding::find("UTF-16").unwrap(), None);
assert_eq!(result.to_bytes_unchecked(), [254, 255, 1, 66, 0, 97, 1, 66])
Retrieves underlying Rust String
from Ruby String
object.
Examples
use rutie::{RString, VM};
let string = RString::new_utf8("Hello, World!");
assert_eq!(string.to_string(), "Hello, World!".to_string());
Ruby:
str = 'Hello, World!'
str == 'Hello, World!'
Retrieves underlying Rust String
from Ruby String
object.
Unlike to_string()
it does not perform any checks for internal null-bytes.
This function may be used to safely get binary data from Ruby.
Examples
use rutie::{RString, VM};
let string = RString::new_utf8("Hello,\0World!");
assert_eq!(string.to_string_unchecked(), "Hello,\0World!".to_string());
Ruby:
str = 'Hello,\0World!'
str == 'Hello,\0World!'
Retrieves Vec<u8>
from Ruby String
object.
Unlike to_string()
it does not perform any checks for internal null-bytes.
This function may be used to safely get binary data from Ruby.
Examples
use rutie::{RString, VM};
let string = RString::new_utf8("Hello,\0World!");
assert_eq!(string.to_vec_u8_unchecked(), (b"Hello,\0World!").to_vec());
Retrieves underlying &str
from Ruby String
object.
Examples
use rutie::{RString, VM};
let string = RString::new_utf8("Hello, World!");
assert_eq!(string.to_str(), "Hello, World!");
Ruby:
str = 'Hello, World!'
str == 'Hello, World!'
Retrieves underlying &str
from Ruby String
object.
Unlike to_str()
it does not perform any checks for internal null-bytes.
This function may be used to safely get binary data from Ruby.
Examples
use rutie::{RString, VM};
let string = RString::new_utf8("Hello,\0World!");
assert_eq!(string.to_str_unchecked(), "Hello,\0World!");
Ruby:
str = 'Hello,\0World!'
str == 'Hello,\0World!'
Retrieves underlying &[u8]
from Ruby String
object.
Unlike to_str()
it does not perform any checks for internal null-bytes.
This function may be used to safely get binary data from Ruby.
Examples
use rutie::{RString, VM};
let string = RString::new_utf8("Hello,\0World!");
assert_eq!(string.to_bytes_unchecked(), b"Hello,\0World!");
Returns an array of each characters codepoints. This is useful as a strings encoding determines where the codepoints are.
Examples
use rutie::{Object, RString, Array, Fixnum, Encoding, EncodingSupport, VM};
VM::require("enc/encdb");
VM::require("enc/trans/transdb");
let string = RString::from_bytes(b"foo\x93_a", &Encoding::find("cp932").unwrap());
let codepoints: Array = [102, 111, 111, 37727, 97].
into_iter().map(|cp| Fixnum::new(*cp as i64).to_any_object()).collect();
assert!(string.codepoints().equals(&codepoints), "not equal!");
Ruby:
str = "foo\x93_a".force_encoding("cp932")
str.codepoints == [102, 111, 111, 37727, 97]
Returns the length of the string in bytes
Examples
use rutie::{RString, VM};
let string = RString::new_utf8("Hello, World!");
let utf8_string = RString::new_utf8("⓯");
assert_eq!(string.bytesize(), 13);
assert_eq!(utf8_string.bytesize(), 3);
Ruby:
string = 'Hello, World!'
utf8_string = '⓯'
string.bytesize == 13
utf8_string.bytesize == 3
Returns the number of characters in the string
Examples
use rutie::{RString, VM};
let string = RString::new_utf8("Hello, World!");
let utf8_string = RString::new_utf8("⓯");
assert_eq!(string.count_chars(), 13);
assert_eq!(utf8_string.count_chars(), 1);
Ruby:
string = 'Hello, World!'
utf8_string = '⓯'
string.length == 13
utf8_string.length == 1
Appends a given string slice onto the end of this String.
Examples
use rutie::{RString, VM};
let mut string = RString::new_utf8("Hello, ");
string.concat("World!");
assert_eq!(string.to_string(), "Hello, World!".to_string());
Ruby:
str = 'Hello, '
str << 'World!'
str == 'Hello, World!'
Trait Implementations
Get the strings Encoding
.
Examples
use rutie::{RString, VM, EncodingSupport};
let string = RString::new_utf8("Hello");
string.encoding();
Ruby:
string = "Hello"
string.encoding()
Changes the encoding to encoding and returns Result<Self, AnyException>
.
Examples
use rutie::{RString, VM, EncodingSupport, Encoding};
let mut string = RString::new_utf8("Hello");
string.force_encoding(Encoding::us_ascii());
assert_eq!(string.encoding().name(), "US-ASCII");
Ruby:
string = "Hello"
string.force_encoding(Encoding::US_ASCII)
string.encoding.name == "US-ASCII"
use rutie::{RString, VM, EncodingSupport, Encoding, Object, Exception};
let mut string = RString::new_utf8("Hello");
string.force_encoding(Encoding::utf8());
string.freeze();
let result = string.force_encoding(Encoding::us_ascii());
match result {
Ok(_) => assert_eq!("This is a bad path.", "You shouldn't get this message."),
Err(happy_path) => assert_eq!(happy_path.message(), "can\'t modify frozen String"),
}
Transcodes to encoding and returns Self
.
Examples
use rutie::{RString, VM, EncodingSupport, Encoding};
let mut string = RString::new_utf8("Hello");
let result = string.encode(Encoding::us_ascii(), None);
assert_eq!(result.encoding().name(), "US-ASCII");
Ruby:
string = "Hello"
result = string.encode(Encoding::US_ASCII)
result.encoding.name == "US-ASCII"
Transcodes to encoding and returns Self
.
Examples
use rutie::{RString, VM, EncodingSupport, Encoding, Object};
let mut string = RString::new_utf8("Hello");
assert!(string.is_valid_encoding(), "not valid encoding!");
VM::require("enc/encdb");
VM::require("enc/trans/transdb");
let result = VM::eval("'Hello'.force_encoding('UTF-32')").unwrap().
try_convert_to::<RString>().unwrap();
assert!(!result.is_valid_encoding(), "is valid encoding!");
Ruby:
string = "Hello"
string.valid_encoding? == true
result = string.encode(Encoding::UTF_32)
result.valid_encoding? == false
Reveals if the given object has a compatible encoding with this String.
Examples
use rutie::{RString, VM, EncodingSupport};
let string1 = RString::new_utf8("Hello");
let string2 = RString::new_usascii_unchecked("Hello");
assert!(string1.compatible_with(&string2));
Ruby:
str1 = 'Hello'.force_encoding("UTF-8")
str2 = 'Hello'.force_encoding("US-ASCII")
str1 + str2 == "HelloHello"
Returns AnyObject
of the compatible encoding between the two objects
or nil if incompatible.
Examples
use rutie::{RString, VM, EncodingSupport};
let string1 = RString::new_utf8("Hello");
let string2 = RString::new_usascii_unchecked("Hello");
RString::compatible_encoding(&string1, &string2);
Ruby:
str1 = 'Hello'.force_encoding("UTF-8")
str2 = 'Hello'.force_encoding("US-ASCII")
begin
(str1 + str2).encoding
rescue
nil
end
Returns a singleton class of current object. Read more
Gets an immutable reference to the Rust structure which is wrapped into a Ruby object. Read more
Gets a mutable reference to the Rust structure which is wrapped into a Ruby object.
Defines an instance method for the given class or object. Read more
Defines a private instance method for the given class or object. Read more
Defines a class method for given class or singleton method for object. Read more
An alias for define_method
(similar to Ruby syntax def some_method
).
An alias for define_private_method
(similar to Ruby syntax private def some_method
).
An alias for define_singleton_method
(similar to Ruby def self.some_method
).
Calls a given method on an object similarly to Ruby Object#send
method Read more
Checks whether the object responds to given method Read more
fn protect_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
fn protect_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
protect_send
returns Result<AnyObject, AnyObject> Read more
fn protect_public_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
fn protect_public_send(
&self,
method: &str,
arguments: &[AnyObject]
) -> Result<AnyObject, AnyException>
protect_public_send
returns Result<AnyObject, AnyObject> Read more
Converts struct to AnyObject
Read more
Gets an instance variable of object Read more
Sets an instance variable for object Read more
Unsafely casts current object to the specified Ruby type Read more
Safely casts current object to the specified Ruby type Read more
Implicit or nil
conversion
Examples
use rutie::{RString, Fixnum, VM, TryConvert, NilClass, Object};
let four = Fixnum::new(4);
let result = RString::try_convert(four.to_any_object());
assert_eq!(result, Err(NilClass::new()));
let five = RString::new_utf8("5");
let result2 = RString::try_convert(five.to_any_object());
if let Ok(r) = result2 {
assert_eq!(r.to_str(), "5")
} else {
unreachable!()
}
Ruby:
four = 4
result = String.try_convert(four)
result == nil
five = "5"
result = String.try_convert(five)
result == "5"