Struct RegExpStringIterator 

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

22.2.9 RegExp String Iterator Objects

A RegExp String Iterator is an object that represents a specific iteration over some specific String instance object, matching against some specific RegExp instance object. There is not a named constructor for RegExp String Iterator objects. Instead, RegExp String Iterator objects are created by calling certain methods of RegExp instance objects.

Trait Implementations

impl Bindable for RegExpStringIterator<'_>

type Of<'a> = RegExpStringIterator<'a>

Bound representation of self. This must always be effectively equal to Self<'a>. Note that we cannot write Self<'a> directly because Self cannot have lifetime parameters attached to it.

fn unbind(self) -> Self::Of<'static>

Unbind this value from the garbage collector lifetime. This is necessary for eg. when using the value as a parameter in a call that can perform garbage collection.

fn bind<'a>(self, _: NoGcScope<'a, '_>) -> Self::Of<'a>

Bind this value to the garbage collector lifetime. This is necessary to enable the borrow checker to check that bindable values are not use-after-free.

impl<'a> Clone for RegExpStringIterator<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for RegExpStringIterator<'a>

impl<'a> Debug for RegExpStringIterator<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for RegExpStringIterator<'a>

impl<'a> From<RegExpStringIterator<'a>> for Value<'a>

fn from(value: RegExpStringIterator<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<RegExpStringIterator<'a>> for Object<'a>

fn from(value: RegExpStringIterator<'a>) -> Self

Converts to this type from the input type.

impl<'a> Hash for RegExpStringIterator<'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> InternalMethods<'a> for RegExpStringIterator<'a>

fn try_get_prototype_of<'gc>( self, agent: &mut Agent, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, Option<Object<'gc>>>

Infallible [[GetPrototypeOf]]

fn internal_get_prototype_of<'gc>( self, agent: &mut Agent, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, Option<Object<'gc>>>

[[GetPrototypeOf]]

fn try_set_prototype_of<'gc>( self, agent: &mut Agent, prototype: Option<Object<'_>>, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, bool>

Infallible [[SetPrototypeOf]]

fn internal_set_prototype_of<'gc>( self, agent: &mut Agent, prototype: Option<Object<'_>>, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, bool>

[[SetPrototypeOf]]

fn try_is_extensible<'gc>( self, agent: &mut Agent, _gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, bool>

Infallible [[IsExtensible]]

fn internal_is_extensible<'gc>( self, agent: &mut Agent, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, bool>

[[IsExtensible]]

fn try_prevent_extensions<'gc>( self, agent: &mut Agent, _gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, bool>

Infallible [[PreventExtensions]]

fn internal_prevent_extensions<'gc>( self, agent: &mut Agent, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, bool>

[[PreventExtensions]]

fn try_get_own_property<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, cache: Option<PropertyLookupCache<'_>>, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, Option<PropertyDescriptor<'gc>>>

Infallible [[GetOwnProperty]]

fn internal_get_own_property<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, Option<PropertyDescriptor<'gc>>>

[[GetOwnProperty]]

fn try_define_own_property<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, property_descriptor: PropertyDescriptor<'_>, cache: Option<PropertyLookupCache<'_>>, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, bool>

Infallible [[DefineOwnProperty]]

fn internal_define_own_property<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, property_descriptor: PropertyDescriptor<'_>, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, bool>

[[DefineOwnProperty]]

fn try_has_property<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, cache: Option<PropertyLookupCache<'_>>, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, TryHasResult<'gc>>

Infallible [[HasProperty]]

fn internal_has_property<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, bool>

[[HasProperty]]

fn try_get<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, receiver: Value<'_>, cache: Option<PropertyLookupCache<'_>>, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, TryGetResult<'gc>>

Try [[Get]]

fn internal_get<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, receiver: Value<'_>, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, Value<'gc>>

[[Get]]

fn try_set<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, value: Value<'_>, receiver: Value<'_>, cache: Option<PropertyLookupCache<'_>>, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, SetResult<'gc>>

Infallible [[Set]]

fn internal_set<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, value: Value<'_>, receiver: Value<'_>, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, bool>

[[Set]]

fn try_delete<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, bool>

Infallible [[Delete]]

fn internal_delete<'gc>( self, agent: &mut Agent, property_key: PropertyKey<'_>, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, bool>

[[Delete]]

fn try_own_property_keys<'gc>( self, agent: &mut Agent, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, Vec<PropertyKey<'gc>>>

Infallible [[OwnPropertyKeys]]

fn internal_own_property_keys<'gc>( self, agent: &mut Agent, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, Vec<PropertyKey<'gc>>>

[[OwnPropertyKeys]]

fn get_own_property_at_offset<'gc>( self, agent: &Agent, offset: PropertyOffset, gc: NoGcScope<'gc, '_>, ) -> TryGetResult<'gc>

[[GetOwnProperty]] method with offset.

fn set_at_offset<'gc>( self, agent: &mut Agent, props: &SetAtOffsetProps<'_>, offset: PropertyOffset, gc: NoGcScope<'gc, '_>, ) -> TryResult<'gc, SetResult<'gc>>

[[Set]] method with offset.

fn internal_call<'gc>( self, agent: &mut Agent, this_value: Value<'_>, arguments_list: ArgumentsList<'_, '_>, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, Value<'gc>>

[[Call]]

fn internal_construct<'gc>( self, agent: &mut Agent, arguments_list: ArgumentsList<'_, '_>, new_target: Function<'_>, gc: GcScope<'gc, '_>, ) -> JsResult<'gc, Object<'gc>>

[[Construct]]

impl<'a> InternalSlots<'a> for RegExpStringIterator<'a>

const DEFAULT_PROTOTYPE: ProtoIntrinsics = ProtoIntrinsics::RegExpStringIterator

Default prototype of the object; this is used by InternalSlots::internal_prototype.

fn get_backing_object(self, agent: &Agent) -> Option<OrdinaryObject<'static>>

[[BackingObject]]

fn set_backing_object( self, agent: &mut Agent, backing_object: OrdinaryObject<'static>, )

[[BackingObject]]

fn create_backing_object(self, agent: &mut Agent) -> OrdinaryObject<'static>

[[BackingObject]]

fn object_shape(self, agent: &mut Agent) -> ObjectShape<'static>

[[ObjectShape]]

fn internal_extensible(self, agent: &Agent) -> bool

[[Extensible]]

fn internal_set_extensible(self, agent: &mut Agent, value: bool)

[[Extensible]]

fn internal_prototype(self, agent: &Agent) -> Option<Object<'static>>

[[Prototype]]

fn internal_set_prototype( self, agent: &mut Agent, prototype: Option<Object<'_>>, )

[[Prototype]]

fn get_or_create_backing_object( self, agent: &mut Agent, ) -> OrdinaryObject<'static>

Helper method that gets an existing backing object or creates it if not yet created.

impl<'a> Ord for RegExpStringIterator<'a>

fn cmp(&self, other: &RegExpStringIterator<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for RegExpStringIterator<'a>

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

fn partial_cmp(&self, other: &RegExpStringIterator<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> StructuralPartialEq for RegExpStringIterator<'a>

impl<'a> TryFrom<Object<'a>> for RegExpStringIterator<'a>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: Object<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<Value<'a>> for RegExpStringIterator<'a>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: Value<'a>) -> Result<Self, Self::Error>

Performs the conversion.