util.hh

Go to the documentation of this file.

#ifndef _DRAMA2_UTIL_INC
#define _DRAMA2_UTIL_INC
 
/*
 * History:
     07-Mar-2015 - TJF - Original version
     30-Sep-2016 - TJF - Start of history after development.
                         Add StatusToString().
 
 * The above ID is for Doxygen, this one has the format ACMM is looking for.
 * "@(#) $Id$"
 */
 
#include <string>
#include "drama2_err.h"
#include "status.h"
#include <atomic>
#include <type_traits>
 
#ifdef RUNNING_DOXYGEN
#define D2DEPRECATED /* */
 
#else
 
#ifdef __GNUC__
#define D2DEPRECATED __attribute__ ((deprecated))
#define D2DEPRECATED_EXPLAIN(_a_) __attribute__ ((deprecated(_a_))) // Version with string to help resolve.
#else
#define D2DEPRECATED /* */
#define D2DEPRECATED_EXPLAIN(_a_) /* _a_ */
#endif
 
#endif // RUNNING_DOXYGEN
 
/*
 * The D2_FMT_DEPRECATED macro is marking methods that use the old
 * SafePrintf() style of formatting string but for which we have
 * a replacement that uses the now preferred fmt::format approach.  
 * 
 * The marking of these methods as depreciated is likely to generate 
 * lots of warning in user code, as there is a lot of code
 * using the old approach.  This impacts MessageUser() methods,
 * LogS() methods and DramaTHROW_S() calls.  
 * 
 * You can disable the warning by defining the macro 
 * D2_NO_FMT_DEPRECATION_ALERTS before including drama.hh.
 */
//#define D2_NO_FMT_DEPRECATION_ALERTS  // Define this to disable the format related depreciation warnings
#if defined(D2_NO_FMT_DEPRECATION_ALERTS)
#define D2_FMT_DEPRECATED(_a_) /* */
 
#elif defined(__GNUC__)
#define D2_FMT_DEPRECATED(_a_) __attribute__((deprecated(_a_)))
 
#else
#define D2_FMT_DEPRECATED(_a_) /* _a_ */
#endif
 
namespace drama { 
 
    template <typename Container>
    void
    stringtok (Container &container, std::string const &in,
               const char * const delimiters = " \t\n\r")
    {
        /*
         * This was sourced from
         *     http://gcc.gnu.org/onlinedocs/libstdc++/21_strings/stringtok_h.txt
         *
         * on 25/Jun/03.
         *
         * After following a reference on
         *     http://gcc.gnu.org/onlinedocs/libstdc++/21_strings/howto.html#3
         *
         *   indicating it was suggested by Chris King and tweaked by 
         *     Petr Prikryl.
         *
         *  There is apparently no copyright notice associated with it.
         */
 
        const std::string::size_type len = in.length();
        std::string::size_type i = 0;
        
        while ( i < len )
        {
            // eat leading whitespace
            i = in.find_first_not_of (delimiters, i);
            if (i == std::string::npos)
                return;   // nothing left but white space
            
            // find the end of the token
            std::string::size_type j = in.find_first_of (delimiters, i);
            
            // push token
            if (j == std::string::npos) {
                container.push_back (in.substr(i));
                return;
            } else
                container.push_back (in.substr(i, j-i));
            
            // set up for next loop
            i = j + 1;
        }
    }
 
 
    std::string FindFile(const std::string &spec, bool impdir=false);
 
 
 
 
    extern std::string StatusToString(StatusType status);
 
 
    template <typename T>
    class ScopeGuard {
    private:
        T & _item;  // Reference to item.
        T _exitVal; // Value to set when destroyed.
    public:
        ScopeGuard(T &item, const T executionVal) : _item(item) {
            _exitVal = _item;       // Save current value.
            _item = executionVal;
        }
        ScopeGuard(T &item, const T executionVal, const T exitVal) : _item(item), _exitVal(exitVal) {
            _item = executionVal;
        }
 
        ~ScopeGuard() {
            _item = _exitVal;
        }
 
    };
 
    template <typename AT, typename T>
    class ScopeGuardAtomic {
        static_assert(std::is_same<AT, std::atomic<T> >::value, "Type AT is not of type std::atomic<T>   (Where T = initial/exit value type and AT is the type of the item we are guarding)");
    private:
        AT & _item;  // Reference to item.
        T _exitVal; // Value to set when destroyed.
    public:
        ScopeGuardAtomic(AT &item, const T executionVal) : _item(item) {
            _exitVal = _item.load();       // Save current value.
            _item.store(executionVal);
        }
        ScopeGuardAtomic(AT &item, const T executionVal, const T exitVal) : _item(item), _exitVal(exitVal) {
            _item.store(executionVal);
        }
        ~ScopeGuardAtomic() {
            _item.store(_exitVal);
        }
 
 
        
    };
 
 
    /* Required for void_t definition below */
    template< class... > struct voider { using type = void; };
    template< class... T0toN > using void_t = typename voider<T0toN...>::type;
 
 
    template <typename, typename = drama::void_t<>> struct is_stl_container : std::false_type{};
    template <typename T>  struct is_stl_container<T, drama::void_t<typename T::iterator>> : std::true_type{};
    template <typename T>  constexpr bool is_stl_container_v = is_stl_container<T>::value;
 
 
    extern bool ActionExists(const std::string &name);
 
} // namespace drama
 
 
 
#endif