Select Page

The mbo library (github.com/helly25/mbo) is a C++20 library that provides some general useful building blocks and integrates with Google’s Abseil library. The goal is to provide production-ready functional blocks that utilize C++20 — often in areas where I was told C++ cannot be used or does not have the right abilities, or where online wisdom could not solve a problem I was facing. Sometimes these building blocks bank on my prior experience, and they are mostly driven by my own need to do things in a sane, elegant or efficient manner, where efficient can either be fast code or something that makes developer’s life easier.

The C++ library is organized in functional groups each residing in their own directory.

* Container
    * `namespace mbo::container`
    * mbo/container:any_scan_cc, mbo/container/any_scan.h
        * class `AnyScan`: A container type independent iteration view - or scan over the container.
        * class `ConstScan`: A container type independent iteration view for const value_types.
        * class `ConvertingScan`: A container scanner that allows for conversions.
        * function `MakeAnyScan`: Helper function to create `AnyScan` instances.
        * function `MakeConstScan`: Helper function to create `ConstScan` instances.
        * function `MakeConvertingScan`: Helper function to create `ConvertingScan` instances.
    * mbo/container:convert_container_cc, mbo/container/convert_container.h
        * conversion struct `ConvertContainer` simplifies copying containers to value convertible containers.
    * mbo/container:limited_map_cc, mbo/container/limited_map.h
        * class `LimitedMap`: A space limited, constexpr compliant `map`.
    * mbo/container:limited_options_cc, mbo/container/limited_options.h
        * class `LimitedOptions`: A compile time configuration option for `LimitedSet` and `LimitedMap`.
    * mbo/container:limited_set_cc, mbo/container/limited_set.h
        * class `LimitedSet`: A space limited, constexpr compliant `set`.
    * mbo/container:limited_vector_cc, mbo/container/limited_vector.h
        * class `LimitedVector`: A space limited, constexpr compliant `vector`.
* Diff
    * `namespace mbo::diff`
    * mbo/diff:unified_dff_cc, mbo/diff/unified_diff.h
        * class `UnifiedDiff`: A class that implements unified-diffing.
    * mbo/diff:unified_diff
        * binary `unfied_diff`: A binary that performs a unified-diff on two files.
    * mbo/diff:diff_bzl, mbo/diff/diff.bzl
        * bzl-macro `difftest`: A test rule that compares an output versus a golden file.
* Files
    * `namespace mbo::files`
    * mbo/file:artefact_cc, mbo/file/artefact.h
        * struct `Artefact`: Holds information about a file (its data content, name, and modified time).
    * mbo/file:file_cc, mbo/file/file.h
        * function `GetContents`: Reads a file and returns its contents or an absl::Status error.
        * function `GetMTime`: Returns the last update/modified time of a file or an absl::Status error.
        * function `GetMaxLines`: Reads at most given number of text lines from a file or returns absl::Status error.
        * function `IsAbsolutePath`: Returns whether a given path is absolute.
        * function `JoinPaths`: Join multiple path elements.
        * function `JoinPathsRespectAbsolute`: Join multiple path elements respecting absolute path elements.
        * function `NormalizePath`: Normalizes a path.
        * function `Readable`: Returns whether a file is readable or an absl::Status error.
        * function `SetContents`: Writes contents to a file.
    * mbo/file/ini:ini_file_cc, mbo/file/ini/ini_file.h
        * class `IniFile`: A simple INI file reader.
* Hash
    * `namespace mbo::hash`
    * mbo/hash:hash_cc, mbo/hash/hash.h
        * function `simple::GetHash(std::string_view)`: A constexpr capable hash function.
* Mope
    * `namespace mbo::mope`
    * The `MOPE` templating engine. Run `bazel run //mbo/mope -- --help` for detailed documentation.
    * mbo/mope
        * binary `mope`.
    * mbo/mope:mope_cc, mbo/mope/mope.h
        * class `Template`: The mope template engine and data holder.
    * mbo/mope:ini_cc, mbo/mope/ini.h
        * function `ReadIniToTemplate`: Helper to initialize a mope Template from an INI file.
    * mbo/mope:mope_bzl, mbo/mope/mope.bzl
        * bzl-rule `mope`: A rule that expands a mope template file.
        * bazl-macro `mope_test`: A test rule that compares mope template expansion against golden files. This
          supports `clang-format` and thus can be used for source-code generation and verification.
* Status
    * `namespace mbo::status`
    * mbo/status:status_macros_cc, mbo/status/status_macros.h
        * macro `MBO_RETURN_IF_ERROR`: Macro that simplifies handling functions returning `absl::Status`.
        * macro `MBO_ASSIGN_OR_RETURN`: Macro that simplifies handling functions returning `absl::StatusOr<T>`.
* Strings
    * `namespace mbo::strings`
    * mbo/strings:indent_cc, mbo/strings/indent.h
        * function `DropIndent`: Converts a raw-string text block as if it had no indent.
        * function `DropIndentAndSplit`: Variant of `DropIndent` that returns the result as lines.
    * mbo/strings:parse_cc, mbo/strings/parse.h
        * function `ParseString`: Parses strings respecting C++ and custom escapes as well as quotes (all configurable).
        * function `ParseStringList`: Parses and splits strings respecting C++ and custom escapes as well as quotes (all configurable).
    * mbo/strings:strip_cc, mbo/strings/strip.h
        * struct `StripCommentsArgs`: Arguments for `StripComments` and `StripLineComments`.
        * function `StripComments`: Strips comments from lines.
        * function `StripLineComments`: Strips comments from a single line.
        * struct `StripParsedCommentsArgs`: Arguments for `StripParsedComments` and `StripParsedLineComments`.
        * function `StripParsedComments`: Strips comments from parsed lines.
        * function `StripLineParsedComments`: Strips comments from a single parsed line.
* Testing
    * `namespace mbo::testing`
    * mbo/testing:matchers_cc, mbo/testing/matchers.h
        * gMock-Matcher `CapacityIs` which checks the capacity of a container.
    * mbo/testing:status_cc, mbo/testing/status.h
        * gMock-matcher `IsOk`: Tests whether an absl::Status or absl::StatusOr is absl::OkStatus.
        * gMock-matcher `IsOkAndHolds`: Tests an absl::StatusOr for absl::OkStatus and contents.
        * gMock-Matcher `StatusIs`: Tests an absl::Status or absl::StatusOr against a specific status code and message.
        * macro `MBO_ASSERT_OK_AND_ASSIGN`: Simplifies testing with functions that return `absl::StatusOr<T>`.
* Types
    * `namespace mbo::types`
    * mbo/types:cases_cc, mbo/types/cases.h
        * meta-type `Cases`: Allows to switch types based on conditions.
        * meta-type `CaseIndex`: Evaluates the first non zero case (1-based, 0 if all zero).
        * meta-type `IfThen`: Helper type to generate if-then `Cases` types.
        * meta-type `IfElse`: Helper type to generate else `Cases` which are always true and must go last.
        * meta-type `IfFalseThenVoid`: Helper type that can be used to skip a case.
        * meta-type `IfTrueThenVoid`: Helper type to inject default cases and to ensure the required type expansion is always possible.
    * mbo/types:compare_cc, mbo/types/compare.h
        * comparator `mbo::types::CompareLess` which is compatible to std::Less but allows container optimizations.
    * mbo/types:extend_cc, mbo/types/extend.h
        * crtp-struct `Extend`: Enables extending of struct/class types with basic functionality.
        * crtp-struct `ExtendNoDefault` Like `Extend` but without default extender functionality.
        * `namespace extender`
            * extender-struct `AbslStringify`: Extender that injects functionality to make an `Extend`ed type work with abseil format/print functions.
            * extender-struct `AbslHashable`: Extender that injects functionality to make an `Extend`ed type work with abseil hashing (and also `std::hash`).
            * extender-struct `Comparable`: Extender that injects functionality to make an `Extend`ed type comparable. All comparators will be injected: `<=>`, `==`, `!=`, `<`, `<=`, `>`, `>=`.
            * extender-struct `Printable`:
                * Extender that injects functionality to make an `Extend`ed type get a `std::string ToString() const` function which can be used to convert a type into a `std::string`.
                * The output is a comma separated list of field values, e.g. `{ 25, 42 }`.
                * If available (Clang 16+) this function prints field names `{ first = 25, second = 42 }`.
            * extender-struct `Streamable`: Extender that injects functionality to make an `Extend`ed type streamable. This allows the type to be used directly with `std::ostream`s.
    * mbo/types:no_destruct_cc, mbo/types/no_destruct.h
        * struct `NoDestruct<T>`: Implements a type that allows to use any type as a static constant.
        * Mainly, this prevents calling the destructor and thus prevents termination issues (initialization order fiasco).
    * mbo/types:ref_wrap_cc, mbo/types/ref_wrap.h
        * template-type `RefWrap<T>`: similar to `std::reference_wrapper` but supports operators `->` and `*`.
    * mbo/types:template_search_cc, mbo/types/template_search.h:
        * template struct `BinarySearch` implements templated binary search algorithm.
        * template struct `LinearSearch` implements templated linear search algorithm.
        * template struct `ReverseSearch` implements templated reverse linear search algorithm.
        * template struct `MaxSearch` implements templated linear search for last match algorithm.
    * mbo/types:traits_cc, mbo/types/traits.h
        * type alias `ContainerConstIteratorValueType` returned the value-type of the const_iterator of a container.
        * concept `ContainerIsForwardIteratable` determines whether a types can be used in forward iteration.
        * concept `ContainerHasEmplace` determines whether a container has `emplace`.
        * concept `ContainerHasEmplaceBack` determines whether a container has `emplace_back`.
        * concept `ContainerHasInsert` determines whether a container has `insert`.
        * concept `ContainerHasPushBack` determines whether a container has `push_back`.
        * concept `ContainerHasForwardIterator` determines whether a container has `begin`, `end` and `std::forward_iterator` compliant iterators.
        * concept `ContainerHasInputIterator` determines whether a container has `begin`, `end` and `std::input_iterator` compliant iterators.
        * type alias `GetDifferenceType` is either set to the type's `difference_type` or `std::ptrdiff_t`.
        * concept `HasDifferenceType` determines whether a type has a `difference_type`.
        * concept `IsAggregate` determines whether a type is an aggregate.
        * concept `IsCharArray` determines whether a type is a `char*` or `char[]` related type.
        * concept `IsDecomposable` determines whether a type can be used in static-bindings.
        * concept `IsInitializerList` determines whether a type is `std::initializer<T> type.
        * concept `IsBracesConstructibleV` determines whether a type can be constructe from given argument types.
        * concept `IsPair` determines whether a type is a `std::pair`.
        * concept `IsSameAsAnyOfRaw` / `NotSameAsAnyOfRaw` which determine whether type is one of a list of types.
        * concept `IsVariant` determines whether a type is a `std::variant` type.
    * mbo/types:tstring_cc, mbo/types/tstring.h
        * struct `tstring`: Implements type `tstring` a compile time string-literal type.
        * operator `operator"" _ts`: String literal support for Clang, GCC and derived compilers.