drama.hh

Go to the documentation of this file.

#ifndef _DRAMA2_INC
#define _DRAMA2_INC
 
/*
 * History:
     07-Jan-2014 - TJF - Original version
     30-Sep-2016 - TJF - Add TSafePrintf() function.
 
 */
 
 
#define DRAMA_ALLOW_CPP_STDLIB  // For old include files.
#define DRAMA2_FMT 202609L      // DRAMA Formatting support version.
 
#if defined __clang__
/*
 * What versions do we need - unclear  5 maybe?
 */
 
#elif defined(__GNUC__) || defined(GNUC)
 
/*
 * Check for a valid version of GCC.  We need 4.7 or higher.
 *  for GCC C++ Version 2011 support.
 */
#  if __GNUC__ < 4
 
#  error "GCC Version too old.  drama.hh needs GCC 4.7 or newer"
 
#  elif __GNUC__ == 4
#    if  __GNUC_MINOR__ < 7 
#        error "GCC Version too old. drama.hh needs GCC 4.7 or newer"
#    endif
 
#  endif /* __GNUC__ == 4 */
 
#endif /* __GNUC__ */
 
#include <string>
#include <algorithm>
#include <tuple>
#include "DitsFix.h"
#include "drama.h"
#include "status.h"
#include "Ers.h"
#include "drama2_err.h"
/* If we include fmt/format.h whilst processing this file with doxygen, then 
 * the macro RUNNING_DOXYGEN seems to disappear OR the C pre-processor
 * code of doxygen fails (likely the later due to a claimed failure to close
 * a quoted string, which is not true)
 */
#ifndef RUNNING_DOXYGEN  
#include "drama/fmt/format.h"
#endif
#include <string>
#include <algorithm>
#include <tuple>
//#include <strstream>
namespace drama { 
 
    extern const char * Drama2Version;
 
    extern const char * Drama2Date;
 
    extern void ErsReport(const std::string &mes, StatusType *status);
 
    template<typename... Args>
    void ErsReportF(StatusType *status, const fmt::format_string<Args...> fmt, Args&&... args) {
        ErsReport(fmt::vformat(fmt.get(), fmt::make_format_args(args...)), status);
    }
 
 
 
    extern void ErsFlushStack(StatusType *status);
 
    extern void ErsAnnulStack(StatusType *status);
 
    class ErsContext {
    public:
        ErsContext() {
            ErsPush();
        }
        ~ErsContext() {
            ErsPop();
        }
    };
 
    extern std::string GetSymbolVal(const std::string &name);
    
    extern bool GetSymbolExists(const std::string &name);
 
    /* To understand the way this works, think of an array
       declared as say  "int a[5]".  When the template
       is invoked, it uses 5 in place of S, so we can 
       just return S
     */
    template <typename T,unsigned S>
    inline unsigned ArraySize(const T (&v)[S]) { 
        // Whilst we don't really use v, we must not comment it out, otherwise doxygen complains.
        //  This is a workaround.  But it is really meant for tuples, so unclear if will always work.
        std::ignore = v; 
        return S; 
    }
 
 
    /* Invokes the drama::CheckLockTaken static method */
    extern  void CheckLockTaken(const std::string func,
                               const std::string &file,
                               const int lineNum) ;
    
 
 
} // namespace drama
 
 
#include "drama/util.hh"
#include "drama/exception.hh"
 
namespace drama { 
    /*
     * Somewhat annoyingly, these need to be after we have included
     * exception.hh, rather then within util.hh where they really
     * belong. (as they use DramaTHROW()).
     */
 
    void SafePrintf( std::ostream &ostream, const char *str);
    template<typename T, typename... Types>
#ifndef RUNNING_DOXYGEN 
            D2_FMT_DEPRECATED("Replace use of SafePrintf  by fmt::format") 
#endif
    void SafePrintf( std::ostream &ostream, 
                      const char * format,
                      const T &value,
                      Types... args) {
        while (*format) 
        {
            if (*format == '%') 
            {
                if (*(format + 1) == '%') 
                {
                    ++format;
                }
                else 
                {
                    ostream << value;
                    // call even when *s == 0 to detect extra arguments
                    SafePrintf(ostream, format + 1, args...); 
                    return;
                }
            }
            ostream << *format++;
        }
        DramaTHROW(DRAMA2__INV_SAFE_PRINTF, "extra arguments provided to drama::SafePrintf()");
    }  
 
    template<typename... Types>
#ifndef RUNNING_DOXYGEN
            D2_FMT_DEPRECATED("Replace TSafePrintf() by fmt::format") 
#endif
    void TSafePrintf( std::ostream &ostream, 
                      const char * format,
                      Types... args) {
 
        /*
         * Our approach is to write the output to a string, via
         * SafePrintf(), then output that in one operation.  Since
         * std::ostream devices will then do the output in one operation.
         */
        std::stringstream sstrm;
        drama::SafePrintf(sstrm, format, args...);
        ostream << sstrm.str();
 
    }  
 
    /* This is after including exception.hh only because it use SafePrintf()*/
    template<typename... Types>
#ifndef RUNNING_DOXYGEN
            D2_FMT_DEPRECATED("Replace ErsReport() by ErsReportF()")
#endif
    void ErsReport(StatusType *status, const char *format, Types... args) {
        /*
         * Our approach is to write the output to a string, via
         * SafePrintf(), then output that in one operation.  Since
         * std::ostream devices will then do the output in one operation.
         */
        std::stringstream sstrm;
        drama::SafePrintf(sstrm, format, args...);
        ErsReport(sstrm.str(), status);
        
    }
 
 
} // namespace drama
 
 
#include "drama/task.hh"
#include "drama/logger.hh"
#include "drama/request.hh"
#include "drama/messagehandler.hh"
#include "drama/threadaction.hh"
#include "drama/threaduface.hh"
#include "drama/path.hh"
#include "drama/threadmonitor.hh"
#include "drama/parameter.hh"
#include "drama/sds.hh"
#include "drama/parsys.hh"
#include "drama/gitarg.hh"
 
 
 
 
#endif