Global Namespace

Overview

// namespaces

namespace math;
namespace mola;
    namespace mola::detail;
namespace mp2p_icp;
    namespace mp2p_icp::internal;
namespace mp2p_icp_filters;
namespace mrpt;
    namespace mrpt::config;
    namespace mrpt::containers;
    namespace mrpt::maps;
    namespace mrpt::obs;
    namespace mrpt::opengl;
    namespace mrpt::rtti;
    namespace mrpt::serialization;
    namespace mrpt::system;
namespace nanogui;
namespace rosbag2_cpp;
    namespace rosbag2_cpp::readers;
namespace rosbag2_storage;
namespace std;
namespace string_literals;
namespace tf2;
namespace tsl;
    namespace tsl::detail_robin_hash;
    namespace tsl::rh;
        namespace tsl::rh::detail;

// typedefs

typedef mrpt::math::CMatrixDouble44 Matrix;
typedef boost::mpl::list<tsl::rh::power_of_two_growth_policy<2>, tsl::rh::power_of_two_growth_policy<4>, tsl::rh::prime_growth_policy, tsl::rh::mod_growth_policy<>, tsl::rh::mod_growth_policy<std::ratio<7, 2>>> test_types;
typedef boost::mpl::list<tsl::robin_map<std::int64_t, std::int64_t>, tsl::robin_map<std::string, std::string>, tsl::robin_map<std::int64_t, std::int64_t, mod_hash<9>>, tsl::robin_map<std::string, std::string, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<self_reference_member_test, self_reference_member_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, true, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, false, tsl::rh::mod_growth_policy<>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, false, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, true, tsl::rh::mod_growth_policy<>>> test_types;
typedef boost::mpl::list<tsl::robin_set<std::int64_t>, tsl::robin_set<std::string>, tsl::robin_set<self_reference_member_test>, tsl::robin_set<move_only_test>, tsl::robin_pg_set<self_reference_member_test>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, true, tsl::rh::prime_growth_policy>, tsl::robin_set<self_reference_member_test, std::hash<self_reference_member_test>, std::equal_to<self_reference_member_test>, std::allocator<self_reference_member_test>, true, tsl::rh::mod_growth_policy<>>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, false, tsl::rh::mod_growth_policy<>>> test_types;

// structs

struct Cli;
struct HandlersContainer;
struct LoadedModules;
struct OLAE_LinearSystems;
struct errors;

template <class T1, class T2>
struct is_pair<std::pair<T1, T2>>;

template <class T>
struct is_pair;

// classes

template <typename T>
class TraitsTest;

class copy_only_test;

template <typename T>
class custom_allocator;

class deserializer;

template <typename T>
class identity_hash;

template <unsigned int MOD>
class mod_hash;

class move_only_test;
class self_reference_member_test;
class serializer;
class utils;

// global variables

static PyObject* markup;
static PyMethodDef module_methods[];
static struct PyModuleDef module_definition = {   PyModuleDef_HEAD_INIT,  "markupsafe._speedups",     NULL,   -1,     module_methods,  NULL,   NULL,   NULL,   NULL };
const float lengths[] = {100, 200, 300, 400, 500, 600, 700, 800};
const int32_t num_lengths = 8;
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t READ_AHEAD_LEN = 10;
constexpr size_t MAX_UNLOAD_LEN = 500;
static const int GZ_COMPRESS_LEVEL = 0;
std::string MOLA_MAP_STORAGE_DIR = mrpt::get_env<std::string>("MOLA_MAP_STORAGE_DIR", "/tmp");
static std::map<std::string, LoadedModules> loaded_lib_handled;
static std::size_t nb_custom_allocs = 0;
constexpr size_t HARD_MAX_MATCHES = 3;
constexpr size_t HARD_MAX_MATCHES = 3;
const std::string datasetsRoot = TEST_DATASETS_ROOT;
static const unsigned int mola_icon_width = 64;
static const unsigned int mola_icon_height = 64;
static const char* mola_icon_data;
static const uint8_t DIPI_SERIALIZATION_VERSION = 0;
static const uint8_t SERIALIZATION_VERSION = 1;
const bool MP2P_ICP_GENERATE_DEBUG_FILES =     mrpt::get_env<bool>("MP2P_ICP_GENERATE_DEBUG_FILES", false);
static const uint8_t SERIALIZATION_VERSION = 0;
constexpr const char* GEOREF_MAGIC_STR = "mp2p_icp::Georeferencing";

// global functions

static int init_constants(void);
static PyObject* escape_unicode_kind1(PyUnicodeObject* in);
static PyObject* escape_unicode_kind2(PyUnicodeObject* in);
static PyObject* escape_unicode_kind4(PyUnicodeObject* in);
static PyObject* escape_unicode(PyUnicodeObject* in);

static PyObject* escape(
    PyObject* self,
    PyObject* text
    );

static PyObject* escape_silent(
    PyObject* self,
    PyObject* text
    );

static PyObject* soft_str(
    PyObject* self,
    PyObject* s
    );

PyMODINIT_FUNC PyInit__speedups(void);
static bool eval(Cli& cli);
static void do_kitti_eval_error(Cli& cli);

int main(
    int argc,
    char** argv
    );

static void parse_calib_line(
    const std::string& line,
    Eigen::Matrix<double, 3, 4>& M
    );

std::vector<Matrix> loadPoses_tum_format(
    Cli& cli,
    const std::string& file_name,
    const std::string& calib_file,
    bool isGT
    );

std::vector<Matrix> loadPoses(string file_name);
vector<float> trajectoryDistances(vector<Matrix>& poses);

int32_t lastFrameFromSegmentLength(
    vector<float>& dist,
    int32_t first_frame,
    float len
    );

float rotationError(Matrix& pose_error);
float translationError(Matrix& pose_error);

vector<errors> calcSequenceErrors(
    vector<Matrix>& poses_gt,
    vector<Matrix>& poses_result
    );

void saveSequenceErrors(
    vector<errors>& err,
    string file_name
    );

void savePathPlot(
    vector<Matrix>& poses_gt,
    vector<Matrix>& poses_result,
    string file_name
    );

vector<int32_t> computeRoi(
    vector<Matrix>& poses_gt,
    vector<Matrix>& poses_result
    );

void plotPathPlot(
    Cli& cli,
    string dir,
    vector<int32_t>& roi,
    int32_t idx
    );

void saveErrorPlots(
    vector<errors>& seq_err,
    string plot_error_dir,
    const char* prefix
    );

void plotErrorPlots(
    Cli& cli,
    string dir,
    const char* prefix
    );

void saveStats(
    vector<errors> err,
    string dir
    );

MRPT_INITIALIZER(do_register_InputROS2);
MRPT_INITIALIZER(do_register_EurocDataset);
MRPT_INITIALIZER(do_register_Kitti360Dataset);
MRPT_INITIALIZER(do_register_KittiOdometryDataset);

static void build_list_files(
    const std::string& dir,
    const std::string& file_extension,
    std::vector<std::string>& out_lst
    );

static void parse_calib_line(
    const std::string& line,
    Eigen::Matrix<double, 3, 4>& M
    );

MRPT_INITIALIZER(do_register_MulranDataset);
MRPT_INITIALIZER(do_register_ParisLucoDataset);

static void build_list_files(
    const std::string& dir,
    const std::string& file_extension,
    std::vector<std::string>& out_lst
    );

MRPT_INITIALIZER(do_register_RawlogDataset);
MRPT_INITIALIZER(do_register_Rosbag2Dataset);
MRPT_FILL_ENUM(mola::InputMode::ImageDirectory);
MRPT_FILL_ENUM(mola::InputMode::VideoFile);
MRPT_FILL_ENUM(mola::InputMode::LiveCamera);
MRPT_INITIALIZER(register_VideoDataset);

IMPLEMENTS_VIRTUAL_SERIALIZABLE(
    EntityBase,
    mrpt::serialization::CSerializable,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    LandmarkPoint3,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    RefPose3,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    RelDynPose3KF,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    RelPose3,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    RelPose3KF,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    FactorConstVelKinematics,
    FactorBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    FactorRelativePose3,
    FactorBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    FactorStereoProjectionPose,
    FactorBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    SmartFactorIMU,
    FactorBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    SmartFactorStereoProjectionPose,
    FactorBase,
    mola
    );

MRPT_INITIALIZER(do_register_mrpt_kernel);
MRPT_INITIALIZER(do_register_mola_metric_maps);
MRPT_INITIALIZER(register_mp2p_icp);
MRPT_INITIALIZER(register_mola_lidar_segmentation);
MRPT_INITIALIZER(register_mp2p_icp_map);

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

static TCLAP::CmdLine cmd("mola-yaml-parser");

static TCLAP::SwitchArg arg_no_includes(
    "",
    "no-includes",
    "Disables solving YAML `$include{}`s(Default: NO)",
    cmd
    );

static TCLAP::SwitchArg arg_no_cmd_runs(
    "",
    "no-cmd-runs",
    "Disables solving YAML `$(cmd)`s(Default: NO)",
    cmd
    );

static TCLAP::SwitchArg arg_no_env_vars(
    "",
    "no-env-vars",
    "Disables solving YAML `${xxx}`s(Default: NO)",
    cmd
    );

static TCLAP::UnlabeledValueArg<std::string> arg_input_files(
    "YAML_file",
    "Input YAML file(required)(*.yml)",
    true,
    "params.yml",
    "YAML files",
    cmd
    );

int main(
    int argc,
    char** argv
    );

const std::map<std::string, LoadedModules>& get_loaded_modules();

void internal_load_lib_modules(
    mrpt::system::COutputLogger& app,
    const std::vector<std::string>& lib_search_paths
    );

static void internal_unload_lib_modules();

void internal_load_lib_modules(
    mrpt::system::COutputLogger& app,
    const std::vector<std::string>& lib_search_paths
    );

const std::map<std::string, LoadedModules>& get_loaded_modules();

template <class T, class U>
bool operator == (
    const custom_allocator<T>&,
    const custom_allocator<U>&
    );

template <class T, class U>
bool operator != (
    const custom_allocator<T>&,
    const custom_allocator<U>&
    );

BOOST_AUTO_TEST_CASE(test_custom_allocator_1);

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_policy,
    Policy,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_policy_min_bucket_count,
    Policy,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_policy_max_bucket_count,
    Policy,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(test_insert, HMap, test_types);
BOOST_AUTO_TEST_CASE(test_range_insert);
BOOST_AUTO_TEST_CASE(test_rehash_0);
BOOST_AUTO_TEST_CASE(test_insert_with_hint);
BOOST_AUTO_TEST_CASE(test_emplace_hint);
BOOST_AUTO_TEST_CASE(test_emplace);
BOOST_AUTO_TEST_CASE(test_try_emplace);
BOOST_AUTO_TEST_CASE(test_try_emplace_2);
BOOST_AUTO_TEST_CASE(test_try_emplace_hint);
BOOST_AUTO_TEST_CASE(test_insert_or_assign);
BOOST_AUTO_TEST_CASE(test_insert_or_assign_hint);
BOOST_AUTO_TEST_CASE(test_range_erase_all);
BOOST_AUTO_TEST_CASE(test_range_erase);

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_erase_loop,
    HMap,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_erase_loop_range,
    HMap,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_insert_erase_insert,
    HMap,
    test_types
    );

BOOST_AUTO_TEST_CASE(test_range_erase_same_iterators);
BOOST_AUTO_TEST_CASE(test_max_load_factor_extreme_factors);
BOOST_AUTO_TEST_CASE(test_min_load_factor_extreme_factors);
BOOST_AUTO_TEST_CASE(test_min_load_factor);
BOOST_AUTO_TEST_CASE(test_min_load_factor_range_erase);
BOOST_AUTO_TEST_CASE(test_rehash_empty);
BOOST_AUTO_TEST_CASE(test_compare);
BOOST_AUTO_TEST_CASE(test_clear);
BOOST_AUTO_TEST_CASE(test_clear_with_min_load_factor);
BOOST_AUTO_TEST_CASE(test_modify_value_through_iterator);
BOOST_AUTO_TEST_CASE(test_modify_value_through_iterator_with_const_qualifier);
BOOST_AUTO_TEST_CASE(test_extreme_bucket_count_value_construction);
BOOST_AUTO_TEST_CASE(test_range_construct);
BOOST_AUTO_TEST_CASE(test_assign_operator);
BOOST_AUTO_TEST_CASE(test_move_constructor);
BOOST_AUTO_TEST_CASE(test_move_constructor_empty);
BOOST_AUTO_TEST_CASE(test_move_operator);
BOOST_AUTO_TEST_CASE(test_move_operator_empty);
BOOST_AUTO_TEST_CASE(test_reassign_moved_object_move_constructor);
BOOST_AUTO_TEST_CASE(test_reassign_moved_object_move_operator);
BOOST_AUTO_TEST_CASE(test_use_after_move_constructor);
BOOST_AUTO_TEST_CASE(test_use_after_move_operator);
BOOST_AUTO_TEST_CASE(test_copy_constructor_and_operator);
BOOST_AUTO_TEST_CASE(test_copy_constructor_empty);
BOOST_AUTO_TEST_CASE(test_copy_operator_empty);
BOOST_AUTO_TEST_CASE(test_at);
BOOST_AUTO_TEST_CASE(test_contains);
BOOST_AUTO_TEST_CASE(test_equal_range);
BOOST_AUTO_TEST_CASE(test_access_operator);
BOOST_AUTO_TEST_CASE(test_swap);
BOOST_AUTO_TEST_CASE(test_swap_empty);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize_empty);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize_with_store_hash);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize_with_different_hash);
BOOST_AUTO_TEST_CASE(test_key_equal);
BOOST_AUTO_TEST_CASE(test_heterogeneous_lookups);
BOOST_AUTO_TEST_CASE(test_empty_map);
BOOST_AUTO_TEST_CASE(test_precalculated_hash);
BOOST_AUTO_TEST_CASE(test_erase_fast);

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_insert,
    HSet,
    test_types
    );

BOOST_AUTO_TEST_CASE(test_compare);
BOOST_AUTO_TEST_CASE(test_insert_pointer);
BOOST_AUTO_TEST_CASE(test_serialize_deserialize);
BOOST_AUTO_TEST_CASE(test_erase_fast);
std::int32_t utils::get_key< std::int32_t >(std::size_t counter);
std::int64_t utils::get_key< std::int64_t >(std::size_t counter);
std::string utils::get_key< std::string >(std::size_t counter);
std::int32_t utils::get_value< std::int32_t >(std::size_t counter);
std::int64_t utils::get_value< std::int64_t >(std::size_t counter);
std::string utils::get_value< std::string >(std::size_t counter);
void test_voxelmap_basic_ops();
void test_voxelmap_insert_2d_scan();

int main(
    ] int argc,
    ] char** argv
    );

void test_voxelmap_basic_ops();
void test_voxelmap_insert_2d_scan();

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

TEST_CLASS_MOVE_COPY_CTORS(mola::SparseVoxelPointCloud);
TEST_CLASS_MOVE_COPY_CTORS(mola::OccGrid);
void test_serialization();

int main(
    ] int argc,
    ] char** argv
    );

void test_voxelmap_basic_ops();
void test_voxelmap_insert_2d_scan();

int main(
    ] int argc,
    ] char** argv
    );

static void test1();

int main(
    ] int argc,
    ] char** argv
    );

static void test1();

int main(
    ] int argc,
    ] char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

MRPT_INITIALIZER(do_register_MolaViz);

int main(
    ] int argc,
    ] char** argv
    );

MRPT_FILL_ENUM(InitLocalization::FixedPose);
MRPT_FILL_ENUM(InitLocalization::FromStateEstimator);
MRPT_FILL_ENUM(InitLocalization::PitchAndRollFromIMU);
MRPT_FILL_ENUM(IterTermReason::Undefined);
MRPT_FILL_ENUM(IterTermReason::NoPairings);
MRPT_FILL_ENUM(IterTermReason::SolverError);
MRPT_FILL_ENUM(IterTermReason::MaxIterations);
MRPT_FILL_ENUM(IterTermReason::Stalled);
MRPT_FILL_ENUM(IterTermReason::QualityCheckpointFailed);
MRPT_FILL_ENUM(IterTermReason::HookRequest);
MRPT_FILL_ENUM(RobustKernel::None);
MRPT_FILL_ENUM(RobustKernel::GemanMcClure);
MRPT_FILL_ENUM(RobustKernel::Cauchy);

static bool se3_l2_internal(
    const mp2p_icp::Pairings& in,
    const WeightParameters& wp,
    const mrpt::math::TPoint3D& ct_local,
    const mrpt::math::TPoint3D& ct_global,
    mrpt::math::CQuaternionDouble& out_attitude,
    OutlierIndices& in_out_outliers
    );

static mrpt::poses::CPose3D gibbs2pose(const Eigen::Vector3d& v);

static OLAE_LinearSystems olae_build_linear_system(
    const Pairings& in,
    const WeightParameters& wp,
    const mrpt::math::TPoint3D& ct_local,
    const mrpt::math::TPoint3D& ct_global,
    OutlierIndices& in_out_outliers
    );

template <typename T>
static void push_back_copy(
    const T& o,
    T& me
    );

template <typename T>
static void push_back_move(
    T&& o,
    T& me
    );

template <typename CONTAINER>
void append_container_size(
    const CONTAINER& c,
    const std::string& name,
    std::string& ret
    );

static void append_from_sorted(
    const std::multimap<double, mrpt::tfest::TMatchingPair>& sorted,
    Pairings& out,
    const double ratio
    );

static void projectPoint(
    const mrpt::math::TPoint3D& P,
    const mrpt::img::TCamera& params,
    double& pixel_x,
    double& pixel_y
    );

static double phi(double x);
static double errorForMismatch(const double x);

static double errorForMismatch(
    const double DeltaRange,
    const double sigma
    );

MRPT_FILL_ENUM(TimestampAdjustMethod::EarliestIsZero);
MRPT_FILL_ENUM(TimestampAdjustMethod::MiddleIsZero);
MRPT_FILL_ENUM(TimestampAdjustMethod::Normalize);
MRPT_FILL_ENUM(DecimateMethod::FirstPoint);
MRPT_FILL_ENUM(DecimateMethod::ClosestToAverage);
MRPT_FILL_ENUM(DecimateMethod::VoxelAverage);
MRPT_FILL_ENUM(DecimateMethod::RandomPoint);

IMPLEMENTS_MRPT_OBJECT(
    FilterDecimateVoxelsQuadratic,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

MRPT_FILL_ENUM_MEMBER(
    mp2p_icp::Coordinate,
    X
    );

MRPT_FILL_ENUM_MEMBER(
    mp2p_icp::Coordinate,
    Y
    );

MRPT_FILL_ENUM_MEMBER(
    mp2p_icp::Coordinate,
    Z
    );

// macros

#define BOOST_TEST_MODULE

#define DECLARE_PARAMETER_IN_OPT( \
    __yaml, \
    __variable, \
    __object \
    )

#define DECLARE_PARAMETER_IN_REQ( \
    __yaml, \
    __variable, \
    __object \
    )

#define DECLARE_PARAMETER_OPT( \
    __yaml, \
    __variable \
    )

#define DECLARE_PARAMETER_REQ( \
    __yaml, \
    __variable \
    )

#define DLL_EXT

#define ENSURE_YAML_ENTRY_EXISTS( \
    _c, \
    _name \
    )

#define GET_DELTA( \
    inp, \
    inp_end, \
    delta \
    )

#define HEADER_PIXEL( \
    data, \
    pixel \
    )

#define MOLA_ARG_N( \
    _1, \
    _2, \
    _3, \
    _4, \
    _5, \
    _6, \
    _7, \
    _8, \
    _9, \
    _10, \
    N, \
    ... \
    )

#define MOLA_NARG(...)
#define MOLA_NARG_I_(...)
#define MOLA_REGISTER_MODULE(_classname)
#define MOLA_RSEQ_N()

#define MOLA_VERSION_CHECK( \
    major, \
    minor, \
    patch \
    )

#define MOLA_VFUNC( \
    name, \
    n \
    )

#define MOLA_VFUNC_( \
    name, \
    n \
    )

#define TEST_CLASS_MOVE_COPY_CTORS(_classname)

#define TSL_RH_CHECK_THROW( \
    S, \
    E \
    )

#define TSL_RH_CHECK_THROW_EITHER( \
    S, \
    E1, \
    E2 \
    )

#define TSL_RH_LIKELY(exp)
#define TSL_RH_NB_PRIMES

#define TSL_RH_THROW_OR_TERMINATE( \
    ex, \
    msg \
    )

#define TSL_RH_UNUSED(x)
#define TSL_RH_VERSION_MAJOR
#define TSL_RH_VERSION_MINOR
#define TSL_RH_VERSION_PATCH

#define VFUNC( \
    func, \
    ... \
    )

#define YAML_LOAD_MEMBER_OPT( \
    _varname, \
    _type \
    )

#define YAML_LOAD_MEMBER_REQ( \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT(...)

#define YAML_LOAD_OPT2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT3( \
    _param_str, \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT_DEG(...)

#define YAML_LOAD_OPT_DEG2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT_DEG3( \
    _param_str, \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ(...)

#define YAML_LOAD_REQ2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ3( \
    _param_str, \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ_DEG(...)

#define YAML_LOAD_REQ_DEG2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ_DEG3( \
    _param_str, \
    _varname, \
    _type \
    )

#define tsl_rh_assert(expr)

Typedefs

typedef boost::mpl::list<tsl::rh::power_of_two_growth_policy<2>, tsl::rh::power_of_two_growth_policy<4>, tsl::rh::prime_growth_policy, tsl::rh::mod_growth_policy<>, tsl::rh::mod_growth_policy<std::ratio<7, 2>>> test_types

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

typedef boost::mpl::list<tsl::robin_map<std::int64_t, std::int64_t>, tsl::robin_map<std::string, std::string>, tsl::robin_map<std::int64_t, std::int64_t, mod_hash<9>>, tsl::robin_map<std::string, std::string, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<self_reference_member_test, self_reference_member_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, true, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, false, tsl::rh::mod_growth_policy<>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, false, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, true, tsl::rh::mod_growth_policy<>>> test_types

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

typedef boost::mpl::list<tsl::robin_set<std::int64_t>, tsl::robin_set<std::string>, tsl::robin_set<self_reference_member_test>, tsl::robin_set<move_only_test>, tsl::robin_pg_set<self_reference_member_test>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, true, tsl::rh::prime_growth_policy>, tsl::robin_set<self_reference_member_test, std::hash<self_reference_member_test>, std::equal_to<self_reference_member_test>, std::allocator<self_reference_member_test>, true, tsl::rh::mod_growth_policy<>>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, false, tsl::rh::mod_growth_policy<>>> test_types

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Global Variables

static std::map<std::string, LoadedModules> loaded_lib_handled

From internal_load_lib_modules()

static std::size_t nb_custom_allocs = 0

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Global Functions

const std::map<std::string, LoadedModules>& get_loaded_modules()

Returns the current list of loaded module dyanmic libraries.

void internal_load_lib_modules(
    mrpt::system::COutputLogger& app,
    const std::vector<std::string>& lib_search_paths
    )

Loads all libs under lib_search_paths_.

Macros

#define BOOST_TEST_MODULE

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#define MOLA_VERSION_CHECK(major, minor, patch)

To be used in #if() checks for >= minimum MOLA versions.

#define TSL_RH_CHECK_THROW(S, E)

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#define TSL_RH_VERSION_MAJOR

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.