Solidity Mapping – How to Access Nested Struct Mapping Members

mappingsoliditystruct

I have 2 structs like this :

struct Wheel {
    uint radius;
    uint width;
}

struct Vehicle {
    string model;
    uint wheelCount;
    mapping(uint => Wheel) wheels;
}

uint public vehicleCount = 0;
mapping(uint => Draw) public vehicles;

function getWheel( uint vid, uint wid) external view returns(Wheel memory) {
    return vehicles[vid].wheels[wid];
}

From my reactjs app I loop "for 1 to vehicleCount" and call contract.vehicle(i).
I get the vehicle structure but without the wheels mapping.

To get the wheels I then loop "for 1 to wheelCount" in each vehicle loop and use the getter I wrote (getWheel( i, j)).

Is there another/better way to get the wheels ? (maybe directly through a custom vehicle getter that would return a struct containing the wheels map).

Thanks !

Best Answer

I think overall the best solution is to rewrite the struct by using an array instead of a mapping:

struct Vehicle {
    string model;
    uint wheelCount;
    uint256[] wheels;
}

If you don't want to change the existing contract, you can add a getter like this:

function getVehicle(uint256 vid) external view returns(string memory model, uint256 wheelCount, uint256[] memory wheels) {
  model = vehicles[vid].model;
  wheelCount = vehicles[vid].wheelCount;
  wheels = new uint256[](wheelCount);
  for (uint256 i=0; i < wheelCount; i++) {
    wheels[i] = vehicles[vid].wheels[i];
  }
}

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;  
  }

Solidity Arrays – Help Using and Reading Arrays and Mappings in Solidity

Here are some patterns that might help you out.

pragma solidity ^0.4.15;

contract Storage {

    struct PlayerStruct {
        uint meaningless;
        uint[] dynamicList;
        uint[10] fixedList;
        mapping(bytes32 => uint) keyToUintMap;
    }

    mapping(address => PlayerStruct) public playerStructs;

    function getPlayerDynListLength(address player) public constant returns(uint count) {
        return playerStructs[player].dynamicList.length;
    }

    function appendPlayerDynList(address player, uint value) public returns(uint length) {
        return playerStructs[player].dynamicList.push(value);
    }

    function setPlayerDynFixedList(address player, uint index, uint value) public returns(bool success) {
        require(index <= 9);
        playerStructs[player].fixedList[index] = value;
        return true;
    }

    function getPlayerDynamicListElement(address player, uint index) public constant returns(uint value) {
        return playerStructs[player].dynamicList[index];
    }

    function setPlayerMappedElement(address player, bytes32 key, uint value) public returns(bool success) {
        playerStructs[player].keyToUintMap[key] = value;
        return true;
    }

    function getPlayerMappedElement(address player, bytes32 key) public constant returns(uint value) {
        return playerStructs[player].keyToUintMap[key];
    }

}

Update:

Here it is in Remix to show it working:

Hope it helps.

Best Answer

Related Solutions

Solidity Memory Management – Does ‘Delete’ Free Mapping Space

Solidity Arrays – Help Using and Reading Arrays and Mappings in Solidity

Related Topic