Akropolis

1pragma solidity ^0.5.12;
2​
3import "../common/Base.sol";
4import "../interfaces/core/CoreInterface.sol";
5import "../utils/AddressMap.sol";
6​
7contract Pool is Base, CoreInterface {
8​
9    /* Short description */
10    string  public name;
11    string  public description;
12    address public founder;
13​
14    /* Modules map */
15    AddressMap.Data modules;
16​
17    using AddressList for AddressList.Data;
18    using AddressMap for AddressMap.Data;
19​
20    /* Module constant mapping */
21    mapping(bytes32 => bool) public is_constant;
22​
23    /**
24     * @dev Contract ABI storage
25     *      the contract interface contains source URI
26     */
27    mapping(address => string) public abiOf;
28    
29    function initialize() public initializer {
30        Base.initialize();
31        founder = _msgSender();
32    }
33​
34    function setMetadata(string memory _name, string  memory _description) public onlyOwner {
35        name = _name;
36        description = _description;
37    }
38      
39    /**
40     * @dev Set new module for given name
41     * @param _name infrastructure node name
42     * @param _module infrastructure node address
43     * @param _constant have a `true` value when you create permanent name of module
44     */
45    function set(string memory _name, address _module, bool _constant) public onlyOwner {
46        
47        require(!isConstant(_name), "Pool: module address can not be replaced");
48​
49        // Notify
50        if (modules.get(_name) != ZERO_ADDRESS)
51            emit ModuleReplaced(_name, modules.get(_name), _module);
52        else
53            emit ModuleAdded(_name, _module);
54 
55        // Set module in the map
56        modules.set(_name, _module);
57​
58        // Register constant flag 
59        is_constant[keccak256(abi.encodePacked(_name))] = _constant;
60    }
61​
62     /**
63     * @dev Remove module by name
64     * @param _name module name
65     */
66    function remove(string memory _name)  public onlyOwner {
67        require(!isConstant(_name), "Pool: module can not be removed");
68​
69        // Notify
70        emit ModuleRemoved(_name, modules.get(_name));
71​
72        // Remove module
73        modules.remove(_name);
74    }
75​
76    /**
77     * @dev Fast module exist check
78     * @param _module is a module address
79     * @return `true` wnen core contains module
80     */
81    function contains(address _module) public view returns (bool)
82    {
83        return modules.items.contains(_module);
84    }
85​
86    /**
87     * @dev Modules counter
88     * @return count of modules in core
89     */
90    function size() public view returns (uint)
91    {
92        return modules.size();
93    }
94​
95    /**
96     * @dev Check for module have permanent name
97     * @param _name is a module name
98     * @return `true` when module have permanent name
99     */
100    function isConstant(string memory _name) public view returns (bool)
101    {
102        return is_constant[keccak256(abi.encodePacked(_name))];
103    }
104​
105    /**
106     * @dev Get module by name
107     * @param _name is module name
108     * @return module address
109     */
110    function get(string memory _name) public view returns (address)
111    {
112        return modules.get(_name);
113    }
114​
115    /*
116     * @dev Get module name by address
117     * @param _module is a module address
118     * @return module name
119     */
120    function getName(address _module) public view returns (string memory)
121    {
122        return modules.keyOf[_module];
123    }
124​
125    /*
126     * @dev Get first module
127     * @return first address
128     */
129    function first() public view returns (address)
130    {
131        return modules.items.head;
132    }
133​
134    /**
135     * @dev Get next module
136     * @param _current is an current address
137     * @return next address
138     */
139    function next(address _current) public view returns (address)
140    {
141        return modules.items.next(_current);
142    }
143​
144}

Solidity Contracts

JavaScript Tests