Struct clarity_repl::clarity::analysis::types::ContractAnalysis

pub struct ContractAnalysis {

    pub contract_identifier: QualifiedContractIdentifier,
    pub private_function_types: BTreeMap<ClarityName, FunctionType>,
    pub variable_types: BTreeMap<ClarityName, TypeSignature>,
    pub public_function_types: BTreeMap<ClarityName, FunctionType>,
    pub read_only_function_types: BTreeMap<ClarityName, FunctionType>,
    pub map_types: BTreeMap<ClarityName, (TypeSignature, TypeSignature)>,
    pub persisted_variable_types: BTreeMap<ClarityName, TypeSignature>,
    pub fungible_tokens: BTreeSet<ClarityName>,
    pub non_fungible_tokens: BTreeMap<ClarityName, TypeSignature>,
    pub defined_traits: BTreeMap<ClarityName, BTreeMap<ClarityName, FunctionSignature>>,
    pub implemented_traits: BTreeSet<TraitIdentifier>,
    pub contract_interface: Option<ContractInterface>,
    pub is_cost_contract_eligible: bool,
    pub dependencies: Vec<QualifiedContractIdentifier>,
    pub expressions: Vec<SymbolicExpression>,
    pub type_map: Option<TypeMap>,
    pub cost_track: Option<LimitedCostTracker>,
}

Fields

contract_identifier: QualifiedContractIdentifier

private_function_types: BTreeMap<ClarityName, FunctionType>

variable_types: BTreeMap<ClarityName, TypeSignature>

public_function_types: BTreeMap<ClarityName, FunctionType>

read_only_function_types: BTreeMap<ClarityName, FunctionType>

map_types: BTreeMap<ClarityName, (TypeSignature, TypeSignature)>

persisted_variable_types: BTreeMap<ClarityName, TypeSignature>

fungible_tokens: BTreeSet<ClarityName>

non_fungible_tokens: BTreeMap<ClarityName, TypeSignature>

defined_traits: BTreeMap<ClarityName, BTreeMap<ClarityName, FunctionSignature>>

implemented_traits: BTreeSet<TraitIdentifier>

contract_interface: Option<ContractInterface>

is_cost_contract_eligible: bool

dependencies: Vec<QualifiedContractIdentifier>

expressions: Vec<SymbolicExpression>

type_map: Option<TypeMap>

cost_track: Option<LimitedCostTracker>

Implementations

impl ContractAnalysis

pub fn new(
    contract_identifier: QualifiedContractIdentifier,
    expressions: Vec<SymbolicExpression>,
    cost_track: LimitedCostTracker
) -> ContractAnalysis

pub fn take_contract_cost_tracker(&mut self) -> LimitedCostTracker

pub fn replace_contract_cost_tracker(&mut self, cost_track: LimitedCostTracker)

pub fn add_map_type(
    &mut self,
    name: ClarityName,
    key_type: TypeSignature,
    map_type: TypeSignature
)

pub fn add_variable_type(
    &mut self,
    name: ClarityName,
    variable_type: TypeSignature
)

pub fn add_persisted_variable_type(
    &mut self,
    name: ClarityName,
    persisted_variable_type: TypeSignature
)

pub fn add_read_only_function(
    &mut self,
    name: ClarityName,
    function_type: FunctionType
)

pub fn add_public_function(
    &mut self,
    name: ClarityName,
    function_type: FunctionType
)

pub fn add_private_function(
    &mut self,
    name: ClarityName,
    function_type: FunctionType
)

pub fn add_non_fungible_token(
    &mut self,
    name: ClarityName,
    nft_type: TypeSignature
)

pub fn add_fungible_token(&mut self, name: ClarityName)

pub fn add_defined_trait(
    &mut self,
    name: ClarityName,
    function_types: BTreeMap<ClarityName, FunctionSignature>
)

pub fn add_implemented_trait(&mut self, trait_identifier: TraitIdentifier)

pub fn add_dependency(&mut self, dependency: QualifiedContractIdentifier)

pub fn get_public_function_type(&self, name: &str) -> Option<&FunctionType>

pub fn get_read_only_function_type(&self, name: &str) -> Option<&FunctionType>

pub fn get_private_function(&self, name: &str) -> Option<&FunctionType>

pub fn get_map_type(&self, name: &str) -> Option<&(TypeSignature, TypeSignature)>

pub fn get_variable_type(&self, name: &str) -> Option<&TypeSignature>

pub fn get_persisted_variable_type(&self, name: &str) -> Option<&TypeSignature>

pub fn get_defined_trait(
    &self,
    name: &str
) -> Option<&BTreeMap<ClarityName, FunctionSignature>>

pub fn check_trait_compliance(
    &self,
    trait_identifier: &TraitIdentifier,
    trait_definition: &BTreeMap<ClarityName, FunctionSignature>
) -> CheckResult<()>

Trait Implementations

impl ClarityDeserializable<ContractAnalysis> for ContractAnalysis

fn deserialize(json: &str) -> Self

impl ClaritySerializable for ContractAnalysis

fn serialize(&self) -> String

impl Clone for ContractAnalysis

fn clone(&self) -> ContractAnalysis

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ContractAnalysis

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ContractAnalysis

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<ContractAnalysis> for ContractAnalysis

fn eq(&self, other: &ContractAnalysis) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ContractAnalysis

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ContractAnalysis