A set of small tools that allow you to state your intentions more explicitly in the interfaces.
A tool for indicating function output parameters in call sites:
void clear(out_param<std::string&> s) // output parameter in function declaration
{
s.get().clear();
}
std::string s {"text"};
clear(out(s)); // in function invokation
For more, see here.
An alternative to type bool
in function arguments. It allows to associate a name with the boolean type. No nasty implicit converisons from/to int
, double
, or pointers. Different instantiations of tagged_bool
are not interconvertible:
using EngineStarted = tagged_bool<class EngineStartedTag>; // one boolean type
using CrewReady = tagged_bool<class CrewReadyTag>; // another boolean type
void set_status(EngineStarted started, CrewReady ready); // function declaration
set_status(EngineStarted{true}, CrewReady{true}); // function invokation
For more, see here.
A tool for disabling some unwanted implicit conversions to types present in your function signatures. For instance, you may want your function to take a filesystem::path
but not allow an implicit conversion from std::string
:
using only_path = only_when<filesystem::path, is_a_non_string>; // you define type trait is_a_non_string
void process(only_path p); // function declaration
process(path); // ok
process(string); // error
For more, see here.
An alternative to type int
in function arguments. It binds to int
s and int proxies but not to double
:
void scale(only_int i); // declaration
scale(2); // ok
scale(2.5); // error
For more, see here.
This allows the constructor parameters to bind to lvalues, but not to rvalues:
struct Processor
{
Big const& _big;
explicit Processor(lvalue_ref<const Big> b) : _big(b) {}
};
const Big b {};
Processor p {b}; // ok
Processor q {Big{}}; // error (temporary)
For more, see here.
This allows to indicate in function interface that a passed pointer is assumed never to be null:
void process(not_null<i*> p); // function declaration
int i = 0;
process(&i); // error: no implicit conversion to not_null
process(as_not_null(&i)); // ok: explicit adjustment
For more, see here.
It is a C++11 header-only library.
Distributed under the Boost Software License, Version 1.0.
The idea of the generalized only_when
was proposed by Vicente J. Botet Escriba. Tomasz Kamiński suggested the support for std::reference_wrapper
in rvalue_ref
.