Solidity – How to Map a List in Smart Contracts

contract-developmentremixsolidity

I have a Map of a List. I am managing the data in the map and the list. I have it working for now, but wanted to find out if there is a better way to do this.

mapping (bytes32 => Receipts[]) receiptsByPersonMap;
Receipts[] dummyReceiptsList;

Receipts newReceipt = new Receipts(_person, _cost);

dummyReceiptsList = receiptsByPersonMap[_person];

dummyReceiptsList.push(newReceipt);
receiptsByPersonMap[_person] = dummyReceiptsList;

This works for now. it seems that the last line is irrelevant – if receiptsList is pointing to the same storage space. Any suggestion of a better way to do this.

Best Answer

Why not do it in one go? Something like:

receiptsByPersonMap[_person].push(new Receipts(_person, _cost));

Incidentally, this may just be an artifact of the way you've simplified the question to post here, but since _person is the key of the mapping where you store your Receipts record, you can't access it unless you already know _person, so you should be able to remove _person from the struct. At that point the struct only contains one item, so you could get rid of it entirely and just store cost in a bytes32 => uint256[] mapping.

Related Solutions

Solidity – Addressing Uninitialized Mapping Member in Struct Creation

Agree with Guiseppe. The code isn't "initializing" new ob, just referencing existing.

Here's a way to have many mappings that don't collide like that. Possibly will give you some ideas.

pragma solidity ^0.4.0;
contract TestcaseResetObject {

    uint public objectCount;

    struct MyObjectStruct {
        mapping(uint => uint) map;
    }

    MyObjectStruct[] myObjects;

    event LogOutput(uint number);

    function makeNewObject() public returns(uint count) {

        MyObjectStruct memory mo;
        objectCount = myObjects.push(mo);
        return objectCount;
    }

    // object numbers start at 0 when objectCount is 1
    function incCounter(uint objectNumber, uint index) public returns(uint newValue) {
        myObjects[objectNumber].map[index] += 1;
        LogOutput(myObjects[objectNumber].map[index]);
        return myObjects[objectNumber].map[index];
    }
}

Let's you "makeNewObject" to create new mappings, and "incCounter" to single out a specific mapping from the array, and a specific location inside the mapping to increment.

Hope it helps.

[Ethereum] Initialization of object in storage(inside contract ) vs Initialization of object in memory(inside function)

Suggest you avoid calling your instance storage because that's a reserved word.

Define your Type and reserve space in the state section, then set the value in the constructor.

contract Storage{
  uint public id;
  uint public status;

  function setId(uint mid) public returns(bool success) {
    id=mid;
    return true;
  }

  function setStatus(uint mStatus) public returns(bool success) {
    status=mStatus;
    return true;
  }
}

// import './Storage.sol';
contract A{

  Storage s; // this defines the type and reserves space

  function A() {
    s = new Storage(); // instantiate it
  }

  function setId(uint id) public returns(bool success) {
     return s.setId(id);
  }

  function setStatus(uint mStatus) public returns(bool success) {
     return s.setStatus(mStatus);
  }

  function getId() public constant returns(uint id) {
     return s.id();
  }
  function getStatus() public constant returns(uint status) {
     return s.status();
  }
}

I removed your mapping because that's another issue and it's not doing anything in this overall structure using simple state variables in the Storage contract.

One or more of these patterns might help you out. Are there well-solved and simple storage patterns for Solidity?

Hope it helps.

Best Answer

Related Solutions

Solidity – Addressing Uninitialized Mapping Member in Struct Creation

[Ethereum] Initialization of object in storage(inside contract ) vs Initialization of object in memory(inside function)

Related Topic