Bond

Linux

Bond must be built with C++11 compiler. We test with Clang (3.8) and GNU C++ (5.4). We recommend Clang as it’s faster with template-heavy code like Bond.

Run the following commands to install the minimal set of packages needed to build the core Bond library on Ubuntu 14.04:

sudo apt-get install \
    clang \
    cmake \
    zlib1g-dev \
    libboost-dev \
    libboost-thread-dev

Additionally, you need the Haskell Tool Stack. If your distro isn’t shipping a new enough version of it, you may encounter some non-obvious build failures, so we recommend installing the latest Stack outside of package management:

curl -sSL https://get.haskellstack.org/ | sh

In the root bond directory run:

mkdir build
cd build
cmake ..
make
sudo make install

The build directory is just an example. Any directory can be used as the build destination.

To build the Bond Python module and all the C++/Python tests and examples, a few more packages are needed.

sudo apt-get install \
    autoconf \
    build-essential \
    libboost-date-time-dev \
    libboost-python-dev \
    libboost-test-dev \
    libtool \
    python2.7-dev

CMake needs to be re-run with different options. This can be done after building just the core libraries: the build tree will simply be updated with the new options.

cd build # or wherever you ran CMake before

Running the following command in the build directory will build and execute all the tests and examples:

make --jobs 8 check
sudo make install # To install the other libraries just built

(The unit tests are large so you may want to run 4-8 build jobs in parallel, assuming you have enough memory.)

Windows

Install the following tools:

Visual Studio 2017 or newer. The following components are required:
- .NET Framework 4.6.2 targeting pack
- C++ development tools. A working C++ compiler is needed to build gbc.
.NET SDK (https://dotnet.microsoft.com/en-us/download)
CMake (http://www.cmake.org/download/)
Haskell Stack (https://docs.haskellstack.org/en/stable/install_and_upgrade/#windows)

If you are building on a network behind a proxy, set the environment variable HTTP_PROXY, e.g.:

set HTTP_PROXY=http://your-proxy-name:80

Now you are ready to build the C# version of Bond. Open the solution file cs\cs.sln in Visual Studio and build as usual. The C# unit tests can also be run from within the solution.

To build using the .NET SDK:

dotnet restore cs\cs.sln
dotnet msbuild cs\cs.sln

The C++ and Python versions of Bond additionally require:

Boost 1.61+ (http://www.boost.org/users/download/)
Python 2.7 (https://www.python.org/downloads/)

You may need to set the environment variables BOOST_ROOT and BOOST_LIBRARYDIR to specify where Boost and its pre-built libraries for your environment (MSVC 12 or MSVC 14) can be found, e.g.:

set BOOST_ROOT=D:\boost_1_61_0
set BOOST_LIBRARYDIR=D:\boost_1_61_0\lib64-msvc-14.0

The core Bond library and most examples only require Boost headers. The pre-built libraries are only needed for unit tests, and Python. If Boost or Python libraries are not found on the system, then some tests and examples will not be built.

You can also get an appropriate version of boost using the same approach as employed by CI. The appveyor.yml file includes an invocation of:

tools\ci-scripts\windows\Install-Boost.ps1 `
                        -Version $env:BOND_BOOST `
                        -VcToolSetVer $vcToolSetVer `
                        -Components $boostComponents

which can also be invoked manually in order to download the relevant version, e.g.

Install-Boost.ps1 -Version 1.61.0 -VcToolSetVer 14.0

This will return the location to which the files were downloaded. It will be a temporary location, so you should subsequently copy the directories to a more permanent location and then configure your environment variables to point to those locations.

To generate a solution to build the Bond Core C++ and Python with Visual Studio 2015 run the following commands from the root bond directory:

mkdir build
cd build
set PreferredToolArchitecture=x64
cmake -G "Visual Studio 14 2015 Win64" ..

Setting PreferredToolArchitecture=x64 selects the 64-bit toolchain which dramatically improves build speed. (The Bond unit tests are too big to build with 32-bit tools.)

Instead of cmake you can also use cmake-gui and specify configuration settings in the UI. This configuration step has to be performed only once. From then on you can use the generated solution build\bond.sln from Visual Studio or build from the command line using cmake:

cmake --build . --target
cmake --build . --target INSTALL

To build and execute the unit tests and examples run:

cmake --build . --target check -- /maxcpucount:8

Alternatively, you can build and install Bond using the vcpkg dependency manager:

git clone https://github.com/microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.bat
./vcpkg integrate install
./vcpkg install bond

The Bond port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please create an issue or pull request in the vcpkg repository.

Linux

Windows

Articles