Step 10 -- Reference Datatype

Author: zeeshanhanif

10_ref_datatypes/README.md

@@ -0,0 +1,7 @@
+# Reference Datatype
+
+Solidity provides the following reference types:
+1) Arrays: These are fixed as well as dynamic arrays. Details are given later in this chapter.
+2) Structs: These are custom, user-defined structures.
+3) String: This is sequence of characters. In Solidity, strings are eventually stored as bytes. Details are give later in this chapter.
+4) Mappings: This is similar to a hash table or dictionary in other languages storing key-value pairs.

10_ref_datatypes/contracts/Contract1.sol

@@ -0,0 +1,70 @@
+pragma solidity ^0.4.23;
+contract Contract1 {
+
+    int[3] public list = [31,32,33];
+    string name = "Hello";
+    struct User {
+        int age;
+        string name;
+    }
+
+    // internal
+    User myUser = User(32,"Asad"); 
+
+    // This will update array's particular location
+    function updateList() public {
+        list[1] = 45;
+    }
+
+    function updateList2() public {
+        receiveListAndUpdate(list);
+    }
+
+    // function parameters are always memory data locations
+    // Will not effect original variable that is passed in parameter
+    function receiveListAndUpdate(int[3] a) public {
+        a[2] = 55;
+    }
+
+    function updateList3() public returns (int) {
+        // Reference types are always at storage location we need to
+        // provide memory keywork to create local variable
+        // And assigning state ref variable to memory ref variable will create a separate copy 
+        // changing one will not effect other
+        int[3] memory newList = list;
+        newList[2] = 67;
+        return list[2]; //33
+    }
+
+    function updateList4() public returns (int) {
+        // By default ref type's location is storage so it works as passby ref
+
+        //int[3] storage newList = list; //this is same below line
+
+        // Assigning Ref state (storage) variable to ref storage local variable
+        // will not create a separate copy so changing one will effect other 
+        int[3] newList = list;
+        newList[1] = 100;
+        return list[1]; //100
+    }
+
+    
+
+    function updateStruct() public returns (int) {
+        // Assigning Ref state (storage) variable to ref storage local variable
+        // will not create a separate copy so changing one will effect other 
+        User myUser2 = myUser;
+        myUser2.age = 40;
+        return myUser.age; // 40
+    }
+
+    function updateStruct2() public returns (int) {
+        // And assigning state ref variable to memory ref variable will create a separate copy 
+        // changing one will not effect other
+        myUser.age = 98;
+        User memory myUser2 = myUser;
+        myUser2.age = 50;
+        return myUser.age; // 98
+    }
+
+}

10_ref_datatypes/contracts/Migrations.sol

@@ -0,0 +1,24 @@
+pragma solidity ^0.4.23;
+
+contract Migrations {
+  address public owner;
+  uint public last_completed_migration;
+
+
+  constructor() public {
+    owner = msg.sender;
+  }
+
+  modifier restricted() {
+    if (msg.sender == owner) _;
+  }
+
+  function setCompleted(uint completed) public restricted {
+    last_completed_migration = completed;
+  }
+
+  function upgrade(address new_address) public restricted {
+    Migrations upgraded = Migrations(new_address);
+    upgraded.setCompleted(last_completed_migration);
+  }
+}

10_ref_datatypes/migrations/1_initial_migration.js

@@ -0,0 +1,5 @@
+var Migrations = artifacts.require("./Migrations.sol");
+
+module.exports = function(deployer) {
+  deployer.deploy(Migrations);
+};

10_ref_datatypes/migrations/2_custom.js

@@ -0,0 +1,5 @@
+var contract1 = artifacts.require("./Contract1.sol");
+
+module.exports = function(deployer) {
+  deployer.deploy(contract1);
+};

10_ref_datatypes/test/TestContract1.sol

@@ -0,0 +1,61 @@
+pragma solidity ^0.4.24;
+import "truffle/Assert.sol";
+import "truffle/DeployedAddresses.sol";
+import "../contracts/Contract1.sol";
+
+contract TestContract1 {
+    
+    function testUpdateList() public { 
+        Contract1 meta = Contract1(DeployedAddresses.Contract1());
+        meta.updateList();
+        Assert.equal(meta.list(0),31,"List 0 should be 31");
+        Assert.equal(meta.list(1),45,"List 1 should be 45");
+        Assert.equal(meta.list(2),33,"List 2 should be 33");
+    }
+
+    function testUpdateList2() public { 
+        Contract1 meta = Contract1(DeployedAddresses.Contract1());
+        // updateList2 function pass state variable which is array to another function
+        // but because function's parameter are always memory location so it
+        // will create separate copy and changing the one will not effect the other
+        meta.updateList2();
+        Assert.equal(meta.list(0),31,"List 0 should be 31");
+        Assert.equal(meta.list(1),45,"List 1 should be 45");
+        Assert.equal(meta.list(2),33,"List 2 should be 33");
+    }
+
+    function testUpdateList3() public { 
+        Contract1 meta = Contract1(DeployedAddresses.Contract1());
+        // And assigning state ref variable to memory ref variable will create a separate copy 
+        // changing one will not effect other
+        int val = meta.updateList3();
+        Assert.equal(val,33,"Val should be 33");
+        
+    }
+
+    function testUpdateList4() public { 
+        Contract1 meta = Contract1(DeployedAddresses.Contract1());
+        // Assigning Ref state (storage) variable to ref storage local variable
+        // will not create a separate copy so changing one will effect other
+        int val = meta.updateList4();
+        Assert.equal(val,100,"Val should be 100");
+        
+    }
+
+    function testUpdateStruct() public { 
+        Contract1 meta = Contract1(DeployedAddresses.Contract1());
+        // Assigning Ref state (storage) variable to ref storage local variable
+        // will not create a separate copy so changing one will effect other 
+        int val = meta.updateStruct();
+        Assert.equal(val,40,"Val should be 40");        
+    }
+
+    function testUpdateStruct2() public { 
+        Contract1 meta = Contract1(DeployedAddresses.Contract1());
+        // And assigning state ref variable to memory ref variable will create a separate copy 
+        // changing one will not effect other
+        int val = meta.updateStruct2();
+        Assert.equal(val,98,"Val should be 98");
+        
+    }
+}

10_ref_datatypes/truffle-config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  // See <http://truffleframework.com/docs/advanced/configuration>
+  // to customize your Truffle configuration!
+};

10_ref_datatypes/truffle.js

@@ -0,0 +1,11 @@
+module.exports = {
+  // See <http://truffleframework.com/docs/advanced/configuration>
+  // to customize your Truffle configuration!
+  networks: {
+    development: {
+      host: "127.0.0.1",
+      port: 8545,
+      network_id: "*" // Match any network id
+    }
+  }
+};