jtl - a spare-tire template library

jtl is a C++14 library which aims to provide an augmentation of the C++ stdlib and boost. It's focused on template meta-programming and achieving a more functional C++.

Header only (easy to add to any project)
Extensive test suite (using jest, a "sane and minimal C++14 unit test framework")

Overview

There exists generated documentation <TODO> which should suffice as a reference. This overview will link to separate sections in the documentation.

Namespaces

Most namespaces come with an alias for shorthand access. For example, jtl::algorithm can be accessed as jtl::alg.

algorithm (alg) Algorithms similar to that of <algorithm>
- policy (pol) Policies which jtl algorithms support
iterator (it) Iterator types similar to that of <iterator>
container Containers and container utilities
trait Traits and other meta-functions similar to that of <type_traits>

A deeper look

algorithm

consume, consume_copy Maps N elements of input to one output

auto const points{ 0, 1, 2, 3, 4, 5 };
std::vector<triangle> tris(2);
jtl::alg::consume<3>(points.begin(), points.end(), tris.begin());

// points has been moved from; use consume_copy to prevent moving
// tris == { { 0, 1, 2 }, { 3, 4, 5 } }

transfer Similar to std::move: operates based on a transfer policy

jtl::alg::transfer<jtl::alg::pol::copy>(foo);

jtl::alg::transfer<jtl::alg::pol::move>(foo);

move_if Transfers with a move policy if true. Otherwise, copies

jtl::alg::move_if<is_integer<T>::value>(foo);

jtl::alg::move_if<true>(foo); // equivalent to std::move(foo)

trim, trim_left, trim_right Trims all trailing/leading vals

std::string s{ "  \t meow\n\t" };
s.erase(jtl::alg::trim(s.begin(), s.end(), " \t\n"), s.end());

// s == "meow"

std::vector<int> v{ 42, 0, 1, 2, 8, 7 };
v.erase(jtl::alg::trim(v.begin(), v.end(), {42, 7, 8}), v.end());

// v == { 0, 1, 2 }

getline Follows std::getline but allows multiple delimiters

std::stringstream ss{ "one\ntwo|three four" };
std::string nums[4];

jtl::alg::getline(ss, nums[0], "\n| ");
jtl::alg::getline(ss, nums[1], "\n| ");
jtl::alg::getline(ss, nums[2], "\n| ");
jtl::alg::getline(ss, nums[3], "\n| ");

// nums == [ "one", "two", "three", "four" ]

transform_if Follows std::transform but allows skipping of items

std::vector<int> const v{ 0, 1, 2, 3, 4 };
std::vector<std::string> out;
jtl::alg::transform_if(v.begin(), v.end(), jtl::it::back_inserter(out),
                       [](auto const i)
                         -> std::experimental::optional<std::string>
                       {
                         if(i % 2)
                         { return { std::to_string(i) }; }
                         else
                         { return {}; }
                       });
                       
// out == { "1", "3" }

iterator

stream_delim Provides iteration over input streams given a delimiter

std::stringstream ss{ "0\n1\n2\n3" };
std::vector<std::string> lines;

std::copy(jtl::iterator::stream_delim<>{ ss }, // default: '\n'
          jtl::iterator::stream_delim<>{},
          std::back_inserter(lines));

// lines == { "0", "1", "2", "3" }

multi_insert, multi_back_insert Inserts ranges at a time

std::string const s{ "data" };
std::string out{ "{}" };
std::transform(s.begin(), s.end(),
               jtl::iterator::multi_inserter(out, std::next(out.begin())),
[](char const c)
{ return "[" + std::string{ c } + "]"; });

// out == "{[d][a][t][a]}"

transmute_back_insert Transmutes output of T<E> to T2<E>

std::stringstream ss{ "w0|w1|w2" };
std::vector<std::vector<char>> out;
std::copy(jtl::iterator::stream_delim<>{ ss, '|' },
          jtl::iterator::stream_delim<>{},
          jtl::iterator::transmute_back_inserter(out));

// would normally expect vector<string>, but transmutation
// allows for other [compatible] container types.
// out == { { 'w', '0' }, { 'w', '1' }, { 'w', '2' } }

make_range Creates a direct or indirect range of [begin, end)

// indirect range on std::vector::const_iterator
std::vector<int> const v{ 0, 1, 2, 3 };
for(auto const i : jtl::it::make_range(v.begin(), std::next(v.begin(), 2)))
{ std::cout << i << " "; }

// output: 0 1

// direct range on int values
for(auto const i : jtl::it::make_range(0, 10))
{ std::cout << i << " "; }

// output: 0 1 2 3 4 5 6 7 8 9

insert, front_insert, back_insert A drop-in, improved replacement for std::insert_iterator and the like

container

make_array Builds an std::array, deducing type and arity

auto constexpr arr(jtl::cont::make_array(1, 2, 3));

// decltype(arr) == std::array<int, 3>

auto arr(jtl::cont::make_array(std::string{ "1" }, "2"));

// Uses std::common_type to deduce "2" to std::string
// decltype(arr) == std::array<std::string, 2>

trait

disable, disable_t, disable_value, disable_value_t Unconditionally returns false, consuming all types/values

template <typename T>
char const* name()
{ static_assert(jtl::trait::disable<T>(), "unsupported type"); }

template <>
char const* name<int>()
{ return "int"; }

is_indirect Determines if a type can use operator->

show Fails compilation using the type pack in order to display each type

// Will halt the compiler and output the typenames

template <typename... Args>
void what_is_going_on()
{ jtl::trait::show<Args...>(); }

License

jtl is under the MIT open-source license.
See the LICENSE file or http://opensource.org/licenses/MIT

drewet/jtl