Struct screeps::RawObjectId[−][src]

pub struct RawObjectId { /* fields omitted */ }

Represents an Object ID using a packed 12-byte representation

Each object id in screeps is represented by a Mongo GUID, which, while not guaranteed, is unlikely to change. This takes advantage of that by storing a packed representation.

To convert to a String in JavaScript, either use RawObjectId::to_array_string, or RawObjectId::unsafe_as_uploaded. See method documentation for more information.

Ordering

To facilitate use as a key in a BTreeMap or other similar data structures, ObjectId implements PartialOrd and Ord.

RawObjectId's are ordered by the corresponding order of their underlying byte values. See ObjectId documentation for more information.

Implementations

`impl RawObjectId`[src]

`pub fn from_packed(packed: [u32; 3]) -> Self`[src]

Creates an object ID from its packed representation.

The input to this function is the bytes representing the up-to-24 hex digits in the object id.

`pub fn from_packed_js_val( packed_val: Reference ) -> Result<Self, ConversionError>`[src]

Creates an object ID from a packed representation stored in JavaScript.

The input must be a reference to a length-3 array of integers.

Recommended to be used with the object_id_to_packed JavaScript utility function, which takes in a string and returns the array of three integers that this function expects.

Example

use screeps::{prelude::*, traits::TryInto, RawObjectId};
use stdweb::js;

let packed_obj_id = (js! {
    let creep = _.sample(Game.creeps);
    return object_id_to_packed(creep.id);
})
.try_into()
.unwrap();

let parsed = RawObjectId::from_packed_js_val(packed_obj_id).unwrap();
println!("found creep with id {}", parsed);

`pub fn to_u128(self) -> u128`[src]

Converts this object ID to a u128 number.

The returned number, when formatted as hex, will produce a string parseable into this object id.

The returned number will be less than or equal to 2^96 - 1, as that's the maximum value that RawObjectId can hold.

`pub fn to_array_string(&self) -> ArrayString<[u8; 24]>`[src]

Formats this object ID as a string on the stack.

This is equivalent to ToString::to_string, but involves no allocation.

To use the produced string in stdweb, use &* to convert it to a string slice.

This is less efficient than RawObjectId::unsafe_as_uploaded, but easier to get right.

Example

use screeps::{prelude::*, RawObjectId};
use stdweb::js;

let object_id: RawObjectId = screeps::game::creeps::values()[0].untyped_id();

let str_repr = object_id.to_array_string();

js! {
    let id = @{&*str_repr};
    console.log("we have a creep with the id " + id);
}

`pub unsafe fn unsafe_as_uploaded(&self) -> UnsafeTypedArray<'_, u32>`[src]

Creates an array accessible from JavaScript which represents part of this object id's packed representation.

Specifically, the resulting array will contain the first non-zero number in this object id, and all following numbers. This allows for a more efficient object_id_from_packed implementation.

Safety

This is highly unsafe.

This creates an UnsafeTypedArray and does not use it in JS, so the restrictions from UnsafeTypedArray apply. When you call into JavaScript using it, you must "use" it immediately before calling into any Rust code whatsoever.

There are other safety concerns as well, but all deriving from UnsafeTypedArray. See UnsafeTypedArray.

Example

use screeps::{prelude::*, RawObjectId};
use stdweb::js;

let object_id: RawObjectId = screeps::game::creeps::values()[0].untyped_id();

let array_view = unsafe { object_id.unsafe_as_uploaded() };

js! {
    let id = object_id_from_packed(@{array_view});
    console.log("we have a creep with the id " + id);
}