Mapping to contract

Question

Solidity documentation says it is possible to use anything as mapping value, which I assume includes a contract:

_ValueType can actually be any type, including mappings.

but I couldn't find an example or documentation on how to work with it.

If I have the following mapping, how can I know if the contract in the mapping exists, or have suicided?

pragma solidity ^0.4.0;

contract MyContract {
  // ...
}

contract MappingExample {
    mapping(uint32 => MyContract) inner_contracts;

    function do_something(uint32 key) {
        MyContract c;
        if(/* inner_contracts[key] exists??? */) {
            c = inner_contracts[key];
        } else {
            c = new MyContract;
            inner_contracts[key] = c;
        }

        // do stuff with c
    }
}

Answer 1

Here is an example.

pragma solidity ^0.4.19;


contract InnerContract {
    uint public value;
    function setValue(uint new_value) {
        value = new_value;
    }
}

contract Contract {
    mapping(address => InnerContract) public contracts;

    function makeNew() {
        contracts[msg.sender] = new InnerContract();
    }
    function initialize() {
      contracts[msg.sender].setValue(3);
    }
    function get() constant returns (uint) {
      return contracts[msg.sender].value();
    }
}

If you play with this code, you'll notice that calling initialize before makeNew doesn't work. The reason is that mapping has default value filled with zeros. In case of contract it's not a good idea.

how can I know if the contract in the mapping exists, or have suicided?

Let's use another mapping for flags!

mapping(address => InnerContract) public is_contract_initialized;

If value is false(which is by default) then you should initialize your contract.

Answer 2

Even if it works it will probably be very expensive. A couple of suggestions.

1. Store the deployed contract addresses (small), then instantiate the contracts as you need them: MyContract c = MyContract(theAddress);
2. Avoid suicide/selfdestruct. It just creates sinks and invalid OPCODES. Instead, if you want to ensure a contract is retired, flip a bit and use a modifier like onlyIfRunning. You can make that variable public and then easily inspect it: if(c.isRunning()) {}
3. You can potentially prune the list of deployed contracts but it's a rather more complex structure and it might be enough to just keep an append-only list as you go and use that isRunning() idea to ascertain which contracts are "shut down" and rejecting state-changes.

I made an example over here: Is There a Simple Contract Factory Pattern?

Hope it helps.