Detailed Description

src/util/memoized.h

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Classes
class	memoized
	Simple memoization implementation for expensive methods. More...

class	memoized< T, Ret >

class	memoized< T, Ret, bool >

class	query_driver_output_extractor
	Executed compiler frontend and extract default system paths. More...

class	thread_pool_executor
	Simple thread pool executor for parallelizing diagram generation. More...

Functions
std::string	get_process_output (const std::string &command)
	Execute a shell `command` and return console output as string.

void	check_process_output (const std::string &command)
	Execute command shell and throw exception if command fails.

std::string	get_env (const std::string &name)
	Get value of an environment variable.

bool	is_git_repository ()
	Check if `$PWD` is in a Git repository.

std::string	run_git_command (const std::string &cmd, const std::string &env_override)

std::string	get_git_branch ()
	Get current Git branch.

std::string	get_git_revision ()
	Get current Git revision.

std::string	get_git_commit ()
	Get current Git commit.

std::string	get_git_toplevel_dir ()
	Get path to the top level Git directory.

std::string	get_os_name ()
	Get descriptive name of the current operating system.

std::string	ltrim (const std::string &s)
	Left trim a string.

std::string	rtrim (const std::string &s)
	Right trim a string.

std::string	trim_typename (const std::string &s)
	Remove `typename` prefix from a string if exists.

std::string	trim (const std::string &s)
	Trim a string.

std::optional< std::pair< std::string, std::string > >	split_at_first (const std::string &separator, const std::string &input)
	Split string at first occurence of separator.

std::vector< std::string >	split (std::string str, std::string_view delimiter, bool skip_empty=true)
	Split a string using delimiter.

std::vector< std::string >	split_isspace (std::string str)

std::string	join (const std::vector< std::string > &toks, std::string_view delimiter)
	Join `toks` into string using `delimiter` as separator.

std::string	abbreviate (const std::string &s, unsigned int max_length)
	Abbreviate string to max_length, and replace last 3 characters with ellipsis.

bool	find_element_alias (const std::string &input, std::tuple< std::string, size_t, size_t > &result)
	Find element alias in Puml note.

bool	replace_all (std::string &input, const std::string &pattern, const std::string &replace_with)
	Find and replace in string.

template<>
bool	starts_with (const std::string &s, const std::string &prefix)

template<>
bool	ends_with (const std::string &value, const std::string &suffix)

std::size_t	hash_seed (std::size_t seed)
	Generate a hash seed.

std::string	path_to_url (const std::filesystem::path &p)
	Convert filesystem path to url path.

std::filesystem::path	ensure_path_is_absolute (const std::filesystem::path &p, const std::filesystem::path &root=std::filesystem::current_path())
	Ensure path is absolute.

bool	is_relative_to (const std::filesystem::path &parent, const std::filesystem::path &child)
	Check if a given path is relative to another path.

std::string	format_message_comment (const std::string &comment, unsigned width)

std::optional< std::pair< std::string, std::string > >	find_entry_by_path_prefix (const std::map< std::string, std::string > &m, const std::string &path)

template<typename T , typename S >
std::unique_ptr< T >	unique_pointer_cast (std::unique_ptr< S > &&p) noexcept

template<typename T , typename F >
void	erase_if (std::vector< T > &v, F &&f)
	Remove and erase elements from a vector.

template<typename... Args>
std::string	join (std::string_view delimiter, Args... args)
	Join `args` into string using `delimiter` as separator.

template<typename T >
void	append (std::vector< T > &l, const std::vector< T > &r)
	Appends a vector to a vector.

template<typename T >
bool	starts_with (const T &col, const T &prefix)
	Checks if collection starts with a prefix.

template<>
bool	starts_with (const std::string &s, const std::string &prefix)

template<typename T >
bool	ends_with (const T &value, const T &suffix)

template<>
bool	ends_with (const std::string &value, const std::string &suffix)

template<typename T >
bool	ends_with (const std::vector< T > &col, const std::vector< T > &suffix)

template<typename T >
void	remove_prefix (std::vector< T > &col, const std::vector< T > &prefix)
	Removes prefix sequence of elements from the beginning of col.

template<typename T , typename E >
bool	contains (const T &container, const E &element)

template<typename T , typename F >
void	for_each (const T &collection, F &&func)

template<typename R , typename T , typename F >
std::vector< R >	map (const std::vector< T > &in, F &&f)

template<typename T , typename F , typename FElse >
void	if_not_null (const T *pointer, F &&func, FElse &&func_else)

template<typename T , typename F >
void	if_not_null (const T *pointer, F &&func)

template<typename F , typename FElse >
void	_if (const bool condition, F &&func, FElse &&func_else)

template<typename F >
void	_if (const bool condition, F &&func)

template<typename T >
void	remove_duplicates (T &coll)

Variables
static const auto	WHITESPACE = " \n\r\t\f\v"

constexpr unsigned	kDefaultMessageCommentWidth {25U}

Function Documentation

◆ _if() [1/2]

template<typename F >

void clanguml::util::_if	(	const bool	condition,
		F &&	func
	)

Definition at line 379 of file util.h.

{
    _if(condition, std::forward<F>(func), []() {});
}

◆ _if() [2/2]

template<typename F , typename FElse >

void clanguml::util::_if	(	const bool	condition,
		F &&	func,
		FElse &&	func_else
	)

Definition at line 369 of file util.h.

{
    if (condition) {
        std::forward<F>(func)();
    }
    else {
        std::forward<FElse>(func_else)();
    }
}

◆ abbreviate()

std::string clanguml::util::abbreviate	(	const std::string &	s,
		unsigned int	max_length
	)

Abbreviate string to max_length, and replace last 3 characters with ellipsis.

Parameters

s	Input string
max_length	Maximum length

Returns: Abbreviated string

Definition at line 333 of file util.cc.

{
    if (s.size() <= max_length)
        return s;
 
    auto res = s;
 
    res.resize(max_length);
 
    if (res.size() > 3) {
        res.replace(res.size() - 3, 3, 3, '.');
    }
 
    return res;
}

◆ append()

template<typename T >

void clanguml::util::append	(	std::vector< T > &	l,
		const std::vector< T > &	r
	)

Appends a vector to a vector.

Template Parameters

T

Parameters

l
r

Definition at line 257 of file util.h.

{
    l.insert(l.end(), r.begin(), r.end());
}

◆ check_process_output()

void clanguml::util::check_process_output ( const std::string & command )

Execute command shell and throw exception if command fails.

Parameters

command Command to execute

Definition at line 97 of file util.cc.

{
    constexpr size_t kBufferSize{1024};
    std::array<char, kBufferSize> buffer{};
    int result{EXIT_FAILURE};
    std::string output;
    pipe_t pipe{command, result};
 
    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
 
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
        output += buffer.data();
    }
 
    pipe.reset();
 
    if (result != EXIT_SUCCESS) {
        throw std::runtime_error(
            fmt::format("External command '{}' failed: {}", command, output));
    }
}

◆ contains()

template<typename T , typename E >

bool clanguml::util::contains	(	const T &	container,
		const E &	element
	)

Returns true if element exists in container.

Template Parameters

T
E

Parameters

container
element

Returns

Definition at line 321 of file util.h.

{
    if constexpr (std::is_pointer_v<E>) {
        return std::find_if(container.begin(), container.end(),
                   [&element](const auto &e) { return *e == *element; }) !=
            container.end();
    }
    else if constexpr (std::is_same_v<std::remove_cv_t<T>, std::string>) {
        return container.find(element) != std::string::npos;
    }
    else {
        return std::find(container.begin(), container.end(), element) !=
            container.end();
    }
}

◆ ends_with() [1/4]

template<>

bool clanguml::util::ends_with	(	const std::string &	value,
		const std::string &	suffix
	)

Definition at line 391 of file util.cc.

{
    if (suffix.size() > value.size())
        return false;
    return std::equal(suffix.rbegin(), suffix.rend(), value.rbegin());
}

◆ ends_with() [2/4]

template<>

bool clanguml::util::ends_with	(	const std::string &	value,
		const std::string &	suffix
	)

Definition at line 391 of file util.cc.

{
    if (suffix.size() > value.size())
        return false;
    return std::equal(suffix.rbegin(), suffix.rend(), value.rbegin());
}

◆ ends_with() [3/4]

template<typename T >

bool clanguml::util::ends_with	(	const std::vector< T > &	col,
		const std::vector< T > &	suffix
	)

Definition at line 286 of file util.h.

{
    if (suffix.size() > col.size())
        return false;
 
    return std::vector<std::string>(suffix.rbegin(), suffix.rend()) ==
        std::vector<std::string>(col.rbegin(), col.rbegin() + suffix.size());
}

◆ ends_with() [4/4]

template<typename T >

bool clanguml::util::ends_with	(	const T &	value,
		const T &	suffix
	)

◆ ensure_path_is_absolute()

std::filesystem::path clanguml::util::ensure_path_is_absolute	(	const std::filesystem::path &	p,
		const std::filesystem::path &	root = `std::filesystem::current_path()`
	)

Ensure path is absolute.

If path is absolute, return the p. If path is not absolute, make it absolute with respect to root directory.

Parameters

p	Path to modify
root	Root against which the path should be made absolute

Returns: Absolute path

Definition at line 435 of file util.cc.

{
    if (p.is_absolute())
        return p;
 
    auto result = root / p;
    result = result.lexically_normal();
    result.make_preferred();
 
    return result;
}

◆ erase_if()

template<typename T , typename F >

void clanguml::util::erase_if	(	std::vector< T > &	v,
		F &&	f
	)

Remove and erase elements from a vector.

Template Parameters

T	Element type
F	Functor type

Parameters

v	Vector to remove elements from
f	Functor to decide which elements to remove

Definition at line 182 of file util.h.

{
    v.erase(std::remove_if(v.begin(), v.end(), std::forward<F>(f)), v.end());
}

◆ find_element_alias()

bool clanguml::util::find_element_alias	(	const std::string &	input,
		std::tuple< std::string, size_t, size_t > &	result
	)

Find element alias in Puml note.

Finds aliases of the form (entity_name) in the Puml notes or directives. The match, if any, is returned in the result tuple: (entity_name, offset, length)

Returns: True if match was found

Definition at line 349 of file util.cc.

{
    const std::regex alias_regex(R"((@A\‍([^\).]+\)))");
 
    auto alias_it =
        std::sregex_iterator(input.begin(), input.end(), alias_regex);
    auto end_it = std::sregex_iterator();
 
    if (alias_it == end_it)
        return false;
 
    const std::smatch &match = *alias_it;
    const std::string alias = match.str().substr(3, match.str().size() - 4);
 
    std::get<0>(result) = alias;
    std::get<1>(result) = match.position();
    std::get<2>(result) = match.length();
 
    return true;
}

◆ find_entry_by_path_prefix()

std::optional< std::pair< std::string, std::string > > clanguml::util::find_entry_by_path_prefix	(	const std::map< std::string, std::string > &	m,
		const std::string &	path
	)

Definition at line 500 of file util.cc.

{
    if (m.empty())
        return {};
 
    // Extract keys and sort them by length in descending order
    std::vector<std::string> keys;
    keys.reserve(m.size());
    for (const auto &[key, pattern] : m) {
        keys.push_back(key);
    }
 
    std::sort(keys.begin(), keys.end(),
        [](const std::string &a, const std::string &b) {
            return a.size() > b.size();
        });
 
    std::filesystem::path file_path{path};
 
    for (const auto &key : keys) {
        const auto &pattern = m.at(key);
        std::filesystem::path key_path{key};
 
        if (is_relative_to(file_path, key_path)) {
            return {{key, pattern}};
        }
    }
 
    if ((path.empty() || file_path.is_relative() || path == ".") &&
        m.count(".") > 0) {
        return {{".", m.at(".")}};
    }
 
    return {};
}

◆ for_each()

template<typename T , typename F >

void clanguml::util::for_each	(	const T &	collection,
		F &&	func
	)

Definition at line 337 of file util.h.

{
    std::for_each(std::begin(collection), std::end(collection),
        std::forward<decltype(func)>(func));
}

◆ format_message_comment()

std::string clanguml::util::format_message_comment	(	const std::string &	comment,
		unsigned	width
	)

Definition at line 464 of file util.cc.

{
    if (width == 0)
        return comment;
 
    std::string result;
 
    if (comment.empty())
        return result;
 
    auto tokens = split_isspace(comment);
 
    if (tokens.empty())
        return result;
 
    unsigned current_line_length{0};
    for (const auto &token : tokens) {
        if (current_line_length < width) {
            result += token;
            result += ' ';
        }
        else {
            result.back() = '\n';
            current_line_length = 0;
            result += token;
            result += ' ';
        }
 
        current_line_length += token.size() + 1;
    }
 
    result.pop_back();
 
    return result;
}

◆ get_env()

std::string clanguml::util::get_env ( const std::string & name )

Get value of an environment variable.

Parameters

name	Name of the environment variable

Returns: Value of the environment variable, or empty if it doesn't exist

Definition at line 121 of file util.cc.

{
#if defined(__linux) || defined(__unix)
    const char *value = std::getenv(name.c_str()); // NOLINT
 
    if (value == nullptr)
        return {};
 
    return std::string{value};
#elif defined(WINDOWS) || defined(_WIN32) || defined(WIN32)
    static constexpr auto kMaxEnvLength = 2096U;
    static char value[kMaxEnvLength];
    const DWORD ret =
        GetEnvironmentVariableA(name.c_str(), value, kMaxEnvLength);
    if (ret == 0 || ret > kMaxEnvLength)
        return {};
    else
        return value;
#else
    return {};
#endif
}

◆ get_git_branch()

std::string clanguml::util::get_git_branch ( )

Get current Git branch.

Returns: Name of the current Git branch

Definition at line 183 of file util.cc.

{
    return run_git_command(
        "git rev-parse --abbrev-ref HEAD", "CLANGUML_GIT_BRANCH");
}

◆ get_git_commit()

std::string clanguml::util::get_git_commit ( )

Get current Git commit.

Returns: Latest Git commit hash

Definition at line 195 of file util.cc.

{
    return run_git_command("git rev-parse HEAD", "CLANGUML_GIT_COMMIT");
}

◆ get_git_revision()

std::string clanguml::util::get_git_revision ( )

Get current Git revision.

Generates a Git revision tag using git describe --tags --always command

Returns: Current repository Git revision

Definition at line 189 of file util.cc.

{
    return run_git_command(
        "git describe --tags --always", "CLANGUML_GIT_REVISION");
}

◆ get_git_toplevel_dir()

std::string clanguml::util::get_git_toplevel_dir ( )

Get path to the top level Git directory.

Returns: Absolut path to the nearest directory containing .git folder

Definition at line 200 of file util.cc.

{
    return run_git_command(
        "git rev-parse --show-toplevel", "CLANGUML_GIT_TOPLEVEL_DIR");
}

◆ get_os_name()

std::string clanguml::util::get_os_name ( )

Get descriptive name of the current operating system.

Returns: Name of the operating system

Definition at line 206 of file util.cc.

{
#ifdef _WIN32
    return "Windows, 32-bit";
#elif _WIN64
    return "Windows, 64-bit";
#elif __has_include(<sys/utsname.h>)
    struct utsname utsn; // NOLINT
    uname(&utsn);
    return fmt::format("{} {} {}", utsn.sysname, utsn.machine, utsn.release);
#elif __linux__
    return "Linux";
#elif __APPLE__ || __MACH__
    return "macOS";
#elif __FreeBSD__
    return "FreeBSD";
#elif __unix__ || __unix
    return "Unix";
#else
    return "Unknown";
#endif
}

◆ get_process_output()

std::string clanguml::util::get_process_output ( const std::string & command )

Execute a shell command and return console output as string.

Parameters

command Shell command to execute

Returns: Console output of the command

Definition at line 70 of file util.cc.

{
    constexpr size_t kBufferSize{1024};
    std::array<char, kBufferSize> buffer{};
    std::string output;
    int result{EXIT_FAILURE};
 
    pipe_t pipe{command, result};
 
    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
 
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
        output += buffer.data();
    }
 
    pipe.reset();
 
    if (result != EXIT_SUCCESS) {
        throw std::runtime_error(
            fmt::format("External command '{}' failed: {}", command, output));
    }
 
    return output;
}

◆ hash_seed()

std::size_t clanguml::util::hash_seed ( std::size_t seed )

Generate a hash seed.

Parameters

seed	Initial seed.

Returns: Hash seed.

Definition at line 398 of file util.cc.

{
    constexpr auto kSeedStart{0x6a3712b5};
    constexpr auto kSeedShiftFirst{6};
    constexpr auto kSeedShiftSecond{2};
 
    return kSeedStart + (seed << kSeedShiftFirst) + (seed >> kSeedShiftSecond);
}

◆ if_not_null() [1/2]

template<typename T , typename F >

void clanguml::util::if_not_null	(	const T *	pointer,
		F &&	func
	)

Definition at line 363 of file util.h.

{
    if_not_null(pointer, std::forward<F>(func), []() {});
}

◆ if_not_null() [2/2]

template<typename T , typename F , typename FElse >

void clanguml::util::if_not_null	(	const T *	pointer,
		F &&	func,
		FElse &&	func_else
	)

Definition at line 353 of file util.h.

{
    if (pointer != nullptr) {
        std::forward<F>(func)(pointer);
    }
    else {
        std::forward<FElse>(func_else)();
    }
}

◆ is_git_repository()

bool clanguml::util::is_git_repository ( )

Check if $PWD is in a Git repository.

This can be overridden by exporting CLANGUML_GIT_COMMIT environment variable.

Returns: True, if the current directory is in a Git repository

Definition at line 144 of file util.cc.

{
    const auto env = get_env("CLANGUML_GIT_COMMIT");
 
    if (!env.empty())
        return true;
 
    std::string output;
 
    try {
        output = get_process_output("git rev-parse --git-dir");
    }
    catch (std::runtime_error &e) {
        return false;
    }
 
    return contains(trim(output), ".git");
}

◆ is_relative_to()

bool clanguml::util::is_relative_to	(	const std::filesystem::path &	parent,
		const std::filesystem::path &	child
	)

Check if a given path is relative to another path.

Parameters

parent	The path to be checked for relativity.
right	The base path against which the relativity is checked.

Returns: True if the child path is relative to the parent path, false otherwise.

Definition at line 448 of file util.cc.

{
    if (child.has_root_directory() != base.has_root_directory())
        return false;
 
    const auto child_ln = child.lexically_normal();
    const auto base_ln = base.lexically_normal();
 
    if (child_ln == base_ln)
        return true;
 
    auto rel = child_ln.lexically_relative(base_ln);
    return !rel.empty() && rel.native()[0] != '.';
}

◆ join() [1/2]

std::string clanguml::util::join	(	const std::vector< std::string > &	toks,
		std::string_view	delimiter
	)

Join toks into string using delimiter as separator.

Parameters

toks	Elements to join into string
delimiter	Separator to use to join elements

Returns: Concatenated elements into one string

Definition at line 327 of file util.cc.

{
    return fmt::format("{}", fmt::join(toks, delimiter));
}

◆ join() [2/2]

template<typename... Args>

std::string clanguml::util::join	(	std::string_view	delimiter,
		Args...	args
	)

Join args into string using delimiter as separator.

Template Parameters

Args	Element type

Parameters

delimiter	Separator to use to join elements
args	Elements to join into string

Returns: Arguments concatenated into one string

Definition at line 206 of file util.h.

{
    std::vector<std::string> coll{args...};
 
    erase_if(coll, [](const auto &s) {
        return s.find_first_not_of(" \t") == std::string::npos;
    });
 
    return fmt::format("{}", fmt::join(coll, delimiter));
}

◆ ltrim()

std::string clanguml::util::ltrim ( const std::string & s )

Left trim a string.

Parameters

s	Input string

Returns: Left trimmed string

Definition at line 229 of file util.cc.

{
    const size_t start = s.find_first_not_of(WHITESPACE);
    return (start == std::string::npos) ? "" : s.substr(start);
}

◆ map()

template<typename R , typename T , typename F >

std::vector< R > clanguml::util::map	(	const std::vector< T > &	in,
		F &&	f
	)

Definition at line 344 of file util.h.

{
    std::vector<R> out;
    std::transform(
        in.cbegin(), in.cend(), std::back_inserter(out), std::forward<F>(f));
    return out;
}

◆ path_to_url()

std::string clanguml::util::path_to_url ( const std::filesystem::path & p )

Convert filesystem path to url path.

The purpose of this function is to make sure that a path can be used in a URL, e.g. it's separators are POSIX-style.

Parameters

p	Path to convert

Returns: String representation of the path in URL format

Definition at line 407 of file util.cc.

{
    std::vector<std::string> path_tokens;
    auto it = p.begin();
    if (p.has_root_directory()) {
#ifdef _MSC_VER
        // On Windows convert the root path using its drive letter, e.g.:
        //   C:\A\B\include.h -> /c/A/B/include.h
        if (p.root_name().string().size() > 1) {
            if (p.is_absolute()) {
                path_tokens.push_back(std::string{
                    std::tolower(p.root_name().string().at(0), std::locale())});
            }
            it++;
        }
#endif
        it++;
    }
 
    for (; it != p.end(); it++)
        path_tokens.push_back(it->string());
 
    if (p.has_root_directory())
        return fmt::format("/{}", fmt::join(path_tokens, "/"));
 
    return fmt::format("{}", fmt::join(path_tokens, "/"));
}

◆ remove_duplicates()

template<typename T >

void clanguml::util::remove_duplicates ( T & coll )

Definition at line 384 of file util.h.

{
    std::sort(coll.begin(), coll.end());
    coll.erase(std::unique(coll.begin(), coll.end()), coll.end());
}

◆ remove_prefix()

template<typename T >

void clanguml::util::remove_prefix	(	std::vector< T > &	col,
		const std::vector< T > &	prefix
	)

Removes prefix sequence of elements from the beginning of col.

Template Parameters

T

Parameters

col
prefix

Definition at line 303 of file util.h.

{
    if (!starts_with(col, prefix))
        return;
 
    col = std::vector<T>(col.begin() + prefix.size(), col.end());
}

◆ replace_all()

bool clanguml::util::replace_all	(	std::string &	input,
		const std::string &	pattern,
		const std::string &	replace_with
	)

Find and replace in string.

Replaces all occurences of pattern with replace_with in input string.

Returns: True if at least on replacement was made

Definition at line 371 of file util.cc.

{
    bool replaced{false};
 
    auto pos = input.find(pattern);
    while (pos < input.size()) {
        input.replace(pos, pattern.size(), replace_with);
        pos = input.find(pattern, pos + replace_with.size());
        replaced = true;
    }
 
    return replaced;
}

◆ rtrim()

std::string clanguml::util::rtrim ( const std::string & s )

Right trim a string.

Parameters

s	Input string

Returns: Right trimmed string

Definition at line 235 of file util.cc.

{
    const size_t end = s.find_last_not_of(WHITESPACE);
    return (end == std::string::npos) ? "" : s.substr(0, end + 1);
}

◆ run_git_command()

std::string clanguml::util::run_git_command	(	const std::string &	cmd,
		const std::string &	env_override
	)

Definition at line 163 of file util.cc.

{
    auto env = get_env(env_override);
 
    if (!env.empty())
        return env;
 
    std::string output;
 
    try {
        output = get_process_output(cmd);
    }
    catch (std::runtime_error &e) {
        return {};
    }
 
    return trim(output);
}

◆ split()

std::vector< std::string > clanguml::util::split	(	std::string	str,
		std::string_view	delimiter,
		bool	skip_empty = `true`
	)

Split a string using delimiter.

Basic string split function, because C++ stdlib does not have one. In case the string does not contain the delimiter, the original string is returned as the only element of the vector.

Parameters

str	String to split
delimiter	Delimiter string
skip_empty	Skip empty toks between delimiters if true

Returns: Vector of string tokens.

Definition at line 270 of file util.cc.

{
    std::vector<std::string> result;
 
    if (!contains(str, delimiter)) {
        if (!str.empty())
            result.push_back(std::move(str));
        else if (!skip_empty)
            result.push_back(std::move(str));
    }
    else
        while (static_cast<unsigned int>(!str.empty()) != 0U) {
            auto index = str.find(delimiter);
            if (index != std::string::npos) {
                auto tok = str.substr(0, index);
                if (!tok.empty())
                    result.push_back(std::move(tok));
                else if (!skip_empty)
                    result.push_back(std::move(tok));
 
                str = str.substr(index + delimiter.size());
            }
            else {
                if (!str.empty())
                    result.push_back(std::move(str));
                else if (!skip_empty)
                    result.push_back(std::move(str));
                str = "";
            }
        }
 
    return result;
}

◆ split_at_first()

std::optional< std::pair< std::string, std::string > > clanguml::util::split_at_first	(	const std::string &	separator,
		const std::string &	input
	)

Split string at first occurence of separator.

Parameters

separator
input

Returns: Elements from

Definition at line 252 of file util.cc.

{
    std::optional<std::pair<std::string, std::string>> res;
 
    std::size_t pos = input.find(separator);
 
    if (pos == std::string::npos) {
        return res;
    }
 
    auto before = input.substr(0, pos);
    auto after = input.substr(pos + separator.size());
 
    return std::make_optional<std::pair<std::string, std::string>>(
        std::move(before), std::move(after));
}

◆ split_isspace()

std::vector< std::string > clanguml::util::split_isspace ( std::string str )

Definition at line 305 of file util.cc.

{
    std::vector<std::string> result;
 
    while (static_cast<unsigned int>(!str.empty()) != 0U) {
        auto index = std::find_if(
            str.begin(), str.end(), [](auto c) { return std::isspace(c); });
        if (index != str.end()) {
            auto tok = str.substr(0, std::distance(str.begin(), index));
            if (!tok.empty())
                result.push_back(std::move(tok));
            str = str.substr(std::distance(str.begin(), index) + 1);
        }
        else {
            if (!str.empty())
                result.push_back(str);
            str = "";
        }
    }
    return result;
}

◆ starts_with() [1/3]

template<>

bool clanguml::util::starts_with	(	const std::string &	s,
		const std::string &	prefix
	)

Definition at line 386 of file util.cc.

{
    return s.rfind(prefix, 0) == 0;
}

◆ starts_with() [2/3]

template<>

bool clanguml::util::starts_with	(	const std::string &	s,
		const std::string &	prefix
	)

Definition at line 386 of file util.cc.

{
    return s.rfind(prefix, 0) == 0;
}

◆ starts_with() [3/3]

template<typename T >

bool clanguml::util::starts_with	(	const T &	col,
		const T &	prefix
	)

Checks if collection starts with a prefix.

Template Parameters

T	e.g. std::vector<std::string>

Parameters

col	Collection to be checked against prefix
prefix	Container, which specifies the prefix

Returns: true if first prefix.size() elements of col are equal to prefix

Definition at line 270 of file util.h.

{
    if (prefix.size() > col.size())
        return false;
 
    return std::search(col.begin(), col.end(), prefix.begin(), prefix.end()) ==
        col.begin();
}

◆ trim()

std::string clanguml::util::trim ( const std::string & s )

Trim a string.

Parameters

s	Input string

Returns: Trimmed string

Definition at line 250 of file util.cc.

250{ return rtrim(ltrim(s)); }

◆ trim_typename()

std::string clanguml::util::trim_typename ( const std::string & s )

Remove typename prefix from a string if exists.

Parameters

s	Input string

Returns: String without typename prefix

Definition at line 241 of file util.cc.

{
    auto res = trim(s);
    if (res.find("typename ") == 0)
        return res.substr(strlen("typename "));
 
    return res;
}

◆ unique_pointer_cast()

template<typename T , typename S >

std::unique_ptr< T > clanguml::util::unique_pointer_cast ( std::unique_ptr< S > && p )

noexcept

Definition at line 137 of file util.h.

{
    if (T *const converted = dynamic_cast<T *>(p.get())) {
        std::move(p).release(); // NOLINT
        return std::unique_ptr<T>{converted};
    }
 
    return {};
}

Variable Documentation

◆ kDefaultMessageCommentWidth

constexpr unsigned clanguml::util::kDefaultMessageCommentWidth {25U}

constexpr

Definition at line 33 of file util.h.

◆ WHITESPACE

const auto clanguml::util::WHITESPACE = " \n\r\t\f\v"

static

Definition at line 29 of file util.cc.

Detailed Description

Classes

Functions

Variables

Function Documentation

◆ _if() [1/2]

◆ _if() [2/2]

◆ abbreviate()

◆ append()

◆ check_process_output()

◆ contains()

◆ ends_with() [1/4]

◆ ends_with() [2/4]

◆ ends_with() [3/4]

◆ ends_with() [4/4]

◆ ensure_path_is_absolute()

◆ erase_if()

◆ find_element_alias()

◆ find_entry_by_path_prefix()

◆ for_each()

◆ format_message_comment()

◆ get_env()

◆ get_git_branch()

◆ get_git_commit()

◆ get_git_revision()

◆ get_git_toplevel_dir()

◆ get_os_name()

◆ get_process_output()

◆ hash_seed()

◆ if_not_null() [1/2]

◆ if_not_null() [2/2]

◆ is_git_repository()

◆ is_relative_to()

◆ join() [1/2]

◆ join() [2/2]

◆ ltrim()

◆ map()

◆ path_to_url()

◆ remove_duplicates()

◆ remove_prefix()

◆ replace_all()

◆ rtrim()

◆ run_git_command()

◆ split()

◆ split_at_first()

◆ split_isspace()

◆ starts_with() [1/3]

◆ starts_with() [2/3]

◆ starts_with() [3/3]

◆ trim()

◆ trim_typename()

◆ unique_pointer_cast()

Variable Documentation

◆ kDefaultMessageCommentWidth

◆ WHITESPACE