Initial implementation and design of pdsl_lang about ink HOT 4 CLOSED

/// The storage data that is hold by the ERC-20 token.
#[derive(Debug, Encode, Decode)]
pub struct Erc20Token {
	/// All peeps done by all users.
	balances: storage::HashMap<Address, Balance>,
	/// Balances that are spendable by non-owners.
	allowances: storage::HashMap<AllowancePair, Balance>,
	/// The total supply.
	total_supply: storage::Value<Balance>,
	/// The allocator for newly allocated entities.
	alloc: storage::alloc::CellChunkAlloc,
}

/// The storage data that is hold by the ERC-20 token.
#[derive(Contract)]
pub struct Erc20Token {
	/// All peeps done by all users.
	balances: storage::HashMap<Address, Balance>,
	/// Balances that are spendable by non-owners.
	allowances: storage::HashMap<AllowancePair, Balance>,
	/// The total supply.
	total_supply: Balance,
}

self.balances.mutate_with(&from, |from| *from -= value)

self.balances[from] -= value

#[derive(Debug, Hash, PartialEq, Eq, Encode, Decode)]

#[derive(Debug, HashStorage)]

use pdsl_lang::contract;
use pdsl_core::storage;

contract! {
    /// A simple contract that has a value that can be
    /// incremented, returned and compared.
    struct Incrementer {
        /// The internal value.
        value: storage::Value<u32>,
    }

    impl Incrementer {
        /// Automatically called when the contract is deployed.
        pub(external) fn on_deploy(&mut self, init_value: u32) {
            self.value.set(init_value);
        }

        /// Increments the internal counter.
        pub(external) fn inc(&mut self, by: u32) {
            self.value += by
        }

        /// Returns the internal counter.
        pub(external) fn get(&self) -> u32 {
            *self.value
        }

        /// Returns `true` if `x` is greater than the internal value.
        pub(external) fn compare(&self, x: u32) -> bool {
            x > *self.value
        }
    }
}

use pdsl_core::storage;

pdsl_model::state! {
    /// A simple contract that has a value that can be
    /// incremented, returned and compared.
    struct Incrementer {
        /// The internal value.
        value: storage::Value<u32>
    }
}

pdsl_model::messages! {
    /// Increments the internal counter.
    0 => Inc(by: u32);
    /// Returns the internal counter.
    1 => Get() -> u32;
    /// Returns `true` if `x` is greater than the internal value.
    2 => Compare(with: u32) -> bool;
}

impl Adder {
    /// Automatically called when the contract is deployed.
    pub fn on_deploy(&mut self, env: &mut pdsl_model::EnvHandler, init_val: u32) {
        self.value.set(init_val)
    }

    /// Increments the internal counter.
    pub fn inc(&mut self, env: &mut pdsl_model::EnvHandler, by: u32) {
        self.value += by
    }

    /// Returns the internal counter.
    pub fn get(&self, env: &pdsl_model::EnvHandler) -> u32 {
        *self.value
    }

    /// Returns `true` if `x` is greater than the internal value.
    pub fn compare(&self, env: &pdsl_model::EnvHandler, x: u32) -> bool {
        x > *self.value
    }
}

fn instantiate() -> impl pdsl_model::Contract {
    pdsl_model::ContractDecl::using::<Adder>()
        .on_deploy(|env, init_val: u32| {
            let (handler, state) = env.split_mut();
            state.on_deploy(handler, init_val)
        })
        .on_msg_mut::<Inc>(|env, by: u32| {
        	let (handler, state) = env.split_mut();
        	state.inc(handler, by)
        })
        .on_msg::<Get>(|env, _| {
        	let (handler, state) = env.split();
        	state.get(handler)
        })
        .on_msg::<Compare>(|env, x: u32| {
        	let (handler, state) = env.split();
        	state.compare(handler, x)
        })
        .instantiate()
}

#[no_mangle]
fn deploy() {
    instantiate().deploy()
}

#[no_mangle]
fn call() {
    instantiate().dispatch()
}

#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use ::std::prelude::v1::*;
#[macro_use]
extern crate std as std;
use pdsl_core::storage;
use pdsl_lang::contract;

#[doc = " A simple contract that has a value that can be"]
#[doc = " incremented, returned and compared."]
struct Incrementer {
    #[doc = " The internal value."]
    value: storage::Value<u32>,
}
impl pdsl_core::storage::Flush for Incrementer {
    fn flush(&mut self) {
        self.value.flush()
    }
}
impl pdsl_core::storage::alloc::AllocateUsing for Incrementer {
    unsafe fn allocate_using<A>(alloc: &mut A) -> Self
    where
        A: pdsl_core::storage::alloc::Allocate,
    {
        use pdsl_core::storage::alloc::AllocateUsing;
        Self {
            value: AllocateUsing::allocate_using(alloc),
        }
    }
}
impl ::pdsl_model::ContractState for Incrementer {
    const NAME: &'static [u8] = "Incrementer".as_bytes();
}
use pdsl_model::messages;
#[doc = " Returns `true` if `x` is greater than the internal value."]
#[rustc_copy_clone_marker]
struct Compare;
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::marker::Copy for Compare {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::clone::Clone for Compare {
    #[inline]
    fn clone(&self) -> Compare {
        {
            *self
        }
    }
}
impl ::pdsl_model::Message for Compare {
    type Input = (u32);
    type Output = bool;
    const ID: ::pdsl_model::MessageHandlerSelector =
        ::pdsl_model::MessageHandlerSelector::new(0);
    const NAME: &'static [u8] = "Compare".as_bytes();
}
#[doc = " Increments the internal counter."]
#[rustc_copy_clone_marker]
struct Inc;
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::marker::Copy for Inc {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::clone::Clone for Inc {
    #[inline]
    fn clone(&self) -> Inc {
        {
            *self
        }
    }
}
impl ::pdsl_model::Message for Inc {
    type Input = (u32);
    type Output = ();
    const ID: ::pdsl_model::MessageHandlerSelector =
        ::pdsl_model::MessageHandlerSelector::new(1);
    const NAME: &'static [u8] = "Inc".as_bytes();
}
#[doc = " Returns the internal counter."]
#[rustc_copy_clone_marker]
struct Get;
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::marker::Copy for Get {}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::clone::Clone for Get {
    #[inline]
    fn clone(&self) -> Get {
        {
            *self
        }
    }
}
impl ::pdsl_model::Message for Get {
    type Input = ();
    type Output = u32;
    const ID: ::pdsl_model::MessageHandlerSelector =
        ::pdsl_model::MessageHandlerSelector::new(2);
    const NAME: &'static [u8] = "Get".as_bytes();
}
impl Incrementer {
    #[doc = " Automatically called when the contract is deployed."]
    pub fn on_deploy(&mut self, env: &mut pdsl_model::EnvHandler, init_value: u32) {
        self.value.set(init_value);
    }
    #[doc = " Returns `true` if `x` is greater than the internal value."]
    pub fn compare(&self, env: &pdsl_model::EnvHandler, x: u32) -> bool {
        x > *self.value
    }
    #[doc = " Increments the internal counter."]
    pub fn inc(&mut self, env: &mut pdsl_model::EnvHandler, by: u32) {
        self.value += by
    }
    #[doc = " Returns the internal counter."]
    pub fn get(&self, env: &pdsl_model::EnvHandler) -> u32 {
        *self.value
    }
}
fn instantiate() -> impl pdsl_model::Contract {
    pdsl_model::ContractDecl::using::<Incrementer>()
        .on_deploy(|env, init_value: u32| {
            let (handler, state) = env.split_mut();
            state.on_deploy(handler, init_value)
        })
        .on_msg::<Compare>(|env, x: u32| {
            let (handler, state) = env.split();
            state.compare(handler, x)
        })
        .on_msg_mut::<Inc>(|env, by: u32| {
            let (handler, state) = env.split_mut();
            state.inc(handler, by)
        })
        .on_msg::<Get>(|env, _| {
            let (handler, state) = env.split();
            state.get(handler)
        })
        .instantiate()
}
#[no_mangle]
fn deploy() {
    instantiate().deploy()
}
#[no_mangle]
fn call() {
    instantiate().dispatch()
}