JetBrains RD

CTPL is a modern, efficient, header-only C++ thread pool library designed for parallel job execution. It minimizes the overhead of creating and destroying threads and allows limiting the number of simultaneous parallel jobs.

Key features include:

• Header-only: No need to compile a binary library.
• Flexible API: Supports pushing lambdas, functors, functions, and std::bind results.
• Dynamic Control: Ability to query idle threads and resize the pool dynamically.
• Standard C++ Integration: Uses standard C++ futures to retrieve return values and exceptions from jobs.
• Variadic Parameters: Supports jobs with a variadic number of parameters, automatically providing the index of the thread running the object.
• License: Apache License.

RdGen is a tool used to generate model serialization and deserialization code in multiple compatible languages: C#, Kotlin, and C++ (experimental).

To define models, you use a domain-specific language (DSL) provided as a Kotlin library. To invoke the generator, the Gradle build system is typically used.

RdReflection is a specialized subsystem within RD designed for scenarios where models are defined primarily in C#. Unlike the standard DSL-based approach, RdReflection allows you to define all models using pure C# code.

Key Features:

• Pure C# Definitions: Models are written in C# rather than RD DSL files.
• Full Entity Support: Supports all standard RD entities including RdMap, RdSet, RdCall, and RdList.
• Live Models: Provides live models integrated with RD entities.
• Scalar Serializers: Includes support for scalar serialization.
• RPC Proxy Generation: Can generate proxy classes for simple RPC (Remote Procedure Call) patterns based on RdCall.

Important Limitation:

• No Interop: RdReflection is intended for C#-to-C# communication only. It does not support interoperability with models generated from standard RD DSL files.

Heterogeneous lookups allow you to perform find or erase operations using a type different from the Key type, provided the types are hashable and comparable.

To enable this, the KeyEqual type must have a using is_transparent = void; declaration. You can use std::equal_to<> to achieve this automatically, or define a custom comparator class.

Both the Hash and KeyEqual functions must be implemented to handle the different types used in the lookup.

struct equal_employee {
    using is_transparent = void;
    
    bool operator()(const employee& empl, int empl_id) const {
        return empl.m_id == empl_id;
    }
    // ... other overloads
};

// Usage with custom comparator
tsl::ordered_map<employee, int, hash_employee, equal_employee> map2;
map2.insert({employee(4, "Johnny Doe"), 2004});
auto it = map2.find(4); // Works using int

To create a string_view from a literal string, the library provides two types of literal operators:

1. sv: The standard-like literal operator. Note that Clang compilers may not allow this under C++11. Enable via -Dnssv_CONFIG_STD_SV_OPERATOR=1.
2. _sv: A user-defined literal operator provided to ensure compatibility even when sv is restricted. This is enabled by default.

These operators are located in the nonstd::literals::string_view_literals namespace. You can access them by using:

• using namespace nonstd::literals;
• using namespace nonstd::string_view_literals;
• using namespace nonstd::literals::string_view_literals;

The tl::optional library is a single-header implementation of std::optional that provides monadic/functional-style extensions. These utilities allow you to chain computations that may or may not produce a value without manual empty-checking (e.g., if (!opt) return std::nullopt;).

Instead of nested conditional checks, you can use .and_then() for operations that return an optional and .map() for operations that return a direct value.

gl::optional<image> get_cute_cat (const image& img) {
    return crop_to_cat(img)
           .and_then(add_bow_tie)
           .and_then(make_eyes_sparkle)
           .map(make_smaller)
           .map(add_rainbow);
}

MPark.Variant requires a standard conformant C++11 compiler. It is continuously tested against various versions of GCC, Clang (including Xcode), and MSVC (Visual Studio 2015/2017).

Important Notes:

• GCC 4.8/4.9: constexpr support is unavailable for visit and relational operators.
• libc++ tests: Enabling libc++ std::variant tests requires -std=c++17 support.