filelog.h

 
#ifndef _BACKENDS_TOFINO_BF_P4C_LOGGING_FILELOG_H_
#define _BACKENDS_TOFINO_BF_P4C_LOGGING_FILELOG_H_
 
#include <sys/stat.h>
 
#include <fstream>
#include <streambuf>
#include <string>
#include <utility>
 
#include "backends/tofino/bf-p4c/logging/manifest.h"
#include "lib/cstring.h"
 
namespace Logging {

enum Mode {
    APPEND,

    CREATE,

    AUTO
};
enum Mode {…};

 
class FileLog {
 private:
    std::basic_streambuf<char> *clog_buff = nullptr;
    std::ofstream *log = nullptr;
 
    static const cstring &name2type(cstring logName);
    static std::set<cstring> filesWritten;
 
 public:
    explicit FileLog(int pipe, cstring logName, Mode mode = AUTO) {
        bool append = true;
        switch (mode) {
            case APPEND:
                append = true;
                break;
            case CREATE:
                append = false;
                break;
            case AUTO:
                append = filesWritten.count(logName);
                break;
        }
 
        filesWritten.insert(logName);
 
        auto logDir = BFNContext::get().getOutputDirectory("logs"_cs, pipe);
        if (logDir) {
            // Assuming cstring has a method to convert to std::string
            std::filesystem::path fullPath =
                std::filesystem::path(logDir.string_view()) / logName.string_view();
 
            // Open the file stream with the full path
            LOG1("Open logfile " << fullPath.string() << " append: " << append);
            Manifest::getManifest().addLog(pipe, name2type(logName), logName);
            clog_buff = std::clog.rdbuf();
            auto flags = std::ios_base::out;
            if (append) flags |= std::ios_base::app;
            log = new std::ofstream(fullPath, flags);
            std::clog.rdbuf(log->rdbuf());
        }
    }

    ~FileLog() { close(); }

    void close() {
        if (clog_buff != nullptr) {
            std::clog.rdbuf(clog_buff);
        }
        if (log) {
            log->flush();
            log->close();
            delete log;
            log = nullptr;
        }
    }
    void close() {…}

    static void close(FileLog *&log) {
        if (!log) return;
        delete log;
        log = nullptr;
    }
    static void close(FileLog *&log) {…}
};
class FileLog {…};
 
}  // end namespace Logging
namespace Logging {…}
 
#endif /* _BACKENDS_TOFINO_BF_P4C_LOGGING_FILELOG_H_ */