Improve encapsulation on ERC721

contracts/token/ERC721/ERC721.sol

@@ -20,19 +20,19 @@ contract ERC721 is SupportsInterfaceWithLookup, ERC721Basic, IERC721 {
   string internal symbol_;
 
   // Mapping from owner to list of owned token IDs
-  mapping(address => uint256[]) internal ownedTokens;
+  mapping(address => uint256[]) private ownedTokens_;
 
   // Mapping from token ID to index of the owner tokens list
-  mapping(uint256 => uint256) internal ownedTokensIndex;
+  mapping(uint256 => uint256) private ownedTokensIndex_;
 
   // Array with all token ids, used for enumeration
-  uint256[] internal allTokens;
+  uint256[] private allTokens_;
 
   // Mapping from token id to position in the allTokens array
-  mapping(uint256 => uint256) internal allTokensIndex;
+  mapping(uint256 => uint256) private allTokensIndex_;
 
   // Optional mapping for token URIs
-  mapping(uint256 => string) internal tokenURIs;
+  mapping(uint256 => string) private tokenURIs_;
 
   /**
    * @dev Constructor function
@@ -69,7 +69,7 @@ contract ERC721 is SupportsInterfaceWithLookup, ERC721Basic, IERC721 {
    */
   function tokenURI(uint256 _tokenId) public view returns (string) {
     require(_exists(_tokenId));
-    return tokenURIs[_tokenId];
+    return tokenURIs_[_tokenId];
   }
 
   /**
@@ -87,15 +87,15 @@ contract ERC721 is SupportsInterfaceWithLookup, ERC721Basic, IERC721 {
     returns (uint256)
   {
     require(_index < balanceOf(_owner));
-    return ownedTokens[_owner][_index];
+    return ownedTokens_[_owner][_index];
   }
 
   /**
    * @dev Gets the total amount of tokens stored by the contract
    * @return uint256 representing the total amount of tokens
    */
   function totalSupply() public view returns (uint256) {
-    return allTokens.length;
+    return allTokens_.length;
   }
 
   /**
@@ -106,7 +106,7 @@ contract ERC721 is SupportsInterfaceWithLookup, ERC721Basic, IERC721 {
    */
   function tokenByIndex(uint256 _index) public view returns (uint256) {
     require(_index < totalSupply());
-    return allTokens[_index];
+    return allTokens_[_index];
   }
 
   /**
@@ -117,7 +117,7 @@ contract ERC721 is SupportsInterfaceWithLookup, ERC721Basic, IERC721 {
    */
   function _setTokenURI(uint256 _tokenId, string _uri) internal {
     require(_exists(_tokenId));
-    tokenURIs[_tokenId] = _uri;
+    tokenURIs_[_tokenId] = _uri;
   }
 
   /**
@@ -127,9 +127,9 @@ contract ERC721 is SupportsInterfaceWithLookup, ERC721Basic, IERC721 {
    */
   function addTokenTo(address _to, uint256 _tokenId) internal {
     super.addTokenTo(_to, _tokenId);
-    uint256 length = ownedTokens[_to].length;
-    ownedTokens[_to].push(_tokenId);
-    ownedTokensIndex[_tokenId] = length;
+    uint256 length = ownedTokens_[_to].length;
+    ownedTokens_[_to].push(_tokenId);
+    ownedTokensIndex_[_tokenId] = length;
   }
 
   /**
@@ -142,20 +142,20 @@ contract ERC721 is SupportsInterfaceWithLookup, ERC721Basic, IERC721 {
 
     // To prevent a gap in the array, we store the last token in the index of the token to delete, and
     // then delete the last slot.
-    uint256 tokenIndex = ownedTokensIndex[_tokenId];
-    uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
-    uint256 lastToken = ownedTokens[_from][lastTokenIndex];
+    uint256 tokenIndex = ownedTokensIndex_[_tokenId];
+    uint256 lastTokenIndex = ownedTokens_[_from].length.sub(1);
+    uint256 lastToken = ownedTokens_[_from][lastTokenIndex];
 
-    ownedTokens[_from][tokenIndex] = lastToken;
+    ownedTokens_[_from][tokenIndex] = lastToken;
     // This also deletes the contents at the last position of the array
-    ownedTokens[_from].length--;
+    ownedTokens_[_from].length--;
 
     // Note that this will handle single-element arrays. In that case, both tokenIndex and lastTokenIndex are going to
     // be zero. Then we can make sure that we will remove _tokenId from the ownedTokens list since we are first swapping
     // the lastToken to the first position, and then dropping the element placed in the last position of the list
 
-    ownedTokensIndex[_tokenId] = 0;
-    ownedTokensIndex[lastToken] = tokenIndex;
+    ownedTokensIndex_[_tokenId] = 0;
+    ownedTokensIndex_[lastToken] = tokenIndex;
   }
 
   /**
@@ -167,8 +167,8 @@ contract ERC721 is SupportsInterfaceWithLookup, ERC721Basic, IERC721 {
   function _mint(address _to, uint256 _tokenId) internal {
     super._mint(_to, _tokenId);
 
-    allTokensIndex[_tokenId] = allTokens.length;
-    allTokens.push(_tokenId);
+    allTokensIndex_[_tokenId] = allTokens_.length;
+    allTokens_.push(_tokenId);
   }
 
   /**
@@ -181,21 +181,21 @@ contract ERC721 is SupportsInterfaceWithLookup, ERC721Basic, IERC721 {
     super._burn(_owner, _tokenId);
 
     // Clear metadata (if any)
-    if (bytes(tokenURIs[_tokenId]).length != 0) {
-      delete tokenURIs[_tokenId];
+    if (bytes(tokenURIs_[_tokenId]).length != 0) {
+      delete tokenURIs_[_tokenId];
     }
 
     // Reorg all tokens array
-    uint256 tokenIndex = allTokensIndex[_tokenId];
-    uint256 lastTokenIndex = allTokens.length.sub(1);
-    uint256 lastToken = allTokens[lastTokenIndex];
+    uint256 tokenIndex = allTokensIndex_[_tokenId];
+    uint256 lastTokenIndex = allTokens_.length.sub(1);
+    uint256 lastToken = allTokens_[lastTokenIndex];
 
-    allTokens[tokenIndex] = lastToken;
-    allTokens[lastTokenIndex] = 0;
+    allTokens_[tokenIndex] = lastToken;
+    allTokens_[lastTokenIndex] = 0;
 
-    allTokens.length--;
-    allTokensIndex[_tokenId] = 0;
-    allTokensIndex[lastToken] = tokenIndex;
+    allTokens_.length--;
+    allTokensIndex_[_tokenId] = 0;
+    allTokensIndex_[lastToken] = tokenIndex;
   }
 
 }

contracts/token/ERC721/ERC721Basic.sol

@@ -21,16 +21,16 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
   bytes4 private constant ERC721_RECEIVED = 0x150b7a02;
 
   // Mapping from token ID to owner
-  mapping (uint256 => address) internal tokenOwner;
+  mapping (uint256 => address) private tokenOwner_;
 
   // Mapping from token ID to approved address
-  mapping (uint256 => address) internal tokenApprovals;
+  mapping (uint256 => address) private tokenApprovals_;
 
   // Mapping from owner to number of owned token
-  mapping (address => uint256) internal ownedTokensCount;
+  mapping (address => uint256) private ownedTokensCount_;
 
   // Mapping from owner to operator approvals
-  mapping (address => mapping (address => bool)) internal operatorApprovals;
+  mapping (address => mapping (address => bool)) private operatorApprovals_;
 
   constructor()
     public
@@ -46,7 +46,7 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
    */
   function balanceOf(address _owner) public view returns (uint256) {
     require(_owner != address(0));
-    return ownedTokensCount[_owner];
+    return ownedTokensCount_[_owner];
   }
 
   /**
@@ -55,7 +55,7 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
    * @return owner address currently marked as the owner of the given token ID
    */
   function ownerOf(uint256 _tokenId) public view returns (address) {
-    address owner = tokenOwner[_tokenId];
+    address owner = tokenOwner_[_tokenId];
     require(owner != address(0));
     return owner;
   }
@@ -73,7 +73,7 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
     require(_to != owner);
     require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
 
-    tokenApprovals[_tokenId] = _to;
+    tokenApprovals_[_tokenId] = _to;
     emit Approval(owner, _to, _tokenId);
   }
 
@@ -83,7 +83,7 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
    * @return address currently approved for the given token ID
    */
   function getApproved(uint256 _tokenId) public view returns (address) {
-    return tokenApprovals[_tokenId];
+    return tokenApprovals_[_tokenId];
   }
 
   /**
@@ -94,7 +94,7 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
    */
   function setApprovalForAll(address _to, bool _approved) public {
     require(_to != msg.sender);
-    operatorApprovals[msg.sender][_to] = _approved;
+    operatorApprovals_[msg.sender][_to] = _approved;
     emit ApprovalForAll(msg.sender, _to, _approved);
   }
 
@@ -112,7 +112,7 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
     view
     returns (bool)
   {
-    return operatorApprovals[_owner][_operator];
+    return operatorApprovals_[_owner][_operator];
   }
 
   /**
@@ -194,7 +194,7 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
    * @return whether the token exists
    */
   function _exists(uint256 _tokenId) internal view returns (bool) {
-    address owner = tokenOwner[_tokenId];
+    address owner = tokenOwner_[_tokenId];
     return owner != address(0);
   }
 
@@ -255,8 +255,8 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
    */
   function clearApproval(address _owner, uint256 _tokenId) internal {
     require(ownerOf(_tokenId) == _owner);
-    if (tokenApprovals[_tokenId] != address(0)) {
-      tokenApprovals[_tokenId] = address(0);
+    if (tokenApprovals_[_tokenId] != address(0)) {
+      tokenApprovals_[_tokenId] = address(0);
     }
   }
 
@@ -266,9 +266,9 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
    * @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
    */
   function addTokenTo(address _to, uint256 _tokenId) internal {
-    require(tokenOwner[_tokenId] == address(0));
-    tokenOwner[_tokenId] = _to;
-    ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
+    require(tokenOwner_[_tokenId] == address(0));
+    tokenOwner_[_tokenId] = _to;
+    ownedTokensCount_[_to] = ownedTokensCount_[_to].add(1);
   }
 
   /**
@@ -278,8 +278,8 @@ contract ERC721Basic is SupportsInterfaceWithLookup, IERC721Basic {
    */
   function removeTokenFrom(address _from, uint256 _tokenId) internal {
     require(ownerOf(_tokenId) == _from);
-    ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
-    tokenOwner[_tokenId] = address(0);
+    ownedTokensCount_[_from] = ownedTokensCount_[_from].sub(1);
+    tokenOwner_[_tokenId] = address(0);
   }
 
   /**