Struct scilla_parser::contract::Contract

pub struct Contract {
    pub name: String,
    pub init_params: FieldList,
    pub fields: FieldList,
    pub transitions: TransitionList,
}

Fields

name: String

Name of the parsed contract

init_params: FieldList

List of parameters needed to deploy the contract.

fields: FieldList

List of the contract’s fields.

transitions: TransitionList

List of the contract’s transitions.

Implementations

impl Contract

pub fn from_path(contract_path: &Path) -> Result<Self, Error>

Parse a contract from a given path.

Examples

use std::{error::Error, path::PathBuf};
use scilla_parser::{Contract, Field, FieldList, Transition, TransitionList, Type};
let contract_path = PathBuf::from("tests/contracts/chainid.scilla");
let contract = Contract::from_path(&contract_path).unwrap();
assert_eq!(
    contract,
    Contract {
        name: "ChainId".to_string(),
        fields: FieldList::default(),
        init_params: FieldList::default(),
        transitions: TransitionList(vec![Transition::new(
            "EventChainID",
            FieldList::default()
        )])
    }
);

Trait Implementations

impl Debug for Contract

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

Formats the value using the given formatter.

impl FromStr for Contract

fn from_str(sexp: &str) -> Result<Self, Self::Err>

Parse a Contract from a string slice

Example

use std::{error::Error, path::PathBuf};
use scilla_parser::{run_scilla_fmt, Contract, Field, FieldList, Transition, TransitionList, Type};
let contract = run_scilla_fmt(&PathBuf::from("tests/contracts/chainid.scilla")).unwrap();

let contract = contract.parse::<Contract>().unwrap();
assert_eq!(
    contract,
    Contract {
        name: "ChainId".to_string(),
        fields: FieldList::default(),
        init_params: FieldList::default(),
        transitions: TransitionList(vec![Transition::new(
            "EventChainID",
            FieldList::default()
        )])
    }
);

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for Contract

fn eq(&self, other: &Contract) -> 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 StructuralPartialEq for Contract