andrey-golubev/clsc

Cute Little Software Capital

CLSC (Cute Little Software Capital)

About

This is a toy-project dedicated to creating useful utilities that relatively modern C++ (C++17) misses. There is also an on-going work on quite interesting features not currently available in master.

Fast start

git clone https://github.com/andrey-golubev/clsc.git --recursive
cd clsc
python3 script/test.py

Note: googletest is used as a git submodule. Thus, it is required to clone it in order to build and run repository tests.

clsc's Issues

Implement simple thread pool

Compile-time all_of, none_of, any_of

Add those just for fun. Draft implementation of one (but requires C++17 - can it be done in C++14?):

#include <type_traits>

template <template <typename, typename> class BinaryPredicate, typename... Ts>
struct all_of {
    static constexpr bool value = (BinaryPredicate<float, Ts>::value && ...);
};

template <template <typename, typename> class BinaryPredicate, typename T>
struct all_of<BinaryPredicate, T> {
    static constexpr bool value = BinaryPredicate<float, T>::value;
};

int main() {
    static_assert(all_of<std::is_same, float>::value, "Failed");
    static_assert(all_of<std::is_same, float, float>::value, "Failed");
    static_assert(!all_of<std::is_same, float, float, float, int>::value, "Failed");
    static_assert(!all_of<std::is_same, float, double, int>::value, "Failed");
    return 0;
}

Improve MAKE_ENUM utility

• Support complex cases with user-defined values for some/each enum value
• Use enum class
• Change VAARGS_LEN to template version
• Improve API

Prototype pre-processor for floating to integer arithmetics conversion

Prototype constexpr associative container

When having an array of certain items (e.g. callables), sometimes one wants to be able to seamlessly access a specific item. In a usual setup, array implies indices (integer values) which are not super convenient to use "as is".

Having a facade that translates user-specified item identifier (namely, a string) into an index of an array and then accesses the array element by an index, would significantly simplify life in certain cases.

It feels that the most natural usage for such idea is when a programmer actually has to write code by himself (not auto-called by some routine), thus, having a constexpr associative container (string -> int, 1-to-1 mapping) is a good enough option to go with.

Implement lower_bound, upper_bound that accept unary predicate instead of value for the search.

For example:

template< class ForwardIt, class UnaryPredicate,  class Compare >
ForwardIt lower_bound( ForwardIt first, ForwardIt last, UnaryPredicate pred, Compare cmp );