Merge tag 'v2.1.1' of github.com:OpenZeppelin/openzeppelin-solidity

v2.1.1

contracts/utils/Address.sol

@@ -1,11 +1,9 @@
-pragma solidity ^0.4.24;
-
+pragma solidity ^0.5.0;
 
 /**
  * Utility library of inline functions on addresses
  */
 library Address {
-
     /**
      * Returns whether the target address is a contract
      * @dev This function will return false if invoked during the constructor of a contract,
@@ -21,7 +19,7 @@ library Address {
         // for more details about how this works.
         // TODO Check this again before the Serenity release, because all addresses will be
         // contracts then.
-        // solium-disable-next-line security/no-inline-assembly
+        // solhint-disable-next-line no-inline-assembly
         assembly { size := extcodesize(account) }
         return size > 0;
     }

contracts/utils/Arrays.sol

@@ -0,0 +1,48 @@
+pragma solidity ^0.5.0;
+
+import "../math/Math.sol";
+
+
+/**
+ * @title Arrays
+ * @dev Utility library of inline array functions
+ */
+library Arrays {
+    /**
+     * @dev Upper bound search function which is kind of binary search algoritm. It searches sorted
+     * array to find index of the element value. If element is found then returns it's index otherwise
+     * it returns index of first element which is grater than searched value. If searched element is
+     * bigger than any array element function then returns first index after last element (i.e. all
+     * values inside the array are smaller than the target). Complexity O(log n).
+     * @param array The array sorted in ascending order.
+     * @param element The element's value to be find.
+     * @return The calculated index value. Returns 0 for empty array.
+     */
+    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
+        if (array.length == 0) {
+            return 0;
+        }
+
+        uint256 low = 0;
+        uint256 high = array.length;
+
+        while (low < high) {
+            uint256 mid = Math.average(low, high);
+
+            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
+            // because Math.average rounds down (it does integer division with truncation).
+            if (array[mid] > element) {
+                high = mid;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
+        if (low > 0 && array[low - 1] == element) {
+            return low - 1;
+        } else {
+            return low;
+        }
+    }
+}

contracts/utils/ReentrancyGuard.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "zos-lib/contracts/Initializable.sol";
 
@@ -9,21 +9,21 @@ import "zos-lib/contracts/Initializable.sol";
  * mark it `external`.
  */
 contract ReentrancyGuard is Initializable {
-
     /// @dev counter to allow mutex lock with only one SSTORE operation
     uint256 private _guardCounter;
 
     function initialize() public initializer {
+        // The counter starts at one to prevent changing it from zero to a non-zero
+        // value, which is a more expensive operation.
         _guardCounter = 1;
     }
 
     /**
      * @dev Prevents a contract from calling itself, directly or indirectly.
-     * If you mark a function `nonReentrant`, you should also
-     * mark it `external`. Calling one `nonReentrant` function from
-     * another is not supported. Instead, you can implement a
-     * `private` function doing the actual work, and an `external`
-     * wrapper marked as `nonReentrant`.
+     * Calling a `nonReentrant` function from another `nonReentrant`
+     * function is not supported. It is possible to prevent this from happening
+     * by making the `nonReentrant` function external, and make it call a
+     * `private` function that does the actual work.
      */
     modifier nonReentrant() {
         _guardCounter += 1;