Rename the scoped allocator example from "scoped_allocator" to
"scoped_alloc" so that it doesn't conflict with the "scoped_allocator"
header from the C++ standard library.
When `--scoped-alloc` is passed to `gbc`, the generated _types.h header
has a `#include <scoped_allocator>`.
When using CMake to generate Makefiles, the directory where the _types.h
generated file is placed is the same directory where the final
executable is placed.
When rebuilding the scoped_allocator example, the preprocessor tries to
`#include` the previous generated executable.
Implementations of the preprocessor differ in how they handle "file" vs.
<file>. Some will search in the current directory for <file>, while some
will not.
Renaming avoids this problem instead of relying on the behavior of
<file>.
The AppVeyor builder images contain some versions of Boost, but not all
the versions that Bond supports for all the compilers that it supports.
This commit:
* Switches to a minimum Boost of 1.61, the minimum supported version as
of this commit.
* Adds a script to easily find the pre-installed Boost library.
* Adds a script to install a given version of Boost from NuGet.org
packages.
* Updates the AppVeyor build to install missing versions of Boost from
NuGet.org.
* Refactors the AppVeyor build to base the MSVC compiler off of the
`BOND_VS_VERSION` or the `APPVEYOR_BUILD_WORKER_IMAGE` variable, which
should set us up to add MSVC 2017 to the build later.
This is the AppVeyor side of https://github.com/Microsoft/bond/issues/771
`bond::maybe` now has better support for rvalue-references and allocator
propagation.
This implementation also avoids default initializing an instance of `T`
when creating an maybe that holds nothing
`bond::maybe` is now implemented in terms of `boost::optional`. We should be
able to `std::optional` with minimal effort when Bond requires a minimum
of C++17.
Additional changes:
* Removed a dangerous implicit conversion operator from `bond::maybe<T>`
to `const T&`. To access a `bond::maybe<T>` value, use
* Added `noexcept` variants of `bond::maybe<T>::value`.
* Added `bond::maybe<T>::emplace` to construct a maybe's value in place.
* Added various rvalue-reference and allocator-aware constructors and
assignment operators.
* Added `bond::maybe<T>::operator==(const T&)` to compare directly to
instances of `T`.
* Improved test coverage of `set_value()`: it was only effectively
constructing a new `T` the first time.
* Added tests for moved-from `bond::maybe` instances.
* Added tests for allocator propagation.
This change has not yet been made, as it breaks the current AppVeyor
build.
Issue https://github.com/Microsoft/bond/issues/845 has been opened to
remind us to bump the minimum version later.
[skip ci]
Drops support for versions of Boost older than two years. Boost 1.61+ or
newer is now required. (Bond will likely continue to work with older
versions of Boost, but we'll no longer actively test against them.)
Using cron jobs, add coverage for all supported versions of Boost with
both Clang and G++.
This is the Travis-side fix for:
* https://github.com/Microsoft/bond/issues/666
* https://github.com/Microsoft/bond/issues/771
* Parser understands the contextual keyword `stream` to indicate whether
an input or response is a stream of messages.
* Methods like `stream stream()` and `stream stream stream()` are
handled properly (the first is a unary method and the second is a
server stream).
* JSON AST augmented with streaming cardnality.
* C# codegen generates the right code for streaming methods.
* Added streaming and generics C# gRPC examples.
This build flavor builds Bond with the latest gRPC master branch so we
can detect potential breaks faster than when we upgrade our submodule.
This build flavor isn't needed on every commit or pull request, so it's
only enabled for Travis's cron builds.
Without this, Java may automatically configure a version string equal to
the checked-out hash prefix, which has a 6/16 chance of starting with a
letter instead of a number. Gradle doesn't seem to resolve dependencies
properly when this happens.
We need the full history so that we have an unbroken chain from the
current commit to the most recent tag.
Fixes https://github.com/Microsoft/bond/issues/835
Splits the C++ build into its own set of scripts, like the other
flavors. This is in preparation for adding another C++ flavor: one that
builds with the gRPC master code instead of the current submodule
version.
This image is a little bit smaller, so should download marginally
faster. It will also help assure we don't take dependencies of libraries
that need an X server.
In commit 3221200462, the gRPC golden tests for gbc were accidentally
removed, as they were being done in a function called
`verifyCsCommCodegen`. This commit restores them.
We were always building gbc with GHC optimizations turned on. We can get
faster build times for things like CI if we don't build with optimizations.
To do that, we now pass different stack & gbc options for the various
CMake build types. The MSBuild Compiler.csproj project translates
MSBuild configurations into CMake configurations.
On macOS (and likely Linux), when gbc was not found under
BOND_COMPILER_DIRECTORY--typically when it was found on $PATH--the
output directory for the generated C# files ended up having inconsistent
directory separator translation applied to it.
gbc was invoked with an output directory like
`--output-dir="obj/Debug/net45/\."`, which placed the generated files in
a directory *under* `net45` named `\.`. However, when csc was invoked,
it was given generated file paths like `obj/Debug/net45//foo_types.cs`,
which did not exist, causing compilation to fail.
This inconsistency occurred because when the command line for gbc from
$PATH was constructed, none of the elements look like a path, so MSBuild
didn't translate the trailing `\.` added to the output-dir argument:
<_BondCommand>"$(_BondExe)" $(BondCodegenMode) $(_BondImportDirs) --jobs=-2 --namespace=bond=Bond --output-dir="$(BondOutputDirectory)\."</_BondCommand>
The `\.` was added to guard against $(BondOutputDirectory) ending with a
slash and then having CMD treat a string like
`--output-dir="obj\Debug\net45\"` as having an escaped double-quote in
it.
When gbc came from BOND_COMPILER_PATH, it looked like a path, so the
added `\.` got translated to `/.`
As a fix, the codegen targets now use $(_BondOutputDirectoryNormalized),
which always has a trailing slash and always uses forward slashes.
Windows, macOS, and Linux can all handle forward slashes for paths.
* Comm examples are excluded, as Comm will be deleted soon.
* The gRPC shared-type-assembly examples are excluded, as they require
starting two processing in a specific order and console input.
In the protocol_transcoding example, if the source code is checked out
with \n instead of \r\n, it won't match the serialized XML
byte-for-byte. We split both into lines and then compare each line to
avoid this issue.
Switch the C# examples to throw when the conditions they are
demonstrating are violated instead of using Debug.Assert.
Debug.Assert often pops up a UI dialog with the details. The example are
all console applications, and this UI dialog caused them to stall
instead of exiting with a non-zero exit code.
Previously, we were just [public signing][1] the .NET Core assemblies.
We intended to fully strong-name sign them, so this commit removes the
"publicSign": true entry from the project files.
[1]: ca61bad288
In a [recent commit][1] the contract for the RemoveDuplicates task was
strengthened. So, we're no longer relying on implementation beahvior but
contractual behavior.
[1]: a050dde415
* Enabled automatic codegen when implicit inclusion is turned on via the
MSBuild property EnableDefaultCompileItems
* Added Visual Studio CPS UI integration so that .bond files appear in
the Visual Studio 2017+ UI.
Fixes https://github.com/Microsoft/bond/issues/636
The change fixes the `bond::value`'s move constructor to actually move
the underlying reader, unless it is a reference type. Also, fixes the
`noexcept` condition for `bond::bonded`'s move constructor that was
missed in 5131a950.
The following code does not compile on clang. The issue does not occur
on MSVC and GCC due to active bugs.
bond::InputBuffer input;
bond::CompactBinaryReader<bond::InputBuffer> reader{ input };
bond::value<uint32_t, decltype(reader)&> value{ reader };
uint8_t var;
value.Deserialize(var); // Deserialize into a non-matching type
The issue is that all the SFINAE-enabled overloads of `Deserialize`
inside of the base `bond::value_common` and derived `bond::value` have
the same signature (e.g. all use the return type for SFINAE check and
the rest of the signature is identical), so the one in the base class
cannot be found because it will be shadowed by the ones in the derived
ones. The fix is to change the signature of the base `Deserialize` by
using a default parameter for a SFINAE check rather than a return type
so that the function will not be shadowed by derived ones.
When moving a bonded<> backed by a reference to a reader, the bonded<>
move ctor wasn't building with Clang and newer versions of MSVC. This
fixes that error by not calling std::move on the reference.
Now that the garbage collector script has been running successfully for
a few days and we've validated its results, we can change it to actually
delete images instead of just printing which ones it would delete.
Fixes https://github.com/Microsoft/bond/issues/800
The blob and nullable types are not customizable. Also is_blob and
is_nullable traits are not part of container concept.
Closes https://github.com/Microsoft/bond/pull/805
Every change (well, most every) to the master branch produces a new
Docker image (for our Linux CI builds). However, we don't use each new
image. Instead, occasionally someone updates .travis.yml to point to a
new image. Thus, there's a build up of Docker images in the repository
that aren't being used.
These images are garbage: garbage in the sense that they're not
reachable from any of the .travis.yml roots.
This commit adds a script that can be used to find and remove these
garbage images.
Given a set of filters to find root commits (e.g., we can specify all
tags and all commits in the past two weeks), the script finds all the
referenced Docker images in the various revisions to .travis.yml. It
then compares the referenced images to those present in the repository,
skips images that are too new to be collected, and--for now--prints the
`az` CLI command to remove that image.
The `az` CLI is implemented in Python, so Python is going to be
available wherever `az` is. Since this script was a bit too complicated
for a shell script, Python 3 was chosen as its implementation language.
This script is intended to be run inside a VSTS build using the Azure
CLI task [1]. However, it will work anywhere that `az login` has been
run and given credentials with read/write access to the
bondciimages.azurecr.io repository.
[1]: https://github.com/Microsoft/vsts-tasks/blob/master/Tasks/AzureCLI/Readme.md
Linux scripts need to always have LF. If not, things like building a
Docker image from Windows will result in un-runable scripts. Update
.gitattributes so these files are always checked out LF.
Use the "headless" JDK in the Travis CI image to avoid installing a
bunch of X11 (and related) packages that we don't need. This also
reduces the size of the image.
After getting this commit into master, the next step is to wait for a
new image to be built and then consume that image in .travis.yml.
[skip ci]
Christopher Warrington
gwishnie
Ara Ayvazyan
Ara Ayvazyan
Christopher Warrington
Ted Stein
Greg Ravikovich