iothread.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_iothread_h
#define INCL_evo_iothread_h

#include "io.h"
#include "thread.h"
#include "file.h"


#define EVO_CONSOLE_MT static evo::ConsoleMT& c = evo::con_mt()

#define EVO_IO_MT(STREAM, CODE) { Mutex::Lock evo_streamlock_(STREAM .mutex); STREAM.stream CODE; }

#if EVO_CATCH_DEBUG == 0
    #define EVO_CATCH_MT(CODE) catch (const evo::Exception& e) { \
        { \
            evo::ConsoleMT& c = evo::con_mt(); \
            Mutex::Lock lock(c.err.mutex); \
            c.err.stream << evo::NL << e.msg() << " -- "; \
            evo::errormsg_out(c.err.stream, e.error()); \
            c.err.stream << evo::NL; \
        } \
        CODE; \
    }
#else
    #define EVO_CATCH_MT(CODE) catch (const evo::Exception& e) { \
        { \
            evo::ConsoleMT& c = evo::con_mt(); \
            Mutex::Lock lock(c.err.mutex); \
            c.err.stream << evo::NL; \
            if (e.file()) \
                c.err.stream << e.file() << '(' << e.line() << evo::SubString("): ", 3); \
            c.err.stream << e.msg() << evo::SubString(" -- ", 4); \
            evo::errormsg_out(c.err.stream, e.error()); \
            c.err.stream << evo::NL; \
        } \
        CODE; \
    }
#endif


// Namespace: evo
namespace evo {



template<class T>
struct StreamMT {
    typedef StreamMT<T> This;    

    Mutex mutex;    
    T     stream;   

    StreamMT(bool exceptions=EVO_EXCEPTIONS) : stream(exceptions)
        { }

private:
    StreamMT(This&);
    This& operator=(This&);
};

template<>
struct StreamMT<File> {
    typedef StreamMT<File> This;    

    Mutex mutex;    
    File  stream;   

    StreamMT(Newline nl=NL, bool exceptions=EVO_EXCEPTIONS) : stream(nl, exceptions)
        { }

    StreamMT(const char* path, Open mode=oREAD, bool flushlines=false, Newline nl=NL_SYS, bool exceptions=EVO_EXCEPTIONS) :
        stream(path, mode, flushlines, nl, exceptions)
        { }

private:
    StreamMT(This&);
    This& operator=(This&);
};

typedef StreamMT<PipeIn>  PipeInMT;       
typedef StreamMT<PipeOut> PipeOutMT;      
typedef StreamMT<File>    FileMT;         


struct ConsoleMT {
    typedef PipeOut::Format Format;             
    typedef StreamExtMT<PipeIn,Mutex>  InT;     
    typedef StreamExtMT<PipeOut,Mutex> OutT;    
    typedef Mutex::Lock Lock;                   

    InT  in;        
    OutT out;       
    OutT err;       

    static ConsoleMT& get()
        { static ConsoleMT console(con()); return console; }

private:
    ConsoleMT(Console& c) : in(c.in), out(c.out), err(c.err)
        { }

    ConsoleMT(const ConsoleMT&);
    ConsoleMT& operator=(const ConsoleMT&);
};

inline ConsoleMT& con_mt()
    { return ConsoleMT::get(); }


}
#endif