Solidity – How to Initialize Empty Struct Array in New Struct

arrayssoliditystruct

Trying to do this:

contract Foo {
    mapping (bytes32 => Thing) things;

    struct Thing {
        Item[] items;
    }

    struct Item {
        uint number;
    }

    function Foo(bytes32 id) {
        Thing memory thing = Thing(); // What to do here to create empty array of type Item[]?
        things[id] = thing;
    }
}

and I get the error message:

Untitled:13:30: Error: Wrong argument count for function call: 0 arguments given but expected 1.
   Thing memory thing = Thing();

Best Answer

Some issues:

The compiler does not yet support copying memory struct arrays to storage, so things[id] = thing; will fail.
Thing thing; will initialize thing to a Thing with thing.items set to an empty array, so there's no need to use the constructor at all.
Since all elements of mappings come pre-initialized to their "zero" values, there's no need to create a Thing in memory, then copy it to the mapping. Just assign values to the mapping's properties.

For example, this is the code I would use, with some added fields to better illustrate the concept:

contract Foo {
    mapping (bytes32 => Thing) things;

    struct Thing {
        Item[] items;
        uint _bar;
    }

    struct Item {
        uint number;
    }

    function Foo(bytes32 id, uint bar) {
        things[id]._bar = bar;
    }
}

This demonstrates how mapping elements are pre-initialized. things[id].items will return an empty Item[].

In addition, you can create an uninitialized Thing, and all of it's fields will default to zero (ore empty, false, etc.)

Related Solutions

Solidity Memory Management – Does ‘Delete’ Free Mapping Space

Based on my Debug observation:

I have tested that:

Firstly I insert data into my map data-structure as I explained in my question.
Secondly, I have returned the address of first mapped index, which is 0, this could be done for other indexes as well (0:10).
Without a delete operation I can retrieve the data perfectly fine from the address of mapped Foo[]. But if I did the delete operation, Solidity gives an error.

This debug result: leads me to conclude that memory is freed or address does not contain any valid information.

Test code:

set_txn_hash     = my_contract.transact().map_insert();
contract_address = unmigrated_chain.wait.for_receipt(set_txn_hash)

for x in range(0, 9):
   for y in range(0, 9):
         output           = my_contract.call().get_(x, y);
         print(output);  //returns correct value.

set_txn_hash     = my_contract.transact().map_remove_map();                                             
contract_address = unmigrated_chain.wait.for_receipt(set_txn_hash)                                      

set_txn_hash     = my_contract.transact().get_map_address(0);
contract_address = unmigrated_chain.wait.for_receipt(set_txn_hash)

output           = my_contract.call().get_map();
print(output);

output           = my_contract.call().try_();
print(output);  //Solidity gives error if delete map_remove_map() is called

Additional functions inside my Contract:

  function map_insert(){
    for(uint i = 0; i < 10; i++)
      for(uint j = 0; j < 10; j++)
        add(i, i*10 + j);
  }

  function map_remove_map(){
    for(uint i = 0; i < 10; i++)
      delete_(i);
  }

  function map_remove_map_item(){
    for(uint i = 0; i < 10; i++)
      for(uint j = 0; j < 10; j++)
        delete_items(i, j);
  }

  function get_map_address(uint id) {
    uint addr;
    Foo[] a = foo[id];

    assembly{
    addr := a
        }
    map_address = addr;
  }

  function get_map() constant returns (uint){
    return map_address;
  }

  function try_() constant returns (uint ){
    uint addr = map_address;
    Foo[] a;
    assembly{
    a := addr
        }
    return a[1].x;  
  }

How to Create a Mapping of Strings and Struct Arrays in Solidity

These are the basic patterns you need and you can base your more sophisticated getter/setter/remover functions on.

pragma solidity ^0.4.11;

contract AuthorizationManager{
    struct User{
      string userId;
      uint roleId;
    }

    mapping (string => User[]) companyUserMap;

    function addUser(string _key,string _userId, uint _roleId){
        companyUserMap[_key].push(User(_userId,_roleId));
    }

    function removeSingleUser(string _key){
        companyUserMap[_key].length--;
    }
}

Generally you should be really cautious when you iterate over large mappings, arrays etc. You could easily run out of gas and potentially lock your contract up. This is an instructive example.

Best Answer

Related Solutions

Solidity Memory Management – Does ‘Delete’ Free Mapping Space

How to Create a Mapping of Strings and Struct Arrays in Solidity

Related Topic