pragma solidity >=0.4.22 <0.6.0; contract Information { struct Uploaders { uint weight; bool uploaded; address delegate; uint up; } struct Proposal { bytes32 name; // short name (up to 32 bytes) uint upCount; } address public ProductTraceability; // This declares a state variable that // stores a `state` struct for each possible address. mapping(address => Uploaders) public state; // A dynamically-sized array of `Proposal` structs. Proposal[] public GainConcent; /// Create a new ballot to choose one of `proposalNames constructor(bytes32[] memory proposalNames) public { ProductTraceability = msg.sender; state[ProductTraceability].weight = 1; // For each of the provided proposal names, // create a new proposal object and add it // to the end of the array. for (uint i = 0; i < proposalNames.length; i++) { // `Proposal({...})` creates a temporary // Proposal object and `proposals.push(...)` // appends it to the end of `proposals`. GainConcent.push(Proposal({ name: proposalNames[i], upCount: 0 })); } } // Give `voter` the right to vote on this ballot. // May only be called by `chairperson`. function Uploader(address voter) public { // If the first argument of `require` evaluates // to `false`, execution terminates and all // changes to the state and to Ether balances // are reverted. // This used to consume all gas in old EVM versions, but // not anymore. // It is often a good idea to use `require` to check if // functions are called correctly. // As a second argument, you can also provide an // explanation about what went wrong. require( msg.sender == ProductTraceability, "Only chairperson can give right to vote." ); require( !state[voter].uploaded, "The voter already voted." ); require(state[voter].weight == 0); state[voter].weight = 1; } /// Delegate your vote to the voter `to`. function UpType(address to) public { // assigns reference Uploaders storage sender = state[msg.sender]; require(!sender.uploaded, "You already voted."); require(to != msg.sender, "Self-delegation is disallowed."); // Forward the delegation as long as // `to` also delegated. // In general, such loops are very dangerous, // because if they run too long, they might // need more gas than is available in a block. // In this case, the delegation will not be executed, // but in other situations, such loops might // cause a contract to get "stuck" completely. while (state[to].delegate != address(0)) { to = state[to].delegate; // We found a loop in the delegation, not allowed. require(to != msg.sender, "Found loop in delegation."); } // Since `sender` is a reference, this // modifies `state[msg.sender].voted` sender.uploaded = true; sender.delegate = to; Uploaders storage delegate_ = state[to]; if (delegate_.uploaded) { // If the delegate already voted, // directly add to the number of votes GainConcent[delegate_.up].upCount += sender.weight; } else { // If the delegate did not vote yet, // add to her weight. delegate_.weight += sender.weight; } } /// Give your vote (including votes delegated to you) /// to proposal `proposals[proposal].name`. function UpConcent(uint proposal) public { Uploaders storage sender = state[msg.sender]; require(sender.weight != 0, "Has no right to vote"); require(!sender.uploaded, "Already voted."); sender.uploaded = true; sender.up = proposal; // If `proposal` is out of the range of the array, // this will throw automatically and revert all // changes. GainConcent[proposal].upCount += sender.weight; } /// @dev Computes the winning proposal taking all /// previous votes into account. function Gainer() public view returns (uint winningProposal_) { uint winningVoteCount = 0; for (uint p = 0; p < GainConcent.length; p++) { if (GainConcent[p].upCount > winningVoteCount) { winningVoteCount = GainConcent[p].upCount; winningProposal_ = p; } } } // Calls winningProposal() function to get the index // of the winner contained in the proposals array and then // returns the name of the winner function GainType() public view returns (bytes32 winnerName_) { winnerName_ = GainConcent[Gainer()].name; } }
0.4.22