diff --git a/.circleci/config.yml b/.circleci/config.yml
new file mode 100644
index 00000000..7d4a55cc
--- /dev/null
+++ b/.circleci/config.yml
@@ -0,0 +1,145 @@
+version: 2
+jobs:
+ build:
+ docker:
+ - image: circleci/openjdk:8u171-jdk-stretch
+
+ working_directory: ~/repo
+
+ environment:
+ TERM: dumb
+ JAVA_TOOL_OPTIONS: -Xmx2048m
+ GRADLE_OPTS: -Dorg.gradle.daemon=false -Dorg.gradle.workers.max=2
+ GRADLE_MAX_TEST_FORKS: 2
+
+ steps:
+ - checkout
+ - run:
+ name: Check submodule status
+ command: git submodule status | tee ~/submodule-status
+
+ - restore_cache:
+ name: Restoring cached submodules
+ keys:
+ - v1-submodules-{{ checksum "~/submodule-status" }}
+
+ - run:
+ name: Update submodules
+ command: git submodule update --init --recursive
+
+ - run:
+ name: Install Sodium Library
+ command: |
+ sudo sh -c "echo 'deb http://deb.debian.org/debian unstable main contrib non-free' > /etc/apt/sources.list"
+ sudo apt-get update
+ sudo apt-get install -y libsodium23
+
+ - restore_cache:
+ name: Restoring cached gradle dependencies
+ keys:
+ - v1-gradle-dir-{{ checksum "build.gradle" }}
+ - v1-gradle-dir-
+
+ - run:
+ name: Downloading dependencies
+ command: ./gradlew allDependencies checkLicenses
+
+ - run:
+ name: Compiling
+ command: ./gradlew spotlessCheck assemble
+
+ - run:
+ name: Collecting artifacts
+ command: |
+ mkdir -p ~/jars
+ find . -type f -regex ".*/build/libs/.*jar" -exec cp {} ~/jars/ \;
+ when: always
+
+ - store_artifacts:
+ name: Uploading artifacts
+ path: ~/jars
+ destination: jars
+ when: always
+
+ - run:
+ name: Running tests
+ command: ./gradlew --stacktrace test
+
+ - run:
+ name: Collecting test results
+ command: |
+ ./gradlew jacocoTestReport
+ mkdir -p ~/test-results/
+ find . -type f -regex ".*/build/test-results/.*xml" -exec cp {} ~/test-results/ \;
+ when: always
+
+ - store_test_results:
+ name: Uploading test results
+ path: ~/test-results
+ destination: tests
+ when: always
+
+ - run:
+ name: Collecting reports
+ command: |
+ mkdir -p ~/reports/license
+ (cd ./build/reports/license && tar c .) | (cd ~/reports/license && tar x)
+ find . -type d -regex ".*/build/reports/tests/test" | while read dir; do
+ module=`echo $dir | sed -e 's/build\/reports\/tests\/test//'`
+ mkdir -p ~/reports/test/"$module"
+ (cd "$dir" && tar c .) | (cd ~/reports/test/"$module" && tar x)
+ done
+ find . -type d -regex ".*/build/reports/jacoco/test/html" | while read dir; do
+ module=`echo $dir | sed -e 's/build\/reports\/jacoco\/test\/html//'`
+ mkdir -p ~/reports/jacoco/"$module"
+ (cd "$dir" && tar c .) | (cd ~/reports/jacoco/"$module" && tar x)
+ done
+ when: always
+
+ - store_artifacts:
+ name: Uploading reports
+ path: ~/reports
+ destination: reports
+
+ - run:
+ name: Building JavaDoc
+ command: ./gradlew :javadoc
+
+ - store_artifacts:
+ name: Uploading JavaDoc
+ path: build/docs/javadoc
+ destination: javadoc
+
+ - run:
+ name: Building Dokka docs
+ command: ./gradlew :dokka
+
+ - store_artifacts:
+ name: Uploading Dokka docs
+ path: build/docs/dokka
+ destination: dokka
+
+ - deploy:
+ name: Deploying snapshot to Bintray (master branch only)
+ command: |
+ if [ "${CIRCLE_BRANCH}" == "master" ]; then
+ echo "Start deployment"
+ ./gradlew deploy
+ else
+ echo "Start dry run deployment"
+ export BINTRAY_DRYRUN=true
+ ./gradlew deploy
+ fi
+
+ - save_cache:
+ name: Caching gradle dependencies
+ paths:
+ - .gradle
+ - ~/.gradle
+ key: v1-gradle-dir-{{ checksum "build.gradle" }}-{{ .Branch }}-{{ .BuildNum }}
+
+ - save_cache:
+ name: Caching submodules
+ paths:
+ - .git/modules
+ key: v1-submodules-{{ checksum "~/submodule-status" }}
diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000..470eda26
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,5 @@
+[*.{kt,kts}]
+indent_size=2
+continuation_indent_size=2
+insert_final_newline=true
+max_line_length=120
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..e9de15c4
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,3 @@
+* text eol=lf
+*.jar -text
+*.bat -text
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..2ce8720d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,26 @@
+*.bak
+*.swp
+*.tmp
+*~.nib
+*.iml
+*.launch
+*.swp
+*.tokens
+.classpath
+.externalToolBuilders/
+.gradle/
+.idea/
+.loadpath
+.metadata
+.prefs
+.project
+.recommenders/
+.settings
+.springBeans
+.vertx
+bin/
+local.properties
+target/
+tmp/
+build/
+out/
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 00000000..184f98fb
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "eth-reference-tests/src/test/resources/tests"]
+ path = eth-reference-tests/src/test/resources/tests
+ url = https://github.com/ethereum/tests.git
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000..723abef8
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,61 @@
+# Contributing to Cava
+
+Welcome to the Cava repository! This document describes the procedure and guidelines for contributing to the Cava project. The subsequent sections encapsulate the criteria used to evaluate additions to, and modifications of, the existing codebase.
+
+## Contributor Workflow
+
+The codebase is maintained using the "*contributor workflow*" where everyone without exception contributes patch proposals using "*pull-requests*". This facilitates social contribution, easy testing and peer review.
+
+To contribute a patch, the workflow is as follows:
+
+* Fork repository
+* Create topic branch
+* Commit patch
+* Create pull-request, adhering to the coding conventions herein set forth
+
+In general a commit serves a single purpose and diffs should be easily comprehensible. For this reason do not mix any formatting fixes or code moves with actual code changes.
+
+## Style Guide
+
+`La mode se démode, le style jamais.`
+
+Guided by the immortal words of Gabrielle Bonheur, we strive to adhere strictly to best stylistic practices for each line of code in this software.
+
+At this stage one should expect comments and reviews from fellow contributors. You can add more commits to your pull request by committing them locally and pushing to your fork until you have satisfied all feedback. Before merging, you should aim to have a clean commit history where each commit identifies an specific change, or where all
+commits are squashed together.
+
+#### Stylistic
+
+The fundamental resource Cava contributors should familiarize themselves with is Oracle's [Code Conventions for the Java TM Programming Language](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html), to establish a general programme on Java coding. Furthermore, all pull-requests should be formatted according to the (slightly modified) [Google Java Style Guide](https://google.github.io/styleguide/javaguide.html), as it will be checked by our continuous integration architecture, and code that does not comply stylistically will fail to build.
+
+#### Architectural Best Practices
+
+Questions on architectural best practices will be guided by the principles set forth in [Effective Java](http://index-of.es/Java/Effective%20Java.pdf) by Joshua Bloch
+
+#### Clear Commit/PR Messages
+
+Commit messages should be verbose by default consisting of a short subject line (50 chars max), a blank line and detailed explanatory text as separate paragraph(s), unless the title alone is self-explanatory (such as "`Implement EXP EVM opcode`") in which case a single title line is sufficient. Commit messages should be helpful to people reading your code in the future, so explain the reasoning for your decisions. Further explanation on commit messages can be found [here](https://chris.beams.io/posts/git-commit/).
+
+#### Test coverage
+
+The test cases are sufficient enough to provide confidence in the code’s robustness, while avoiding redundant tests.
+
+#### Readability
+
+The code is easy to understand.
+
+#### Simplicity
+
+The code is not over-engineered, sufficient effort is made to minimize the cyclomatic complexity of the software.
+
+#### Functional
+
+Insofar as is possible the code intuitively and expeditiously executes the designated task.
+
+#### Clean
+
+The code is free from glaring typos (*e.g. misspelled comments*), thinkos, or formatting issues (*e.g. incorrect indentation*).
+
+#### Appropriately Commented
+
+Ambiguous or unclear code segments are commented. The comments are written in complete sentences.
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..8dada3ed
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "{}"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/PACKAGES.md b/PACKAGES.md
new file mode 100644
index 00000000..078ef1bc
--- /dev/null
+++ b/PACKAGES.md
@@ -0,0 +1,119 @@
+# Module cava
+
+In the spirit of [Google Guava](https://github.com/google/guava/), Cava is a set of libraries and other tools to aid development of blockchain and other decentralized software in Java and other JVM languages.
+
+# Package net.consensys.cava.bytes
+
+Classes and utilities for working with byte arrays.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-bytes` (`cava-bytes.jar`).
+
+# Package net.consensys.cava.concurrent
+
+Classes and utilities for working with concurrency.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-concurrent` (`cava-concurrent.jar`).
+
+# Package net.consensys.cava.config
+
+A general-purpose library for managing configuration data.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-config` (`cava-config.jar`).
+
+# Package net.consensys.cava.concurrent.coroutines.experimental
+
+Extensions for mapping [AsyncResult][net.consensys.cava.concurrent.AsyncResult] and [AsyncCompletion][net.consensys.cava.concurrent.AsyncCompletion] objects to and from Kotlin coroutines.
+
+# Package net.consensys.cava.crypto
+
+Classes and utilities for working with cryptography.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-crypto` (`cava-crypto.jar`).
+
+# Package net.consensys.cava.crypto.sodium
+
+Classes and utilities for working with the sodium native library.
+
+Classes and utilities in this package provide an interface to the native Sodium crypto library (https://www.libsodium.org/), which must be installed on the same system as the JVM. It will be searched for in common library locations, or its it can be loaded explicitly using [net.consensys.cava.crypto.sodium.Sodium.loadLibrary].
+
+Classes in this package also depend upon the JNR-FFI library being available on the classpath, along with its dependencies. See https://github.com/jnr/jnr-ffi. JNR-FFI can be included using the gradle dependency `com.github.jnr:jnr-ffi`.
+
+# Package net.consensys.cava.eth.domain
+
+Classes and utilities for working with Ethereum domain objects.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-eth-domain` (`cava-eth-domain.jar`).
+
+# Package net.consensys.cava.io
+
+Classes and utilities for handling file and network IO.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-io` (`cava-io.jar`).
+
+# Package net.consensys.cava.io.file
+
+General utilities for working with files and the filesystem.
+
+# Package net.consensys.cava.junit
+
+Utilities for better junit testing.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-junit` (`cava-junit.jar`).
+
+# Package net.consensys.cava.kv
+
+Classes and utilities for working with key/value stores.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-kv` (`cava-kv.jar`).
+
+# Package net.consensys.cava.net
+
+Classes and utilities for working with networking.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-net` (`cava-net.jar`).
+
+# Package net.consensys.cava.net.tls
+
+Utilities for doing fingerprint based TLS certificate checking.
+
+# Package net.consensys.cava.rlp
+
+Recursive Length Prefix (RLP) encoding and decoding.
+
+An implementation of the Ethereum Recursive Length Prefix (RLP) algorithm, as described at https://github.com/ethereum/wiki/wiki/RLP.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-rlp` (`cava-rlp.jar`).
+
+# Package net.consensys.cava.toml
+
+A parser for Tom's Obvious, Minimal Language (TOML).
+
+A parser and semantic checker for Tom's Obvious, Minimal Language (TOML), as described at https://github.com/toml-lang/toml/.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-toml` (cava-toml.jar).
+
+# Package net.consensys.cava.trie
+
+Merkle Trie implementations.
+
+Implementations of the Ethereum Patricia Trie, as described at https://github.com/ethereum/wiki/wiki/Patricia-Tree.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-merkle-trie` (`cava-merkle-trie.jar`).
+
+# Package net.consensys.cava.trie.experimental
+
+Merkle Trie implementations using Kotlin coroutines.
+
+# Package net.consensys.cava.units
+
+Classes and utilities for working with 256 bit integers and Ethereum units.
+
+These classes are included in the standard Cava distribution, or separately when using the gradle dependency `net.consensys.cava:cava-units` (`cava-units.jar`).
+
+# Package net.consensys.cava.units.bigints
+
+Classes and utilities for working with 256 bit integers.
+
+# Package net.consensys.cava.units.ethereum
+
+Classes and utilities for working with Ethereum units.
diff --git a/README.md b/README.md
new file mode 100644
index 00000000..f12c4cbf
--- /dev/null
+++ b/README.md
@@ -0,0 +1,51 @@
+# Cava: ConsenSys Core Libraries for Java (& Kotlin)
+
+[](https://circleci.com/gh/ConsenSys/cava)
+[](https://github.com/consensys/cava/blob/master/LICENSE)
+[ ](https://bintray.com/consensys/consensys/cava/0.1.0)
+
+In the spirit of [Google Guava](https://github.com/google/guava/), Cava is a set of libraries and other tools to aid development of blockchain and other decentralized software in Java and other JVM languages.
+
+It includes a low-level bytes library, serialization and deserialization codecs (e.g. [RLP](https://github.com/ethereum/wiki/wiki/RLP)), various cryptography functions and primatives, and lots of other helpful utilities.
+
+Cava is developed for JDK 1.8 or higher, and depends on various other FOSS libraries, including Guava.
+
+## Getting cava
+
+> Note that these libraries are experimental and are subject to change.
+
+The libraries are published to [ConsenSys bintray repository](https://consensys.bintray.com/consensys/) and linked to JCenter.
+
+You can import all modules using the cava jar.
+
+With Maven:
+```
+
+ net.consensys.cava
+ cava
+ 0.1.0
+
+```
+
+With Gradle: `compile 'net.consensys.cava:cava:0.1.0'`
+
+[PACKAGES.md](PACKAGES.md) contains the list of modules and instructions to import them separately.
+
+## Build Instructions
+
+To build, clone this repo and run with `./gradlew` like so:
+
+```
+git clone --recursive https://github.com/ConsenSys/cava
+cd cava
+./gradlew
+```
+
+After a successful build, libraries will be available in `build/libs`.
+
+## Links
+
+- [GitHub project](https://github.com/consensys/cava)
+- [Issue tracker: Report a defect or feature request](https://github.com/google/cava/issues/new)
+- [StackOverflow: Ask "how-to" and "why-didn't-it-work" questions](https://stackoverflow.com/questions/ask?tags=cava+java)
+- [cava-discuss: For open-ended questions and discussion](http://groups.google.com/group/cava-discuss)
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 00000000..32ab1cbe
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,394 @@
+import java.util.regex.Pattern
+
+buildscript {
+ repositories {
+ maven { url 'https://consensys.bintray.com/consensys/' }
+ jcenter()
+ }
+ dependencies { classpath 'com.yubico:gradle-gpg-signing-plugin:0.1.0-alpha1' }
+}
+plugins {
+ id 'com.diffplug.gradle.spotless' version '3.12.0'
+ id 'net.ltgt.errorprone' version '0.0.14'
+ id 'io.spring.dependency-management' version '1.0.4.RELEASE'
+ id 'com.github.hierynomus.license' version '0.14.0'
+ id 'com.jfrog.bintray' version '1.8.1'
+ id 'org.jetbrains.kotlin.jvm' version '1.2.41'
+ id 'org.jetbrains.dokka' version '0.9.17'
+}
+
+
+//////
+// Version numbering
+
+def versionNumber = '0.1.0'
+def buildVersion = versionNumber + buildTag()
+
+static String buildTag() {
+ if (System.getenv('BUILD_TAG_MODE') == 'release') {
+ return ''
+ }
+ if (!System.getenv('CIRCLECI')) {
+ return '-dev'
+ }
+ return '-' + System.getenv('CIRCLE_SHA1').take(4).toUpperCase() +
+ String.format('%02X', System.getenv('CIRCLE_BUILD_NUM').toInteger() % 256, 16) +
+ (System.getenv('BUILD_ENVIRONMENT_TAG') ?: '-snapshot')
+}
+
+
+//////
+// Default tasks and build aliases
+
+defaultTasks 'checkLicenses', 'spotlessCheck', 'jar', 'test', ':javadoc'
+
+def buildAliases = ['dev': [
+ 'spotlessApply',
+ 'checkLicenses',
+ ':jar',
+ 'test',
+ ':javadoc'
+ ]]
+
+def expandedTaskList = []
+gradle.startParameter.taskNames.each {
+ expandedTaskList << (buildAliases[it] ? buildAliases[it] : it)
+}
+gradle.startParameter.taskNames = expandedTaskList.flatten()
+
+task deploy() {}
+
+allprojects {
+ apply plugin: 'java-library'
+ apply plugin: 'kotlin'
+ apply plugin: 'com.diffplug.gradle.spotless'
+ apply plugin: 'io.spring.dependency-management'
+ apply plugin: 'jacoco'
+ apply plugin: 'net.ltgt.errorprone'
+ apply plugin: 'com.jfrog.bintray'
+ apply plugin: 'maven-publish'
+ apply plugin: 'org.jetbrains.dokka'
+ apply plugin: 'signing'
+ apply plugin: 'com.yubico.signing.gpg'
+ apply from: "${rootDir}/dependency-versions.gradle"
+ apply from: "${rootDir}/gradle/check-licenses.gradle"
+
+ version = buildVersion
+
+ repositories { jcenter() }
+
+ //////
+ // Use JUnit5 for testing
+
+ test { useJUnitPlatform() { includeEngines 'spek', 'junit-jupiter' } }
+
+
+ //////
+ // Source formatting
+
+ spotless {
+ java {
+ target project.fileTree(project.rootDir) {
+ include '**/*.java'
+ exclude '**/generated-src/**/*.*'
+ }
+ removeUnusedImports()
+ licenseHeaderFile rootProject.file('gradle/license-header.txt')
+ eclipse().configFile(rootProject.file('gradle/eclipse-java-consensys-style.xml'))
+ importOrder 'net.consensys', 'java', ''
+ endWithNewline()
+ }
+ groovyGradle {
+ target '**/*.gradle'
+ greclipse().configFile(rootProject.file('gradle/greclipse-gradle-consensys-style.properties'))
+ endWithNewline()
+ }
+ kotlin {
+ licenseHeaderFile rootProject.file('gradle/license-header.txt')
+ ktlint().userData(['indent_size': '2', 'continuation_indent_size' : '2', 'max_line_length': '120'])
+ endWithNewline()
+ }
+ }
+
+
+ //////
+ // Compiler arguments
+
+ dependencies { errorprone 'com.google.errorprone:error_prone_core' }
+
+ tasks.withType(JavaCompile) {
+ options.compilerArgs += [
+ '-proc:none',
+ '-Xlint:unchecked',
+ '-Xlint:cast',
+ '-Xlint:rawtypes',
+ '-Xlint:overloads',
+ '-Xlint:divzero',
+ '-Xlint:finally',
+ '-Xlint:static',
+ '-Werror',
+ '-Xep:FutureReturnValueIgnored:OFF'
+ ]
+ }
+
+ tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
+ kotlinOptions {
+ jvmTarget = "1.8"
+ allWarningsAsErrors = true
+ freeCompilerArgs = ['-Xjsr305=strict']
+ }
+ }
+
+ kotlin.experimental.coroutines = 'enable'
+
+
+ //////
+ // Documentation
+
+ dokka {
+ outputFormat = 'html'
+ outputDirectory = "$buildDir/docs/dokka"
+ jdkVersion = 8
+ includeNonPublic = false
+ def relativePath = rootDir.toPath().relativize(projectDir.toPath()).toString()
+ linkMapping {
+ dir = projectDir.toString()
+ url = "https://github.com/consensys/cava/blob/master/$relativePath"
+ suffix = "#L"
+ }
+ }
+
+
+ //////
+ // Packaging and deployment
+
+ tasks.withType(Jar) {
+ if (rootProject == project) {
+ baseName = project.name
+ } else {
+ baseName = rootProject.name + '-' + project.name
+ }
+ manifest {
+ attributes('Implementation-Title': baseName,
+ 'Implementation-Version': project.version)
+ }
+ }
+
+ jar {
+ destinationDir = file("${rootProject.buildDir}/libs")
+ }
+
+ task sourcesJar(type: Jar, dependsOn: classes) {
+ destinationDir = file("${rootProject.buildDir}/src")
+ classifier = 'sources'
+ from sourceSets.main.allSource
+ }
+
+ task dokkaJar(type: Jar, dependsOn: dokka) {
+ destinationDir = file("${rootProject.buildDir}/docs")
+ classifier = 'dokka'
+ from dokka.outputDirectory
+ }
+
+ if (project.name != 'eth-reference-tests') {
+ signing {
+ useGpgCmd()
+ sign configurations.archives
+ }
+
+ tasks.withType(Sign) {
+ onlyIf { System.getenv('ENABLE_SIGNING') == 'true' }
+ }
+
+ artifacts {
+ archives jar
+ archives sourcesJar
+ archives dokkaJar
+ }
+
+ publishing {
+ publications {
+ MavenDeployment(MavenPublication) { publication ->
+ from components.java
+ artifact sourcesJar { classifier 'sources' }
+ artifact dokkaJar { classifier 'javadoc' }
+ groupId 'net.consensys.cava'
+ artifactId project.jar.baseName
+ version project.version
+
+ pom.withXml {
+ def root = asNode()
+ root.appendNode('description', project.description)
+ root.appendNode('name', project.jar.baseName)
+ root.appendNode('url', 'https://github.com/ConsenSys/cava')
+ def license = root.appendNode('licenses').appendNode('license')
+ license.appendNode('name', 'The Apache Software License, Version 2.0')
+ license.appendNode('url', 'http://www.apache.org/licenses/LICENSE-2.0.txt')
+ license.appendNode('distribution', 'repo')
+ def scm = root.appendNode('scm')
+ scm.appendNode('url', 'https://github.com/ConsenSys/cava')
+ scm.appendNode('connection', 'scm:https://github.com/ConsenSys/cava.git')
+ scm.appendNode('developerConnection', 'scm:git@github.com:ConsenSys/cava.git')
+ }
+ }
+ }
+ }
+
+ def artifactIdMatcher = Pattern.compile("(.*)-\\d.*")
+ bintray {
+ user = System.getenv('BINTRAY_USER')
+ key = System.getenv('BINTRAY_KEY')
+ publications = ['MavenDeployment']
+ filesSpec {
+ project.extensions.getByType(PublishingExtension).publications.all { publication ->
+ publication.getArtifacts().all {
+ def ascFile = new File(it.file.getParentFile(), it.file.getName() + '.asc')
+ if (ascFile.exists()) {
+ def matcher = artifactIdMatcher.matcher(it.file.getName())
+ matcher.find()
+ def artifactId = matcher.group(1)
+ from ascFile.getAbsolutePath()
+ into publication.groupId.replaceAll('\\.', '/') + '/' + artifactId + '/' + publication.version + '/'
+ }
+ }
+ }
+ }
+ dryRun = System.getenv('BINTRAY_DRYRUN') == 'true'
+ pkg {
+ repo = 'consensys'
+ name = 'cava'
+ userOrg = 'consensys'
+ licenses = ['Apache-2.0']
+ version {
+ name = project.version
+ desc = 'Cava distribution'
+ released = new Date()
+ vcsTag = project.version
+ }
+ }
+ }
+ deploy.dependsOn bintrayUpload
+ }
+}
+
+
+subprojects {
+
+ //////
+ // Parallel build execution
+
+ tasks.withType(Test) {
+ // If GRADLE_MAX_TEST_FORKS is not set, use half the available processors
+ maxParallelForks = (System.getenv('GRADLE_MAX_TEST_FORKS') ?:
+ (Runtime.runtime.availableProcessors().intdiv(2) ?: 1)).toInteger()
+ }
+
+ tasks.withType(JavaCompile) {
+ options.fork = true
+ options.incremental = true
+ }
+
+ task allDependencies(type: DependencyReportTask) {}
+}
+
+//////
+// Deploy the site
+
+task publishSite(type: Exec) { commandLine "${rootProject.projectDir}/site/deploy.sh", "${versionNumber}" }
+
+
+//////
+// Bundle all subprojects
+
+subprojects.each { evaluationDependsOn(it.path) }
+
+jar {
+ baseName = rootProject.name
+ manifest {
+ attributes('Implementation-Title': baseName,
+ 'Implementation-Version': project.version)
+ }
+ subprojects.each {
+ from it.sourceSets.main.output
+ dependsOn it.classes
+ }
+}
+
+dependencies {
+ subprojects.each {
+ it.configurations.compile.allDependencies.each { d ->
+ if (d instanceof ExternalModuleDependency) {
+ add('compile', d)
+ }
+ }
+ it.configurations.runtime.allDependencies.each { d ->
+ if (d instanceof ExternalModuleDependency) {
+ add('runtime', d)
+ }
+ }
+ }
+}
+
+sourcesJar {
+ baseName = rootProject.name
+ manifest {
+ attributes('Implementation-Title': baseName,
+ 'Implementation-Version': project.version)
+ }
+ subprojects.each {
+ from it.sourceSets.main.allSource
+ dependsOn it.classes
+ }
+}
+
+javadoc {
+ subprojects.each {
+ source += it.javadoc.source
+ classpath += it.javadoc.classpath
+ }
+}
+
+dokka {
+ moduleName = rootProject.name
+ subprojects.each {
+ dependsOn it.classes
+ it.sourceSets.main.output.each { d ->
+ if (d.exists()) {
+ classpath += d
+ }
+ }
+ }
+ sourceDirs = files(subprojects.collect {
+ return [
+ new File(it.projectDir, '/src/main/kotlin'),
+ new File(it.projectDir, '/src/main/java')
+ ]
+ })
+ linkMapping {
+ dir = rootDir.toString()
+ url = "https://github.com/consensys/cava/blob/master"
+ suffix = "#L"
+ }
+
+ includes = ['PACKAGES.md']
+
+ externalDocumentationLink {
+ url = new URL("https://docs.oracle.com/javase/8/docs/api/")
+ }
+
+ externalDocumentationLink {
+ url = new URL('https://atoulme.github.io/kotlinx.coroutines/kotlinx-coroutines-core/')
+ }
+}
+
+dokkaJar {
+ baseName = rootProject.name
+ manifest {
+ attributes('Implementation-Title': baseName,
+ 'Implementation-Version': project.version)
+ }
+}
+
+if (!file("${rootDir}/eth-reference-tests/src/test/resources/tests/README.md").exists()) {
+ throw new GradleException("eth-reference-tests/src/test/resources/tests/README.md missing: please clone submodules (git submodule update --init --recursive)")
+}
diff --git a/bytes/build.gradle b/bytes/build.gradle
new file mode 100644
index 00000000..aefc8679
--- /dev/null
+++ b/bytes/build.gradle
@@ -0,0 +1,12 @@
+description = 'Classes and utilities for working with byte arrays.'
+
+dependencies {
+ compile 'com.google.guava:guava'
+ compileOnly 'io.vertx:vertx-core'
+
+ testCompile 'io.vertx:vertx-core'
+ testCompile 'org.junit.jupiter:junit-jupiter-api'
+ testCompile 'org.junit.jupiter:junit-jupiter-params'
+
+ testRuntime 'org.junit.jupiter:junit-jupiter-engine'
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/AbstractBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/AbstractBytes.java
new file mode 100644
index 00000000..1ad2849b
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/AbstractBytes.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+/**
+ * An abstract {@link Bytes} value that provides implementations of {@link #equals(Object)}, {@link #hashCode()} and
+ * {@link #toString()}.
+ */
+public abstract class AbstractBytes implements Bytes {
+
+ static final char[] HEX_CODE = "0123456789ABCDEF".toCharArray();
+
+ /**
+ * Compare this value and the provided one for equality.
+ *
+ *
+ * Two {@link Bytes} values are equal is they have contain the exact same bytes.
+ *
+ * @param obj The object to test for equality with.
+ * @return true if this value and {@code obj} are equal.
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof Bytes)) {
+ return false;
+ }
+
+ Bytes other = (Bytes) obj;
+ if (this.size() != other.size()) {
+ return false;
+ }
+
+ for (int i = 0; i < size(); i++) {
+ if (this.get(i) != other.get(i)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = 1;
+ for (int i = 0; i < size(); i++) {
+ result = 31 * result + get(i);
+ }
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return toHexString();
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/ArrayWrappingBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/ArrayWrappingBytes.java
new file mode 100644
index 00000000..2f365630
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/ArrayWrappingBytes.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+import java.security.MessageDigest;
+import java.util.Arrays;
+
+import io.vertx.core.buffer.Buffer;
+
+class ArrayWrappingBytes extends AbstractBytes {
+
+ protected final byte[] bytes;
+ protected final int offset;
+ protected final int length;
+
+ ArrayWrappingBytes(byte[] bytes) {
+ this(bytes, 0, bytes.length);
+ }
+
+ ArrayWrappingBytes(byte[] bytes, int offset, int length) {
+ checkArgument(length >= 0, "Invalid negative length");
+ if (bytes.length > 0) {
+ checkElementIndex(offset, bytes.length);
+ }
+ checkArgument(
+ offset + length <= bytes.length,
+ "Provided length %s is too big: the value has only %s bytes from offset %s",
+ length,
+ bytes.length - offset,
+ offset);
+
+ this.bytes = bytes;
+ this.offset = offset;
+ this.length = length;
+ }
+
+ @Override
+ public int size() {
+ return length;
+ }
+
+ @Override
+ public byte get(int i) {
+ // Check bounds because while the array access would throw, the error message would be confusing
+ // for the caller.
+ checkElementIndex(i, size());
+ return bytes[offset + i];
+ }
+
+ @Override
+ public Bytes slice(int i, int length) {
+ if (i == 0 && length == this.length) {
+ return this;
+ }
+ if (length == 0) {
+ return Bytes.EMPTY;
+ }
+
+ checkElementIndex(i, this.length);
+ checkArgument(
+ i + length <= this.length,
+ "Provided length %s is too big: the value has size %s and has only %s bytes from %s",
+ length,
+ this.length,
+ this.length - i,
+ i);
+
+ return length == Bytes32.SIZE ? new ArrayWrappingBytes32(bytes, offset + i)
+ : new ArrayWrappingBytes(bytes, offset + i, length);
+ }
+
+ // MUST be overridden by mutable implementations
+ @Override
+ public Bytes copy() {
+ if (offset == 0 && length == bytes.length) {
+ return this;
+ }
+ return new ArrayWrappingBytes(toArray());
+ }
+
+ @Override
+ public MutableBytes mutableCopy() {
+ return new MutableArrayWrappingBytes(toArray());
+ }
+
+ @Override
+ public int commonPrefixLength(Bytes other) {
+ if (!(other instanceof ArrayWrappingBytes)) {
+ return super.commonPrefixLength(other);
+ }
+ ArrayWrappingBytes o = (ArrayWrappingBytes) other;
+ int i = 0;
+ while (i < length && i < o.length && bytes[offset + i] == o.bytes[o.offset + i]) {
+ i++;
+ }
+ return i;
+ }
+
+ @Override
+ public void update(MessageDigest digest) {
+ digest.update(bytes, offset, length);
+ }
+
+ @Override
+ public void copyTo(MutableBytes destination, int destinationOffset) {
+ if (!(destination instanceof MutableArrayWrappingBytes)) {
+ super.copyTo(destination, destinationOffset);
+ return;
+ }
+
+ int size = size();
+ if (size == 0) {
+ return;
+ }
+
+ checkElementIndex(destinationOffset, destination.size());
+ checkArgument(
+ destination.size() - destinationOffset >= size,
+ "Cannot copy %s bytes, destination has only %s bytes from index %s",
+ size,
+ destination.size() - destinationOffset,
+ destinationOffset);
+
+ MutableArrayWrappingBytes d = (MutableArrayWrappingBytes) destination;
+ System.arraycopy(bytes, offset, d.bytes, d.offset + destinationOffset, size);
+ }
+
+ @Override
+ public void appendTo(Buffer buffer) {
+ buffer.appendBytes(bytes, offset, length);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof ArrayWrappingBytes)) {
+ return super.equals(obj);
+ }
+ ArrayWrappingBytes other = (ArrayWrappingBytes) obj;
+ if (length != other.length) {
+ return false;
+ }
+ for (int i = 0; i < length; ++i) {
+ if (bytes[offset + i] != other.bytes[other.offset + i]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = 1;
+ int size = size();
+ for (int i = 0; i < size; i++) {
+ result = 31 * result + bytes[offset + i];
+ }
+ return result;
+ }
+
+ @Override
+ public byte[] toArray() {
+ return Arrays.copyOfRange(bytes, offset, offset + length);
+ }
+
+ @Override
+ public byte[] toArrayUnsafe() {
+ if (offset == 0 && length == bytes.length) {
+ return bytes;
+ }
+ return toArray();
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/ArrayWrappingBytes32.java b/bytes/src/main/java/net/consensys/cava/bytes/ArrayWrappingBytes32.java
new file mode 100644
index 00000000..8859e437
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/ArrayWrappingBytes32.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+final class ArrayWrappingBytes32 extends ArrayWrappingBytes implements Bytes32 {
+
+ ArrayWrappingBytes32(byte[] bytes) {
+ this(checkLength(bytes), 0);
+ }
+
+ ArrayWrappingBytes32(byte[] bytes, int offset) {
+ super(checkLength(bytes, offset), offset, SIZE);
+ }
+
+ // Ensures a proper error message.
+ private static byte[] checkLength(byte[] bytes) {
+ checkArgument(bytes.length == SIZE, "Expected %s bytes but got %s", SIZE, bytes.length);
+ return bytes;
+ }
+
+ // Ensures a proper error message.
+ private static byte[] checkLength(byte[] bytes, int offset) {
+ checkArgument(
+ bytes.length - offset >= SIZE,
+ "Expected at least %s bytes from offset %s but got only %s",
+ SIZE,
+ offset,
+ bytes.length - offset);
+ return bytes;
+ }
+
+ @Override
+ public Bytes32 copy() {
+ if (offset == 0 && length == bytes.length) {
+ return this;
+ }
+ return new ArrayWrappingBytes32(toArray());
+ }
+
+ @Override
+ public MutableBytes32 mutableCopy() {
+ return new MutableArrayWrappingBytes32(toArray());
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/BufferWrappingBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/BufferWrappingBytes.java
new file mode 100644
index 00000000..46beb633
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/BufferWrappingBytes.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+import io.vertx.core.buffer.Buffer;
+
+class BufferWrappingBytes extends AbstractBytes {
+
+ protected final Buffer buffer;
+
+ BufferWrappingBytes(Buffer buffer) {
+ this.buffer = buffer;
+ }
+
+ BufferWrappingBytes(Buffer buffer, int offset, int length) {
+ checkArgument(length >= 0, "Invalid negative length");
+ int bufferLength = buffer.length();
+ checkElementIndex(offset, bufferLength + 1);
+ checkArgument(
+ offset + length <= bufferLength,
+ "Provided length %s is too big: the buffer has size %s and has only %s bytes from %s",
+ length,
+ bufferLength,
+ bufferLength - offset,
+ offset);
+
+ if (offset == 0 && length == bufferLength) {
+ this.buffer = buffer;
+ } else {
+ this.buffer = buffer.slice(offset, offset + length);
+ }
+ }
+
+ @Override
+ public int size() {
+ return buffer.length();
+ }
+
+ @Override
+ public byte get(int i) {
+ return buffer.getByte(i);
+ }
+
+ @Override
+ public int getInt(int i) {
+ return buffer.getInt(i);
+ }
+
+ @Override
+ public long getLong(int i) {
+ return buffer.getLong(i);
+ }
+
+ @Override
+ public Bytes slice(int i, int length) {
+ int size = buffer.length();
+ if (i == 0 && length == size) {
+ return this;
+ }
+ if (length == 0) {
+ return Bytes.EMPTY;
+ }
+
+ checkElementIndex(i, size);
+ checkArgument(
+ i + length <= size,
+ "Provided length %s is too big: the value has size %s and has only %s bytes from %s",
+ length,
+ size,
+ size - i,
+ i);
+
+ return new BufferWrappingBytes(buffer.slice(i, i + length));
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof BufferWrappingBytes)) {
+ return super.equals(obj);
+ }
+ BufferWrappingBytes other = (BufferWrappingBytes) obj;
+ return buffer.equals(other.buffer);
+ }
+
+ @Override
+ public int hashCode() {
+ return buffer.hashCode();
+ }
+
+ // MUST be overridden by mutable implementations
+ @Override
+ public Bytes copy() {
+ return Bytes.wrap(toArray());
+ }
+
+ @Override
+ public MutableBytes mutableCopy() {
+ return MutableBytes.wrap(toArray());
+ }
+
+ @Override
+ public void appendTo(Buffer buffer) {
+ buffer.appendBuffer(this.buffer);
+ }
+
+ @Override
+ public byte[] toArray() {
+ return buffer.getBytes();
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/ByteBufWrappingBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/ByteBufWrappingBytes.java
new file mode 100644
index 00000000..ec0929d9
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/ByteBufWrappingBytes.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+import io.netty.buffer.ByteBuf;
+import io.vertx.core.buffer.Buffer;
+
+class ByteBufWrappingBytes extends AbstractBytes {
+
+ protected final ByteBuf byteBuf;
+
+ ByteBufWrappingBytes(ByteBuf byteBuf) {
+ this.byteBuf = byteBuf;
+ }
+
+ ByteBufWrappingBytes(ByteBuf byteBuf, int offset, int length) {
+ checkArgument(length >= 0, "Invalid negative length");
+ int bufferLength = byteBuf.capacity();
+ checkElementIndex(offset, bufferLength + 1);
+ checkArgument(
+ offset + length <= bufferLength,
+ "Provided length %s is too big: the buffer has size %s and has only %s bytes from %s",
+ length,
+ bufferLength,
+ bufferLength - offset,
+ offset);
+
+ if (offset == 0 && length == bufferLength) {
+ this.byteBuf = byteBuf;
+ } else {
+ this.byteBuf = byteBuf.slice(offset, length);
+ }
+ }
+
+ @Override
+ public int size() {
+ return byteBuf.capacity();
+ }
+
+ @Override
+ public byte get(int i) {
+ return byteBuf.getByte(i);
+ }
+
+ @Override
+ public int getInt(int i) {
+ return byteBuf.getInt(i);
+ }
+
+ @Override
+ public long getLong(int i) {
+ return byteBuf.getLong(i);
+ }
+
+ @Override
+ public Bytes slice(int i, int length) {
+ int size = byteBuf.capacity();
+ if (i == 0 && length == size) {
+ return this;
+ }
+ if (length == 0) {
+ return Bytes.EMPTY;
+ }
+
+ checkElementIndex(i, size);
+ checkArgument(
+ i + length <= size,
+ "Provided length %s is too big: the value has size %s and has only %s bytes from %s",
+ length,
+ size,
+ size - i,
+ i);
+
+ return new ByteBufWrappingBytes(byteBuf.slice(i, length));
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof ByteBufWrappingBytes)) {
+ return super.equals(obj);
+ }
+ ByteBufWrappingBytes other = (ByteBufWrappingBytes) obj;
+ return byteBuf.equals(other.byteBuf);
+ }
+
+ @Override
+ public int hashCode() {
+ return byteBuf.hashCode();
+ }
+
+ // MUST be overridden by mutable implementations
+ @Override
+ public Bytes copy() {
+ return Bytes.wrap(toArray());
+ }
+
+ @Override
+ public MutableBytes mutableCopy() {
+ return MutableBytes.wrap(toArray());
+ }
+
+ @Override
+ public void appendTo(Buffer buffer) {
+ buffer.appendBuffer(Buffer.buffer(this.byteBuf));
+ }
+
+ @Override
+ public byte[] toArray() {
+ int size = byteBuf.capacity();
+ byte[] array = new byte[size];
+ byteBuf.getBytes(0, array);
+ return array;
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/ByteBufferWrappingBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/ByteBufferWrappingBytes.java
new file mode 100644
index 00000000..83d910d2
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/ByteBufferWrappingBytes.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+class ByteBufferWrappingBytes extends AbstractBytes {
+
+ protected final ByteBuffer byteBuffer;
+ protected final int offset;
+ protected final int length;
+
+ ByteBufferWrappingBytes(ByteBuffer byteBuffer) {
+ this(byteBuffer, 0, byteBuffer.limit());
+ }
+
+ ByteBufferWrappingBytes(ByteBuffer byteBuffer, int offset, int length) {
+ checkArgument(length >= 0, "Invalid negative length");
+ int bufferLength = byteBuffer.capacity();
+ if (bufferLength > 0) {
+ checkElementIndex(offset, bufferLength);
+ }
+ checkArgument(
+ offset + length <= bufferLength,
+ "Provided length %s is too big: the value has only %s bytes from offset %s",
+ length,
+ bufferLength - offset,
+ offset);
+
+ this.byteBuffer = byteBuffer;
+ this.offset = offset;
+ this.length = length;
+ }
+
+ @Override
+ public int size() {
+ return length;
+ }
+
+ @Override
+ public int getInt(int i) {
+ return byteBuffer.getInt(offset + i);
+ }
+
+ @Override
+ public long getLong(int i) {
+ return byteBuffer.getLong(offset + i);
+ }
+
+ @Override
+ public byte get(int i) {
+ return byteBuffer.get(offset + i);
+ }
+
+ @Override
+ public Bytes slice(int i, int length) {
+ if (i == 0 && length == this.length) {
+ return this;
+ }
+ if (length == 0) {
+ return Bytes.EMPTY;
+ }
+
+ checkElementIndex(i, this.length);
+ checkArgument(
+ i + length <= this.length,
+ "Provided length %s is too big: the value has size %s and has only %s bytes from %s",
+ length,
+ this.length,
+ this.length - i,
+ i);
+
+ return new ByteBufferWrappingBytes(byteBuffer, offset + i, length);
+ }
+
+ // MUST be overridden by mutable implementations
+ @Override
+ public Bytes copy() {
+ if (offset == 0 && length == byteBuffer.limit()) {
+ return this;
+ }
+ return new ArrayWrappingBytes(toArray());
+ }
+
+ @Override
+ public MutableBytes mutableCopy() {
+ return new MutableArrayWrappingBytes(toArray());
+ }
+
+ @Override
+ public byte[] toArray() {
+ if (!byteBuffer.hasArray()) {
+ return super.toArray();
+ }
+ int arrayOffset = byteBuffer.arrayOffset();
+ return Arrays.copyOfRange(byteBuffer.array(), arrayOffset + offset, arrayOffset + offset + length);
+ }
+
+ @Override
+ public byte[] toArrayUnsafe() {
+ if (!byteBuffer.hasArray()) {
+ return toArray();
+ }
+ byte[] array = byteBuffer.array();
+ if (array.length != length || byteBuffer.arrayOffset() != 0) {
+ return toArray();
+ }
+ return array;
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/Bytes.java b/bytes/src/main/java/net/consensys/cava/bytes/Bytes.java
new file mode 100644
index 00000000..02d68f31
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/Bytes.java
@@ -0,0 +1,1144 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.lang.String.format;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.security.MessageDigest;
+import java.util.Arrays;
+
+import io.netty.buffer.ByteBuf;
+import io.vertx.core.buffer.Buffer;
+
+/**
+ * A value made of bytes.
+ *
+ *
+ * This interface makes no thread-safety guarantee, and a {@link Bytes} value is generally not thread safe. However,
+ * specific implementations may be thread-safe. For instance, the value returned by {@link #copy} is guaranteed to be
+ * thread-safe as it is immutable.
+ */
+public interface Bytes {
+
+ /**
+ * The empty value (with 0 bytes).
+ */
+ Bytes EMPTY = wrap(new byte[0]);
+
+ /**
+ * Wrap the provided byte array as a {@link Bytes} value.
+ *
+ *
+ * Note that value is not copied and thus any future update to {@code value} will be reflected in the returned value.
+ *
+ * @param value The value to wrap.
+ * @return A {@link Bytes} value wrapping {@code value}.
+ */
+ static Bytes wrap(byte[] value) {
+ return wrap(value, 0, value.length);
+ }
+
+ /**
+ * Wrap a slice of a byte array as a {@link Bytes} value.
+ *
+ *
+ * Note that value is not copied and thus any future update to {@code value} within the slice will be reflected in the
+ * returned value.
+ *
+ * @param value The value to wrap.
+ * @param offset The index (inclusive) in {@code value} of the first byte exposed by the returned value. In other
+ * words, you will have {@code wrap(value, o, l).get(0) == value[o]}.
+ * @param length The length of the resulting value.
+ * @return A {@link Bytes} value that expose the bytes of {@code value} from {@code offset} (inclusive) to
+ * {@code offset + length} (exclusive).
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (value.length > 0 && offset >=
+ * value.length)}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + length > value.length}.
+ */
+ static Bytes wrap(byte[] value, int offset, int length) {
+ checkNotNull(value);
+ if (length == 32) {
+ return new ArrayWrappingBytes32(value, offset);
+ }
+ return new ArrayWrappingBytes(value, offset, length);
+ }
+
+ /**
+ * Wrap a list of other values into a concatenated view.
+ *
+ *
+ * Note that the values are not copied and thus any future update to the values will be reflected in the returned
+ * value. If copying the inputs is desired, use {@link #concatenate(Bytes...)}.
+ *
+ * @param values The values to wrap.
+ * @return A value representing a view over the concatenation of all {@code values}.
+ * @throws IllegalArgumentException if the result overflows an int.
+ */
+ static Bytes wrap(Bytes... values) {
+ return ConcatenatedBytes.wrap(values);
+ }
+
+ /**
+ * Create a value containing the concatenation of the values provided.
+ *
+ * @param values The values to copy and concatenate.
+ * @return A value containing the result of concatenating the value from {@code values} in their provided order.
+ * @throws IllegalArgumentException if the result overflows an int.
+ */
+ static Bytes concatenate(Bytes... values) {
+ if (values.length == 0) {
+ return EMPTY;
+ }
+
+ int size;
+ try {
+ size = Arrays.stream(values).mapToInt(Bytes::size).reduce(0, Math::addExact);
+ } catch (ArithmeticException e) {
+ throw new IllegalArgumentException("Combined length of values is too long (> Integer.MAX_VALUE)");
+ }
+
+ MutableBytes result = MutableBytes.create(size);
+ int offset = 0;
+ for (Bytes value : values) {
+ value.copyTo(result, offset);
+ offset += value.size();
+ }
+ return result;
+ }
+
+ /**
+ * Wrap a full Vert.x {@link Buffer} as a {@link Bytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value.
+ *
+ * @param buffer The buffer to wrap.
+ * @return A {@link Bytes} value.
+ */
+ static Bytes wrapBuffer(Buffer buffer) {
+ checkNotNull(buffer);
+ if (buffer.length() == 0) {
+ return EMPTY;
+ }
+ return new BufferWrappingBytes(buffer);
+ }
+
+ /**
+ * Wrap a slice of a Vert.x {@link Buffer} as a {@link Bytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value.
+ *
+ * @param buffer The buffer to wrap.
+ * @param offset The offset in {@code buffer} from which to expose the bytes in the returned value. That is,
+ * {@code wrapBuffer(buffer, i, 1).get(0) == buffer.getByte(i)}.
+ * @param size The size of the returned value.
+ * @return A {@link Bytes} value.
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (buffer.length() > 0 && offset >=
+ * buffer.length())}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + length > buffer.length()}.
+ */
+ static Bytes wrapBuffer(Buffer buffer, int offset, int size) {
+ checkNotNull(buffer);
+ if (size == 0) {
+ return EMPTY;
+ }
+ return new BufferWrappingBytes(buffer, offset, size);
+ }
+
+ /**
+ * Wrap a full Netty {@link ByteBuf} as a {@link Bytes} value.
+ *
+ *
+ * Note that any change to the content of the byteBuf may be reflected in the returned value.
+ *
+ * @param byteBuf The {@link ByteBuf} to wrap.
+ * @return A {@link Bytes} value.
+ */
+ static Bytes wrapByteBuf(ByteBuf byteBuf) {
+ checkNotNull(byteBuf);
+ if (byteBuf.capacity() == 0) {
+ return EMPTY;
+ }
+ return new ByteBufWrappingBytes(byteBuf);
+ }
+
+ /**
+ * Wrap a slice of a Netty {@link ByteBuf} as a {@link Bytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value.
+ *
+ * @param byteBuf The {@link ByteBuf} to wrap.
+ * @param offset The offset in {@code byteBuf} from which to expose the bytes in the returned value. That is,
+ * {@code wrapByteBuf(byteBuf, i, 1).get(0) == byteBuf.getByte(i)}.
+ * @param size The size of the returned value.
+ * @return A {@link Bytes} value.
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (byteBuf.capacity() > 0 && offset >=
+ * byteBuf.capacity())}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + length > byteBuf.capacity()}.
+ */
+ static Bytes wrapByteBuf(ByteBuf byteBuf, int offset, int size) {
+ checkNotNull(byteBuf);
+ if (size == 0) {
+ return EMPTY;
+ }
+ return new ByteBufWrappingBytes(byteBuf, offset, size);
+ }
+
+ /**
+ * Wrap a full Java NIO {@link ByteBuffer} as a {@link Bytes} value.
+ *
+ *
+ * Note that any change to the content of the byteBuf may be reflected in the returned value.
+ *
+ * @param byteBuffer The {@link ByteBuffer} to wrap.
+ * @return A {@link Bytes} value.
+ */
+ static Bytes wrapByteBuffer(ByteBuffer byteBuffer) {
+ checkNotNull(byteBuffer);
+ if (byteBuffer.limit() == 0) {
+ return EMPTY;
+ }
+ return new ByteBufferWrappingBytes(byteBuffer);
+ }
+
+ /**
+ * Wrap a slice of a Java NIO {@link ByteBuf} as a {@link Bytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value.
+ *
+ * @param byteBuffer The {@link ByteBuffer} to wrap.
+ * @param offset The offset in {@code byteBuffer} from which to expose the bytes in the returned value. That is,
+ * {@code wrapByteBuffer(byteBuffer, i, 1).get(0) == byteBuffer.getByte(i)}.
+ * @param size The size of the returned value.
+ * @return A {@link Bytes} value.
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (byteBuffer.limit() > 0 && offset >=
+ * byteBuf.limit())}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + length > byteBuffer.limit()}.
+ */
+ static Bytes wrapByteBuffer(ByteBuffer byteBuffer, int offset, int size) {
+ checkNotNull(byteBuffer);
+ if (size == 0) {
+ return EMPTY;
+ }
+ return new ByteBufferWrappingBytes(byteBuffer, offset, size);
+ }
+
+ /**
+ * Create a value that contains the specified bytes in their specified order.
+ *
+ * @param bytes The bytes that must compose the returned value.
+ * @return A value containing the specified bytes.
+ */
+ static Bytes of(byte... bytes) {
+ return wrap(bytes);
+ }
+
+ /**
+ * Create a value that contains the specified bytes in their specified order.
+ *
+ * @param bytes The bytes.
+ * @return A value containing bytes are the one from {@code bytes}.
+ * @throws IllegalArgumentException if any of the specified would be truncated when storing as a byte.
+ */
+ static Bytes of(int... bytes) {
+ byte[] result = new byte[bytes.length];
+ for (int i = 0; i < bytes.length; i++) {
+ int b = bytes[i];
+ checkArgument(b == (((byte) b) & 0xff), "%sth value %s does not fit a byte", i + 1, b);
+ result[i] = (byte) b;
+ }
+ return Bytes.wrap(result);
+ }
+
+ /**
+ * Return a 2 bytes value corresponding to the provided value interpreted as an unsigned short value.
+ *
+ * @param value The value, which must fit an unsigned short.
+ * @return A 2 bytes value corresponding to {@code v}.
+ * @throws IllegalArgumentException if {@code v < 0} or {@code v} is too big to fit an unsigned 2-bytes short (that
+ * is, if {@code v >= (1 << 16)}).
+ */
+ static Bytes ofUnsignedShort(int value) {
+ checkArgument(
+ value >= 0 && value <= BytesValues.MAX_UNSIGNED_SHORT,
+ "Value %s cannot be represented as an unsigned short (it is negative or too big)",
+ value);
+ byte[] res = new byte[2];
+ res[0] = (byte) ((value >> 8) & 0xFF);
+ res[1] = (byte) (value & 0xFF);
+ return Bytes.wrap(res);
+ }
+
+ /**
+ * Return a 4 bytes value corresponding to the provided value interpreted as an unsigned int value.
+ *
+ * @param value The value, which must fit an unsigned int.
+ * @return A 4 bytes value corresponding to {@code v}.
+ * @throws IllegalArgumentException if {@code v < 0} or {@code v} is too big to fit an unsigned 4-bytes int (that is,
+ * if {@code v >= (1L << 32)}).
+ */
+ static Bytes ofUnsignedInt(long value) {
+ checkArgument(
+ value >= 0 && value <= BytesValues.MAX_UNSIGNED_INT,
+ "Value %s cannot be represented as an unsigned int (it is negative or too big)",
+ value);
+ byte[] res = new byte[4];
+ res[0] = (byte) ((value >> 24) & 0xFF);
+ res[1] = (byte) ((value >> 16) & 0xFF);
+ res[2] = (byte) ((value >> 8) & 0xFF);
+ res[3] = (byte) ((value) & 0xFF);
+ return Bytes.wrap(res);
+ }
+
+ /**
+ * Return the smallest bytes value whose bytes correspond to the provided long. That is, the returned value may be of
+ * size less than 8 if the provided long has leading zero bytes.
+ *
+ * @param value The long from which to create the bytes value.
+ * @return The minimal bytes representation corresponding to {@code l}.
+ */
+ static Bytes minimalBytes(long value) {
+ if (value == 0) {
+ return Bytes.EMPTY;
+ }
+
+ int zeros = Long.numberOfLeadingZeros(value);
+ int resultBytes = 8 - (zeros / 8);
+
+ byte[] result = new byte[resultBytes];
+ int shift = 0;
+ for (int i = 0; i < resultBytes; i++) {
+ result[resultBytes - i - 1] = (byte) ((value >> shift) & 0xFF);
+ shift += 8;
+ }
+ return Bytes.wrap(result);
+ }
+
+ /**
+ * Parse a hexadecimal string into a {@link Bytes} value.
+ *
+ *
+ * This method is lenient in that {@code str} may of an odd length, in which case it will behave exactly as if it had
+ * an additional 0 in front.
+ *
+ * @param str The hexadecimal string to parse, which may or may not start with "0x".
+ * @return The value corresponding to {@code str}.
+ * @throws IllegalArgumentException if {@code str} does not correspond to valid hexadecimal representation.
+ */
+ static Bytes fromHexStringLenient(String str) {
+ checkNotNull(str);
+ return BytesValues.fromHexString(str, -1, true);
+ }
+
+ /**
+ * Parse a hexadecimal string into a {@link Bytes} value of the provided size.
+ *
+ *
+ * This method allows for {@code str} to have an odd length, in which case it will behave exactly as if it had an
+ * additional 0 in front.
+ *
+ * @param str The hexadecimal string to parse, which may or may not start with "0x".
+ * @param destinationSize The size of the returned value, which must be big enough to hold the bytes represented by
+ * {@code str}. If it is strictly bigger those bytes from {@code str}, the returned value will be left padded
+ * with zeros.
+ * @return A value of size {@code destinationSize} corresponding to {@code str} potentially left-padded.
+ * @throws IllegalArgumentException if {@code str} does not correspond to valid hexadecimal representation, represents
+ * more bytes than {@code destinationSize} or {@code destinationSize < 0}.
+ */
+ static Bytes fromHexStringLenient(String str, int destinationSize) {
+ checkNotNull(str);
+ checkArgument(destinationSize >= 0, "Invalid negative destination size %s", destinationSize);
+ return BytesValues.fromHexString(str, destinationSize, true);
+ }
+
+ /**
+ * Parse a hexadecimal string into a {@link Bytes} value.
+ *
+ *
+ * This method requires that {@code str} have an even length.
+ *
+ * @param str The hexadecimal string to parse, which may or may not start with "0x".
+ * @return The value corresponding to {@code str}.
+ * @throws IllegalArgumentException if {@code str} does not correspond to valid hexadecimal representation, or is of
+ * an odd length.
+ */
+ static Bytes fromHexString(String str) {
+ checkNotNull(str);
+ return BytesValues.fromHexString(str, -1, false);
+ }
+
+ /**
+ * Parse a hexadecimal string into a {@link Bytes} value.
+ *
+ *
+ * This method requires that {@code str} have an even length.
+ *
+ * @param str The hexadecimal string to parse, which may or may not start with "0x".
+ * @param destinationSize The size of the returned value, which must be big enough to hold the bytes represented by
+ * {@code str}. If it is strictly bigger those bytes from {@code str}, the returned value will be left padded
+ * with zeros.
+ * @return A value of size {@code destinationSize} corresponding to {@code str} potentially left-padded.
+ * @throws IllegalArgumentException if {@code str} does correspond to valid hexadecimal representation, or is of an
+ * odd length.
+ * @throws IllegalArgumentException if {@code str} does not correspond to valid hexadecimal representation, or is of
+ * an odd length, or represents more bytes than {@code destinationSize} or {@code destinationSize < 0}.
+ */
+ static Bytes fromHexString(String str, int destinationSize) {
+ checkNotNull(str);
+ checkArgument(destinationSize >= 0, "Invalid negative destination size %s", destinationSize);
+ return BytesValues.fromHexString(str, destinationSize, false);
+ }
+
+ /** @return The number of bytes this value represents. */
+ int size();
+
+ /**
+ * Retrieve a byte in this value.
+ *
+ * @param i The index of the byte to fetch within the value (0-indexed).
+ * @return The byte at index {@code i} in this value.
+ * @throws IndexOutOfBoundsException if {@code i < 0} or {i >= size()}.
+ */
+ byte get(int i);
+
+ /**
+ * Retrieve the 4 bytes starting at the provided index in this value as an integer.
+ *
+ * @param i The index from which to get the int, which must less than or equal to {@code size() -
+ * 4}.
+ * @return An integer whose value is the 4 bytes from this value starting at index {@code i}.
+ * @throws IndexOutOfBoundsException if {@code i < 0} or {@code i > size() - 4}.
+ */
+ default int getInt(int i) {
+ int size = size();
+ checkElementIndex(i, size);
+ if (i > (size - 4)) {
+ throw new IndexOutOfBoundsException(
+ format("Value of size %s has not enough bytes to read a 4 bytes int from index %s", size, i));
+ }
+
+ int value = 0;
+ value |= ((int) get(i) & 0xFF) << 24;
+ value |= ((int) get(i + 1) & 0xFF) << 16;
+ value |= ((int) get(i + 2) & 0xFF) << 8;
+ value |= ((int) get(i + 3) & 0xFF);
+ return value;
+ }
+
+ /**
+ * The value corresponding to interpreting these bytes as an integer.
+ *
+ * @return An value corresponding to this value interpreted as an integer.
+ * @throws IllegalArgumentException if {@code size() > 4}.
+ */
+ default int intValue() {
+ int i = size();
+ checkArgument(i <= 4, "Value of size %s has more than 4 bytes", size());
+ if (i == 0) {
+ return 0;
+ }
+ int value = ((int) get(--i) & 0xFF);
+ if (i == 0) {
+ return value;
+ }
+ value |= ((int) get(--i) & 0xFF) << 8;
+ if (i == 0) {
+ return value;
+ }
+ value |= ((int) get(--i) & 0xFF) << 16;
+ if (i == 0) {
+ return value;
+ }
+ return value | ((int) get(--i) & 0xFF) << 24;
+ }
+
+ /**
+ * Whether this value contains no bytes.
+ *
+ * @return true if the value contains no bytes
+ */
+ default boolean isEmpty() {
+ return size() == 0;
+ }
+
+ /**
+ * Retrieves the 8 bytes starting at the provided index in this value as a long.
+ *
+ * @param i The index from which to get the long, which must less than or equal to {@code size() -
+ * 8}.
+ * @return A long whose value is the 8 bytes from this value starting at index {@code i}.
+ * @throws IndexOutOfBoundsException if {@code i < 0} or {@code i > size() - 8}.
+ */
+ default long getLong(int i) {
+ int size = size();
+ checkElementIndex(i, size);
+ if (i > (size - 8)) {
+ throw new IndexOutOfBoundsException(
+ format("Value of size %s has not enough bytes to read a 8 bytes long from index %s", size, i));
+ }
+
+ long value = 0;
+ value |= ((long) get(i) & 0xFF) << 56;
+ value |= ((long) get(i + 1) & 0xFF) << 48;
+ value |= ((long) get(i + 2) & 0xFF) << 40;
+ value |= ((long) get(i + 3) & 0xFF) << 32;
+ value |= ((long) get(i + 4) & 0xFF) << 24;
+ value |= ((long) get(i + 5) & 0xFF) << 16;
+ value |= ((long) get(i + 6) & 0xFF) << 8;
+ value |= ((long) get(i + 7) & 0xFF);
+ return value;
+ }
+
+ /**
+ * The value corresponding to interpreting these bytes as a long.
+ *
+ * @return An value corresponding to this value interpreted as a long.
+ * @throws IllegalArgumentException if {@code size() > 8}.
+ */
+ default long longValue() {
+ int i = size();
+ checkArgument(i <= 8, "Value of size %s has more than 8 bytes", size());
+ if (i == 0) {
+ return 0;
+ }
+ long value = ((long) get(--i) & 0xFF);
+ if (i == 0) {
+ return value;
+ }
+ value |= ((long) get(--i) & 0xFF) << 8;
+ if (i == 0) {
+ return value;
+ }
+ value |= ((long) get(--i) & 0xFF) << 16;
+ if (i == 0) {
+ return value;
+ }
+ value |= ((long) get(--i) & 0xFF) << 24;
+ if (i == 0) {
+ return value;
+ }
+ value |= ((long) get(--i) & 0xFF) << 32;
+ if (i == 0) {
+ return value;
+ }
+ value |= ((long) get(--i) & 0xFF) << 40;
+ if (i == 0) {
+ return value;
+ }
+ value |= ((long) get(--i) & 0xFF) << 48;
+ if (i == 0) {
+ return value;
+ }
+ return value | ((long) get(--i) & 0xFF) << 56;
+ }
+
+ /**
+ * The BigInteger corresponding to interpreting these bytes as a two's-complement signed integer.
+ *
+ * @return A {@link BigInteger} corresponding to interpreting these bytes as a two's-complement signed integer.
+ */
+ default BigInteger bigIntegerValue() {
+ if (size() == 0) {
+ return BigInteger.ZERO;
+ }
+ return new BigInteger(toArrayUnsafe());
+ }
+
+ /**
+ * The BigInteger corresponding to interpreting these bytes as an unsigned integer.
+ *
+ * @return A positive (or zero) {@link BigInteger} corresponding to interpreting these bytes as an unsigned integer.
+ */
+ default BigInteger unsignedBigIntegerValue() {
+ return new BigInteger(1, toArrayUnsafe());
+ }
+
+ /**
+ * Whether this value has only zero bytes.
+ *
+ * @return true if all the bits of this value are zeros.
+ */
+ default boolean isZero() {
+ for (int i = size() - 1; i >= 0; --i) {
+ if (get(i) != 0)
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Whether the bytes start with a zero bit value.
+ *
+ * @return true if the first bit equals zero
+ */
+ default boolean hasLeadingZero() {
+ return size() > 0 && (get(0) & 0x80) == 0;
+ }
+
+ /**
+ * @return The number of zero bits preceding the highest-order ("leftmost") one-bit, or {@code size() * 8} if all bits
+ * are zero.
+ */
+ default int numberOfLeadingZeros() {
+ int size = size();
+ for (int i = 0; i < size; i++) {
+ byte b = get(i);
+ if (b == 0) {
+ continue;
+ }
+
+ return (i * 8) + Integer.numberOfLeadingZeros(b & 0xFF) - 3 * 8;
+ }
+ return size * 8;
+ }
+
+ /**
+ * Whether the bytes start with a zero byte value.
+ *
+ * @return true if the first byte equals zero
+ */
+ default boolean hasLeadingZeroByte() {
+ return size() > 0 && get(0) == 0;
+ }
+
+ /**
+ * @return The number of leading zero bytes of the value.
+ */
+ default int numberOfLeadingZeroBytes() {
+ int size = size();
+ for (int i = 0; i < size; i++) {
+ if (get(i) != 0) {
+ return i - 1;
+ }
+ }
+ return size;
+ }
+
+ /**
+ * @return The number of bits following and including the highest-order ("leftmost") one-bit, or zero if all bits are
+ * zero.
+ */
+ default int bitLength() {
+ int size = size();
+ for (int i = 0; i < size; i++) {
+ byte b = get(i);
+ if (b == 0)
+ continue;
+
+ return (size * 8) - (i * 8) - (Integer.numberOfLeadingZeros(b & 0xFF) - 3 * 8);
+ }
+ return 0;
+ }
+
+ /**
+ * Return a bit-wise AND of these bytes and the supplied bytes.
+ *
+ * If this value and the supplied value are different lengths, then the shorter will be zero-padded to the left.
+ *
+ * @param other The bytes to perform the operation with.
+ * @return The result of a bit-wise AND.
+ */
+ default Bytes and(Bytes other) {
+ return and(other, MutableBytes.create(Math.max(size(), other.size())));
+ }
+
+ /**
+ * Calculate a bit-wise AND of these bytes and the supplied bytes.
+ *
+ *
+ * If this value or the supplied value are shorter in length than the output vector, then they will be zero-padded to
+ * the left. Likewise, if either this value or the supplied valid is longer in length than the output vector, then
+ * they will be truncated to the left.
+ *
+ * @param other The bytes to perform the operation with.
+ * @param result The mutable output vector for the result.
+ * @param The {@link MutableBytes} value type.
+ * @return The {@code result} output vector.
+ */
+ default T and(Bytes other, T result) {
+ checkNotNull(other);
+ checkNotNull(result);
+ int rSize = result.size();
+ int offsetSelf = rSize - size();
+ int offsetOther = rSize - other.size();
+ for (int i = 0; i < rSize; i++) {
+ byte b1 = (i < offsetSelf) ? 0x00 : get(i - offsetSelf);
+ byte b2 = (i < offsetOther) ? 0x00 : other.get(i - offsetOther);
+ result.set(i, (byte) (b1 & b2));
+ }
+ return result;
+ }
+
+ /**
+ * Return a bit-wise OR of these bytes and the supplied bytes.
+ *
+ *
+ * If this value and the supplied value are different lengths, then the shorter will be zero-padded to the left.
+ *
+ * @param other The bytes to perform the operation with.
+ * @return The result of a bit-wise OR.
+ */
+ default Bytes or(Bytes other) {
+ return or(other, MutableBytes.create(Math.max(size(), other.size())));
+ }
+
+ /**
+ * Calculate a bit-wise OR of these bytes and the supplied bytes.
+ *
+ *
+ * If this value or the supplied value are shorter in length than the output vector, then they will be zero-padded to
+ * the left. Likewise, if either this value or the supplied valid is longer in length than the output vector, then
+ * they will be truncated to the left.
+ *
+ * @param other The bytes to perform the operation with.
+ * @param result The mutable output vector for the result.
+ * @param The {@link MutableBytes} value type.
+ * @return The {@code result} output vector.
+ */
+ default T or(Bytes other, T result) {
+ checkNotNull(other);
+ checkNotNull(result);
+ int rSize = result.size();
+ int offsetSelf = rSize - size();
+ int offsetOther = rSize - other.size();
+ for (int i = 0; i < rSize; i++) {
+ byte b1 = (i < offsetSelf) ? 0x00 : get(i - offsetSelf);
+ byte b2 = (i < offsetOther) ? 0x00 : other.get(i - offsetOther);
+ result.set(i, (byte) (b1 | b2));
+ }
+ return result;
+ }
+
+ /**
+ * Return a bit-wise XOR of these bytes and the supplied bytes.
+ *
+ *
+ * If this value and the supplied value are different lengths, then the shorter will be zero-padded to the left.
+ *
+ * @param other The bytes to perform the operation with.
+ * @return The result of a bit-wise XOR.
+ */
+ default Bytes xor(Bytes other) {
+ return or(other, MutableBytes.create(Math.max(size(), other.size())));
+ }
+
+ /**
+ * Calculate a bit-wise XOR of these bytes and the supplied bytes.
+ *
+ *
+ * If this value or the supplied value are shorter in length than the output vector, then they will be zero-padded to
+ * the left. Likewise, if either this value or the supplied valid is longer in length than the output vector, then
+ * they will be truncated to the left.
+ *
+ * @param other The bytes to perform the operation with.
+ * @param result The mutable output vector for the result.
+ * @param The {@link MutableBytes} value type.
+ * @return The {@code result} output vector.
+ */
+ default T xor(Bytes other, T result) {
+ checkNotNull(other);
+ checkNotNull(result);
+ int rSize = result.size();
+ int offsetSelf = rSize - size();
+ int offsetOther = rSize - other.size();
+ for (int i = 0; i < rSize; i++) {
+ byte b1 = (i < offsetSelf) ? 0x00 : get(i - offsetSelf);
+ byte b2 = (i < offsetOther) ? 0x00 : other.get(i - offsetOther);
+ result.set(i, (byte) (b1 ^ b2));
+ }
+ return result;
+ }
+
+ /**
+ * Return a bit-wise NOT of these bytes.
+ *
+ * @return The result of a bit-wise NOT.
+ */
+ default Bytes not() {
+ return not(MutableBytes.create(size()));
+ }
+
+ /**
+ * Calculate a bit-wise NOT of these bytes.
+ *
+ *
+ * If this value is shorter in length than the output vector, then it will be zero-padded to the left. Likewise, if
+ * this value is longer in length than the output vector, then it will be truncated to the left.
+ *
+ * @param result The mutable output vector for the result.
+ * @param The {@link MutableBytes} value type.
+ * @return The {@code result} output vector.
+ */
+ default T not(T result) {
+ checkNotNull(result);
+ int rSize = result.size();
+ int offsetSelf = rSize - size();
+ for (int i = 0; i < rSize; i++) {
+ byte b1 = (i < offsetSelf) ? 0x00 : get(i - offsetSelf);
+ result.set(i, (byte) ~b1);
+ }
+ return result;
+ }
+
+ /**
+ * Shift all bits in this value to the right.
+ *
+ * @param distance The number of bits to shift by.
+ * @return A value containing the shifted bits.
+ */
+ default Bytes shiftRight(int distance) {
+ return shiftRight(distance, MutableBytes.create(size()));
+ }
+
+ /**
+ * Shift all bits in this value to the right.
+ *
+ *
+ * If this value is shorter in length than the output vector, then it will be zero-padded to the left. Likewise, if
+ * this value is longer in length than the output vector, then it will be truncated to the left (after shifting).
+ *
+ * @param distance The number of bits to shift by.
+ * @param result The mutable output vector for the result.
+ * @param The {@link MutableBytes} value type.
+ * @return The {@code result} output vector.
+ */
+ default T shiftRight(int distance, T result) {
+ checkNotNull(result);
+ int rSize = result.size();
+ int offsetSelf = rSize - size();
+
+ int d = distance / 8;
+ int s = distance % 8;
+ int resIdx = rSize - 1;
+ for (int i = rSize - 1 - d; i >= 0; i--) {
+ byte res;
+ if (i < offsetSelf) {
+ res = 0;
+ } else {
+ int selfIdx = i - offsetSelf;
+ int leftSide = (get(selfIdx) & 0xFF) >>> s;
+ int rightSide = (selfIdx == 0) ? 0 : get(selfIdx - 1) << (8 - s);
+ res = (byte) (leftSide | rightSide);
+ }
+ result.set(resIdx--, res);
+ }
+ for (; resIdx >= 0; resIdx--) {
+ result.set(resIdx, (byte) 0);
+ }
+ return result;
+ }
+
+ /**
+ * Shift all bits in this value to the left.
+ *
+ * @param distance The number of bits to shift by.
+ * @return A value containing the shifted bits.
+ */
+ default Bytes shiftLeft(int distance) {
+ return shiftLeft(distance, MutableBytes.create(size()));
+ }
+
+ /**
+ * Shift all bits in this value to the left.
+ *
+ *
+ * If this value is shorter in length than the output vector, then it will be zero-padded to the left. Likewise, if
+ * this value is longer in length than the output vector, then it will be truncated to the left.
+ *
+ * @param distance The number of bits to shift by.
+ * @param result The mutable output vector for the result.
+ * @param The {@link MutableBytes} value type.
+ * @return The {@code result} output vector.
+ */
+ default T shiftLeft(int distance, T result) {
+ checkNotNull(result);
+ int size = size();
+ int rSize = result.size();
+ int offsetSelf = rSize - size;
+
+ int d = distance / 8;
+ int s = distance % 8;
+ int resIdx = 0;
+ for (int i = d; i < rSize; i++) {
+ byte res;
+ if (i < offsetSelf) {
+ res = 0;
+ } else {
+ int selfIdx = i - offsetSelf;
+ int leftSide = get(selfIdx) << s;
+ int rightSide = (selfIdx == size - 1) ? 0 : (get(selfIdx + 1) & 0xFF) >>> (8 - s);
+ res = (byte) (leftSide | rightSide);
+ }
+ result.set(resIdx++, res);
+ }
+ for (; resIdx < rSize; resIdx++) {
+ result.set(resIdx, (byte) 0);
+ }
+ return result;
+ }
+
+ /**
+ * Create a new value representing (a view of) a slice of the bytes of this value.
+ *
+ *
+ * Please note that the resulting slice is only a view and as such maintains a link to the underlying full value. So
+ * holding a reference to the returned slice may hold more memory than the slide represents. Use {@link #copy} on the
+ * returned slice if that is not what you want.
+ *
+ * @param i The start index for the slice.
+ * @return A new value providing a view over the bytes from index {@code i} (included) to the end.
+ * @throws IndexOutOfBoundsException if {@code i < 0}.
+ */
+ default Bytes slice(int i) {
+ int size = size();
+ if (i >= size) {
+ return EMPTY;
+ }
+ return slice(i, size - i);
+ }
+
+ /**
+ * Create a new value representing (a view of) a slice of the bytes of this value.
+ *
+ *
+ * Please note that the resulting slice is only a view and as such maintains a link to the underlying full value. So
+ * holding a reference to the returned slice may hold more memory than the slide represents. Use {@link #copy} on the
+ * returned slice if that is not what you want.
+ *
+ * @param i The start index for the slice.
+ * @param length The length of the resulting value.
+ * @return A new value providing a view over the bytes from index {@code i} (included) to {@code i + length}
+ * (excluded).
+ * @throws IllegalArgumentException if {@code length < 0}.
+ * @throws IndexOutOfBoundsException if {@code i < 0} or {i >= size()} or {i + length > size()} .
+ */
+ Bytes slice(int i, int length);
+
+ /**
+ * Return a value equivalent to this one but guaranteed to 1) be deeply immutable (i.e. the underlying value will be
+ * immutable) and 2) to not retain more bytes than exposed by the value.
+ *
+ * @return A value, equals to this one, but deeply immutable and that doesn't retain any "unreachable" bytes. For
+ * performance reasons, this is allowed to return this value however if it already fit those constraints.
+ */
+ Bytes copy();
+
+ /**
+ * Return a new mutable value initialized with the content of this value.
+ *
+ * @return A mutable copy of this value. This will copy bytes, modifying the returned value will not modify
+ * this value.
+ */
+ MutableBytes mutableCopy();
+
+ /**
+ * Copy the bytes of this value to the provided mutable one, which must have the same size.
+ *
+ * @param destination The mutable value to which to copy the bytes to, which must have the same size as this value. If
+ * you want to copy value where size differs, you should use {@link #slice} and/or
+ * {@link MutableBytes#mutableSlice} and apply the copy to the result.
+ * @throws IllegalArgumentException if {@code this.size() != destination.size()}.
+ */
+ default void copyTo(MutableBytes destination) {
+ checkNotNull(destination);
+ checkArgument(
+ destination.size() == size(),
+ "Cannot copy %s bytes to destination of non-equal size %s",
+ size(),
+ destination.size());
+ copyTo(destination, 0);
+ }
+
+ /**
+ * Copy the bytes of this value to the provided mutable one from a particular offset.
+ *
+ *
+ * This is a (potentially slightly more efficient) shortcut for {@code
+ * copyTo(destination.mutableSlice(destinationOffset, this.size()))}.
+ *
+ * @param destination The mutable value to which to copy the bytes to, which must have enough bytes from
+ * {@code destinationOffset} for the copied value.
+ * @param destinationOffset The offset in {@code destination} at which the copy starts.
+ * @throws IllegalArgumentException if the destination doesn't have enough room, that is if {@code
+ * this.size() > (destination.size() - destinationOffset)}.
+ */
+ default void copyTo(MutableBytes destination, int destinationOffset) {
+ checkNotNull(destination);
+
+ // Special casing an empty source or the following checks might throw (even though we have
+ // nothing to copy anyway) and this gets inconvenient for generic methods using copyTo() as
+ // they may have to special case empty values because of this. As an example,
+ // concatenate(EMPTY, EMPTY) would need to be special cased without this.
+ int size = size();
+ if (size == 0) {
+ return;
+ }
+
+ checkElementIndex(destinationOffset, destination.size());
+ checkArgument(
+ destination.size() - destinationOffset >= size,
+ "Cannot copy %s bytes, destination has only %s bytes from index %s",
+ size,
+ destination.size() - destinationOffset,
+ destinationOffset);
+
+ for (int i = 0; i < size; i++) {
+ destination.set(destinationOffset + i, get(i));
+ }
+ }
+
+ /**
+ * Append the bytes of this value to the provided Vert.x {@link Buffer}.
+ *
+ *
+ * Note that since a Vert.x {@link Buffer} will grow as necessary, this method never fails.
+ *
+ * @param buffer The {@link Buffer} to which to append this value.
+ */
+ default void appendTo(Buffer buffer) {
+ checkNotNull(buffer);
+ for (int i = 0; i < size(); i++) {
+ buffer.appendByte(get(i));
+ }
+ }
+
+ /**
+ * Return the number of bytes in common between this set of bytes and another.
+ *
+ * @param other The bytes to compare to.
+ * @return The number of common bytes.
+ */
+ default int commonPrefixLength(Bytes other) {
+ checkNotNull(other);
+ int ourSize = size();
+ int otherSize = other.size();
+ int i = 0;
+ while (i < ourSize && i < otherSize && get(i) == other.get(i)) {
+ i++;
+ }
+ return i;
+ }
+
+ /**
+ * Return a slice over the common prefix between this set of bytes and another.
+ *
+ * @param other The bytes to compare to.
+ * @return A slice covering the common prefix.
+ */
+ default Bytes commonPrefix(Bytes other) {
+ return slice(0, commonPrefixLength(other));
+ }
+
+ /**
+ * Return a slice of representing the same value but without any leading zero bytes.
+ *
+ * @return {@code value} if its left-most byte is non zero, or a slice that exclude any leading zero bytes.
+ */
+ default Bytes trimLeadingZeros() {
+ int size = size();
+ for (int i = 0; i < size; i++) {
+ if (get(i) != 0) {
+ return slice(i);
+ }
+ }
+ return Bytes.EMPTY;
+ }
+
+ /**
+ * Update the provided message digest with the bytes of this value.
+ *
+ * @param digest The digest to update.
+ */
+ default void update(MessageDigest digest) {
+ checkNotNull(digest);
+ for (int i = 0; i < size(); i++) {
+ digest.update(get(i));
+ }
+ }
+
+ /**
+ * Extract the bytes of this value into a byte array.
+ *
+ * @return A byte array with the same content than this value.
+ */
+ default byte[] toArray() {
+ int size = size();
+ byte[] array = new byte[size];
+ for (int i = 0; i < size; i++) {
+ array[i] = get(i);
+ }
+ return array;
+ }
+
+ /**
+ * Get the bytes represented by this value as byte array.
+ *
+ *
+ * Contrarily to {@link #toArray()}, this may avoid allocating a new array and directly return the backing array of
+ * this value if said value is array backed and doing so is possible. As such, modifications to the returned array may
+ * or may not impact this value. As such, this method should be used with care and hence the "unsafe" moniker.
+ *
+ * @return A byte array with the same content than this value, which may or may not be the direct backing of this
+ * value.
+ */
+ default byte[] toArrayUnsafe() {
+ return toArray();
+ }
+
+ /**
+ * Return the hexadecimal string representation of this value.
+ *
+ * @return The hexadecimal representation of this value, starting with "0x".
+ */
+ @Override
+ String toString();
+
+ /**
+ * @return This value represented as hexadecimal, starting with "0x".
+ */
+ default String toHexString() {
+ int size = size();
+ StringBuilder r = new StringBuilder(2 + size * 2);
+ r.append("0x");
+
+ for (int i = 0; i < size; i++) {
+ byte b = get(i);
+ r.append(AbstractBytes.HEX_CODE[b >> 4 & 15]);
+ r.append(AbstractBytes.HEX_CODE[b & 15]);
+ }
+
+ return r.toString();
+ }
+
+ /** @return This value represented as a minimal hexadecimal string (without any leading zero). */
+ default String toShortHexString() {
+ String hex = toString();
+ // Skipping '0x'
+ if (hex.charAt(2) != '0')
+ return hex;
+
+ int i = 3;
+ while (i < hex.length() && hex.charAt(i) == '0') {
+ i++;
+ }
+ return "0x" + hex.substring(i);
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/Bytes32.java b/bytes/src/main/java/net/consensys/cava/bytes/Bytes32.java
new file mode 100644
index 00000000..31d1f4f6
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/Bytes32.java
@@ -0,0 +1,240 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * A {@link Bytes} value that is guaranteed to contain exactly 32 bytes.
+ */
+public interface Bytes32 extends Bytes {
+ /** The number of bytes in this value - i.e. 32 */
+ int SIZE = 32;
+
+ /** A {@code Bytes32} containing all zero bytes */
+ Bytes32 ZERO = wrap(new byte[32]);
+
+ /**
+ * Wrap the provided byte array, which must be of length 32, as a {@link Bytes32}.
+ *
+ *
+ * Note that value is not copied, only wrapped, and thus any future update to {@code value} will be reflected in the
+ * returned value.
+ *
+ * @param bytes The bytes to wrap.
+ * @return A {@link Bytes32} wrapping {@code value}.
+ * @throws IllegalArgumentException if {@code value.length != 32}.
+ */
+ static Bytes32 wrap(byte[] bytes) {
+ checkNotNull(bytes);
+ checkArgument(bytes.length == SIZE, "Expected %s bytes but got %s", SIZE, bytes.length);
+ return wrap(bytes, 0);
+ }
+
+ /**
+ * Wrap a slice/sub-part of the provided array as a {@link Bytes32}.
+ *
+ *
+ * Note that value is not copied, only wrapped, and thus any future update to {@code value} within the wrapped parts
+ * will be reflected in the returned value.
+ *
+ * @param bytes The bytes to wrap.
+ * @param offset The index (inclusive) in {@code value} of the first byte exposed by the returned value. In other
+ * words, you will have {@code wrap(value, i).get(0) == value[i]}.
+ * @return A {@link Bytes32} that exposes the bytes of {@code value} from {@code offset} (inclusive) to
+ * {@code offset + 32} (exclusive).
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (value.length > 0 && offset >=
+ * value.length)}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + 32 > value.length}.
+ */
+ static Bytes32 wrap(byte[] bytes, int offset) {
+ checkNotNull(bytes);
+ return new ArrayWrappingBytes32(bytes, offset);
+ }
+
+ /**
+ * Wrap a the provided value, which must be of size 32, as a {@link Bytes32}.
+ *
+ *
+ * Note that value is not copied, only wrapped, and thus any future update to {@code value} will be reflected in the
+ * returned value.
+ *
+ * @param value The bytes to wrap.
+ * @return A {@link Bytes32} that exposes the bytes of {@code value}.
+ * @throws IllegalArgumentException if {@code value.size() != 32}.
+ */
+ static Bytes32 wrap(Bytes value) {
+ checkNotNull(value);
+ if (value instanceof Bytes32) {
+ return (Bytes32) value;
+ }
+ return DelegatingBytes32.delegateTo(value);
+ }
+
+ /**
+ * Wrap a slice/sub-part of the provided value as a {@link Bytes32}.
+ *
+ *
+ * Note that value is not copied, only wrapped, and thus any future update to {@code value} within the wrapped parts
+ * will be reflected in the returned value.
+ *
+ * @param value The bytes to wrap.
+ * @param offset The index (inclusive) in {@code value} of the first byte exposed by the returned value. In other
+ * words, you will have {@code wrap(value, i).get(0) == value.get(i)}.
+ * @return A {@link Bytes32} that exposes the bytes of {@code value} from {@code offset} (inclusive) to
+ * {@code offset + 32} (exclusive).
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (value.size() > 0 && offset >=
+ * value.size())}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + 32 > value.size()}.
+ */
+ static Bytes32 wrap(Bytes value, int offset) {
+ checkNotNull(value);
+ if (value instanceof Bytes32) {
+ return (Bytes32) value;
+ }
+ Bytes slice = value.slice(offset, Bytes32.SIZE);
+ if (slice instanceof Bytes32) {
+ return (Bytes32) slice;
+ }
+ return DelegatingBytes32.delegateTo(slice);
+ }
+
+ /**
+ * Left pad a {@link Bytes} value with zero bytes to create a {@link Bytes32}.
+ *
+ * @param value The bytes value pad.
+ * @return A {@link Bytes32} that exposes the left-padded bytes of {@code value}.
+ * @throws IllegalArgumentException if {@code value.size() > 32}.
+ */
+ static Bytes32 leftPad(Bytes value) {
+ checkNotNull(value);
+ if (value instanceof Bytes32) {
+ return (Bytes32) value;
+ }
+ checkArgument(value.size() <= SIZE, "Expected at most %s bytes but got %s", SIZE, value.size());
+ MutableBytes32 result = MutableBytes32.create();
+ value.copyTo(result, SIZE - value.size());
+ return result;
+ }
+
+ /**
+ * Parse a hexadecimal string into a {@link Bytes32}.
+ *
+ *
+ * This method is lenient in that {@code str} may of an odd length, in which case it will behave exactly as if it had
+ * an additional 0 in front.
+ *
+ * @param str The hexadecimal string to parse, which may or may not start with "0x". That representation may contain
+ * less than 32 bytes, in which case the result is left padded with zeros (see {@link #fromHexStringStrict} if
+ * this is not what you want).
+ * @return The value corresponding to {@code str}.
+ * @throws IllegalArgumentException if {@code str} does not correspond to valid hexadecimal representation or contains
+ * more than 32 bytes.
+ */
+ static Bytes32 fromHexStringLenient(String str) {
+ checkNotNull(str);
+ return wrap(BytesValues.fromRawHexString(str, SIZE, true));
+ }
+
+ /**
+ * Parse a hexadecimal string into a {@link Bytes32}.
+ *
+ *
+ * This method is strict in that {@code str} must of an even length.
+ *
+ * @param str The hexadecimal string to parse, which may or may not start with "0x". That representation may contain
+ * less than 32 bytes, in which case the result is left padded with zeros (see {@link #fromHexStringStrict} if
+ * this is not what you want).
+ * @return The value corresponding to {@code str}.
+ * @throws IllegalArgumentException if {@code str} does not correspond to valid hexadecimal representation, is of an
+ * odd length, or contains more than 32 bytes.
+ */
+ static Bytes32 fromHexString(String str) {
+ checkNotNull(str);
+ return wrap(BytesValues.fromRawHexString(str, SIZE, false));
+ }
+
+ /**
+ * Parse a hexadecimal string into a {@link Bytes32}.
+ *
+ *
+ * This method is extra strict in that {@code str} must of an even length and the provided representation must have
+ * exactly 32 bytes.
+ *
+ * @param str The hexadecimal string to parse, which may or may not start with "0x".
+ * @return The value corresponding to {@code str}.
+ * @throws IllegalArgumentException if {@code str} does not correspond to valid hexadecimal representation, is of an
+ * odd length or does not contain exactly 32 bytes.
+ */
+ static Bytes32 fromHexStringStrict(String str) {
+ checkNotNull(str);
+ return wrap(BytesValues.fromRawHexString(str, -1, false));
+ }
+
+ @Override
+ default int size() {
+ return SIZE;
+ }
+
+ /**
+ * Return a bit-wise AND of these bytes and the supplied bytes.
+ *
+ * @param other The bytes to perform the operation with.
+ * @return The result of a bit-wise AND.
+ */
+ default Bytes32 and(Bytes32 other) {
+ return and(other, MutableBytes32.create());
+ }
+
+ /**
+ * Return a bit-wise OR of these bytes and the supplied bytes.
+ *
+ * @param other The bytes to perform the operation with.
+ * @return The result of a bit-wise OR.
+ */
+ default Bytes32 or(Bytes32 other) {
+ return or(other, MutableBytes32.create());
+ }
+
+ /**
+ * Return a bit-wise XOR of these bytes and the supplied bytes.
+ *
+ * @param other The bytes to perform the operation with.
+ * @return The result of a bit-wise XOR.
+ */
+ default Bytes32 xor(Bytes32 other) {
+ return xor(other, MutableBytes32.create());
+ }
+
+ @Override
+ default Bytes32 not() {
+ return not(MutableBytes32.create());
+ }
+
+ @Override
+ default Bytes32 shiftRight(int distance) {
+ return shiftRight(distance, MutableBytes32.create());
+ }
+
+ @Override
+ default Bytes32 shiftLeft(int distance) {
+ return shiftLeft(distance, MutableBytes32.create());
+ }
+
+ @Override
+ Bytes32 copy();
+
+ @Override
+ MutableBytes32 mutableCopy();
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/BytesValues.java b/bytes/src/main/java/net/consensys/cava/bytes/BytesValues.java
new file mode 100644
index 00000000..d81e6f22
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/BytesValues.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+final class BytesValues {
+ private BytesValues() {}
+
+ static final int MAX_UNSIGNED_SHORT = (1 << 16) - 1;
+ static final long MAX_UNSIGNED_INT = (1L << 32) - 1;
+
+ static Bytes fromHexString(String str, int destSize, boolean lenient) {
+ return Bytes.wrap(fromRawHexString(str, destSize, lenient));
+ }
+
+ static byte[] fromRawHexString(String str, int destSize, boolean lenient) {
+ String hex = str;
+ if (str.startsWith("0x")) {
+ hex = str.substring(2);
+ }
+
+ int len = hex.length();
+ int idxShift = 0;
+ if (len % 2 != 0) {
+ if (!lenient) {
+ throw new IllegalArgumentException("Invalid odd-length hex binary representation '" + str + "'");
+ }
+
+ hex = "0" + hex;
+ len += 1;
+ idxShift = 1;
+ }
+
+ int size = len / 2;
+ if (destSize < 0) {
+ destSize = size;
+ } else {
+ checkArgument(
+ size <= destSize,
+ "Hex value %s is too big: expected at most %s bytes but got %s",
+ str,
+ destSize,
+ size);
+ }
+
+ byte[] out = new byte[destSize];
+
+ int destOffset = (destSize - size);
+ for (int i = 0; i < len; i += 2) {
+ int h = hexToBin(hex.charAt(i));
+ int l = hexToBin(hex.charAt(i + 1));
+ if (h == -1) {
+ throw new IllegalArgumentException(
+ String.format(
+ "Illegal character '%c' found at index %d in hex binary representation '%s'",
+ hex.charAt(i),
+ i - idxShift,
+ str));
+ }
+ if (l == -1) {
+ throw new IllegalArgumentException(
+ String.format(
+ "Illegal character '%c' found at index %d in hex binary representation '%s'",
+ hex.charAt(i + 1),
+ i + 1 - idxShift,
+ str));
+ }
+
+ out[destOffset + (i / 2)] = (byte) (h * 16 + l);
+ }
+ return out;
+ }
+
+ private static int hexToBin(char ch) {
+ if ('0' <= ch && ch <= '9') {
+ return ch - 48;
+ } else if ('A' <= ch && ch <= 'F') {
+ return ch - 65 + 10;
+ } else {
+ return 'a' <= ch && ch <= 'f' ? ch - 97 + 10 : -1;
+ }
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/ConcatenatedBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/ConcatenatedBytes.java
new file mode 100644
index 00000000..310be19f
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/ConcatenatedBytes.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+final class ConcatenatedBytes extends AbstractBytes {
+
+ private final Bytes[] values;
+ private final int size;
+
+ private ConcatenatedBytes(Bytes[] values, int totalSize) {
+ this.values = values;
+ this.size = totalSize;
+ }
+
+ static Bytes wrap(Bytes... values) {
+ if (values.length == 0) {
+ return EMPTY;
+ }
+ if (values.length == 1) {
+ return values[0];
+ }
+
+ int count = 0;
+ int totalSize = 0;
+
+ for (Bytes value : values) {
+ int size = value.size();
+ try {
+ totalSize = Math.addExact(totalSize, size);
+ } catch (ArithmeticException e) {
+ throw new IllegalArgumentException("Combined length of values is too long (> Integer.MAX_VALUE)");
+ }
+ if (value instanceof ConcatenatedBytes) {
+ count += ((ConcatenatedBytes) value).values.length;
+ } else if (size != 0) {
+ count += 1;
+ }
+ }
+
+ if (count == 0) {
+ return Bytes.EMPTY;
+ }
+ if (count == values.length) {
+ return new ConcatenatedBytes(values, totalSize);
+ }
+
+ Bytes[] concatenated = new Bytes[count];
+ int i = 0;
+ for (Bytes value : values) {
+ if (value instanceof ConcatenatedBytes) {
+ Bytes[] subvalues = ((ConcatenatedBytes) value).values;
+ System.arraycopy(subvalues, 0, concatenated, i, subvalues.length);
+ i += subvalues.length;
+ } else if (value.size() != 0) {
+ concatenated[i++] = value;
+ }
+ }
+ return new ConcatenatedBytes(concatenated, totalSize);
+ }
+
+ @Override
+ public int size() {
+ return size;
+ }
+
+ @Override
+ public byte get(int i) {
+ checkElementIndex(i, size);
+ for (Bytes value : values) {
+ int vSize = value.size();
+ if (i < vSize) {
+ return value.get(i);
+ }
+ i -= vSize;
+ }
+ throw new IllegalStateException("element sizes do not match total size");
+ }
+
+ @Override
+ public Bytes slice(int i, final int length) {
+ if (i == 0 && length == size) {
+ return this;
+ }
+ if (length == 0) {
+ return Bytes.EMPTY;
+ }
+
+ checkElementIndex(i, size);
+ checkArgument(
+ (i + length) <= size,
+ "Provided length %s is too large: the value has size %s and has only %s bytes from %s",
+ length,
+ size,
+ size - i,
+ i);
+
+ int j = 0;
+ int vSize;
+ while (true) {
+ vSize = values[j].size();
+ if (i < vSize) {
+ break;
+ }
+ i -= vSize;
+ ++j;
+ }
+
+ if ((i + length) < vSize) {
+ return values[j].slice(i, length);
+ }
+
+ int remaining = length - (vSize - i);
+ Bytes firstValue = this.values[j].slice(i);
+ int firstOffset = j;
+
+ while (remaining > 0) {
+ if (++j >= this.values.length) {
+ throw new IllegalStateException("element sizes do not match total size");
+ }
+ vSize = this.values[j].size();
+ if (length < vSize) {
+ break;
+ }
+ remaining -= vSize;
+ }
+
+ Bytes[] combined = new Bytes[j - firstOffset + 1];
+ combined[0] = firstValue;
+ if (remaining > 0) {
+ if (combined.length > 2) {
+ System.arraycopy(this.values, firstOffset + 1, combined, 1, combined.length - 2);
+ }
+ combined[combined.length - 1] = this.values[j].slice(0, remaining);
+ } else if (combined.length > 1) {
+ System.arraycopy(this.values, firstOffset + 1, combined, 1, combined.length - 1);
+ }
+ return new ConcatenatedBytes(combined, length);
+ }
+
+ @Override
+ public Bytes copy() {
+ if (size == 0) {
+ return Bytes.EMPTY;
+ }
+ MutableBytes result = MutableBytes.create(size);
+ copyToUnchecked(result, 0);
+ return result;
+ }
+
+ @Override
+ public MutableBytes mutableCopy() {
+ if (size == 0) {
+ return MutableBytes.EMPTY;
+ }
+ MutableBytes result = MutableBytes.create(size);
+ copyToUnchecked(result, 0);
+ return result;
+ }
+
+ @Override
+ public void copyTo(MutableBytes destination, int destinationOffset) {
+ if (size == 0) {
+ return;
+ }
+
+ checkElementIndex(destinationOffset, destination.size());
+ checkArgument(
+ destination.size() - destinationOffset >= size,
+ "Cannot copy %s bytes, destination has only %s bytes from index %s",
+ size,
+ destination.size() - destinationOffset,
+ destinationOffset);
+
+ copyToUnchecked(destination, destinationOffset);
+ }
+
+ @Override
+ public byte[] toArray() {
+ if (size == 0) {
+ return new byte[0];
+ }
+
+ MutableBytes result = MutableBytes.create(size);
+ copyToUnchecked(result, 0);
+ return result.toArrayUnsafe();
+ }
+
+ private void copyToUnchecked(MutableBytes destination, int destinationOffset) {
+ int offset = 0;
+ for (Bytes value : values) {
+ int vSize = value.size();
+ if ((offset + vSize) > size) {
+ throw new IllegalStateException("element sizes do not match total size");
+ }
+ value.copyTo(destination, destinationOffset);
+ offset += vSize;
+ destinationOffset += vSize;
+ }
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/DelegatingBytes32.java b/bytes/src/main/java/net/consensys/cava/bytes/DelegatingBytes32.java
new file mode 100644
index 00000000..652a34c8
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/DelegatingBytes32.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import java.math.BigInteger;
+import java.security.MessageDigest;
+
+import io.vertx.core.buffer.Buffer;
+
+final class DelegatingBytes32 implements Bytes32 {
+
+ private final Bytes delegate;
+
+ private DelegatingBytes32(Bytes delegate) {
+ this.delegate = delegate;
+ }
+
+ static Bytes32 delegateTo(Bytes value) {
+ checkArgument(value.size() == SIZE, "Expected %s bytes but got %s", SIZE, value.size());
+ return new DelegatingBytes32(value);
+ }
+
+ @Override
+ public int size() {
+ return Bytes32.SIZE;
+ }
+
+ @Override
+ public byte get(int i) {
+ return delegate.get(i);
+ }
+
+ @Override
+ public int getInt(int i) {
+ return delegate.getInt(i);
+ }
+
+ @Override
+ public int intValue() {
+ return delegate.intValue();
+ }
+
+ @Override
+ public long getLong(int i) {
+ return delegate.getLong(i);
+ }
+
+ @Override
+ public long longValue() {
+ return delegate.longValue();
+ }
+
+ @Override
+ public BigInteger bigIntegerValue() {
+ return delegate.bigIntegerValue();
+ }
+
+ @Override
+ public BigInteger unsignedBigIntegerValue() {
+ return delegate.unsignedBigIntegerValue();
+ }
+
+ @Override
+ public boolean isZero() {
+ return delegate.isZero();
+ }
+
+ @Override
+ public int numberOfLeadingZeros() {
+ return delegate.numberOfLeadingZeros();
+ }
+
+ @Override
+ public int numberOfLeadingZeroBytes() {
+ return delegate.numberOfLeadingZeroBytes();
+ }
+
+ @Override
+ public boolean hasLeadingZeroByte() {
+ return delegate.hasLeadingZeroByte();
+ }
+
+ @Override
+ public boolean hasLeadingZero() {
+ return delegate.hasLeadingZero();
+ }
+
+ @Override
+ public int bitLength() {
+ return delegate.bitLength();
+ }
+
+ @Override
+ public Bytes and(Bytes other) {
+ return delegate.and(other);
+ }
+
+ @Override
+ public T and(Bytes other, T result) {
+ return delegate.and(other, result);
+ }
+
+ @Override
+ public Bytes or(Bytes other) {
+ return delegate.or(other);
+ }
+
+ @Override
+ public T or(Bytes other, T result) {
+ return delegate.or(other, result);
+ }
+
+ @Override
+ public Bytes xor(Bytes other) {
+ return delegate.xor(other);
+ }
+
+ @Override
+ public T xor(Bytes other, T result) {
+ return delegate.xor(other, result);
+ }
+
+ @Override
+ public T not(T result) {
+ return delegate.not(result);
+ }
+
+ @Override
+ public T shiftRight(int distance, T result) {
+ return delegate.shiftRight(distance, result);
+ }
+
+ @Override
+ public T shiftLeft(int distance, T result) {
+ return delegate.shiftLeft(distance, result);
+ }
+
+ @Override
+ public Bytes slice(int index) {
+ return delegate.slice(index);
+ }
+
+ @Override
+ public Bytes slice(int index, int length) {
+ return delegate.slice(index, length);
+ }
+
+ @Override
+ public Bytes32 copy() {
+ return Bytes32.wrap(toArray());
+ }
+
+ @Override
+ public MutableBytes32 mutableCopy() {
+ return MutableBytes32.wrap(toArray());
+ }
+
+ @Override
+ public void copyTo(MutableBytes destination) {
+ delegate.copyTo(destination);
+ }
+
+ @Override
+ public void copyTo(MutableBytes destination, int destinationOffset) {
+ delegate.copyTo(destination, destinationOffset);
+ }
+
+ @Override
+ public void appendTo(Buffer buffer) {
+ delegate.appendTo(buffer);
+ }
+
+ @Override
+ public int commonPrefixLength(Bytes other) {
+ return delegate.commonPrefixLength(other);
+ }
+
+ @Override
+ public Bytes commonPrefix(Bytes other) {
+ return delegate.commonPrefix(other);
+ }
+
+ @Override
+ public void update(MessageDigest digest) {
+ delegate.update(digest);
+ }
+
+ @Override
+ public byte[] toArray() {
+ return delegate.toArray();
+ }
+
+ @Override
+ public byte[] toArrayUnsafe() {
+ return delegate.toArrayUnsafe();
+ }
+
+ @Override
+ public String toString() {
+ return delegate.toString();
+ }
+
+ @Override
+ public String toHexString() {
+ return delegate.toHexString();
+ }
+
+ @Override
+ public String toShortHexString() {
+ return delegate.toShortHexString();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return delegate.equals(obj);
+ }
+
+ @Override
+ public int hashCode() {
+ return delegate.hashCode();
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/DelegatingMutableBytes32.java b/bytes/src/main/java/net/consensys/cava/bytes/DelegatingMutableBytes32.java
new file mode 100644
index 00000000..aea97788
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/DelegatingMutableBytes32.java
@@ -0,0 +1,264 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import java.math.BigInteger;
+import java.security.MessageDigest;
+
+import io.vertx.core.buffer.Buffer;
+
+final class DelegatingMutableBytes32 implements MutableBytes32 {
+
+ private final MutableBytes delegate;
+
+ private DelegatingMutableBytes32(MutableBytes delegate) {
+ this.delegate = delegate;
+ }
+
+ static MutableBytes32 delegateTo(MutableBytes value) {
+ checkArgument(value.size() == SIZE, "Expected %s bytes but got %s", SIZE, value.size());
+ return new DelegatingMutableBytes32(value);
+ }
+
+ @Override
+ public void set(int i, byte b) {
+ delegate.set(i, b);
+ }
+
+ @Override
+ public void setInt(int i, int value) {
+ delegate.setInt(i, value);
+ }
+
+ @Override
+ public void setLong(int i, long value) {
+ delegate.setLong(i, value);
+ }
+
+ @Override
+ public MutableBytes mutableSlice(int i, int length) {
+ return delegate.mutableSlice(i, length);
+ }
+
+ @Override
+ public void fill(byte b) {
+ delegate.fill(b);
+ }
+
+ @Override
+ public void clear() {
+ delegate.clear();
+ }
+
+ @Override
+ public int size() {
+ return delegate.size();
+ }
+
+ @Override
+ public byte get(int i) {
+ return delegate.get(i);
+ }
+
+ @Override
+ public int getInt(int i) {
+ return delegate.getInt(i);
+ }
+
+ @Override
+ public int intValue() {
+ return delegate.intValue();
+ }
+
+ @Override
+ public long getLong(int i) {
+ return delegate.getLong(i);
+ }
+
+ @Override
+ public long longValue() {
+ return delegate.longValue();
+ }
+
+ @Override
+ public BigInteger bigIntegerValue() {
+ return delegate.bigIntegerValue();
+ }
+
+ @Override
+ public BigInteger unsignedBigIntegerValue() {
+ return delegate.unsignedBigIntegerValue();
+ }
+
+ @Override
+ public boolean isZero() {
+ return delegate.isZero();
+ }
+
+ @Override
+ public int numberOfLeadingZeros() {
+ return delegate.numberOfLeadingZeros();
+ }
+
+ @Override
+ public int numberOfLeadingZeroBytes() {
+ return delegate.numberOfLeadingZeroBytes();
+ }
+
+ @Override
+ public boolean hasLeadingZeroByte() {
+ return delegate.hasLeadingZeroByte();
+ }
+
+ @Override
+ public boolean hasLeadingZero() {
+ return delegate.hasLeadingZero();
+ }
+
+ @Override
+ public int bitLength() {
+ return delegate.bitLength();
+ }
+
+ @Override
+ public Bytes and(Bytes other) {
+ return delegate.and(other);
+ }
+
+ @Override
+ public T and(Bytes other, T result) {
+ return delegate.and(other, result);
+ }
+
+ @Override
+ public Bytes or(Bytes other) {
+ return delegate.or(other);
+ }
+
+ @Override
+ public T or(Bytes other, T result) {
+ return delegate.or(other, result);
+ }
+
+ @Override
+ public Bytes xor(Bytes other) {
+ return delegate.xor(other);
+ }
+
+ @Override
+ public T xor(Bytes other, T result) {
+ return delegate.xor(other, result);
+ }
+
+ @Override
+ public T not(T result) {
+ return delegate.not(result);
+ }
+
+ @Override
+ public T shiftRight(int distance, T result) {
+ return delegate.shiftRight(distance, result);
+ }
+
+ @Override
+ public T shiftLeft(int distance, T result) {
+ return delegate.shiftLeft(distance, result);
+ }
+
+ @Override
+ public Bytes slice(int index) {
+ return delegate.slice(index);
+ }
+
+ @Override
+ public Bytes slice(int index, int length) {
+ return delegate.slice(index, length);
+ }
+
+ @Override
+ public Bytes32 copy() {
+ return Bytes32.wrap(delegate.toArray());
+ }
+
+ @Override
+ public MutableBytes32 mutableCopy() {
+ return MutableBytes32.wrap(delegate.toArray());
+ }
+
+ @Override
+ public void copyTo(MutableBytes destination) {
+ delegate.copyTo(destination);
+ }
+
+ @Override
+ public void copyTo(MutableBytes destination, int destinationOffset) {
+ delegate.copyTo(destination, destinationOffset);
+ }
+
+ @Override
+ public void appendTo(Buffer buffer) {
+ delegate.appendTo(buffer);
+ }
+
+ @Override
+ public int commonPrefixLength(Bytes other) {
+ return delegate.commonPrefixLength(other);
+ }
+
+ @Override
+ public Bytes commonPrefix(Bytes other) {
+ return delegate.commonPrefix(other);
+ }
+
+ @Override
+ public void update(MessageDigest digest) {
+ delegate.update(digest);
+ }
+
+ @Override
+ public byte[] toArray() {
+ return delegate.toArray();
+ }
+
+ @Override
+ public byte[] toArrayUnsafe() {
+ return delegate.toArrayUnsafe();
+ }
+
+ @Override
+ public String toString() {
+ return delegate.toString();
+ }
+
+ @Override
+ public String toHexString() {
+ return delegate.toHexString();
+ }
+
+ @Override
+ public String toShortHexString() {
+ return delegate.toShortHexString();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ return delegate.equals(obj);
+ }
+
+ @Override
+ public int hashCode() {
+ return delegate.hashCode();
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/MutableArrayWrappingBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/MutableArrayWrappingBytes.java
new file mode 100644
index 00000000..441e4e73
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/MutableArrayWrappingBytes.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+import java.util.Arrays;
+
+class MutableArrayWrappingBytes extends ArrayWrappingBytes implements MutableBytes {
+
+ MutableArrayWrappingBytes(byte[] bytes) {
+ super(bytes);
+ }
+
+ MutableArrayWrappingBytes(byte[] bytes, int offset, int length) {
+ super(bytes, offset, length);
+ }
+
+ @Override
+ public void set(int i, byte b) {
+ // Check bounds because while the array access would throw, the error message would be confusing
+ // for the caller.
+ checkElementIndex(i, size());
+ this.bytes[offset + i] = b;
+ }
+
+ @Override
+ public MutableBytes mutableSlice(int i, int length) {
+ if (i == 0 && length == this.length)
+ return this;
+ if (length == 0)
+ return MutableBytes.EMPTY;
+
+ checkElementIndex(i, this.length);
+ checkArgument(
+ i + length <= this.length,
+ "Specified length %s is too large: the value has size %s and has only %s bytes from %s",
+ length,
+ this.length,
+ this.length - i,
+ i);
+ return length == Bytes32.SIZE ? new MutableArrayWrappingBytes32(bytes, offset + i)
+ : new MutableArrayWrappingBytes(bytes, offset + i, length);
+ }
+
+ @Override
+ public void fill(byte b) {
+ Arrays.fill(bytes, offset, offset + length, b);
+ }
+
+ @Override
+ public Bytes copy() {
+ return new ArrayWrappingBytes(toArray());
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/MutableArrayWrappingBytes32.java b/bytes/src/main/java/net/consensys/cava/bytes/MutableArrayWrappingBytes32.java
new file mode 100644
index 00000000..891fab3d
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/MutableArrayWrappingBytes32.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+final class MutableArrayWrappingBytes32 extends MutableArrayWrappingBytes implements MutableBytes32 {
+
+ MutableArrayWrappingBytes32(byte[] bytes) {
+ this(bytes, 0);
+ }
+
+ MutableArrayWrappingBytes32(byte[] bytes, int offset) {
+ super(bytes, offset, SIZE);
+ }
+
+ @Override
+ public Bytes32 copy() {
+ return new ArrayWrappingBytes32(toArray());
+ }
+
+ @Override
+ public MutableBytes32 mutableCopy() {
+ return new MutableArrayWrappingBytes32(toArray());
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/MutableBufferWrappingBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/MutableBufferWrappingBytes.java
new file mode 100644
index 00000000..5fcd727a
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/MutableBufferWrappingBytes.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+import io.vertx.core.buffer.Buffer;
+
+final class MutableBufferWrappingBytes extends BufferWrappingBytes implements MutableBytes {
+
+ MutableBufferWrappingBytes(Buffer buffer) {
+ super(buffer);
+ }
+
+ MutableBufferWrappingBytes(Buffer buffer, int offset, int length) {
+ super(buffer, offset, length);
+ }
+
+ @Override
+ public void set(int i, byte b) {
+ buffer.setByte(i, b);
+ }
+
+ @Override
+ public void setInt(int i, int value) {
+ buffer.setInt(i, value);
+ }
+
+ @Override
+ public void setLong(int i, long value) {
+ buffer.setLong(i, value);
+ }
+
+ @Override
+ public MutableBytes mutableSlice(int i, int length) {
+ int size = size();
+ if (i == 0 && length == size) {
+ return this;
+ }
+ if (length == 0) {
+ return MutableBytes.EMPTY;
+ }
+
+ checkElementIndex(i, size);
+ checkArgument(
+ i + length <= size,
+ "Provided length %s is too big: the value has size %s and has only %s bytes from %s",
+ length,
+ size,
+ size - i,
+ i);
+
+ return new MutableBufferWrappingBytes(buffer.slice(i, i + length));
+ }
+
+ @Override
+ public Bytes copy() {
+ return Bytes.wrap(toArray());
+ }
+
+ @Override
+ public MutableBytes mutableCopy() {
+ return MutableBytes.wrap(toArray());
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/MutableByteBufWrappingBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/MutableByteBufWrappingBytes.java
new file mode 100644
index 00000000..ff56eca8
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/MutableByteBufWrappingBytes.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+import io.netty.buffer.ByteBuf;
+
+final class MutableByteBufWrappingBytes extends ByteBufWrappingBytes implements MutableBytes {
+
+ MutableByteBufWrappingBytes(ByteBuf buffer) {
+ super(buffer);
+ }
+
+ MutableByteBufWrappingBytes(ByteBuf buffer, int offset, int length) {
+ super(buffer, offset, length);
+ }
+
+ @Override
+ public void clear() {
+ byteBuf.setZero(0, byteBuf.capacity());
+ }
+
+ @Override
+ public void set(int i, byte b) {
+ byteBuf.setByte(i, b);
+ }
+
+ @Override
+ public void setInt(int i, int value) {
+ byteBuf.setInt(i, value);
+ }
+
+ @Override
+ public void setLong(int i, long value) {
+ byteBuf.setLong(i, value);
+ }
+
+ @Override
+ public MutableBytes mutableSlice(int i, int length) {
+ int size = size();
+ if (i == 0 && length == size) {
+ return this;
+ }
+ if (length == 0) {
+ return MutableBytes.EMPTY;
+ }
+
+ checkElementIndex(i, size);
+ checkArgument(
+ i + length <= size,
+ "Provided length %s is too big: the value has size %s and has only %s bytes from %s",
+ length,
+ size,
+ size - i,
+ i);
+
+ return new MutableByteBufWrappingBytes(byteBuf.slice(i, length));
+ }
+
+ @Override
+ public Bytes copy() {
+ return Bytes.wrap(toArray());
+ }
+
+ @Override
+ public MutableBytes mutableCopy() {
+ return MutableBytes.wrap(toArray());
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/MutableByteBufferWrappingBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/MutableByteBufferWrappingBytes.java
new file mode 100644
index 00000000..d3c47021
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/MutableByteBufferWrappingBytes.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+import java.nio.ByteBuffer;
+
+public class MutableByteBufferWrappingBytes extends ByteBufferWrappingBytes implements MutableBytes {
+
+ MutableByteBufferWrappingBytes(ByteBuffer byteBuffer) {
+ super(byteBuffer);
+ }
+
+ MutableByteBufferWrappingBytes(ByteBuffer byteBuffer, int offset, int length) {
+ super(byteBuffer, offset, length);
+ }
+
+ @Override
+ public void setInt(int i, int value) {
+ byteBuffer.putInt(offset + i, value);
+ }
+
+ @Override
+ public void setLong(int i, long value) {
+ byteBuffer.putLong(offset + i, value);
+ }
+
+ @Override
+ public void set(int i, byte b) {
+ byteBuffer.put(offset + i, b);
+ }
+
+ @Override
+ public MutableBytes mutableSlice(int i, int length) {
+ if (i == 0 && length == this.length) {
+ return this;
+ }
+ if (length == 0) {
+ return MutableBytes.EMPTY;
+ }
+
+ checkElementIndex(i, this.length);
+ checkArgument(
+ i + length <= this.length,
+ "Provided length %s is too big: the value has size %s and has only %s bytes from %s",
+ length,
+ this.length,
+ this.length - i,
+ i);
+
+ return new MutableByteBufferWrappingBytes(byteBuffer, offset + i, length);
+ }
+
+ @Override
+ public Bytes copy() {
+ return new ArrayWrappingBytes(toArray());
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/MutableBytes.java b/bytes/src/main/java/net/consensys/cava/bytes/MutableBytes.java
new file mode 100644
index 00000000..0f71d383
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/MutableBytes.java
@@ -0,0 +1,295 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkElementIndex;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.lang.String.format;
+
+import java.nio.ByteBuffer;
+
+import io.netty.buffer.ByteBuf;
+import io.vertx.core.buffer.Buffer;
+
+/**
+ * A mutable {@link Bytes} value.
+ */
+public interface MutableBytes extends Bytes {
+
+ /**
+ * The empty value (with 0 bytes).
+ */
+ MutableBytes EMPTY = wrap(new byte[0]);
+
+ /**
+ * Create a new mutable byte value.
+ *
+ * @param size The size of the returned value.
+ * @return A {@link MutableBytes} value.
+ */
+ static MutableBytes create(int size) {
+ if (size == 32) {
+ return MutableBytes32.create();
+ }
+ return new MutableArrayWrappingBytes(new byte[size]);
+ }
+
+ /**
+ * Wrap a byte array in a {@link MutableBytes} value.
+ *
+ * @param value The value to wrap.
+ * @return A {@link MutableBytes} value wrapping {@code value}.
+ */
+ static MutableBytes wrap(byte[] value) {
+ checkNotNull(value);
+ return new MutableArrayWrappingBytes(value);
+ }
+
+ /**
+ * Wrap a slice of a byte array as a {@link MutableBytes} value.
+ *
+ *
+ * Note that value is not copied and thus any future update to {@code value} within the slice will be reflected in the
+ * returned value.
+ *
+ * @param value The value to wrap.
+ * @param offset The index (inclusive) in {@code value} of the first byte exposed by the returned value. In other
+ * words, you will have {@code wrap(value, o, l).get(0) == value[o]}.
+ * @param length The length of the resulting value.
+ * @return A {@link Bytes} value that expose the bytes of {@code value} from {@code offset} (inclusive) to
+ * {@code offset + length} (exclusive).
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (value.length > 0 && offset >=
+ * value.length)}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + length > value.length}.
+ */
+ static MutableBytes wrap(byte[] value, int offset, int length) {
+ checkNotNull(value);
+ if (length == 32) {
+ return new MutableArrayWrappingBytes32(value, offset);
+ }
+ return new MutableArrayWrappingBytes(value, offset, length);
+ }
+
+ /**
+ * Wrap a full Vert.x {@link Buffer} as a {@link MutableBytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value.
+ *
+ * @param buffer The buffer to wrap.
+ * @return A {@link MutableBytes} value.
+ */
+ static MutableBytes wrapBuffer(Buffer buffer) {
+ checkNotNull(buffer);
+ if (buffer.length() == 0) {
+ return EMPTY;
+ }
+ return new MutableBufferWrappingBytes(buffer);
+ }
+
+ /**
+ * Wrap a slice of a Vert.x {@link Buffer} as a {@link MutableBytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value, and any change to the
+ * returned value will be reflected in the buffer.
+ *
+ * @param buffer The buffer to wrap.
+ * @param offset The offset in {@code buffer} from which to expose the bytes in the returned value. That is,
+ * {@code wrapBuffer(buffer, i, 1).get(0) == buffer.getByte(i)}.
+ * @param size The size of the returned value.
+ * @return A {@link MutableBytes} value.
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (buffer.length() > 0 && offset >=
+ * buffer.length())}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + length > buffer.length()}.
+ */
+ static MutableBytes wrapBuffer(Buffer buffer, int offset, int size) {
+ checkNotNull(buffer);
+ if (size == 0) {
+ return EMPTY;
+ }
+ return new MutableBufferWrappingBytes(buffer, offset, size);
+ }
+
+ /**
+ * Wrap a full Netty {@link ByteBuf} as a {@link MutableBytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value.
+ *
+ * @param byteBuf The {@link ByteBuf} to wrap.
+ * @return A {@link MutableBytes} value.
+ */
+ static MutableBytes wrapByteBuf(ByteBuf byteBuf) {
+ checkNotNull(byteBuf);
+ if (byteBuf.capacity() == 0) {
+ return EMPTY;
+ }
+ return new MutableByteBufWrappingBytes(byteBuf);
+ }
+
+ /**
+ * Wrap a slice of a Netty {@link ByteBuf} as a {@link MutableBytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value, and any change to the
+ * returned value will be reflected in the buffer.
+ *
+ * @param byteBuf The {@link ByteBuf} to wrap.
+ * @param offset The offset in {@code byteBuf} from which to expose the bytes in the returned value. That is,
+ * {@code wrapByteBuf(byteBuf, i, 1).get(0) == byteBuf.getByte(i)}.
+ * @param size The size of the returned value.
+ * @return A {@link MutableBytes} value.
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (byteBuf.capacity() > 0 && offset >=
+ * byteBuf.capacity())}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + length > byteBuf.capacity()}.
+ */
+ static MutableBytes wrapByteBuf(ByteBuf byteBuf, int offset, int size) {
+ checkNotNull(byteBuf);
+ if (size == 0) {
+ return EMPTY;
+ }
+ return new MutableByteBufWrappingBytes(byteBuf, offset, size);
+ }
+
+ /**
+ * Wrap a full Java NIO {@link ByteBuffer} as a {@link MutableBytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value.
+ *
+ * @param byteBuffer The {@link ByteBuffer} to wrap.
+ * @return A {@link MutableBytes} value.
+ */
+ static MutableBytes wrapByteBuffer(ByteBuffer byteBuffer) {
+ checkNotNull(byteBuffer);
+ if (byteBuffer.limit() == 0) {
+ return EMPTY;
+ }
+ return new MutableByteBufferWrappingBytes(byteBuffer);
+ }
+
+ /**
+ * Wrap a slice of a Java NIO {@link ByteBuffer} as a {@link MutableBytes} value.
+ *
+ *
+ * Note that any change to the content of the buffer may be reflected in the returned value, and any change to the
+ * returned value will be reflected in the buffer.
+ *
+ * @param byteBuffer The {@link ByteBuffer} to wrap.
+ * @param offset The offset in {@code byteBuffer} from which to expose the bytes in the returned value. That is,
+ * {@code wrapByteBuffer(byteBuffer, i, 1).get(0) == byteBuffer.getByte(i)}.
+ * @param size The size of the returned value.
+ * @return A {@link MutableBytes} value.
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (byteBuffer.limit() > 0 && offset >=
+ * byteBuffer.limit())}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + length > byteBuffer.limit()}.
+ */
+ static MutableBytes wrapByteBuffer(ByteBuffer byteBuffer, int offset, int size) {
+ checkNotNull(byteBuffer);
+ if (size == 0) {
+ return EMPTY;
+ }
+ return new MutableByteBufferWrappingBytes(byteBuffer, offset, size);
+ }
+
+ /**
+ * Set a byte in this value.
+ *
+ * @param i The index of the byte to set.
+ * @param b The value to set that byte to.
+ * @throws IndexOutOfBoundsException if {@code i < 0} or {i >= size()}.
+ */
+ void set(int i, byte b);
+
+ /**
+ * Set the 4 bytes starting at the specified index to the specified integer value.
+ *
+ * @param i The index, which must less than or equal to {@code size() - 4}.
+ * @param value The integer value.
+ * @throws IndexOutOfBoundsException if {@code i < 0} or {@code i > size() - 4}.
+ */
+ default void setInt(int i, int value) {
+ int size = size();
+ checkElementIndex(i, size);
+ if (i > (size - 4)) {
+ throw new IndexOutOfBoundsException(
+ format("Value of size %s has not enough bytes to write a 4 bytes int from index %s", size, i));
+ }
+
+ set(i++, (byte) (value >>> 24));
+ set(i++, (byte) ((value >>> 16) & 0xFF));
+ set(i++, (byte) ((value >>> 8) & 0xFF));
+ set(i, (byte) (value & 0xFF));
+ }
+
+ /**
+ * Set the 8 bytes starting at the specified index to the specified long value.
+ *
+ * @param i The index, which must less than or equal to {@code size() - 8}.
+ * @param value The long value.
+ * @throws IndexOutOfBoundsException if {@code i < 0} or {@code i > size() - 8}.
+ */
+ default void setLong(int i, long value) {
+ int size = size();
+ checkElementIndex(i, size);
+ if (i > (size - 8)) {
+ throw new IndexOutOfBoundsException(
+ format("Value of size %s has not enough bytes to write a 8 bytes long from index %s", size, i));
+ }
+
+ set(i++, (byte) (value >>> 56));
+ set(i++, (byte) ((value >>> 48) & 0xFF));
+ set(i++, (byte) ((value >>> 40) & 0xFF));
+ set(i++, (byte) ((value >>> 32) & 0xFF));
+ set(i++, (byte) ((value >>> 24) & 0xFF));
+ set(i++, (byte) ((value >>> 16) & 0xFF));
+ set(i++, (byte) ((value >>> 8) & 0xFF));
+ set(i, (byte) (value & 0xFF));
+ }
+
+ /**
+ * Create a mutable slice of the bytes of this value.
+ *
+ *
+ * Note: the resulting slice is only a view over the original value. Holding a reference to the returned slice may
+ * hold more memory than the slide represents. Use {@link #copy} on the returned slice to avoid this.
+ *
+ * @param i The start index for the slice.
+ * @param length The length of the resulting value.
+ * @return A new mutable view over the bytes of this value from index {@code i} (included) to index {@code i + length}
+ * (excluded).
+ * @throws IllegalArgumentException if {@code length < 0}.
+ * @throws IndexOutOfBoundsException if {@code i < 0} or {i >= size()} or {i + length > size()} .
+ */
+ MutableBytes mutableSlice(int i, int length);
+
+ /**
+ * Fill all the bytes of this value with the specified byte.
+ *
+ * @param b The byte to use to fill the value.
+ */
+ default void fill(byte b) {
+ int size = size();
+ for (int i = 0; i < size; i++) {
+ set(i, b);
+ }
+ }
+
+ /**
+ * Set all bytes in this value to 0.
+ */
+ default void clear() {
+ fill((byte) 0);
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/MutableBytes32.java b/bytes/src/main/java/net/consensys/cava/bytes/MutableBytes32.java
new file mode 100644
index 00000000..5aa1a92e
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/MutableBytes32.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * A mutable {@link Bytes32}, that is a mutable {@link Bytes} value of exactly 32 bytes.
+ */
+public interface MutableBytes32 extends MutableBytes, Bytes32 {
+
+ /**
+ * Create a new mutable 32 bytes value.
+ *
+ * @return A newly allocated {@link MutableBytes} value.
+ */
+ static MutableBytes32 create() {
+ return new MutableArrayWrappingBytes32(new byte[SIZE]);
+ }
+
+ /**
+ * Wrap a 32 bytes array as a mutable 32 bytes value.
+ *
+ * @param value The value to wrap.
+ * @return A {@link MutableBytes32} wrapping {@code value}.
+ * @throws IllegalArgumentException if {@code value.length != 32}.
+ */
+ static MutableBytes32 wrap(byte[] value) {
+ checkNotNull(value);
+ return new MutableArrayWrappingBytes32(value);
+ }
+
+ /**
+ * Wrap a the provided array as a {@link MutableBytes32}.
+ *
+ *
+ * Note that value is not copied, only wrapped, and thus any future update to {@code value} within the wrapped parts
+ * will be reflected in the returned value.
+ *
+ * @param value The bytes to wrap.
+ * @param offset The index (inclusive) in {@code value} of the first byte exposed by the returned value. In other
+ * words, you will have {@code wrap(value, i).get(0) == value[i]}.
+ * @return A {@link MutableBytes32} that exposes the bytes of {@code value} from {@code offset} (inclusive) to
+ * {@code offset + 32} (exclusive).
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (value.length > 0 && offset >=
+ * value.length)}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + 32 > value.length}.
+ */
+ static MutableBytes32 wrap(byte[] value, int offset) {
+ checkNotNull(value);
+ return new MutableArrayWrappingBytes32(value, offset);
+ }
+
+ /**
+ * Wrap a the provided value, which must be of size 32, as a {@link MutableBytes32}.
+ *
+ *
+ * Note that value is not copied, only wrapped, and thus any future update to {@code value} will be reflected in the
+ * returned value.
+ *
+ * @param value The bytes to wrap.
+ * @return A {@link MutableBytes32} that exposes the bytes of {@code value}.
+ * @throws IllegalArgumentException if {@code value.size() != 32}.
+ */
+ static MutableBytes32 wrap(MutableBytes value) {
+ checkNotNull(value);
+ if (value instanceof MutableBytes32) {
+ return (MutableBytes32) value;
+ }
+ return DelegatingMutableBytes32.delegateTo(value);
+ }
+
+ /**
+ * Wrap a slice/sub-part of the provided value as a {@link MutableBytes32}.
+ *
+ *
+ * Note that the value is not copied, and thus any future update to {@code value} within the wrapped parts will be
+ * reflected in the returned value.
+ *
+ * @param value The bytes to wrap.
+ * @param offset The index (inclusive) in {@code value} of the first byte exposed by the returned value. In other
+ * words, you will have {@code wrap(value, i).get(0) == value.get(i)}.
+ * @return A {@link Bytes32} that exposes the bytes of {@code value} from {@code offset} (inclusive) to
+ * {@code offset + 32} (exclusive).
+ * @throws IndexOutOfBoundsException if {@code offset < 0 || (value.size() > 0 && offset >=
+ * value.size())}.
+ * @throws IllegalArgumentException if {@code length < 0 || offset + 32 > value.size()}.
+ */
+ static MutableBytes32 wrap(MutableBytes value, int offset) {
+ checkNotNull(value);
+ if (value instanceof MutableBytes32) {
+ return (MutableBytes32) value;
+ }
+ MutableBytes slice = value.mutableSlice(offset, Bytes32.SIZE);
+ if (slice instanceof MutableBytes32) {
+ return (MutableBytes32) slice;
+ }
+ return DelegatingMutableBytes32.delegateTo(slice);
+ }
+}
diff --git a/bytes/src/main/java/net/consensys/cava/bytes/package-info.java b/bytes/src/main/java/net/consensys/cava/bytes/package-info.java
new file mode 100644
index 00000000..3707b77a
--- /dev/null
+++ b/bytes/src/main/java/net/consensys/cava/bytes/package-info.java
@@ -0,0 +1,11 @@
+/**
+ * Classes and utilities for working with byte arrays.
+ *
+ *
+ * These classes are included in the standard Cava distribution, or separately when using the gradle dependency
+ * 'net.consensys.cava:cava-bytes' (cava-bytes.jar).
+ */
+@ParametersAreNonnullByDefault
+package net.consensys.cava.bytes;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/bytes/src/test/java/net/consensys/cava/bytes/BufferBytesTest.java b/bytes/src/test/java/net/consensys/cava/bytes/BufferBytesTest.java
new file mode 100644
index 00000000..1fb885be
--- /dev/null
+++ b/bytes/src/test/java/net/consensys/cava/bytes/BufferBytesTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import io.vertx.core.buffer.Buffer;
+
+class BufferBytesTest extends CommonBytesTests {
+
+ @Override
+ Bytes h(String hex) {
+ return Bytes.wrapBuffer(Buffer.buffer(Bytes.fromHexString(hex).toArrayUnsafe()));
+ }
+
+ @Override
+ MutableBytes m(int size) {
+ return MutableBytes.wrapBuffer(Buffer.buffer(new byte[size]));
+ }
+
+ @Override
+ Bytes w(byte[] bytes) {
+ return Bytes.wrapBuffer(Buffer.buffer(Bytes.of(bytes).toArray()));
+ }
+
+ @Override
+ Bytes of(int... bytes) {
+ return Bytes.wrapBuffer(Buffer.buffer(Bytes.of(bytes).toArray()));
+ }
+}
diff --git a/bytes/src/test/java/net/consensys/cava/bytes/ByteBufBytesTest.java b/bytes/src/test/java/net/consensys/cava/bytes/ByteBufBytesTest.java
new file mode 100644
index 00000000..3aa4e1d8
--- /dev/null
+++ b/bytes/src/test/java/net/consensys/cava/bytes/ByteBufBytesTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import io.netty.buffer.Unpooled;
+
+class ByteBufBytesTest extends CommonBytesTests {
+
+ @Override
+ Bytes h(String hex) {
+ return Bytes.wrapByteBuf(Unpooled.copiedBuffer(Bytes.fromHexString(hex).toArrayUnsafe()));
+ }
+
+ @Override
+ MutableBytes m(int size) {
+ return MutableBytes.wrapByteBuf(Unpooled.copiedBuffer(new byte[size]));
+ }
+
+ @Override
+ Bytes w(byte[] bytes) {
+ return Bytes.wrapByteBuf(Unpooled.copiedBuffer(Bytes.of(bytes).toArray()));
+ }
+
+ @Override
+ Bytes of(int... bytes) {
+ return Bytes.wrapByteBuf(Unpooled.copiedBuffer(Bytes.of(bytes).toArray()));
+ }
+}
diff --git a/bytes/src/test/java/net/consensys/cava/bytes/ByteBufferBytesTest.java b/bytes/src/test/java/net/consensys/cava/bytes/ByteBufferBytesTest.java
new file mode 100644
index 00000000..5aac46b9
--- /dev/null
+++ b/bytes/src/test/java/net/consensys/cava/bytes/ByteBufferBytesTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import java.nio.ByteBuffer;
+
+class ByteBufferBytesTest extends CommonBytesTests {
+
+ @Override
+ Bytes h(String hex) {
+ return Bytes.wrapByteBuffer(ByteBuffer.wrap(Bytes.fromHexString(hex).toArrayUnsafe()));
+ }
+
+ @Override
+ MutableBytes m(int size) {
+ return MutableBytes.wrapByteBuffer(ByteBuffer.allocate(size));
+ }
+
+ @Override
+ Bytes w(byte[] bytes) {
+ return Bytes.wrapByteBuffer(ByteBuffer.wrap(Bytes.of(bytes).toArray()));
+ }
+
+ @Override
+ Bytes of(int... bytes) {
+ return Bytes.wrapByteBuffer(ByteBuffer.wrap(Bytes.of(bytes).toArray()));
+ }
+}
diff --git a/bytes/src/test/java/net/consensys/cava/bytes/Bytes32Test.java b/bytes/src/test/java/net/consensys/cava/bytes/Bytes32Test.java
new file mode 100644
index 00000000..4859d027
--- /dev/null
+++ b/bytes/src/test/java/net/consensys/cava/bytes/Bytes32Test.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+class Bytes32Test {
+
+ @Test
+ void failsWhenWrappingArraySmallerThan32() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes32.wrap(new byte[31]));
+ assertEquals("Expected 32 bytes but got 31", exception.getMessage());
+ }
+
+ @Test
+ void failsWhenWrappingArrayLargerThan32() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes32.wrap(new byte[33]));
+ assertEquals("Expected 32 bytes but got 33", exception.getMessage());
+ }
+
+ @Test
+ void leftPadAValueToBytes32() {
+ Bytes32 b32 = Bytes32.leftPad(Bytes.of(1, 2, 3));
+ assertEquals(32, b32.size());
+ for (int i = 0; i < 28; ++i) {
+ assertEquals((byte) 0, b32.get(i));
+ }
+ assertEquals((byte) 1, b32.get(29));
+ assertEquals((byte) 2, b32.get(30));
+ assertEquals((byte) 3, b32.get(31));
+ }
+
+ @Test
+ void failsWhenLeftPaddingValueLargerThan32() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes32.leftPad(MutableBytes.create(33)));
+ assertEquals("Expected at most 32 bytes but got 33", exception.getMessage());
+ }
+}
diff --git a/bytes/src/test/java/net/consensys/cava/bytes/BytesTest.java b/bytes/src/test/java/net/consensys/cava/bytes/BytesTest.java
new file mode 100644
index 00000000..1ad04ece
--- /dev/null
+++ b/bytes/src/test/java/net/consensys/cava/bytes/BytesTest.java
@@ -0,0 +1,370 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class BytesTest extends CommonBytesTests {
+
+ @Override
+ Bytes h(String hex) {
+ return Bytes.fromHexString(hex);
+ }
+
+ @Override
+ MutableBytes m(int size) {
+ return MutableBytes.create(size);
+ }
+
+ @Override
+ Bytes w(byte[] bytes) {
+ return Bytes.wrap(bytes);
+ }
+
+ @Override
+ Bytes of(int... bytes) {
+ return Bytes.of(bytes);
+ }
+
+ @Test
+ void wrapEmpty() {
+ Bytes wrap = Bytes.wrap(new byte[0]);
+ assertEquals(Bytes.EMPTY, wrap);
+ }
+
+ @ParameterizedTest
+ @MethodSource("wrapProvider")
+ void wrap(Object arr) {
+ byte[] bytes = (byte[]) arr;
+ Bytes value = Bytes.wrap(bytes);
+ assertEquals(bytes.length, value.size());
+ assertArrayEquals(value.toArray(), bytes);
+ }
+
+ private static Stream wrapProvider() {
+ return Stream.of(
+ Arguments.of(new Object[] {new byte[10]}),
+ Arguments.of(new Object[] {new byte[] {1}}),
+ Arguments.of(new Object[] {new byte[] {1, 2, 3, 4}}),
+ Arguments.of(new Object[] {new byte[] {-1, 127, -128}}));
+ }
+
+ @Test
+ void wrapNull() {
+ assertThrows(NullPointerException.class, () -> Bytes.wrap((byte[]) null));
+ }
+
+ /**
+ * Checks that modifying a wrapped array modifies the value itself.
+ */
+ @Test
+ void wrapReflectsUpdates() {
+ byte[] bytes = new byte[] {1, 2, 3, 4, 5};
+ Bytes value = Bytes.wrap(bytes);
+
+ assertEquals(bytes.length, value.size());
+ assertArrayEquals(value.toArray(), bytes);
+
+ bytes[1] = 127;
+ bytes[3] = 127;
+
+ assertEquals(bytes.length, value.size());
+ assertArrayEquals(value.toArray(), bytes);
+ }
+
+ @Test
+ void wrapSliceEmpty() {
+ assertEquals(Bytes.EMPTY, Bytes.wrap(new byte[0], 0, 0));
+ assertEquals(Bytes.EMPTY, Bytes.wrap(new byte[] {1, 2, 3}, 0, 0));
+ assertEquals(Bytes.EMPTY, Bytes.wrap(new byte[] {1, 2, 3}, 2, 0));
+ }
+
+ @ParameterizedTest
+ @MethodSource("wrapSliceProvider")
+ void wrapSlice(Object arr, int offset, int length) {
+ assertWrapSlice((byte[]) arr, offset, length);
+ }
+
+ private static Stream wrapSliceProvider() {
+ return Stream.of(
+ Arguments.of(new byte[] {1, 2, 3, 4}, 0, 4),
+ Arguments.of(new byte[] {1, 2, 3, 4}, 0, 2),
+ Arguments.of(new byte[] {1, 2, 3, 4}, 2, 1),
+ Arguments.of(new byte[] {1, 2, 3, 4}, 2, 2));
+ }
+
+ private void assertWrapSlice(byte[] bytes, int offset, int length) {
+ Bytes value = Bytes.wrap(bytes, offset, length);
+ assertEquals(length, value.size());
+ assertArrayEquals(value.toArray(), Arrays.copyOfRange(bytes, offset, offset + length));
+ }
+
+ @Test
+ void wrapSliceNull() {
+ assertThrows(NullPointerException.class, () -> Bytes.wrap(null, 0, 2));
+ }
+
+ @Test
+ void wrapSliceNegativeOffset() {
+ assertThrows(IndexOutOfBoundsException.class, () -> assertWrapSlice(new byte[] {1, 2, 3, 4}, -1, 4));
+ }
+
+ @Test
+ void wrapSliceOutOfBoundOffset() {
+ assertThrows(IndexOutOfBoundsException.class, () -> assertWrapSlice(new byte[] {1, 2, 3, 4}, 5, 1));
+ }
+
+ @Test
+ void wrapSliceNegativeLength() {
+ Throwable exception =
+ assertThrows(IllegalArgumentException.class, () -> assertWrapSlice(new byte[] {1, 2, 3, 4}, 0, -2));
+ assertEquals("Invalid negative length", exception.getMessage());
+ }
+
+ @Test
+ void wrapSliceTooBig() {
+ Throwable exception =
+ assertThrows(IllegalArgumentException.class, () -> assertWrapSlice(new byte[] {1, 2, 3, 4}, 2, 3));
+ assertEquals("Provided length 3 is too big: the value has only 2 bytes from offset 2", exception.getMessage());
+ }
+
+ /**
+ * Checks that modifying a wrapped array modifies the value itself, but only if within the wrapped slice.
+ */
+ @Test
+ void wrapSliceReflectsUpdates() {
+ byte[] bytes = new byte[] {1, 2, 3, 4, 5};
+ assertWrapSlice(bytes, 2, 2);
+ bytes[2] = 127;
+ bytes[3] = 127;
+ assertWrapSlice(bytes, 2, 2);
+
+ Bytes wrapped = Bytes.wrap(bytes, 2, 2);
+ Bytes copy = wrapped.copy();
+
+ // Modify the bytes outside of the wrapped slice and check this doesn't affect the value (that
+ // it is still equal to the copy from before the updates)
+ bytes[0] = 127;
+ assertEquals(copy, wrapped);
+
+ // Sanity check for copy(): modify within the wrapped slice and check the copy differs now.
+ bytes[2] = 42;
+ assertNotEquals(copy, wrapped);
+ }
+
+ @Test
+ void ofBytes() {
+ assertArrayEquals(Bytes.of().toArray(), new byte[] {});
+ assertArrayEquals(Bytes.of((byte) 1, (byte) 2).toArray(), new byte[] {1, 2});
+ assertArrayEquals(Bytes.of((byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5).toArray(), new byte[] {1, 2, 3, 4, 5});
+ assertArrayEquals(Bytes.of((byte) -1, (byte) 2, (byte) -3).toArray(), new byte[] {-1, 2, -3});
+ }
+
+ @Test
+ void ofInts() {
+ assertArrayEquals(Bytes.of(1, 2).toArray(), new byte[] {1, 2});
+ assertArrayEquals(Bytes.of(1, 2, 3, 4, 5).toArray(), new byte[] {1, 2, 3, 4, 5});
+ assertArrayEquals(Bytes.of(0xff, 0x7f, 0x80).toArray(), new byte[] {-1, 127, -128});
+ }
+
+ @Test
+ void ofIntsTooBig() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.of(2, 3, 256));
+ assertEquals("3th value 256 does not fit a byte", exception.getMessage());
+ }
+
+ @Test
+ void ofIntsTooLow() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.of(2, -1, 3));
+ assertEquals("2th value -1 does not fit a byte", exception.getMessage());
+ }
+
+ @Test
+ void minimalBytes() {
+ assertEquals(h("0x"), Bytes.minimalBytes(0));
+ assertEquals(h("0x01"), Bytes.minimalBytes(1));
+ assertEquals(h("0x04"), Bytes.minimalBytes(4));
+ assertEquals(h("0x10"), Bytes.minimalBytes(16));
+ assertEquals(h("0xFF"), Bytes.minimalBytes(255));
+ assertEquals(h("0x0100"), Bytes.minimalBytes(256));
+ assertEquals(h("0x0200"), Bytes.minimalBytes(512));
+ assertEquals(h("0x010000"), Bytes.minimalBytes(1L << 16));
+ assertEquals(h("0x01000000"), Bytes.minimalBytes(1L << 24));
+ assertEquals(h("0x0100000000"), Bytes.minimalBytes(1L << 32));
+ assertEquals(h("0x010000000000"), Bytes.minimalBytes(1L << 40));
+ assertEquals(h("0x01000000000000"), Bytes.minimalBytes(1L << 48));
+ assertEquals(h("0x0100000000000000"), Bytes.minimalBytes(1L << 56));
+ assertEquals(h("0xFFFFFFFFFFFFFFFF"), Bytes.minimalBytes(-1L));
+ }
+
+ @Test
+ void ofUnsignedShort() {
+ assertEquals(h("0x0000"), Bytes.ofUnsignedShort(0));
+ assertEquals(h("0x0001"), Bytes.ofUnsignedShort(1));
+ assertEquals(h("0x0100"), Bytes.ofUnsignedShort(256));
+ assertEquals(h("0xFFFF"), Bytes.ofUnsignedShort(65535));
+ }
+
+ @Test
+ void ofUnsignedShortNegative() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.ofUnsignedShort(-1));
+ assertEquals(
+ "Value -1 cannot be represented as an unsigned short (it is negative or too big)",
+ exception.getMessage());
+ }
+
+ @Test
+ void ofUnsignedShortTooBig() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.ofUnsignedShort(65536));
+ assertEquals(
+ "Value 65536 cannot be represented as an unsigned short (it is negative or too big)",
+ exception.getMessage());
+ }
+
+ @Test
+ void asUnsignedBigIntegerConstants() {
+ assertEquals(bi("0"), Bytes.EMPTY.unsignedBigIntegerValue());
+ assertEquals(bi("1"), Bytes.of(1).unsignedBigIntegerValue());
+ }
+
+ @Test
+ void asSignedBigIntegerConstants() {
+ assertEquals(bi("0"), Bytes.EMPTY.bigIntegerValue());
+ assertEquals(bi("1"), Bytes.of(1).bigIntegerValue());
+ }
+
+ @Test
+ void fromHexStringLenient() {
+ assertEquals(Bytes.of(), Bytes.fromHexStringLenient(""));
+ assertEquals(Bytes.of(), Bytes.fromHexStringLenient("0x"));
+ assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("0"));
+ assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("0x0"));
+ assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("00"));
+ assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("0x00"));
+ assertEquals(Bytes.of(1), Bytes.fromHexStringLenient("0x1"));
+ assertEquals(Bytes.of(1), Bytes.fromHexStringLenient("0x01"));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("1FF2A"));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1FF2A"));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1ff2a"));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1fF2a"));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("01FF2A"));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x01FF2A"));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x01ff2A"));
+ }
+
+ @Test
+ void fromHexStringLenientInvalidInput() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexStringLenient("foo"));
+ assertEquals("Illegal character 'o' found at index 1 in hex binary representation 'foo'", exception.getMessage());
+ }
+
+ @Test
+ void fromHexStringLenientLeftPadding() {
+ assertEquals(Bytes.of(), Bytes.fromHexStringLenient("", 0));
+ assertEquals(Bytes.of(0), Bytes.fromHexStringLenient("", 1));
+ assertEquals(Bytes.of(0, 0), Bytes.fromHexStringLenient("", 2));
+ assertEquals(Bytes.of(0, 0), Bytes.fromHexStringLenient("0x", 2));
+ assertEquals(Bytes.of(0, 0, 0), Bytes.fromHexStringLenient("0", 3));
+ assertEquals(Bytes.of(0, 0, 0), Bytes.fromHexStringLenient("0x0", 3));
+ assertEquals(Bytes.of(0, 0, 0), Bytes.fromHexStringLenient("00", 3));
+ assertEquals(Bytes.of(0, 0, 0), Bytes.fromHexStringLenient("0x00", 3));
+ assertEquals(Bytes.of(0, 0, 1), Bytes.fromHexStringLenient("0x1", 3));
+ assertEquals(Bytes.of(0, 0, 1), Bytes.fromHexStringLenient("0x01", 3));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("1FF2A", 3));
+ assertEquals(Bytes.of(0x00, 0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1FF2A", 4));
+ assertEquals(Bytes.of(0x00, 0x00, 0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1ff2a", 5));
+ assertEquals(Bytes.of(0x00, 0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x1fF2a", 4));
+ assertEquals(Bytes.of(0x00, 0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("01FF2A", 4));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x01FF2A", 3));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexStringLenient("0x01ff2A", 3));
+ }
+
+ @Test
+ void fromHexStringLenientLeftPaddingInvalidInput() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexStringLenient("foo", 10));
+ assertEquals("Illegal character 'o' found at index 1 in hex binary representation 'foo'", exception.getMessage());
+ }
+
+ @Test
+ void fromHexStringLenientLeftPaddingInvalidSize() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexStringLenient("0x001F34", 2));
+ assertEquals("Hex value 0x001F34 is too big: expected at most 2 bytes but got 3", exception.getMessage());
+ }
+
+ @Test
+ void fromHexString() {
+ assertEquals(Bytes.of(), Bytes.fromHexString("0x"));
+ assertEquals(Bytes.of(0), Bytes.fromHexString("00"));
+ assertEquals(Bytes.of(0), Bytes.fromHexString("0x00"));
+ assertEquals(Bytes.of(1), Bytes.fromHexString("0x01"));
+ assertEquals(Bytes.of(1, 0xff, 0x2a), Bytes.fromHexString("01FF2A"));
+ assertEquals(Bytes.of(1, 0xff, 0x2a), Bytes.fromHexString("0x01FF2A"));
+ assertEquals(Bytes.of(1, 0xff, 0x2a), Bytes.fromHexString("0x01ff2a"));
+ assertEquals(Bytes.of(1, 0xff, 0x2a), Bytes.fromHexString("0x01fF2a"));
+ }
+
+ @Test
+ void fromHexStringInvalidInput() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexString("fooo"));
+ assertEquals("Illegal character 'o' found at index 1 in hex binary representation 'fooo'", exception.getMessage());
+ }
+
+ @Test
+ void fromHexStringNotLenient() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexString("0x100"));
+ assertEquals("Invalid odd-length hex binary representation '0x100'", exception.getMessage());
+ }
+
+ @Test
+ void fromHexStringLeftPadding() {
+ assertEquals(Bytes.of(), Bytes.fromHexString("0x", 0));
+ assertEquals(Bytes.of(0, 0), Bytes.fromHexString("0x", 2));
+ assertEquals(Bytes.of(0, 0, 0, 0), Bytes.fromHexString("0x", 4));
+ assertEquals(Bytes.of(0, 0), Bytes.fromHexString("00", 2));
+ assertEquals(Bytes.of(0, 0), Bytes.fromHexString("0x00", 2));
+ assertEquals(Bytes.of(0, 0, 1), Bytes.fromHexString("0x01", 3));
+ assertEquals(Bytes.of(0x00, 0x01, 0xff, 0x2a), Bytes.fromHexString("01FF2A", 4));
+ assertEquals(Bytes.of(0x01, 0xff, 0x2a), Bytes.fromHexString("0x01FF2A", 3));
+ assertEquals(Bytes.of(0x00, 0x00, 0x01, 0xff, 0x2a), Bytes.fromHexString("0x01ff2a", 5));
+ assertEquals(Bytes.of(0x00, 0x00, 0x01, 0xff, 0x2a), Bytes.fromHexString("0x01fF2a", 5));
+ }
+
+ @Test
+ void fromHexStringLeftPaddingInvalidInput() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexString("fooo", 4));
+ assertEquals("Illegal character 'o' found at index 1 in hex binary representation 'fooo'", exception.getMessage());
+ }
+
+ @Test
+ void fromHexStringLeftPaddingNotLenient() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexString("0x100", 4));
+ assertEquals("Invalid odd-length hex binary representation '0x100'", exception.getMessage());
+ }
+
+ @Test
+ void fromHexStringLeftPaddingInvalidSize() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> Bytes.fromHexStringLenient("0x001F34", 2));
+ assertEquals("Hex value 0x001F34 is too big: expected at most 2 bytes but got 3", exception.getMessage());
+ }
+}
diff --git a/bytes/src/test/java/net/consensys/cava/bytes/CommonBytesTests.java b/bytes/src/test/java/net/consensys/cava/bytes/CommonBytesTests.java
new file mode 100644
index 00000000..c90d049b
--- /dev/null
+++ b/bytes/src/test/java/net/consensys/cava/bytes/CommonBytesTests.java
@@ -0,0 +1,575 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.math.BigInteger;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Arrays;
+import java.util.function.Function;
+
+import io.vertx.core.buffer.Buffer;
+import org.junit.jupiter.api.Test;
+
+abstract class CommonBytesTests {
+
+ abstract Bytes h(String hex);
+
+ abstract MutableBytes m(int size);
+
+ abstract Bytes w(byte[] bytes);
+
+ abstract Bytes of(int... bytes);
+
+ BigInteger bi(String decimal) {
+ return new BigInteger(decimal);
+ }
+
+ @Test
+ void asUnsignedBigInteger() {
+ // Make sure things are interpreted unsigned.
+ assertEquals(bi("255"), h("0xFF").unsignedBigIntegerValue());
+
+ // Try 2^100 + Long.MAX_VALUE, as an easy to define a big not too special big integer.
+ BigInteger expected = BigInteger.valueOf(2).pow(100).add(BigInteger.valueOf(Long.MAX_VALUE));
+
+ // 2^100 is a one followed by 100 zeros, that's 12 bytes of zeros (=96) plus 4 more zeros (so
+ // 0x10 == 16).
+ MutableBytes v = m(13);
+ v.set(0, (byte) 16);
+ v.setLong(v.size() - 8, Long.MAX_VALUE);
+ assertEquals(expected, v.unsignedBigIntegerValue());
+ }
+
+ @Test
+ void testAsSignedBigInteger() {
+ // Make sure things are interpreted signed.
+ assertEquals(bi("-1"), h("0xFF").bigIntegerValue());
+
+ // Try 2^100 + Long.MAX_VALUE, as an easy to define a big but not too special big integer.
+ BigInteger expected = BigInteger.valueOf(2).pow(100).add(BigInteger.valueOf(Long.MAX_VALUE));
+
+ // 2^100 is a one followed by 100 zeros, that's 12 bytes of zeros (=96) plus 4 more zeros (so
+ // 0x10 == 16).
+ MutableBytes v = m(13);
+ v.set(0, (byte) 16);
+ v.setLong(v.size() - 8, Long.MAX_VALUE);
+ assertEquals(expected, v.bigIntegerValue());
+
+ // And for a large negative one, we use -(2^100 + Long.MAX_VALUE), which is:
+ // 2^100 + Long.MAX_VALUE = 0x10(4 bytes of 0)7F( 7 bytes of 1)
+ // inverse = 0xEF(4 bytes of 1)80( 7 bytes of 0)
+ // +1 = 0xEF(4 bytes of 1)80(6 bytes of 0)01
+ expected = expected.negate();
+ v = m(13);
+ v.set(0, (byte) 0xEF);
+ for (int i = 1; i < 5; i++) {
+ v.set(i, (byte) 0xFF);
+ }
+ v.set(5, (byte) 0x80);
+ // 6 bytes of 0
+ v.set(12, (byte) 1);
+ assertEquals(expected, v.bigIntegerValue());
+ }
+
+ @Test
+ void testSize() {
+ assertEquals(0, w(new byte[0]).size());
+ assertEquals(1, w(new byte[1]).size());
+ assertEquals(10, w(new byte[10]).size());
+ }
+
+ @Test
+ void testGet() {
+ Bytes v = w(new byte[] {1, 2, 3, 4});
+ assertEquals((int) (byte) 1, (int) v.get(0));
+ assertEquals((int) (byte) 2, (int) v.get(1));
+ assertEquals((int) (byte) 3, (int) v.get(2));
+ assertEquals((int) (byte) 4, (int) v.get(3));
+ }
+
+ @Test
+ void testGetNegativeIndex() {
+ assertThrows(IndexOutOfBoundsException.class, () -> w(new byte[] {1, 2, 3, 4}).get(-1));
+ }
+
+ @Test
+ void testGetOutOfBound() {
+ assertThrows(IndexOutOfBoundsException.class, () -> w(new byte[] {1, 2, 3, 4}).get(4));
+ }
+
+ @Test
+ void testGetInt() {
+ Bytes value = w(new byte[] {0, 0, 1, 0, -1, -1, -1, -1});
+
+ // 0x00000100 = 256
+ assertEquals(256, value.getInt(0));
+ // 0x000100FF = 65536 + 255 = 65791
+ assertEquals(65791, value.getInt(1));
+ // 0x0100FFFF = 16777216 (2^24) + (65536 - 1) = 16842751
+ assertEquals(16842751, value.getInt(2));
+ // 0xFFFFFFFF = -1
+ assertEquals(-1, value.getInt(4));
+ }
+
+ @Test
+ void testGetIntNegativeIndex() {
+ assertThrows(IndexOutOfBoundsException.class, () -> w(new byte[] {1, 2, 3, 4}).getInt(-1));
+ }
+
+ @Test
+ void testGetIntOutOfBound() {
+ assertThrows(IndexOutOfBoundsException.class, () -> w(new byte[] {1, 2, 3, 4}).getInt(4));
+ }
+
+ @Test
+ void testGetIntNotEnoughBytes() {
+ assertThrows(IndexOutOfBoundsException.class, () -> w(new byte[] {1, 2, 3, 4}).getInt(1));
+ }
+
+ @Test
+ void testAsInt() {
+ assertEquals(0, Bytes.EMPTY.intValue());
+ Bytes value1 = w(new byte[] {0, 0, 1, 0});
+ // 0x00000100 = 256
+ assertEquals(256, value1.intValue());
+ assertEquals(256, value1.slice(2).intValue());
+
+ Bytes value2 = w(new byte[] {0, 1, 0, -1});
+ // 0x000100FF = 65536 + 255 = 65791
+ assertEquals(65791, value2.intValue());
+ assertEquals(65791, value2.slice(1).intValue());
+
+ Bytes value3 = w(new byte[] {1, 0, -1, -1});
+ // 0x0100FFFF = 16777216 (2^24) + (65536 - 1) = 16842751
+ assertEquals(16842751, value3.intValue());
+
+ Bytes value4 = w(new byte[] {-1, -1, -1, -1});
+ // 0xFFFFFFFF = -1
+ assertEquals(-1, value4.intValue());
+ }
+
+ @Test
+ void testAsIntTooManyBytes() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> w(new byte[] {1, 2, 3, 4, 5}).intValue());
+ assertEquals("Value of size 5 has more than 4 bytes", exception.getMessage());
+ }
+
+ @Test
+ void testGetLong() {
+ Bytes value1 = w(new byte[] {0, 0, 1, 0, -1, -1, -1, -1, 0, 0});
+ // 0x00000100FFFFFFFF = (2^40) + (2^32) - 1 = 1103806595071
+ assertEquals(1103806595071L, value1.getLong(0));
+ // 0x 000100FFFFFFFF00 = (2^48) + (2^40) - 1 - 255 = 282574488338176
+ assertEquals(282574488338176L, value1.getLong(1));
+
+ Bytes value2 = w(new byte[] {-1, -1, -1, -1, -1, -1, -1, -1});
+ assertEquals(-1L, value2.getLong(0));
+ }
+
+ @Test
+ void testGetLongNegativeIndex() {
+ assertThrows(IndexOutOfBoundsException.class, () -> w(new byte[] {1, 2, 3, 4, 5, 6, 7, 8}).getLong(-1));
+ }
+
+ @Test
+ void testGetLongOutOfBound() {
+ assertThrows(IndexOutOfBoundsException.class, () -> w(new byte[] {1, 2, 3, 4, 5, 6, 7, 8}).getLong(8));
+ }
+
+ @Test
+ void testGetLongNotEnoughBytes() {
+ assertThrows(IndexOutOfBoundsException.class, () -> w(new byte[] {1, 2, 3, 4}).getLong(0));
+ }
+
+ @Test
+ void testAsLong() {
+ assertEquals(0, Bytes.EMPTY.longValue());
+ Bytes value1 = w(new byte[] {0, 0, 1, 0, -1, -1, -1, -1});
+ // 0x00000100FFFFFFFF = (2^40) + (2^32) - 1 = 1103806595071
+ assertEquals(1103806595071L, value1.longValue());
+ assertEquals(1103806595071L, value1.slice(2).longValue());
+ Bytes value2 = w(new byte[] {0, 1, 0, -1, -1, -1, -1, 0});
+ // 0x000100FFFFFFFF00 = (2^48) + (2^40) - 1 - 255 = 282574488338176
+ assertEquals(282574488338176L, value2.longValue());
+ assertEquals(282574488338176L, value2.slice(1).longValue());
+
+ Bytes value3 = w(new byte[] {-1, -1, -1, -1, -1, -1, -1, -1});
+ assertEquals(-1L, value3.longValue());
+ }
+
+ @Test
+ void testAsLongTooManyBytes() {
+ Throwable exception =
+ assertThrows(IllegalArgumentException.class, () -> w(new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9}).longValue());
+ assertEquals("Value of size 9 has more than 8 bytes", exception.getMessage());
+ }
+
+ @Test
+ void testSlice() {
+ assertEquals(h("0x"), h("0x0123456789").slice(0, 0));
+ assertEquals(h("0x"), h("0x0123456789").slice(2, 0));
+ assertEquals(h("0x01"), h("0x0123456789").slice(0, 1));
+ assertEquals(h("0x0123"), h("0x0123456789").slice(0, 2));
+
+ assertEquals(h("0x4567"), h("0x0123456789").slice(2, 2));
+ assertEquals(h("0x23456789"), h("0x0123456789").slice(1, 4));
+ }
+
+ @Test
+ void testSliceNegativeOffset() {
+ assertThrows(IndexOutOfBoundsException.class, () -> h("0x012345").slice(-1, 2));
+ }
+
+ @Test
+ void testSliceOffsetOutOfBound() {
+ assertThrows(IndexOutOfBoundsException.class, () -> h("0x012345").slice(3, 2));
+ }
+
+ @Test
+ void testSliceTooLong() {
+ Throwable exception = assertThrows(IllegalArgumentException.class, () -> h("0x012345").slice(1, 3));
+ assertEquals(
+ "Provided length 3 is too big: the value has size 3 and has only 2 bytes from 1",
+ exception.getMessage());
+ }
+
+ @Test
+ void testMutableCopy() {
+ Bytes v = h("0x012345");
+ MutableBytes mutableCopy = v.mutableCopy();
+
+ // Initially, copy must be equal.
+ assertEquals(mutableCopy, v);
+
+ // Upon modification, original should not have been modified.
+ mutableCopy.set(0, (byte) -1);
+ assertNotEquals(mutableCopy, v);
+ assertEquals(h("0x012345"), v);
+ assertEquals(h("0xFF2345"), mutableCopy);
+ }
+
+ @Test
+ void testCopyTo() {
+ MutableBytes dest;
+
+ // The follow does nothing, but simply making sure it doesn't throw.
+ dest = MutableBytes.EMPTY;
+ Bytes.EMPTY.copyTo(dest);
+ assertEquals(Bytes.EMPTY, dest);
+
+ dest = MutableBytes.create(1);
+ of(1).copyTo(dest);
+ assertEquals(h("0x01"), dest);
+
+ dest = MutableBytes.create(1);
+ of(10).copyTo(dest);
+ assertEquals(h("0x0A"), dest);
+
+ dest = MutableBytes.create(2);
+ of(0xff, 0x03).copyTo(dest);
+ assertEquals(h("0xFF03"), dest);
+
+ dest = MutableBytes.create(4);
+ of(0xff, 0x03).copyTo(dest.mutableSlice(1, 2));
+ assertEquals(h("0x00FF0300"), dest);
+ }
+
+ @Test
+ void testCopyToTooSmall() {
+ Throwable exception =
+ assertThrows(IllegalArgumentException.class, () -> of(1, 2, 3).copyTo(MutableBytes.create(2)));
+ assertEquals("Cannot copy 3 bytes to destination of non-equal size 2", exception.getMessage());
+ }
+
+ @Test
+ void testCopyToTooBig() {
+ Throwable exception =
+ assertThrows(IllegalArgumentException.class, () -> of(1, 2, 3).copyTo(MutableBytes.create(4)));
+ assertEquals("Cannot copy 3 bytes to destination of non-equal size 4", exception.getMessage());
+ }
+
+ @Test
+ void testCopyToWithOffset() {
+ MutableBytes dest;
+
+ dest = MutableBytes.wrap(new byte[] {1, 2, 3});
+ Bytes.EMPTY.copyTo(dest, 0);
+ assertEquals(h("0x010203"), dest);
+
+ dest = MutableBytes.wrap(new byte[] {1, 2, 3});
+ of(1).copyTo(dest, 1);
+ assertEquals(h("0x010103"), dest);
+
+ dest = MutableBytes.wrap(new byte[] {1, 2, 3});
+ of(2).copyTo(dest, 0);
+ assertEquals(h("0x020203"), dest);
+
+ dest = MutableBytes.wrap(new byte[] {1, 2, 3});
+ of(1, 1).copyTo(dest, 1);
+ assertEquals(h("0x010101"), dest);
+
+ dest = MutableBytes.create(4);
+ of(0xff, 0x03).copyTo(dest, 1);
+ assertEquals(h("0x00FF0300"), dest);
+ }
+
+ @Test
+ void testCopyToWithOffsetTooSmall() {
+ Throwable exception =
+ assertThrows(IllegalArgumentException.class, () -> of(1, 2, 3).copyTo(MutableBytes.create(4), 2));
+ assertEquals("Cannot copy 3 bytes, destination has only 2 bytes from index 2", exception.getMessage());
+ }
+
+ @Test
+ void testCopyToWithNegativeOffset() {
+ assertThrows(IndexOutOfBoundsException.class, () -> of(1, 2, 3).copyTo(MutableBytes.create(10), -1));
+ }
+
+ @Test
+ void testCopyToWithOutOfBoundIndex() {
+ assertThrows(IndexOutOfBoundsException.class, () -> of(1, 2, 3).copyTo(MutableBytes.create(10), 10));
+ }
+
+ @Test
+ void testAppendTo() {
+ testAppendTo(Bytes.EMPTY, Buffer.buffer(), Bytes.EMPTY);
+ testAppendTo(Bytes.EMPTY, Buffer.buffer(h("0x1234").toArrayUnsafe()), h("0x1234"));
+ testAppendTo(h("0x1234"), Buffer.buffer(), h("0x1234"));
+ testAppendTo(h("0x5678"), Buffer.buffer(h("0x1234").toArrayUnsafe()), h("0x12345678"));
+ }
+
+ private void testAppendTo(Bytes toAppend, Buffer buffer, Bytes expected) {
+ toAppend.appendTo(buffer);
+ assertEquals(expected, Bytes.wrap(buffer.getBytes()));
+ }
+
+ @Test
+ void testIsZero() {
+ assertTrue(Bytes.EMPTY.isZero());
+ assertTrue(Bytes.of(0).isZero());
+ assertTrue(Bytes.of(0, 0, 0).isZero());
+
+ assertFalse(Bytes.of(1).isZero());
+ assertFalse(Bytes.of(1, 0, 0).isZero());
+ assertFalse(Bytes.of(0, 0, 1).isZero());
+ assertFalse(Bytes.of(0, 0, 1, 0, 0).isZero());
+ }
+
+ @Test
+ void testIsEmpty() {
+ assertTrue(Bytes.EMPTY.isEmpty());
+
+ assertFalse(Bytes.of(0).isEmpty());
+ assertFalse(Bytes.of(0, 0, 0).isEmpty());
+ assertFalse(Bytes.of(1).isEmpty());
+ }
+
+ @Test
+ void findsCommonPrefix() {
+ Bytes v = Bytes.of(1, 2, 3, 4, 5, 6, 7);
+ Bytes o = Bytes.of(1, 2, 3, 4, 4, 3, 2);
+ assertEquals(4, v.commonPrefixLength(o));
+ assertEquals(Bytes.of(1, 2, 3, 4), v.commonPrefix(o));
+ }
+
+ @Test
+ void findsCommonPrefixOfShorter() {
+ Bytes v = Bytes.of(1, 2, 3, 4, 5, 6, 7);
+ Bytes o = Bytes.of(1, 2, 3, 4);
+ assertEquals(4, v.commonPrefixLength(o));
+ assertEquals(Bytes.of(1, 2, 3, 4), v.commonPrefix(o));
+ }
+
+ @Test
+ void findsCommonPrefixOfLonger() {
+ Bytes v = Bytes.of(1, 2, 3, 4);
+ Bytes o = Bytes.of(1, 2, 3, 4, 4, 3, 2);
+ assertEquals(4, v.commonPrefixLength(o));
+ assertEquals(Bytes.of(1, 2, 3, 4), v.commonPrefix(o));
+ }
+
+ @Test
+ void findsCommonPrefixOfSliced() {
+ Bytes v = Bytes.of(1, 2, 3, 4).slice(2, 2);
+ Bytes o = Bytes.of(3, 4, 3, 3, 2).slice(3, 2);
+ assertEquals(1, v.commonPrefixLength(o));
+ assertEquals(Bytes.of(3), v.commonPrefix(o));
+ }
+
+ @Test
+ void testTrimLeadingZeroes() {
+ assertEquals(h("0x"), h("0x").trimLeadingZeros());
+ assertEquals(h("0x"), h("0x00").trimLeadingZeros());
+ assertEquals(h("0x"), h("0x00000000").trimLeadingZeros());
+
+ assertEquals(h("0x01"), h("0x01").trimLeadingZeros());
+ assertEquals(h("0x01"), h("0x00000001").trimLeadingZeros());
+
+ assertEquals(h("0x3010"), h("0x3010").trimLeadingZeros());
+ assertEquals(h("0x3010"), h("0x00003010").trimLeadingZeros());
+
+ assertEquals(h("0xFFFFFFFF"), h("0xFFFFFFFF").trimLeadingZeros());
+ assertEquals(h("0xFFFFFFFF"), h("0x000000000000FFFFFFFF").trimLeadingZeros());
+ }
+
+ @Test
+ void slideToEnd() {
+ assertEquals(Bytes.of(1, 2, 3, 4), Bytes.of(1, 2, 3, 4).slice(0));
+ assertEquals(Bytes.of(2, 3, 4), Bytes.of(1, 2, 3, 4).slice(1));
+ assertEquals(Bytes.of(3, 4), Bytes.of(1, 2, 3, 4).slice(2));
+ assertEquals(Bytes.of(4), Bytes.of(1, 2, 3, 4).slice(3));
+ }
+
+ @Test
+ void slicePastEndReturnsEmpty() {
+ assertEquals(Bytes.EMPTY, Bytes.of(1, 2, 3, 4).slice(4));
+ assertEquals(Bytes.EMPTY, Bytes.of(1, 2, 3, 4).slice(5));
+ }
+
+ @Test
+ void testUpdate() throws NoSuchAlgorithmException {
+ // Digest the same byte array in 4 ways:
+ // 1) directly from the array
+ // 2) after wrapped using the update() method
+ // 3) after wrapped and copied using the update() method
+ // 4) after wrapped but getting the byte manually
+ // and check all compute the same digest.
+ MessageDigest md1 = MessageDigest.getInstance("SHA-1");
+ MessageDigest md2 = MessageDigest.getInstance("SHA-1");
+ MessageDigest md3 = MessageDigest.getInstance("SHA-1");
+ MessageDigest md4 = MessageDigest.getInstance("SHA-1");
+
+ byte[] toDigest = new BigInteger("12324029423415041783577517238472017314").toByteArray();
+ Bytes wrapped = w(toDigest);
+
+ byte[] digest1 = md1.digest(toDigest);
+
+ wrapped.update(md2);
+ byte[] digest2 = md2.digest();
+
+ wrapped.copy().update(md3);
+ byte[] digest3 = md3.digest();
+
+ for (int i = 0; i < wrapped.size(); i++)
+ md4.update(wrapped.get(i));
+ byte[] digest4 = md4.digest();
+
+ assertArrayEquals(digest2, digest1);
+ assertArrayEquals(digest3, digest1);
+ assertArrayEquals(digest4, digest1);
+ }
+
+ @Test
+ void testArrayExtraction() {
+ // extractArray() and getArrayUnsafe() have essentially the same contract...
+ testArrayExtraction(Bytes::toArray);
+ testArrayExtraction(Bytes::toArrayUnsafe);
+
+ // But on top of the basic, extractArray() guarantees modifying the returned array is safe from
+ // impacting the original value (not that getArrayUnsafe makes no guarantees here one way or
+ // another, so there is nothing to test).
+ byte[] orig = new byte[] {1, 2, 3, 4};
+ Bytes value = w(orig);
+ byte[] extracted = value.toArray();
+ assertArrayEquals(orig, extracted);
+ Arrays.fill(extracted, (byte) -1);
+ assertArrayEquals(extracted, new byte[] {-1, -1, -1, -1});
+ assertArrayEquals(orig, new byte[] {1, 2, 3, 4});
+ assertEquals(of(1, 2, 3, 4), value);
+ }
+
+ private void testArrayExtraction(Function extractor) {
+ byte[] bytes = new byte[0];
+ assertArrayEquals(extractor.apply(Bytes.EMPTY), bytes);
+
+ byte[][] toTest = new byte[][] {new byte[] {1}, new byte[] {1, 2, 3, 4, 5, 6}, new byte[] {-1, -1, 0, -1}};
+ for (byte[] array : toTest) {
+ assertArrayEquals(extractor.apply(w(array)), array);
+ }
+
+ // Test slightly more complex interactions
+ assertArrayEquals(extractor.apply(w(new byte[] {1, 2, 3, 4, 5}).slice(2, 2)), new byte[] {3, 4});
+ assertArrayEquals(extractor.apply(w(new byte[] {1, 2, 3, 4, 5}).slice(2, 0)), new byte[] {});
+ }
+
+ @Test
+ void testToString() {
+ assertEquals("0x", Bytes.EMPTY.toString());
+
+ assertEquals("0x01", of(1).toString());
+ assertEquals("0x0AFF03", of(0x0a, 0xff, 0x03).toString());
+ }
+
+ @Test
+ void testHasLeadingZeroByte() {
+ assertFalse(Bytes.fromHexString("0x").hasLeadingZeroByte());
+ assertTrue(Bytes.fromHexString("0x0012").hasLeadingZeroByte());
+ assertFalse(Bytes.fromHexString("0x120012").hasLeadingZeroByte());
+ }
+
+ @Test
+ void testHasLeadingZeroBit() {
+ assertFalse(Bytes.fromHexString("0x").hasLeadingZero());
+ assertTrue(Bytes.fromHexString("0x01").hasLeadingZero());
+ assertFalse(Bytes.fromHexString("0xFF0012").hasLeadingZero());
+ }
+
+ @Test
+ void testEquals() {
+ SecureRandom random = new SecureRandom();
+ byte[] key = new byte[32];
+ random.nextBytes(key);
+ Bytes b = w(key);
+ Bytes b2 = w(key);
+ assertEquals(b.hashCode(), b2.hashCode());
+ }
+
+ @Test
+ void testEqualsWithOffset() {
+ SecureRandom random = new SecureRandom();
+ byte[] key = new byte[32];
+ random.nextBytes(key);
+ Bytes b = w(key).slice(16, 4);
+ Bytes b2 = w(key).slice(16, 8).slice(0, 4);
+ assertEquals(b, b2);
+ }
+
+ @Test
+ void testHashCode() {
+ SecureRandom random = new SecureRandom();
+ byte[] key = new byte[32];
+ random.nextBytes(key);
+ Bytes b = w(key);
+ Bytes b2 = w(key);
+ assertEquals(b.hashCode(), b2.hashCode());
+ }
+
+ @Test
+ void testHashCodeWithOffset() {
+ SecureRandom random = new SecureRandom();
+ byte[] key = new byte[32];
+ random.nextBytes(key);
+ Bytes b = w(key).slice(16, 16);
+ Bytes b2 = w(key).slice(16, 16);
+ assertEquals(b.hashCode(), b2.hashCode());
+ }
+}
diff --git a/bytes/src/test/java/net/consensys/cava/bytes/ConcatenatedBytesTest.java b/bytes/src/test/java/net/consensys/cava/bytes/ConcatenatedBytesTest.java
new file mode 100644
index 00000000..bf03bb3b
--- /dev/null
+++ b/bytes/src/test/java/net/consensys/cava/bytes/ConcatenatedBytesTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.bytes;
+
+import static net.consensys.cava.bytes.Bytes.fromHexString;
+import static net.consensys.cava.bytes.Bytes.wrap;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class ConcatenatedBytesTest {
+
+ @ParameterizedTest
+ @MethodSource("concatenatedWrapProvider")
+ void concatenatedWrap(Object arr1, Object arr2) {
+ byte[] first = (byte[]) arr1;
+ byte[] second = (byte[]) arr2;
+ byte[] res = wrap(wrap(first), wrap(second)).toArray();
+ assertArrayEquals(Arrays.copyOfRange(res, 0, first.length), first);
+ assertArrayEquals(Arrays.copyOfRange(res, first.length, res.length), second);
+ }
+
+ private static Stream concatenatedWrapProvider() {
+ return Stream.of(
+ Arguments.of(new byte[] {}, new byte[] {}),
+ Arguments.of(new byte[] {}, new byte[] {1, 2, 3}),
+ Arguments.of(new byte[] {1, 2, 3}, new byte[] {}),
+ Arguments.of(new byte[] {1, 2, 3}, new byte[] {4, 5}));
+ }
+
+ @Test
+ void testConcatenatedWrapReflectsUpdates() {
+ byte[] first = new byte[] {1, 2, 3};
+ byte[] second = new byte[] {4, 5};
+ byte[] expected1 = new byte[] {1, 2, 3, 4, 5};
+ Bytes res = wrap(wrap(first), wrap(second));
+ assertArrayEquals(res.toArray(), expected1);
+
+ first[1] = 42;
+ second[0] = 42;
+ byte[] expected2 = new byte[] {1, 42, 3, 42, 5};
+ assertArrayEquals(res.toArray(), expected2);
+ }
+
+ @Test
+ void shouldReadConcatenatedValue() {
+ Bytes bytes = wrap(fromHexString("0x01234567"), fromHexString("0x89ABCDEF"));
+ assertEquals(8, bytes.size());
+ assertEquals("0x0123456789ABCDEF", bytes.toHexString());
+ }
+
+ @Test
+ void shouldSliceConcatenatedValue() {
+ Bytes bytes = wrap(
+ fromHexString("0x01234567"),
+ fromHexString("0x89ABCDEF"),
+ fromHexString("0x01234567"),
+ fromHexString("0x89ABCDEF"));
+ assertEquals("0x", bytes.slice(4, 0).toHexString());
+ assertEquals("0x0123456789ABCDEF0123456789ABCDEF", bytes.slice(0, 16).toHexString());
+ assertEquals("0x01234567", bytes.slice(0, 4).toHexString());
+ assertEquals("0x0123", bytes.slice(0, 2).toHexString());
+ assertEquals("0x6789", bytes.slice(3, 2).toHexString());
+ assertEquals("0x89ABCDEF", bytes.slice(4, 4).toHexString());
+ assertEquals("0xABCD", bytes.slice(5, 2).toHexString());
+ assertEquals("0xEF012345", bytes.slice(7, 4).toHexString());
+ assertEquals("0x01234567", bytes.slice(8, 4).toHexString());
+ assertEquals("0x456789ABCDEF", bytes.slice(10, 6).toHexString());
+ assertEquals("0x89ABCDEF", bytes.slice(12, 4).toHexString());
+ }
+
+ @Test
+ void shouldReadDeepConcatenatedValue() {
+ Bytes bytes = wrap(
+ wrap(fromHexString("0x01234567"), fromHexString("0x89ABCDEF")),
+ wrap(fromHexString("0x01234567"), fromHexString("0x89ABCDEF")),
+ fromHexString("0x01234567"),
+ fromHexString("0x89ABCDEF"));
+ assertEquals(24, bytes.size());
+ assertEquals("0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF", bytes.toHexString());
+ }
+}
diff --git a/concurrent/build.gradle b/concurrent/build.gradle
new file mode 100644
index 00000000..58dd6be5
--- /dev/null
+++ b/concurrent/build.gradle
@@ -0,0 +1,13 @@
+description = 'Classes and utilities for working with concurrency.'
+
+dependencies {
+ compile 'com.google.guava:guava'
+ compileOnly 'org.jetbrains.kotlinx:kotlinx-coroutines-core'
+ compileOnly 'io.vertx:vertx-core'
+
+ testCompile 'org.junit.jupiter:junit-jupiter-api'
+ testCompile 'org.junit.jupiter:junit-jupiter-params'
+ testCompile 'org.assertj:assertj-core'
+
+ testRuntime 'org.junit.jupiter:junit-jupiter-engine'
+}
diff --git a/concurrent/src/main/java/net/consensys/cava/concurrent/AsyncCompletion.java b/concurrent/src/main/java/net/consensys/cava/concurrent/AsyncCompletion.java
new file mode 100644
index 00000000..749b531a
--- /dev/null
+++ b/concurrent/src/main/java/net/consensys/cava/concurrent/AsyncCompletion.java
@@ -0,0 +1,478 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.concurrent;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import io.vertx.core.Vertx;
+import io.vertx.core.WorkerExecutor;
+
+/**
+ * A completion that will be complete at a future time.
+ */
+public interface AsyncCompletion {
+
+ AsyncCompletion COMPLETED = new DefaultCompletableAsyncCompletion(CompletableFuture.completedFuture(null));
+
+ /**
+ * Return an already completed completion.
+ *
+ * @return A completed completion.
+ */
+ static AsyncCompletion completed() {
+ return COMPLETED;
+ }
+
+ /**
+ * Return an already failed completion, caused by the given exception.
+ *
+ * @param ex The exception.
+ * @return A failed result.
+ */
+ static AsyncCompletion exceptional(Throwable ex) {
+ requireNonNull(ex);
+ CompletableAsyncCompletion completion = new DefaultCompletableAsyncCompletion();
+ completion.completeExceptionally(ex);
+ return completion;
+ }
+
+ /**
+ * Return an incomplete completion, that can be later completed or failed.
+ *
+ * @return An incomplete completion.
+ */
+ static CompletableAsyncCompletion incomplete() {
+ return new DefaultCompletableAsyncCompletion();
+ }
+
+ /**
+ * Returns an {@link AsyncCompletion} that completes when all of the given completions complete. If any completions
+ * complete exceptionally, then the resulting completion also completes exceptionally.
+ *
+ * @param cs The completions to combine.
+ * @return A completion.
+ */
+ static AsyncCompletion allOf(AsyncCompletion... cs) {
+ return allOf(Arrays.stream(cs));
+ }
+
+ /**
+ * Returns an {@link AsyncCompletion} that completes when all of the given completions complete. If any completions
+ * complete exceptionally, then the resulting completion also completes exceptionally.
+ *
+ * @param cs The completions to combine.
+ * @return A completion.
+ */
+ static AsyncCompletion allOf(Collection cs) {
+ return allOf(cs.stream());
+ }
+
+ /**
+ * Returns an {@link AsyncCompletion} that completes when all of the given completions complete. If any completions
+ * complete exceptionally, then the resulting completion also completes exceptionally.
+ *
+ * @param cs The completions to combine.
+ * @return A completion.
+ */
+ static AsyncCompletion allOf(Stream cs) {
+ @SuppressWarnings("rawtypes")
+ java.util.concurrent.CompletableFuture[] completableFutures = cs.map(completion -> {
+ java.util.concurrent.CompletableFuture javaFuture = new java.util.concurrent.CompletableFuture<>();
+ completion.whenComplete(ex -> {
+ if (ex == null) {
+ javaFuture.complete(null);
+ } else {
+ javaFuture.completeExceptionally(ex);
+ }
+ });
+ return javaFuture;
+ }).toArray(java.util.concurrent.CompletableFuture[]::new);
+ return new DefaultCompletableAsyncCompletion(java.util.concurrent.CompletableFuture.allOf(completableFutures));
+ }
+
+ /**
+ * Returns a completion that, after the given function executes on a vertx context and returns a completion, completes
+ * when the completion from the function does.
+ *
+ * @param vertx The vertx context.
+ * @param fn The function returning a completion.
+ * @return A completion.
+ */
+ static AsyncCompletion runOnContext(Vertx vertx, Supplier fn) {
+ requireNonNull(fn);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ vertx.runOnContext(ev -> {
+ try {
+ fn.get().whenComplete(ex2 -> {
+ if (ex2 == null) {
+ try {
+ completion.complete();
+ } catch (Throwable ex3) {
+ completion.completeExceptionally(ex3);
+ }
+ } else {
+ completion.completeExceptionally(ex2);
+ }
+ });
+ } catch (Throwable ex1) {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ /**
+ * Returns a completion that completes after the given action executes on a vertx context.
+ *
+ *
+ * Note that the given function is run directly on the context and should not block.
+ *
+ * @param vertx The vertx context.
+ * @param action The action to execute.
+ * @return A completion.
+ */
+ static AsyncCompletion runOnContext(Vertx vertx, Runnable action) {
+ requireNonNull(action);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ vertx.runOnContext(ev -> {
+ try {
+ action.run();
+ completion.complete();
+ } catch (Throwable ex) {
+ completion.completeExceptionally(ex);
+ }
+ });
+ return completion;
+ }
+
+ /**
+ * Returns a completion that completes after the given blocking action executes asynchronously on
+ * {@link ForkJoinPool#commonPool()}.
+ *
+ * @param action The blocking action to execute.
+ * @return A completion.
+ */
+ static AsyncCompletion executeBlocking(Runnable action) {
+ requireNonNull(action);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ ForkJoinPool.commonPool().execute(() -> {
+ try {
+ action.run();
+ completion.complete();
+ } catch (Throwable ex) {
+ completion.completeExceptionally(ex);
+ }
+ });
+ return completion;
+ }
+
+ /**
+ * Returns a completion that completes after the given blocking action executes asynchronously on an {@link Executor}.
+ *
+ * @param executor The executor.
+ * @param action The blocking action to execute.
+ * @return A completion.
+ */
+ static AsyncCompletion executeBlocking(Executor executor, Runnable action) {
+ requireNonNull(action);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ executor.execute(() -> {
+ try {
+ action.run();
+ completion.complete();
+ } catch (Throwable ex) {
+ completion.completeExceptionally(ex);
+ }
+ });
+ return completion;
+ }
+
+ /**
+ * Returns a completion that completes after the given blocking action executes asynchronously on a vertx context.
+ *
+ * @param vertx The vertx context.
+ * @param action The blocking action to execute.
+ * @return A completion.
+ */
+ static AsyncCompletion executeBlocking(Vertx vertx, Runnable action) {
+ requireNonNull(action);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ vertx.executeBlocking(future -> {
+ action.run();
+ future.complete();
+ }, false, res -> {
+ if (res.succeeded()) {
+ completion.complete();
+ } else {
+ completion.completeExceptionally(res.cause());
+ }
+ });
+ return completion;
+ }
+
+ /**
+ * Returns a completion that completes after the given blocking action executes asynchronously on a vertx executor.
+ *
+ * @param executor A vertx executor.
+ * @param action The blocking action to execute.
+ * @return A completion.
+ */
+ static AsyncCompletion executeBlocking(WorkerExecutor executor, Runnable action) {
+ requireNonNull(action);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ executor.executeBlocking(future -> {
+ action.run();
+ future.complete();
+ }, false, res -> {
+ if (res.succeeded()) {
+ completion.complete();
+ } else {
+ completion.completeExceptionally(res.cause());
+ }
+ });
+ return completion;
+ }
+
+ /**
+ * Returns true if completed normally, completed exceptionally or cancelled.
+ *
+ * @return true if completed.
+ */
+ boolean isDone();
+
+ /**
+ * Returns true if completed exceptionally or cancelled.
+ *
+ * @return true if completed exceptionally or cancelled.
+ */
+ boolean isCompletedExceptionally();
+
+ /**
+ * Attempt to cancel execution of this task.
+ *
+ *
+ * This attempt will fail if the task has already completed, has already been cancelled, or could not be cancelled for
+ * some other reason. If successful, and this task has not started when {@code cancel} is called, this task should
+ * never run.
+ *
+ *
+ * After this method returns, subsequent calls to {@link #isDone()} will always return true. Subsequent calls
+ * to {@link #isCancelled()} will always return true if this method returned true.
+ *
+ * @return true if this completion transitioned to a cancelled state.
+ */
+ boolean cancel();
+
+ /**
+ * Returns true if this task was cancelled before it completed normally.
+ *
+ * @return true if completed.
+ */
+ boolean isCancelled();
+
+ /**
+ * Waits if necessary for the computation to complete.
+ *
+ * @throws CompletionException If the computation threw an exception.
+ * @throws InterruptedException If the current thread was interrupted while waiting.
+ */
+ void join() throws CompletionException, InterruptedException;
+
+ /**
+ * Waits if necessary for at most the given time for the computation to complete.
+ *
+ * @param timeout The maximum time to wait.
+ * @param unit The time unit of the timeout argument.
+ * @throws CompletionException If the computation threw an exception.
+ * @throws TimeoutException If the wait timed out.
+ * @throws InterruptedException If the current thread was interrupted while waiting.
+ */
+ void join(long timeout, TimeUnit unit) throws CompletionException, TimeoutException, InterruptedException;
+
+ /**
+ * Returns a new completion that, when this completion completes normally, completes with the same value or exception
+ * as the result returned after executing the given function.
+ *
+ * @param fn The function returning a new result.
+ * @param The type of the returned result's value.
+ * @return A new result.
+ */
+ AsyncResult then(Supplier> fn);
+
+ /**
+ * Returns a new result that, when this completion completes normally, completes with the same value or exception as
+ * the completion returned after executing the given function on the vertx context.
+ *
+ * @param vertx The vertx context.
+ * @param fn The function returning a new result.
+ * @param The type of the returned result's value.
+ * @return A new result.
+ */
+ AsyncResult thenSchedule(Vertx vertx, Supplier> fn);
+
+ /**
+ * Returns a new completion that, when this completion completes normally, completes after given action is executed.
+ *
+ * @param runnable Te action to perform before completing the returned {@link AsyncCompletion}.
+ * @return A completion.
+ */
+ AsyncCompletion thenRun(Runnable runnable);
+
+ /**
+ * Returns a new completion that, when this completion completes normally, completes after the given action is
+ * executed on the vertx context.
+ *
+ * @param vertx The vertx context.
+ * @param runnable The action to execute on the vertx context before completing the returned completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenScheduleRun(Vertx vertx, Runnable runnable);
+
+ /**
+ * Returns a new completion that, when this completion completes normally, completes after the given blocking action
+ * is executed on the vertx context.
+ *
+ * @param vertx The vertx context.
+ * @param runnable The action to execute on the vertx context before completing the returned completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenScheduleBlockingRun(Vertx vertx, Runnable runnable);
+
+ /**
+ * Returns a new completion that, when this completion completes normally, completes after the given blocking action
+ * is executed on the vertx executor.
+ *
+ * @param executor The vertx executor.
+ * @param runnable The action to execute on the vertx context before completing the returned completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenScheduleBlockingRun(WorkerExecutor executor, Runnable runnable);
+
+ /**
+ * When this result completes normally, invokes the given function with the resulting value and obtain a new
+ * {@link AsyncCompletion}.
+ *
+ * @param fn The function returning a new completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenCompose(Supplier fn);
+
+ /**
+ * Returns a completion that, when this result completes normally, completes with the value obtained after executing
+ * the supplied function.
+ *
+ * @param supplier The function to use to compute the value of the returned result.
+ * @param The function's return type.
+ * @return A new result.
+ */
+ AsyncResult thenSupply(Supplier supplier);
+
+ /**
+ * Returns a completion that, when this result completes normally, completes with the value obtained after executing
+ * the supplied function on the vertx context.
+ *
+ * @param vertx The vertx context.
+ * @param supplier The function to use to compute the value of the returned result.
+ * @param The function's return type.
+ * @return A new result.
+ */
+ AsyncResult thenSupply(Vertx vertx, Supplier supplier);
+
+ /**
+ * Returns a completion that, when this completion and the supplied result both complete normally, completes after
+ * executing the supplied function with the value from the supplied result as an argument.
+ *
+ * @param other The other result.
+ * @param consumer The function to execute.
+ * @param The type of the other's value.
+ * @return A new result.
+ */
+ AsyncCompletion thenConsume(AsyncResult other, Consumer consumer);
+
+ /**
+ * Returns a result that, when this completion and the other result both complete normally, completes with the value
+ * obtained from executing the supplied function with the value from the other result as an argument.
+ *
+ * @param other The other result.
+ * @param fn The function to execute.
+ * @param The type of the other's value.
+ * @param The type of the value returned by the function.
+ * @return A new result.
+ */
+ AsyncResult thenApply(AsyncResult other, Function fn);
+
+ /**
+ * Returns a completion that completes when both this completion and the other complete normally.
+ *
+ * @param other The other completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenCombine(AsyncCompletion other);
+
+ /**
+ * Returns a new completion that, when this result completes exceptionally, completes after executing the supplied
+ * function. Otherwise, if this result completes normally, then the returned result also completes normally with the
+ * same value.
+ *
+ * @param consumer The function to execute.
+ * @return A new result.
+ */
+ AsyncCompletion exceptionally(Consumer consumer);
+
+ /**
+ * Returns a new completion that completes in the same manner as this completion, after executing the given function
+ * with this completion's exception (if any).
+ *
+ * The exception supplied to the function will be {@code null} if this completion completes successfully.
+ *
+ * @param consumer The action to execute.
+ * @return A new result.
+ */
+ AsyncCompletion whenComplete(Consumer consumer);
+
+ /**
+ * Returns a new result that, when this result completes either normally or exceptionally, completes with the value
+ * obtained from executing the supplied function with this result's exception (if any) as an argument.
+ *
+ * The exception supplied to the function will be {@code null} if this completion completes successfully.
+ *
+ * @param fn The function to execute.
+ * @param The type of the value returned from the function.
+ * @return A new result.
+ */
+ AsyncResult handle(Function fn);
+
+ /**
+ * Returns a new completion that completes successfully, after executing the given function with this completion's
+ * exception (if any).
+ *
+ * The exception supplied to the function will be {@code null} if this completion completes successfully.
+ *
+ * @param consumer The action to execute.
+ * @return A new result.
+ */
+ AsyncCompletion accept(Consumer consumer);
+}
diff --git a/concurrent/src/main/java/net/consensys/cava/concurrent/AsyncResult.java b/concurrent/src/main/java/net/consensys/cava/concurrent/AsyncResult.java
new file mode 100644
index 00000000..6a99ac2d
--- /dev/null
+++ b/concurrent/src/main/java/net/consensys/cava/concurrent/AsyncResult.java
@@ -0,0 +1,515 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.concurrent;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.*;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.*;
+import java.util.stream.Stream;
+
+import io.vertx.core.Vertx;
+import io.vertx.core.WorkerExecutor;
+
+/**
+ * A result that will be available at a future time.
+ *
+ * @param The type of the result object.
+ */
+public interface AsyncResult {
+
+ /**
+ * Return an already completed result containing the given value.
+ *
+ * @param value The value.
+ * @param The type of the value.
+ * @return A completed result.
+ */
+ static AsyncResult completed(T value) {
+ requireNonNull(value);
+ CompletableAsyncResult result = new DefaultCompletableAsyncResult<>();
+ result.complete(value);
+ return result;
+ }
+
+ /**
+ * Return an already failed result, caused by the given exception.
+ *
+ * @param ex The exception.
+ * @param The type of the value that would be available if this result hadn't completed exceptionally.
+ * @return A failed result.
+ */
+ static AsyncResult exceptional(Throwable ex) {
+ requireNonNull(ex);
+ CompletableAsyncResult result = new DefaultCompletableAsyncResult<>();
+ result.completeExceptionally(ex);
+ return result;
+ }
+
+ /**
+ * Return an incomplete result, that can be later completed or failed.
+ *
+ * @param The type of the value that this result will complete with.
+ * @return An incomplete result.
+ */
+ static CompletableAsyncResult incomplete() {
+ return new DefaultCompletableAsyncResult<>();
+ }
+
+ /**
+ * Returns an {@link AsyncCompletion} that completes when all of the given results complete. If any results complete
+ * exceptionally, then the resulting completion also completes exceptionally.
+ *
+ * @param rs The results to combine.
+ * @return A completion.
+ */
+ static AsyncCompletion allOf(AsyncResult... rs) {
+ return allOf(Arrays.stream(rs));
+ }
+
+ /**
+ * Returns an {@link AsyncCompletion} that completes when all of the given results complete. If any results complete
+ * exceptionally, then the resulting completion also completes exceptionally.
+ *
+ * @param rs The results to combine.
+ * @return A completion.
+ */
+ static AsyncCompletion allOf(Collection> rs) {
+ return allOf(rs.stream());
+ }
+
+ /**
+ * Returns an {@link AsyncCompletion} that completes when all of the given results complete. If any results complete
+ * exceptionally, then the resulting completion also completes exceptionally.
+ *
+ * @param rs The results to combine.
+ * @return A completion.
+ */
+ static AsyncCompletion allOf(Stream> rs) {
+ @SuppressWarnings("rawtypes")
+ java.util.concurrent.CompletableFuture[] completableFutures = rs.map(result -> {
+ java.util.concurrent.CompletableFuture javaFuture = new java.util.concurrent.CompletableFuture<>();
+ result.whenComplete((v, ex) -> {
+ if (ex == null) {
+ javaFuture.complete(null);
+ } else {
+ javaFuture.completeExceptionally(ex);
+ }
+ });
+ return javaFuture;
+ }).toArray(java.util.concurrent.CompletableFuture[]::new);
+ return new DefaultCompletableAsyncCompletion(java.util.concurrent.CompletableFuture.allOf(completableFutures));
+ }
+
+ /**
+ * Returns a result that completes when all of the given results complete. If any results complete exceptionally, then
+ * the resulting completion also completes exceptionally.
+ *
+ * @param The type of the values that this result will complete with.
+ * @param rs The results to combine.
+ * @return A new result.
+ */
+ static AsyncResult> combine(Collection> rs) {
+ return combine(rs.stream());
+ }
+
+ /**
+ * Returns a result that completes when all of the given results complete. If any results complete exceptionally, then
+ * the resulting completion also completes exceptionally.
+ *
+ * @param The type of the values that this result will complete with.
+ * @param rs The results to combine.
+ * @return A new result.
+ */
+ static AsyncResult> combine(Stream> rs) {
+ Stream>> ls = rs.map(r -> r.thenApply(Collections::singletonList));
+ return ls.reduce(AsyncResult.completed(new ArrayList<>()), (r1, r2) -> r1.thenCombine(r2, (l1, l2) -> {
+ l1.addAll(l2);
+ return l1;
+ }));
+ }
+
+ /**
+ * Returns a result that, after the given function executes on a vertx context and returns a result, completes when
+ * the returned result completes, with the same value or exception.
+ *
+ *
+ * Note that the given function is run directly on the context and should not block.
+ *
+ * @param vertx The vertx context.
+ * @param fn The function returning a result.
+ * @param The type of the returned result's value.
+ * @return A new result.
+ */
+ static AsyncResult runOnContext(Vertx vertx, Supplier> fn) {
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ vertx.runOnContext(ev -> {
+ try {
+ fn.get().whenComplete((u, ex2) -> {
+ if (ex2 == null) {
+ try {
+ asyncResult.complete(u);
+ } catch (Throwable ex3) {
+ asyncResult.completeExceptionally(ex3);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex2);
+ }
+ });
+ } catch (Throwable ex1) {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ /**
+ * Returns a result that, after the given blocking function executes asynchronously on
+ * {@link ForkJoinPool#commonPool()} and returns a result, completes when the returned result completes, with the same
+ * value or exception.
+ *
+ * @param fn The function returning a result.
+ * @param The type of the returned result's value.
+ * @return A new result.
+ */
+ static AsyncResult executeBlocking(Supplier fn) {
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ ForkJoinPool.commonPool().execute(() -> {
+ try {
+ asyncResult.complete(fn.get());
+ } catch (Throwable ex) {
+ asyncResult.completeExceptionally(ex);
+ }
+ });
+ return asyncResult;
+ }
+
+ /**
+ * Returns a result that, after the given blocking function executes asynchronously on an {@link Executor} and returns
+ * a result, completes when the returned result completes, with the same value or exception.
+ *
+ * @param executor The executor.
+ * @param fn The function returning a result.
+ * @param The type of the returned result's value.
+ * @return A new result.
+ */
+ static AsyncResult executeBlocking(Executor executor, Supplier fn) {
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ executor.execute(() -> {
+ try {
+ asyncResult.complete(fn.get());
+ } catch (Throwable ex) {
+ asyncResult.completeExceptionally(ex);
+ }
+ });
+ return asyncResult;
+ }
+
+ /**
+ * Returns a result that, after the given blocking function executes asynchronously on a vertx context and returns a
+ * result, completes when the returned result completes, with the same value or exception.
+ *
+ * @param vertx The vertx context.
+ * @param fn The function returning a result.
+ * @param The type of the returned result's value.
+ * @return A new result.
+ */
+ static AsyncResult executeBlocking(Vertx vertx, Supplier fn) {
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ vertx.executeBlocking(future -> future.complete(fn.get()), false, res -> {
+ if (res.succeeded()) {
+ asyncResult.complete(res.result());
+ } else {
+ asyncResult.completeExceptionally(res.cause());
+ }
+ });
+ return asyncResult;
+ }
+
+ /**
+ * Returns a result that, after the given blocking function executes asynchronously on a vertx executor and returns a
+ * result, completes when the returned result completes, with the same value or exception.
+ *
+ * @param executor A vertx executor.
+ * @param fn The function returning a result.
+ * @param The type of the returned result's value.
+ * @return A new result.
+ */
+ static AsyncResult executeBlocking(WorkerExecutor executor, Supplier fn) {
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ executor.executeBlocking(future -> future.complete(fn.get()), false, res -> {
+ if (res.succeeded()) {
+ asyncResult.complete(res.result());
+ } else {
+ asyncResult.completeExceptionally(res.cause());
+ }
+ });
+ return asyncResult;
+ }
+
+ /**
+ * Returns true if completed normally, completed exceptionally or cancelled.
+ *
+ * @return true if completed.
+ */
+ boolean isDone();
+
+ /**
+ * Returns true if completed exceptionally or cancelled.
+ *
+ * @return true if completed exceptionally or cancelled.
+ */
+ boolean isCompletedExceptionally();
+
+ /**
+ * Attempt to cancel execution of this task.
+ *
+ *
+ * This attempt will fail if the task has already completed, has already been cancelled, or could not be cancelled for
+ * some other reason. If successful, and this task has not started when {@code cancel} is called, this task should
+ * never run.
+ *
+ *
+ * After this method returns, subsequent calls to {@link #isDone()} will always return true. Subsequent calls
+ * to {@link #isCancelled()} will always return true if this method returned true.
+ *
+ * @return true if this result transitioned to a cancelled state.
+ */
+ boolean cancel();
+
+ /**
+ * Returns true if this task was cancelled before it completed normally.
+ *
+ * @return true if completed.
+ */
+ boolean isCancelled();
+
+ /**
+ * Waits if necessary for the computation to complete, and then retrieves its result.
+ *
+ * @return The computed result.
+ * @throws CompletionException If the computation threw an exception.
+ * @throws InterruptedException If the current thread was interrupted while waiting.
+ */
+ T get() throws CompletionException, InterruptedException;
+
+ /**
+ * Waits if necessary for at most the given time for the computation to complete, and then retrieves its result.
+ *
+ * @param timeout The maximum time to wait.
+ * @param unit The time unit of the timeout argument.
+ * @return The computed result.
+ * @throws CompletionException If the computation threw an exception.
+ * @throws TimeoutException If the wait timed out.
+ * @throws InterruptedException If the current thread was interrupted while waiting.
+ */
+ T get(long timeout, TimeUnit unit) throws CompletionException, TimeoutException, InterruptedException;
+
+ /**
+ * Returns a new result that, when this result completes normally, completes with the same value or exception as the
+ * result returned after executing the given function with this results value as an argument.
+ *
+ * @param fn The function returning a new result.
+ * @param The type of the returned result's value.
+ * @return A new result.
+ */
+ AsyncResult then(Function> fn);
+
+ /**
+ * Returns a new result that, when this result completes normally, completes with the same value or exception as the
+ * completion returned after executing the given function on the vertx context with this results value as an argument.
+ *
+ * @param vertx The vertx context.
+ * @param fn The function returning a new result.
+ * @param The type of the returned result's value.
+ * @return A new result.
+ */
+ AsyncResult thenSchedule(Vertx vertx, Function> fn);
+
+ /**
+ * When this result completes normally, invokes the given function with the resulting value and obtains a new
+ * {@link AsyncCompletion}.
+ *
+ * @param fn The function returning a new completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenCompose(Function fn);
+
+ /**
+ * Returns a new completion that, when this result completes normally, completes after given action is executed.
+ *
+ * @param runnable The action to execute before completing the returned completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenRun(Runnable runnable);
+
+ /**
+ * Returns a new completion that, when this result completes normally, completes after the given action is executed on
+ * the vertx context.
+ *
+ * @param vertx The vertx context.
+ * @param runnable The action to execute on the vertx context before completing the returned completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenScheduleRun(Vertx vertx, Runnable runnable);
+
+ /**
+ * Returns a new completion that, when this result completes normally, completes after the given blocking action is
+ * executed on the vertx context.
+ *
+ * @param vertx The vertx context.
+ * @param runnable The action to execute on the vertx context before completing the returned completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenScheduleBlockingRun(Vertx vertx, Runnable runnable);
+
+ /**
+ * Returns a new completion that, when this result completes normally, completes after the given blocking action is
+ * executed on the vertx executor.
+ *
+ * @param executor The vertx executor.
+ * @param runnable The action to execute on the vertx context before completing the returned completion.
+ * @return A completion.
+ */
+ AsyncCompletion thenScheduleBlockingRun(WorkerExecutor executor, Runnable runnable);
+
+ /**
+ * Returns a result that, when this result completes normally, completes with the value obtained from executing the
+ * supplied function with this result's value as an argument.
+ *
+ * @param fn The function to use to compute the value of the returned result.
+ * @param The function's return type.
+ * @return A new result.
+ */
+ AsyncResult thenApply(Function fn);
+
+ /**
+ * Returns a result that, when this result completes normally, completes with the value obtained from executing the
+ * supplied function on the vertx context with this result's value as an argument.
+ *
+ * @param vertx The vertx context.
+ * @param fn The function to use to compute the value of the returned result.
+ * @param The function's return type.
+ * @return A new result.
+ */
+ AsyncResult thenScheduleApply(Vertx vertx, Function fn);
+
+ /**
+ * Returns a result that, when this result completes normally, completes with the value obtained from executing the
+ * supplied blocking function on the vertx context with this result's value as an argument.
+ *
+ * @param vertx The vertx context.
+ * @param fn The function to use to compute the value of the returned result.
+ * @param The function's return type.
+ * @return A new result.
+ */
+ AsyncResult thenScheduleBlockingApply(Vertx vertx, Function fn);
+
+ /**
+ * Returns a result that, when this result completes normally, completes with the value obtained from executing the
+ * supplied blocking function on the vertx executor with this result's value as an argument.
+ *
+ * @param executor The vertx executor.
+ * @param fn The function to use to compute the value of the returned result.
+ * @param The function's return type.
+ * @return A new result.
+ */
+ AsyncResult thenScheduleBlockingApply(WorkerExecutor executor, Function fn);
+
+ /**
+ * Returns a completion that, when this result completes normally, completes after executing the supplied consumer
+ * with this result's value as an argument.
+ *
+ * @param consumer The consumer for the value of this result.
+ * @return A completion.
+ */
+ AsyncCompletion thenAccept(Consumer consumer);
+
+ /**
+ * Returns a completion that, when this result and the other result both complete normally, completes after executing
+ * the supplied consumer with both this result's value and the value from the other result as arguments.
+ *
+ * @param other The other result.
+ * @param consumer The consumer for both values.
+ * @param The type of the other's value.
+ * @return A completion.
+ */
+ AsyncCompletion thenAcceptBoth(AsyncResult other, BiConsumer consumer);
+
+ /**
+ * Returns a result that, when this result and the other result both complete normally, completes with the value
+ * obtained from executing the supplied function with both this result's value and the value from the other result as
+ * arguments.
+ *
+ * @param other The other result.
+ * @param fn The function to execute.
+ * @param The type of the other's value.
+ * @param The type of the value returned by the function.
+ * @return A new result.
+ */
+ AsyncResult thenCombine(AsyncResult other, BiFunction fn);
+
+ /**
+ * Returns a new result that, when this result completes exceptionally, completes with the value obtained from
+ * executing the supplied function with this result's exception as an argument. Otherwise, if this result completes
+ * normally, then the returned result also completes normally with the same value.
+ *
+ * @param fn The function to execute.
+ * @return A new result.
+ */
+ AsyncResult exceptionally(Function fn);
+
+ /**
+ * Returns a new result that completes with the same value or exception as this result, after executing the given
+ * action with this result's value or exception.
+ *
+ * Either the value or the exception supplied to the action will be {@code null}.
+ *
+ * @param action The action to execute.
+ * @return A new result.
+ */
+ AsyncResult whenComplete(BiConsumer action);
+
+ /**
+ * Returns a new result that, when this result completes either normally or exceptionally, completes with the value
+ * obtained from executing the supplied function with this result's value and exception as arguments.
+ *
+ * Either the value or the exception supplied to the function will be {@code null}.
+ *
+ * @param fn The function to execute.
+ * @param The type of the value returned from the function.
+ * @return A new result.
+ */
+ AsyncResult handle(BiFunction fn);
+
+ /**
+ * Returns a new completion that, when this result completes either normally or exceptionally, completes after
+ * executing the supplied function with this result's value and exception as arguments.
+ *
+ * Either the value or the exception supplied to the function will be {@code null}.
+ *
+ * @param consumer The consumer to execute.
+ * @return A completion.
+ */
+ AsyncCompletion accept(BiConsumer consumer);
+}
diff --git a/concurrent/src/main/java/net/consensys/cava/concurrent/AtomicSlotMap.java b/concurrent/src/main/java/net/consensys/cava/concurrent/AtomicSlotMap.java
new file mode 100644
index 00000000..53f97b3f
--- /dev/null
+++ b/concurrent/src/main/java/net/consensys/cava/concurrent/AtomicSlotMap.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.concurrent;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import com.google.common.collect.DiscreteDomain;
+
+/**
+ * An atomic map that locates available keys within a {@link DiscreteDomain}.
+ *
+ *
+ * This is an atomic map that will allocate key slots based on availability. It will attempt to keep the range compact
+ * by filling slots as they become available.
+ *
+ * This implementation should be used with small sets, as addition is an O(N) operation.
+ *
+ * @param The type of the map keys.
+ * @param The type of values to store in the map.
+ */
+@SuppressWarnings("rawtypes") // allow ungenerified Comparable types
+public final class AtomicSlotMap {
+ private final DiscreteDomain domain;
+ private final ConcurrentHashMap> slots = new ConcurrentHashMap<>();
+ private final AtomicInteger size = new AtomicInteger(0);
+
+ /**
+ * Create a slot map over the range of integers > 0.
+ *
+ * @param The type of values to store in the map.
+ * @return A new slot map.
+ */
+ public static AtomicSlotMap positiveIntegerSlots() {
+ return new AtomicSlotMap<>(PositiveIntegerDomain.INSTANCE);
+ }
+
+ /**
+ * Create a slot map over the provided domain.
+ *
+ * @param domain The {@link DiscreteDomain} that defines the slots to be used.
+ */
+ public AtomicSlotMap(DiscreteDomain domain) {
+ requireNonNull(domain);
+ this.domain = domain;
+ }
+
+ /**
+ * Add a value to the slot map, using the first available slot.
+ *
+ * @param value The value.
+ * @return The slot that was used to store the value.
+ */
+ public K add(V value) {
+ requireNonNull(value);
+ K slot = domain.minValue();
+ Optional storedValue = Optional.of(value);
+ while (slots.containsKey(slot) || slots.putIfAbsent(slot, storedValue) != null) {
+ slot = domain.next(slot);
+ }
+ size.incrementAndGet();
+ return slot;
+ }
+
+ /**
+ * Put a value into a specific slot.
+ *
+ * @param slot The slot to put the value in.
+ * @param value The value.
+ * @return The previous value in the slot, if present.
+ */
+ public Optional put(K slot, V value) {
+ requireNonNull(slot);
+ requireNonNull(value);
+ Optional previous = slots.put(slot, Optional.of(value));
+ if (previous == null || !previous.isPresent()) {
+ size.incrementAndGet();
+ return Optional.empty();
+ }
+ return previous;
+ }
+
+ /**
+ * Find a slot and compute a value for it.
+ *
+ * @param fn A function to compute the value for a slot.
+ * @return The slot for which the value was computed.
+ */
+ public K compute(Function fn) {
+ requireNonNull(fn);
+ K slot = domain.minValue();
+ // store an empty optional to prevent contention on the slot, then replace with computed value.
+ Optional placeholder = Optional.empty();
+ while (slots.containsKey(slot) || slots.putIfAbsent(slot, placeholder) != null) {
+ slot = domain.next(slot);
+ }
+ try {
+ if (slots.replace(slot, placeholder, Optional.of(fn.apply(slot)))) {
+ size.incrementAndGet();
+ }
+ return slot;
+ } catch (Throwable ex) {
+ slots.remove(slot, placeholder);
+ throw ex;
+ }
+ }
+
+ /**
+ * Find a slot and compute a value for it.
+ *
+ * @param fn A function to compute the value for a slot.
+ * @return A result that will complete with the slot for which the value was computed.
+ */
+ public AsyncResult computeAsync(Function> fn) {
+ requireNonNull(fn);
+ K slot = domain.minValue();
+ // store an empty optional to prevent contention on the slot, then replace with computed value.
+ Optional placeholder = Optional.empty();
+ while (slots.containsKey(slot) || slots.putIfAbsent(slot, placeholder) != null) {
+ slot = domain.next(slot);
+ }
+ K finalSlot = slot;
+ try {
+ return fn.apply(finalSlot).thenApply(value -> {
+ if (slots.replace(finalSlot, placeholder, Optional.of(value))) {
+ size.incrementAndGet();
+ }
+ return finalSlot;
+ });
+ } catch (Throwable ex) {
+ slots.remove(finalSlot, placeholder);
+ throw ex;
+ }
+ }
+
+ /**
+ * Get the value in a slot.
+ *
+ * @param slot The slot.
+ * @return The value, if present.
+ */
+ public Optional get(K slot) {
+ requireNonNull(slot);
+ Optional value = slots.get(slot);
+ if (value == null) {
+ return Optional.empty();
+ }
+ return value;
+ }
+
+ /**
+ * Remove a value from a slot, making the slot available again.
+ *
+ * @param slot The slot.
+ * @return The value that was in the slot, if any.
+ */
+ public Optional remove(K slot) {
+ requireNonNull(slot);
+ Optional previous = slots.remove(slot);
+ if (previous == null) {
+ return Optional.empty();
+ }
+ size.decrementAndGet();
+ return previous;
+ }
+
+ /**
+ * @return The number of slots filled.
+ */
+ public int size() {
+ return size.get();
+ }
+
+ /**
+ * @return A stream over the entries in the slot map.
+ */
+ public Stream> entries() {
+ return slots.entrySet().stream().filter(e -> e.getValue().isPresent()).map(e -> new Map.Entry() {
+ @Override
+ public K getKey() {
+ return e.getKey();
+ }
+
+ @Override
+ public V getValue() {
+ return e.getValue().get();
+ }
+
+ @Override
+ public V setValue(Object value) {
+ throw new UnsupportedOperationException();
+ }
+ });
+ }
+
+ /**
+ * @return A stream over the values stored in the slot map.
+ */
+ public Stream values() {
+ return slots.values().stream().filter(Optional::isPresent).map(Optional::get);
+ }
+
+ private static final class PositiveIntegerDomain extends DiscreteDomain {
+ private static final PositiveIntegerDomain INSTANCE = new PositiveIntegerDomain();
+
+ @Override
+ public Integer next(Integer value) {
+ int i = value;
+ return (i == Integer.MAX_VALUE) ? null : i + 1;
+ }
+
+ @Override
+ public Integer previous(Integer value) {
+ int i = value;
+ return (i == 1) ? null : i - 1;
+ }
+
+ @Override
+ public long distance(Integer start, Integer end) {
+ return (long) end - start;
+ }
+
+ @Override
+ public Integer minValue() {
+ return 1;
+ }
+
+ @Override
+ public Integer maxValue() {
+ return Integer.MAX_VALUE;
+ }
+ }
+}
diff --git a/concurrent/src/main/java/net/consensys/cava/concurrent/CompletableAsyncCompletion.java b/concurrent/src/main/java/net/consensys/cava/concurrent/CompletableAsyncCompletion.java
new file mode 100644
index 00000000..06dff5bd
--- /dev/null
+++ b/concurrent/src/main/java/net/consensys/cava/concurrent/CompletableAsyncCompletion.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.concurrent;
+
+/**
+ * An {@link AsyncCompletion} that can later be completed successfully or with a provided exception.
+ */
+public interface CompletableAsyncCompletion extends AsyncCompletion {
+
+ /**
+ * Complete this completion.
+ *
+ * @return true if this invocation caused this completion to transition to a completed state, else
+ * false.
+ */
+ boolean complete();
+
+ /**
+ * Complete this completion with the given exception.
+ *
+ * @param ex The exception to complete this result with.
+ * @return true if this invocation caused this completion to transition to a completed state, else
+ * false.
+ */
+ boolean completeExceptionally(Throwable ex);
+}
diff --git a/concurrent/src/main/java/net/consensys/cava/concurrent/CompletableAsyncResult.java b/concurrent/src/main/java/net/consensys/cava/concurrent/CompletableAsyncResult.java
new file mode 100644
index 00000000..187fe341
--- /dev/null
+++ b/concurrent/src/main/java/net/consensys/cava/concurrent/CompletableAsyncResult.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.concurrent;
+
+/**
+ * An {@link AsyncResult} that can be later completed successfully with a provided value, or completed with an
+ * exception.
+ *
+ * @param The type of the value returned by this result.
+ */
+public interface CompletableAsyncResult extends AsyncResult {
+
+ /**
+ * Complete this result with the given value.
+ *
+ * @param value The value to complete this result with.
+ * @return true if this invocation caused this result to transition to a completed state, else
+ * false.
+ */
+ boolean complete(T value);
+
+ /**
+ * Complete this result with the given exception.
+ *
+ * @param ex The exception to complete this result with.
+ * @return true if this invocation caused this result to transition to a completed state, else
+ * false.
+ */
+ boolean completeExceptionally(Throwable ex);
+}
diff --git a/concurrent/src/main/java/net/consensys/cava/concurrent/DefaultCompletableAsyncCompletion.java b/concurrent/src/main/java/net/consensys/cava/concurrent/DefaultCompletableAsyncCompletion.java
new file mode 100644
index 00000000..e7da74a0
--- /dev/null
+++ b/concurrent/src/main/java/net/consensys/cava/concurrent/DefaultCompletableAsyncCompletion.java
@@ -0,0 +1,374 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.concurrent;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import io.vertx.core.Vertx;
+import io.vertx.core.WorkerExecutor;
+
+final class DefaultCompletableAsyncCompletion implements CompletableAsyncCompletion {
+
+ private final CompletableFuture future;
+
+ DefaultCompletableAsyncCompletion() {
+ this(new CompletableFuture<>());
+ }
+
+ DefaultCompletableAsyncCompletion(CompletableFuture future) {
+ this.future = future;
+ }
+
+ @Override
+ public boolean complete() {
+ return future.complete(null);
+ }
+
+ @Override
+ public boolean completeExceptionally(Throwable ex) {
+ return future.completeExceptionally(ex);
+ }
+
+ @Override
+ public boolean cancel() {
+ return future.cancel(false);
+ }
+
+ @Override
+ public boolean isDone() {
+ return future.isDone();
+ }
+
+ @Override
+ public boolean isCompletedExceptionally() {
+ return future.isCompletedExceptionally();
+ }
+
+ @Override
+ public boolean isCancelled() {
+ return future.isCancelled();
+ }
+
+ @Override
+ public void join() throws CompletionException, InterruptedException {
+ try {
+ join(10, TimeUnit.SECONDS);
+ } catch (TimeoutException ex) {
+ throw new RuntimeException("Default timeout triggered for blocking call to AsyncCompletion::join()", ex);
+ }
+ }
+
+ @Override
+ public void join(long timeout, TimeUnit unit) throws CompletionException, TimeoutException, InterruptedException {
+ requireNonNull(unit);
+ try {
+ future.get(timeout, unit);
+ } catch (ExecutionException ex) {
+ throw new CompletionException(ex.getMessage(), ex.getCause());
+ }
+ }
+
+ @Override
+ public AsyncResult then(Supplier> fn) {
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ future.whenComplete((v, ex1) -> {
+ if (ex1 == null) {
+ try {
+ fn.get().whenComplete((u, ex3) -> {
+ if (ex3 == null) {
+ asyncResult.complete(u);
+ } else {
+ asyncResult.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ asyncResult.completeExceptionally(ex2);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ @Override
+ public AsyncResult thenSchedule(Vertx vertx, Supplier> fn) {
+ requireNonNull(vertx);
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ future.whenComplete((v, ex1) -> {
+ if (ex1 == null) {
+ try {
+ vertx.runOnContext(ev -> {
+ try {
+ fn.get().whenComplete((u, ex4) -> {
+ if (ex4 == null) {
+ asyncResult.complete(u);
+ } else {
+ asyncResult.completeExceptionally(ex4);
+ }
+ });
+ } catch (Throwable ex3) {
+ asyncResult.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ asyncResult.completeExceptionally(ex2);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ @Override
+ public AsyncCompletion thenCompose(Supplier fn) {
+ requireNonNull(fn);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ future.whenComplete((v, ex1) -> {
+ if (ex1 == null) {
+ try {
+ fn.get().whenComplete(ex3 -> {
+ if (ex3 == null) {
+ completion.complete();
+ } else {
+ completion.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncCompletion thenRun(Runnable action) {
+ requireNonNull(action);
+ return new DefaultCompletableAsyncCompletion(future.thenRun(action));
+ }
+
+ @Override
+ public AsyncCompletion thenScheduleRun(Vertx vertx, Runnable runnable) {
+ requireNonNull(vertx);
+ requireNonNull(runnable);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ vertx.runOnContext(ev -> {
+ try {
+ runnable.run();
+ } catch (Throwable ex3) {
+ completion.completeExceptionally(ex3);
+ return;
+ }
+ completion.complete();
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncCompletion thenScheduleBlockingRun(Vertx vertx, Runnable runnable) {
+ requireNonNull(vertx);
+ requireNonNull(runnable);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ vertx.executeBlocking(vertxFuture -> {
+ runnable.run();
+ vertxFuture.complete(null);
+ }, false, res -> {
+ if (res.succeeded()) {
+ completion.complete();
+ } else {
+ completion.completeExceptionally(res.cause());
+ }
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncCompletion thenScheduleBlockingRun(WorkerExecutor executor, Runnable runnable) {
+ requireNonNull(executor);
+ requireNonNull(runnable);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ executor.executeBlocking(vertxFuture -> {
+ runnable.run();
+ vertxFuture.complete(null);
+ }, false, res -> {
+ if (res.succeeded()) {
+ completion.complete();
+ } else {
+ completion.completeExceptionally(res.cause());
+ }
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncResult thenSupply(Supplier supplier) {
+ requireNonNull(supplier);
+ return new DefaultCompletableAsyncResult<>(future.thenApply(v -> supplier.get()));
+ }
+
+ @Override
+ public AsyncResult thenSupply(Vertx vertx, Supplier supplier) {
+ requireNonNull(vertx);
+ requireNonNull(supplier);
+ CompletableAsyncResult completion = AsyncResult.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ vertx.runOnContext(ev -> {
+ try {
+ completion.complete(supplier.get());
+ } catch (Throwable ex3) {
+ completion.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncCompletion thenConsume(AsyncResult other, Consumer consumer) {
+ requireNonNull(other);
+ requireNonNull(consumer);
+ return new DefaultCompletableAsyncCompletion(future.thenAccept(v -> other.thenAccept(consumer::accept)));
+ }
+
+ @Override
+ public AsyncResult thenApply(AsyncResult other, Function fn) {
+ requireNonNull(other);
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ future.whenComplete((v, ex1) -> {
+ if (ex1 == null) {
+ try {
+ other.whenComplete((u, ex3) -> {
+ if (ex3 == null) {
+ asyncResult.complete(fn.apply(u));
+ } else {
+ asyncResult.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ asyncResult.completeExceptionally(ex2);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ @Override
+ public AsyncCompletion thenCombine(AsyncCompletion other) {
+ requireNonNull(other);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ future.whenComplete((v, ex1) -> {
+ if (ex1 == null) {
+ try {
+ other.whenComplete(ex3 -> {
+ if (ex3 == null) {
+ completion.complete();
+ } else {
+ completion.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncCompletion exceptionally(Consumer consumer) {
+ requireNonNull(consumer);
+ return new DefaultCompletableAsyncCompletion(future.exceptionally(ex -> {
+ consumer.accept(ex);
+ return null;
+ }));
+ }
+
+ @Override
+ public AsyncCompletion whenComplete(Consumer consumer) {
+ requireNonNull(consumer);
+ return new DefaultCompletableAsyncCompletion(future.whenComplete((v, ex) -> consumer.accept(ex)));
+ }
+
+ @Override
+ public AsyncResult handle(Function fn) {
+ requireNonNull(fn);
+ return new DefaultCompletableAsyncResult<>(future.handle((v, ex) -> fn.apply(ex)));
+ }
+
+ @Override
+ public AsyncCompletion accept(Consumer consumer) {
+ requireNonNull(consumer);
+ return new DefaultCompletableAsyncCompletion(future.handle((v, ex) -> {
+ consumer.accept(ex);
+ return null;
+ }));
+ }
+}
diff --git a/concurrent/src/main/java/net/consensys/cava/concurrent/DefaultCompletableAsyncResult.java b/concurrent/src/main/java/net/consensys/cava/concurrent/DefaultCompletableAsyncResult.java
new file mode 100644
index 00000000..9b431a2c
--- /dev/null
+++ b/concurrent/src/main/java/net/consensys/cava/concurrent/DefaultCompletableAsyncResult.java
@@ -0,0 +1,406 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.concurrent;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import io.vertx.core.Vertx;
+import io.vertx.core.WorkerExecutor;
+
+final class DefaultCompletableAsyncResult implements CompletableAsyncResult {
+
+ private final CompletableFuture future;
+
+ DefaultCompletableAsyncResult() {
+ this(new CompletableFuture<>());
+ }
+
+ DefaultCompletableAsyncResult(CompletableFuture future) {
+ this.future = future;
+ }
+
+ @Override
+ public boolean complete(T value) {
+ return future.complete(value);
+ }
+
+ @Override
+ public boolean completeExceptionally(Throwable ex) {
+ return future.completeExceptionally(ex);
+ }
+
+ @Override
+ public boolean cancel() {
+ return future.cancel(false);
+ }
+
+ @Override
+ public boolean isDone() {
+ return future.isDone();
+ }
+
+ @Override
+ public boolean isCompletedExceptionally() {
+ return future.isCompletedExceptionally();
+ }
+
+ @Override
+ public boolean isCancelled() {
+ return future.isCancelled();
+ }
+
+ @Override
+ public T get() throws CompletionException, InterruptedException {
+ try {
+ return get(10, TimeUnit.SECONDS);
+ } catch (TimeoutException ex) {
+ throw new RuntimeException("Default timeout triggered for blocking call to AsyncResult::get()", ex);
+ }
+ }
+
+ @Override
+ public T get(long timeout, TimeUnit unit) throws CompletionException, TimeoutException, InterruptedException {
+ requireNonNull(unit);
+ try {
+ return future.get(timeout, unit);
+ } catch (ExecutionException ex) {
+ throw new CompletionException(ex.getMessage(), ex.getCause());
+ }
+ }
+
+ @Override
+ public AsyncResult then(Function> fn) {
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ fn.apply(t).whenComplete((u, ex3) -> {
+ if (ex3 == null) {
+ asyncResult.complete(u);
+ } else {
+ asyncResult.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ asyncResult.completeExceptionally(ex2);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ @Override
+ public AsyncResult thenSchedule(Vertx vertx, Function> fn) {
+ requireNonNull(vertx);
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ vertx.runOnContext(ev -> {
+ try {
+ fn.apply(t).whenComplete((u, ex4) -> {
+ if (ex4 == null) {
+ asyncResult.complete(u);
+ } else {
+ asyncResult.completeExceptionally(ex4);
+ }
+ });
+ } catch (Throwable ex3) {
+ asyncResult.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ asyncResult.completeExceptionally(ex2);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ @Override
+ public AsyncCompletion thenCompose(Function fn) {
+ requireNonNull(fn);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ fn.apply(t).whenComplete(ex3 -> {
+ if (ex3 == null) {
+ completion.complete();
+ } else {
+ completion.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncCompletion thenRun(Runnable action) {
+ requireNonNull(action);
+ return new DefaultCompletableAsyncCompletion(future.thenRun(action));
+ }
+
+ @Override
+ public AsyncCompletion thenScheduleRun(Vertx vertx, Runnable runnable) {
+ requireNonNull(vertx);
+ requireNonNull(runnable);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ vertx.runOnContext(ev -> {
+ try {
+ runnable.run();
+ } catch (Throwable ex3) {
+ completion.completeExceptionally(ex3);
+ return;
+ }
+ completion.complete();
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncCompletion thenScheduleBlockingRun(Vertx vertx, Runnable runnable) {
+ requireNonNull(vertx);
+ requireNonNull(runnable);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ vertx.executeBlocking(vertxFuture -> {
+ runnable.run();
+ vertxFuture.complete(null);
+ }, false, res -> {
+ if (res.succeeded()) {
+ completion.complete();
+ } else {
+ completion.completeExceptionally(res.cause());
+ }
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncCompletion thenScheduleBlockingRun(WorkerExecutor executor, Runnable runnable) {
+ requireNonNull(executor);
+ requireNonNull(runnable);
+ CompletableAsyncCompletion completion = AsyncCompletion.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ executor.executeBlocking(vertxFuture -> {
+ runnable.run();
+ vertxFuture.complete(null);
+ }, false, res -> {
+ if (res.succeeded()) {
+ completion.complete();
+ } else {
+ completion.completeExceptionally(res.cause());
+ }
+ });
+ } catch (Throwable ex2) {
+ completion.completeExceptionally(ex2);
+ }
+ } else {
+ completion.completeExceptionally(ex1);
+ }
+ });
+ return completion;
+ }
+
+ @Override
+ public AsyncResult thenApply(Function fn) {
+ requireNonNull(fn);
+ return new DefaultCompletableAsyncResult<>(future.thenApply(fn));
+ }
+
+ @Override
+ public AsyncResult thenScheduleApply(Vertx vertx, Function fn) {
+ requireNonNull(vertx);
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ vertx.runOnContext(ev -> {
+ try {
+ asyncResult.complete(fn.apply(t));
+ } catch (Throwable ex3) {
+ asyncResult.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ asyncResult.completeExceptionally(ex2);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ @Override
+ public AsyncResult thenScheduleBlockingApply(Vertx vertx, Function fn) {
+ requireNonNull(vertx);
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ vertx.executeBlocking(vertxFuture -> vertxFuture.complete(fn.apply(t)), false, res -> {
+ if (res.succeeded()) {
+ asyncResult.complete(res.result());
+ } else {
+ asyncResult.completeExceptionally(res.cause());
+ }
+ });
+ } catch (Throwable ex2) {
+ asyncResult.completeExceptionally(ex2);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ @Override
+ public AsyncResult thenScheduleBlockingApply(WorkerExecutor executor, Function fn) {
+ requireNonNull(executor);
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ executor.executeBlocking(vertxFuture -> vertxFuture.complete(fn.apply(t)), false, res -> {
+ if (res.succeeded()) {
+ asyncResult.complete(res.result());
+ } else {
+ asyncResult.completeExceptionally(res.cause());
+ }
+ });
+ } catch (Throwable ex2) {
+ asyncResult.completeExceptionally(ex2);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ @Override
+ public AsyncCompletion thenAccept(Consumer consumer) {
+ requireNonNull(consumer);
+ return new DefaultCompletableAsyncCompletion(future.thenAccept(consumer));
+ }
+
+ @Override
+ public AsyncCompletion thenAcceptBoth(AsyncResult other, BiConsumer consumer) {
+ requireNonNull(other);
+ requireNonNull(consumer);
+ return new DefaultCompletableAsyncCompletion(future.thenAccept(t -> other.thenAccept(u -> consumer.accept(t, u))));
+ }
+
+ @Override
+ public AsyncResult thenCombine(
+ AsyncResult other,
+ BiFunction fn) {
+ requireNonNull(other);
+ requireNonNull(fn);
+ CompletableAsyncResult asyncResult = AsyncResult.incomplete();
+ future.whenComplete((t, ex1) -> {
+ if (ex1 == null) {
+ try {
+ other.whenComplete((u, ex3) -> {
+ if (ex3 == null) {
+ asyncResult.complete(fn.apply(t, u));
+ } else {
+ asyncResult.completeExceptionally(ex3);
+ }
+ });
+ } catch (Throwable ex2) {
+ asyncResult.completeExceptionally(ex2);
+ }
+ } else {
+ asyncResult.completeExceptionally(ex1);
+ }
+ });
+ return asyncResult;
+ }
+
+ @Override
+ public AsyncResult exceptionally(Function fn) {
+ requireNonNull(fn);
+ return new DefaultCompletableAsyncResult<>(future.exceptionally(fn::apply));
+ }
+
+ @Override
+ public AsyncResult whenComplete(BiConsumer action) {
+ requireNonNull(action);
+ return new DefaultCompletableAsyncResult<>(future.whenComplete(action::accept));
+ }
+
+ @Override
+ public AsyncResult handle(BiFunction fn) {
+ requireNonNull(fn);
+ return new DefaultCompletableAsyncResult<>(future.handle(fn::apply));
+ }
+
+ @Override
+ public AsyncCompletion accept(BiConsumer consumer) {
+ requireNonNull(consumer);
+ return new DefaultCompletableAsyncCompletion(future.handle((t, ex) -> {
+ consumer.accept(t, ex);
+ return null;
+ }));
+ }
+}
diff --git a/concurrent/src/main/java/net/consensys/cava/concurrent/ExpiringMap.java b/concurrent/src/main/java/net/consensys/cava/concurrent/ExpiringMap.java
new file mode 100644
index 00000000..5449cb10
--- /dev/null
+++ b/concurrent/src/main/java/net/consensys/cava/concurrent/ExpiringMap.java
@@ -0,0 +1,261 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+package net.consensys.cava.concurrent;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.function.LongSupplier;
+import java.util.stream.Collectors;
+
+import com.google.common.annotations.VisibleForTesting;
+
+/**
+ * A concurrent hash map that stores values along with an expiry.
+ *
+ * Values are stored in the map until their expiry is reached, after which they will no longer be available and will
+ * appear as if removed. The actual removal is done lazily whenever the map is accessed, or when the
+ * {@link #purgeExpired()} method is invoked.
+ *
+ * @param The key type.
+ * @param The value type.
+ */
+public final class ExpiringMap implements Map {
+
+ private static final long MAX_EXPIRY = Long.MAX_VALUE;
+
+ // Uses object equality, to ensure uniqueness as a value in the storage map
+ private static final class ExpiringEntry implements Comparable> {
+ private K key;
+ private V value;
+ private long expiry;
+
+ ExpiringEntry(K key, V value, long expiry) {
+ this.key = key;
+ this.value = value;
+ this.expiry = expiry;
+ }
+
+ @Override
+ public int compareTo(ExpiringEntry o) {
+ return Long.compare(expiry, o.expiry);
+ }
+ }
+
+ private final ConcurrentHashMap> storage = new ConcurrentHashMap<>();
+ private final PriorityBlockingQueue> expiryQueue = new PriorityBlockingQueue<>();
+ private final LongSupplier currentTimeSupplier;
+
+ /**
+ * Construct an empty map.
+ */
+ public ExpiringMap() {
+ this(System::currentTimeMillis);
+ }
+
+ @VisibleForTesting
+ ExpiringMap(LongSupplier currentTimeSupplier) {
+ this.currentTimeSupplier = currentTimeSupplier;
+ }
+
+ @Override
+ public V get(Object key) {
+ requireNonNull(key);
+ purgeExpired();
+ ExpiringEntry entry = storage.get(key);
+ return (entry == null) ? null : entry.value;
+ }
+
+ @Override
+ public boolean containsKey(Object key) {
+ requireNonNull(key);
+ purgeExpired();
+ return storage.containsKey(key);
+ }
+
+ @Override
+ public boolean containsValue(Object value) {
+ requireNonNull(value);
+ purgeExpired();
+ return storage.values().stream().anyMatch(e -> e.value.equals(value));
+ }
+
+ @Override
+ public int size() {
+ purgeExpired();
+ return storage.size();
+ }
+
+ @Override
+ public boolean isEmpty() {
+ purgeExpired();
+ return storage.isEmpty();
+ }
+
+ @Override
+ public V put(K key, V value) {
+ requireNonNull(key);
+ requireNonNull(value);
+ purgeExpired();
+ ExpiringEntry oldEntry = storage.put(key, new ExpiringEntry<>(key, value, MAX_EXPIRY));
+ return (oldEntry == null) ? null : oldEntry.value;
+ }
+
+ /**
+ * Associates the specified value with the specified key in this map, and expires the entry when the specified expiry
+ * time is reached. If the map previously contained a mapping for the key, the old value is replaced by the specified
+ * value.
+ *
+ * @param key The key with which the specified value is to be associated.
+ * @param value The value to be associated with the specified key.
+ * @param expiry The expiry time for the value, in milliseconds since the epoch.
+ * @return The previous value associated with {@code key}, or {@code null} if there was no mapping for {@code key}.
+ */
+ public synchronized V put(K key, V value, long expiry) {
+ requireNonNull(key);
+ requireNonNull(value);
+ if (expiry >= MAX_EXPIRY) {
+ return put(key, value);
+ }
+
+ long now = currentTimeSupplier.getAsLong();
+ if (expiry <= now) {
+ return remove(key);
+ }
+
+ purgeExpired(now);
+ ExpiringEntry newEntry = new ExpiringEntry<>(key, value, expiry);
+ ExpiringEntry oldEntry = storage.put(key, newEntry);
+ expiryQueue.offer(newEntry);
+ return (oldEntry == null) ? null : oldEntry.value;
+ }
+
+ @Override
+ public void putAll(Map m) {
+ requireNonNull(m);
+ purgeExpired();
+ for (Map.Entry e : m.entrySet()) {
+ storage.put(e.getKey(), new ExpiringEntry<>(e.getKey(), e.getValue(), MAX_EXPIRY));
+ }
+ }
+
+ @Override
+ public V remove(Object key) {
+ requireNonNull(key);
+ purgeExpired();
+ ExpiringEntry entry = storage.remove(key);
+ if (entry == null) {
+ return null;
+ }
+ if (entry.expiry < MAX_EXPIRY) {
+ expiryQueue.remove(entry);
+ }
+ return entry.value;
+ }
+
+ @Override
+ public synchronized boolean remove(Object key, Object value) {
+ requireNonNull(key);
+ requireNonNull(value);
+ purgeExpired();
+ ExpiringEntry entry = storage.get(key);
+ if (entry == null || !value.equals(entry.value)) {
+ return false;
+ }
+ storage.remove(key);
+ if (entry.expiry < MAX_EXPIRY) {
+ expiryQueue.remove(entry);
+ }
+ return true;
+ }
+
+ @Override
+ public synchronized void clear() {
+ expiryQueue.clear();
+ storage.clear();
+ }
+
+ @Override
+ public Set keySet() {
+ purgeExpired();
+ return storage.keySet();
+ }
+
+ @Override
+ public Collection values() {
+ purgeExpired();
+ return storage.values().stream().map(e -> e.value).collect(Collectors.toList());
+ }
+
+ @Override
+ public Set> entrySet() {
+ purgeExpired();
+ return storage.entrySet().stream().map(e -> new Map.Entry() {
+ @Override
+ public K getKey() {
+ return e.getKey();
+ }
+
+ @Override
+ public V getValue() {
+ return e.getValue().value;
+ }
+
+ @Override
+ public V setValue(V value) {
+ throw new UnsupportedOperationException();
+ }
+ }).collect(Collectors.toSet());
+ }
+
+ /**
+ * Force immediate expiration of any key/value pairs that have reached their expiry.
+ */
+ public void purgeExpired() {
+ purgeExpired(currentTimeSupplier.getAsLong());
+ }
+
+ private synchronized void purgeExpired(long oldest) {
+ ExpiringEntry head;
+ while ((head = expiryQueue.peek()) != null && head.expiry <= oldest) {
+ // only remove if it's still mapped to the same entry (object equality is used)
+ storage.remove(head.key, head);
+ expiryQueue.remove();
+ }
+ }
+
+ @SuppressWarnings("rawtypes")
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == null) {
+ return false;
+ }
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof ExpiringMap)) {
+ return false;
+ }
+ ExpiringMap other = (ExpiringMap) obj;
+ return storage.equals(other.storage);
+ }
+
+ @Override
+ public int hashCode() {
+ return storage.hashCode();
+ }
+}
diff --git a/concurrent/src/main/java/net/consensys/cava/concurrent/package-info.java b/concurrent/src/main/java/net/consensys/cava/concurrent/package-info.java
new file mode 100644
index 00000000..136ab2bb
--- /dev/null
+++ b/concurrent/src/main/java/net/consensys/cava/concurrent/package-info.java
@@ -0,0 +1,11 @@
+/**
+ * Classes and utilities for working with concurrency.
+ *
+ *
+ * These classes are included in the standard Cava distribution, or separately when using the gradle dependency
+ * 'net.consensys.cava:cava-concurrent' (cava-concurrent.jar).
+ */
+@ParametersAreNonnullByDefault
+package net.consensys.cava.concurrent;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/concurrent/src/main/kotlin/net/consensys/cava/concurrent/coroutines/experimental/AsyncCompletion.kt b/concurrent/src/main/kotlin/net/consensys/cava/concurrent/coroutines/experimental/AsyncCompletion.kt
new file mode 100644
index 00000000..c698e26f
--- /dev/null
+++ b/concurrent/src/main/kotlin/net/consensys/cava/concurrent/coroutines/experimental/AsyncCompletion.kt
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.consensys.cava.concurrent.coroutines.experimental
+
+import kotlinx.coroutines.experimental.CancellableContinuation
+import kotlinx.coroutines.experimental.CommonPool
+import kotlinx.coroutines.experimental.CompletableDeferred
+import kotlinx.coroutines.experimental.CoroutineDispatcher
+import kotlinx.coroutines.experimental.CoroutineScope
+import kotlinx.coroutines.experimental.CoroutineStart
+import kotlinx.coroutines.experimental.DefaultDispatcher
+import kotlinx.coroutines.experimental.Deferred
+import kotlinx.coroutines.experimental.Job
+import kotlinx.coroutines.experimental.newCoroutineContext
+import kotlinx.coroutines.experimental.suspendCancellableCoroutine
+import net.consensys.cava.concurrent.AsyncCompletion
+import net.consensys.cava.concurrent.CompletableAsyncCompletion
+import java.util.concurrent.CancellationException
+import java.util.concurrent.CompletionException
+import java.util.function.Consumer
+import kotlin.coroutines.experimental.Continuation
+import kotlin.coroutines.experimental.ContinuationInterceptor
+import kotlin.coroutines.experimental.CoroutineContext
+
+/**
+ * Starts new coroutine and returns its result as an [AsyncCompletion].
+ *
+ * This coroutine builder uses [CommonPool] context by default and is conceptually similar to
+ * [AsyncCompletion.executeBlocking].
+ *
+ * The running coroutine is cancelled when the [AsyncCompletion] is cancelled or otherwise completed.
+ *
+ * The [context] for the new coroutine can be explicitly specified. See [CoroutineDispatcher] for the standard context
+ * implementations that are provided by `kotlinx.coroutines`. The [context][CoroutineScope.coroutineContext] of the
+ * parent coroutine from its [scope][CoroutineScope] may be used, in which case the [Job] of the resulting coroutine is
+ * a child of the job of the parent coroutine. The parent job may be also explicitly specified using [parent]
+ * parameter.
+ *
+ * If the context does not have any dispatcher nor any other [ContinuationInterceptor], then [DefaultDispatcher] is
+ * used.
+ *
+ * By default, the coroutine is immediately scheduled for execution. Other options can be specified via `start`
+ * parameter. See [CoroutineStart] for details. A value of [CoroutineStart.LAZY] is not supported (since
+ * [AsyncCompletion] does not provide the corresponding capability) and produces [IllegalArgumentException].
+ *
+ * See [newCoroutineContext] for a description of debugging facilities that are available for newly created coroutine.
+ *
+ * @param context context of the coroutine. The default value is [DefaultDispatcher].
+ * @param start coroutine start option. The default value is [CoroutineStart.DEFAULT].
+ * @param parent explicitly specifies the parent job, overrides job from the [context] (if any).
+ * @param block the coroutine code.
+ */
+fun asyncCompletion(
+ context: CoroutineContext = DefaultDispatcher,
+ start: CoroutineStart = CoroutineStart.DEFAULT,
+ parent: Job? = null,
+ block: suspend CoroutineScope.() -> Unit
+): AsyncCompletion {
+ require(!start.isLazy) { "$start start is not supported" }
+ val newContext = newCoroutineContext(context, parent)
+ val job = Job(newContext[Job])
+ val coroutine = AsyncCompletionCoroutine(newContext + job)
+ job.invokeOnCompletion { coroutine.completion.cancel() }
+ coroutine.completion.whenComplete { exception -> job.cancel(exception) }
+ start(block, receiver = coroutine, completion = coroutine) // use the specified start strategy
+ return coroutine.completion
+}
+
+private class AsyncCompletionCoroutine(
+ override val context: CoroutineContext,
+ val completion: CompletableAsyncCompletion = AsyncCompletion.incomplete()
+) : Continuation, CoroutineScope {
+ override val coroutineContext: CoroutineContext get() = context
+ override val isActive: Boolean get() = context[Job]!!.isActive
+ override fun resume(value: Unit) {
+ completion.complete()
+ }
+
+ override fun resumeWithException(exception: Throwable) {
+ completion.completeExceptionally(exception)
+ }
+}
+
+/**
+ * Converts this deferred value to a [AsyncCompletion].
+ * The deferred value is cancelled when the returned [AsyncCompletion] is cancelled or otherwise completed.
+ */
+fun Deferred.asAsyncCompletion(): AsyncCompletion {
+ val asyncCompletion = AsyncCompletion.incomplete()
+ asyncCompletion.whenComplete { exception -> cancel(exception) }
+ invokeOnCompletion {
+ try {
+ asyncCompletion.complete()
+ } catch (exception: Exception) {
+ asyncCompletion.completeExceptionally(exception)
+ }
+ }
+ return asyncCompletion
+}
+
+/**
+ * Converts this job to a [AsyncCompletion].
+ * The job is cancelled when the returned [AsyncCompletion] is cancelled or otherwise completed.
+ */
+fun Job.asAsyncCompletion(): AsyncCompletion {
+ val asyncCompletion = AsyncCompletion.incomplete()
+ asyncCompletion.whenComplete { exception -> cancel(exception) }
+ invokeOnCompletion {
+ try {
+ asyncCompletion.complete()
+ } catch (exception: Exception) {
+ asyncCompletion.completeExceptionally(exception)
+ }
+ }
+ return asyncCompletion
+}
+
+/**
+ * Converts this [AsyncCompletion] to an instance of [Deferred].
+ * The [AsyncCompletion] is cancelled when the resulting deferred is cancelled.
+ */
+fun AsyncCompletion.asDeferred(): Deferred {
+ // Fast path if already completed
+ if (isDone) {
+ return try {
+ CompletableDeferred(join())
+ } catch (e: Throwable) {
+ // unwrap original cause from CompletionException
+ val original = (e as? CompletionException)?.cause ?: e
+ CompletableDeferred().also { it.completeExceptionally(original) }
+ }
+ }
+ val result = CompletableDeferred()
+ whenComplete { exception ->
+ if (exception == null) {
+ result.complete(Unit)
+ } else {
+ result.completeExceptionally(exception)
+ }
+ }
+ result.invokeOnCompletion { this.cancel() }
+ return result
+}
+
+/**
+ * Awaits for completion of the [AsyncCompletion] without blocking a thread.
+ *
+ * This suspending function is cancellable. If the [Job] of the current coroutine is cancelled or completed while this
+ * suspending function is waiting, this function stops waiting for the [AsyncCompletion] and immediately resumes with
+ * [CancellationException].
+ *
+ * Note, that [AsyncCompletion] does not support prompt removal of listeners, so on cancellation of this wait a few
+ * small objects will remain in the [AsyncCompletion] stack of completion actions until it completes itself. However,
+ * care is taken to clear the reference to the waiting coroutine itself, so that its memory can be released even if the
+ * [AsyncCompletion] never completes.
+ */
+suspend fun AsyncCompletion.await() {
+ // fast path when CompletableFuture is already done (does not suspend)
+ if (isDone) {
+ try {
+ return join()
+ } catch (e: CompletionException) {
+ throw e.cause ?: e // unwrap original cause from CompletionException
+ }
+ }
+ // slow path -- suspend
+ return suspendCancellableCoroutine { cont: CancellableContinuation ->
+ val consumer = ContinuationConsumer(cont)
+ whenComplete(consumer)
+ cont.invokeOnCancellation {
+ consumer.cont = null // shall clear reference to continuation
+ }
+ }
+}
+
+private class ContinuationConsumer(
+ @Volatile @JvmField var cont: Continuation?
+) : Consumer {
+ override fun accept(exception: Throwable?) {
+ val cont = this.cont ?: return // atomically read current value unless null
+ if (exception == null) // the future has been completed normally
+ cont.resume(Unit)
+ else // the future has completed with an exception
+ cont.resumeWithException(exception)
+ }
+}
diff --git a/concurrent/src/main/kotlin/net/consensys/cava/concurrent/coroutines/experimental/AsyncResult.kt b/concurrent/src/main/kotlin/net/consensys/cava/concurrent/coroutines/experimental/AsyncResult.kt
new file mode 100644
index 00000000..b3064ec8
--- /dev/null
+++ b/concurrent/src/main/kotlin/net/consensys/cava/concurrent/coroutines/experimental/AsyncResult.kt
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2018, ConsenSys Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.consensys.cava.concurrent.coroutines.experimental
+
+import kotlinx.coroutines.experimental.CancellableContinuation
+import kotlinx.coroutines.experimental.CommonPool
+import kotlinx.coroutines.experimental.CompletableDeferred
+import kotlinx.coroutines.experimental.CoroutineDispatcher
+import kotlinx.coroutines.experimental.CoroutineScope
+import kotlinx.coroutines.experimental.CoroutineStart
+import kotlinx.coroutines.experimental.DefaultDispatcher
+import kotlinx.coroutines.experimental.Deferred
+import kotlinx.coroutines.experimental.Job
+import kotlinx.coroutines.experimental.newCoroutineContext
+import kotlinx.coroutines.experimental.suspendCancellableCoroutine
+import net.consensys.cava.concurrent.AsyncResult
+import net.consensys.cava.concurrent.CompletableAsyncResult
+import java.util.concurrent.CancellationException
+import java.util.concurrent.CompletionException
+import java.util.function.BiConsumer
+import kotlin.coroutines.experimental.Continuation
+import kotlin.coroutines.experimental.ContinuationInterceptor
+import kotlin.coroutines.experimental.CoroutineContext
+
+/**
+ * Starts new coroutine and returns its result as an [AsyncResult].
+ *
+ * This coroutine builder uses [CommonPool] context by default and is conceptually similar to
+ * [AsyncResult.executeBlocking].
+ *
+ * The running coroutine is cancelled when the [AsyncResult] is cancelled or otherwise completed.
+ *
+ * The [context] for the new coroutine can be explicitly specified. See [CoroutineDispatcher] for the standard context
+ * implementations that are provided by `kotlinx.coroutines`. The [context][CoroutineScope.coroutineContext] of the
+ * parent coroutine from its [scope][CoroutineScope] may be used, in which case the [Job] of the resulting coroutine is
+ * a child of the job of the parent coroutine. The parent job may be also explicitly specified using [parent]
+ * parameter.
+ *
+ * If the context does not have any dispatcher nor any other [ContinuationInterceptor], then [DefaultDispatcher] is
+ * used.
+ *
+ * By default, the coroutine is immediately scheduled for execution. Other options can be specified via `start`
+ * parameter. See [CoroutineStart] for details. A value of [CoroutineStart.LAZY] is not supported (since [AsyncResult]
+ * does not provide the corresponding capability) and produces [IllegalArgumentException].
+ *
+ * See [newCoroutineContext] for a description of debugging facilities that are available for newly created coroutine.
+ *
+ * @param context context of the coroutine. The default value is [DefaultDispatcher].
+ * @param start coroutine start option. The default value is [CoroutineStart.DEFAULT].
+ * @param parent explicitly specifies the parent job, overrides job from the [context] (if any).
+ * @param block the coroutine code.
+ */
+fun asyncResult(
+ context: CoroutineContext = DefaultDispatcher,
+ start: CoroutineStart = CoroutineStart.DEFAULT,
+ parent: Job? = null,
+ block: suspend CoroutineScope.() -> T
+): AsyncResult {
+ require(!start.isLazy) { "$start start is not supported" }
+ val newContext = newCoroutineContext(context, parent)
+ val job = Job(newContext[Job])
+ val coroutine = AsyncResultCoroutine(newContext + job)
+ job.invokeOnCompletion { coroutine.result.cancel() }
+ coroutine.result.whenComplete { _, exception -> job.cancel(exception) }
+ start(block, receiver = coroutine, completion = coroutine) // use the specified start strategy
+ return coroutine.result
+}
+
+private class AsyncResultCoroutine(
+ override val context: CoroutineContext,
+ val result: CompletableAsyncResult = AsyncResult.incomplete()
+) : Continuation, CoroutineScope {
+ override val coroutineContext: CoroutineContext get() = context
+ override val isActive: Boolean get() = context[Job]!!.isActive
+ override fun resume(value: T) {
+ result.complete(value)
+ }
+
+ override fun resumeWithException(exception: Throwable) {
+ result.completeExceptionally(exception)
+ }
+}
+
+/**
+ * Converts this deferred value to an [AsyncResult].
+ * The deferred value is cancelled when the returned [AsyncResult] is cancelled or otherwise completed.
+ */
+fun Deferred.asAsyncResult(): AsyncResult {
+ val asyncResult = AsyncResult.incomplete