[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

utilities.hxx File Reference
#include "config.hxx"
#include "error.hxx"
#include "metaprogramming.hxx"
#include "tuple.hxx"
#include "diff2d.hxx"
#include "mathutil.hxx"
#include <string>
#include <sstream>
#include <cctype>
#include <tuple>

Go to the source code of this file.

Namespaces

namespace  vigra
 

Macros

#define VIGRA_FINALLY(destructor)    VIGRA_FINALLY_IMPL(destructor, __COUNTER__)
 

Functions

template<class T >
std::string asString (T t)(...)
 
template<typename TPL , typename FUNCTOR >
void for_each_in_tuple (TPL &&t, FUNCTOR &&f)
 
std::string normalizeString (std::string const &s)
 
std::string tolower (std::string s)
 

Macro Definition Documentation

◆ VIGRA_FINALLY

#define VIGRA_FINALLY (   destructor)     VIGRA_FINALLY_IMPL(destructor, __COUNTER__)

Emulate the 'finally' keyword as known from Python and other languages.

This macro improves upon the famous Resource Acquisition Is Initialization idiom, where a resource (e.g. heap memory or a mutex) is automatically free'ed when program execution leaves the current scope. This is normally achieved by placing a call which releases the resource into the destructor of a dedicated helper class (e.g. std::unique_ptr or std::lock_guard<std::mutex>).

Traditionally, a separate helper class is needed for every type of resource to be handled. In contrast, the macro VIGRA_FINALLY creates such a class on the fly by means of an embedded lambda expression.

Usage:

#include <vigra/utilities.hxx>

std::mutex my_mutex;
...
{
// the following two lines are equivalent to
// std::unique_ptr<std::string> my_string = new std::string("foo");
std::string * my_string = new std::string("foo");
VIGRA_FINALLY(delete my_string);
// the following two lines are equivalent to
// std::lock_guard<std::mutex> lock(my_mutex);
my_mutex.lock();
VIGRA_FINALLY(my_mutex.unlock());
...
}
// the string has been deallocated and the mutex is unlocked
#define VIGRA_FINALLY(destructor)
Definition utilities.hxx:207

You can pass any code to this macro. Multiple statements must be enclosed in braces as usual. Arbitrary many calls to VIGRA_FINALLY can be placed in the same scope. Their actions will be executed in the reversed order of declaration:

int i = 0;
...
{
VIGRA_FINALLY({ // execute multiple statements
i = i*i;
++i;
});
VIGRA_FINALLY( i += 2 ); // this executes first
assert(i == 0); // as yet, nothing happend
}
assert(i == 5); // 'finally' code was executed in reversed order at end-of-scope

This idea was popularized by Marko Tintor in The Auto Macro: A Clean Approach to C++ Error Handling.

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.12.2