Struct Replace

pub struct Replace(pub usize, pub usize);

A struct that represents a string replacement operation.

It includes two public fields, both of type usize, which likely denote positions or lengths in a string where a replacement operation is intended to take place. The straightforward structure of this item suggests it serves as a utility to encapsulate parameters for a replace-like task within a larger synthesis or transformation process.

Tuple Fields

0: usize

1: usize

Implementations

impl Replace

pub fn from_config(config: &Config) -> Self

Creates a new instance by extracting configuration values.

It fetches the “cost” and “enum_replace_cost” from the given Config object, setting them as the first and second elements respectively. If the configuration values are not present, it defaults to using 1 for “cost” and 3 for “enum_replace_cost”. This approach allows the object to be instantiated with specific costs based on the provided configuration, facilitating customizability within the synthesis framework.

pub fn name() -> &'static str

Returns the name associated with the Replace operation.

This functionality provides a static method that outputs the string "str.replace", serving as an identifier for the operation within the synthesis framework. This is useful for referencing the operation in logs, configuration, or other parts of the system where consistent naming is necessary.

Trait Implementations

impl Clone for Replace

fn clone(&self) -> Replace

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Replace

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

Formats the value using the given formatter.

impl Default for Replace

fn default() -> Self

Creates a new instance with default configuration.

This method initializes the instance using the from_config function, passing a default configuration. The implementation implies the Replace structure can be configured with external settings, yet defaults allow creating a baseline instance without specifying particular attributes.

impl Display for Replace

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

Formats the Replace instance for display purposes.

This implementation of the fmt function, part of the std::fmt module, uses the name method of the Replace struct itself to provide a formatted representation. The formatted output is directed to a given formatter instance, which integrates the Replace instance into a formatted output stream.

impl Enumerator3 for Replace

fn enumerate( &self, this: &'static Op3Enum, exec: &'static Executor, nt: [usize; 3], ) -> Result<(), ()>

Enumerates possible expressions in the context of the synthesis problem.

This function first checks if the executor’s available size meets the minimum cost requirement, terminating early if it does not. It calculates the total allowable size for enumeration and iterates over combinations of sub-expressions e1, e2, and e3 from the executor’s data, constrained by the maximum specified size. Within these loops, it constructs a ternary operation expression with the provided Op3Enum. The function attempts to evaluate this new expression using given values, and if successful, it proceeds to enumerate the expression in the executor with its evaluated value. The process ensures that only valid expressions with feasible evaluations are considered, thus optimizing the string synthesis tasks.

impl From<Replace> for Op3Enum

fn from(v: Replace) -> Op3Enum

Converts to this type from the input type.

impl Hash for Replace

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 Op3 for Replace

fn cost(&self) -> usize

Provides functionality to calculate the cost of a Replace operation.

The cost method, when called on an instance of Replace, returns the first element of the tuple. This represents the operational cost or significance of the replacement process defined by the instance.

fn try_eval(&self, a1: Value, a2: Value, a3: Value) -> (bool, Value)

Provides a method to attempt the evaluation of a replacement operation within a given context of string values.

This method takes three Value parameters, a1, a2, and a3, assuming they are all strings. It performs a replacement operation using the Rust replacen string method, which replaces the first occurrence of a substring (from a1 and a2 combinations) with a new string (a3). The use of itertools::izip! allows iterating over the characters of the input strings in parallel, applying the replacement on each character triplet. If the inputs match the expected string types, the method returns a tuple indicating success and the resulting string; otherwise, it returns a tuple indicating failure with a Value::Null. The galloc_str and galloc_scollect methods are employed to efficiently handle memory allocation for the resulting strings.

impl PartialEq for Replace

fn eq(&self, other: &Replace) -> 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 TryInto<Replace> for Op3Enum

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Replace, <Self as TryInto<Replace>>::Error>

Performs the conversion.

impl Copy for Replace

impl Eq for Replace

impl StructuralPartialEq for Replace