Log.h

Veure la documentació d'aquest fitxer.

#if !defined(_TFCWEB_LOG_H_)
#define _TFCWEB_LOG_H_

/*
 * Copyright (c) 2012 Toni Corvera
 *
 * This file is part of TFCWeb.
 *
 * TFCWeb is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * TFCWeb is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with TFCWeb. If not, see <http://www.gnu.org/licenses/>.
 */
// La construcció de missatges combinada amb una impressió "atòmica" hauria de permetre
// treballar cocurrentment sense problema

#include "Excepcions.h"

#include <fstream>
#include <memory>
#include <ostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <boost/filesystem.hpp>
#include <boost/thread.hpp>

namespace tfc {

// EXCEPCIONS

class ErrorLogNoValid : public ErrorTFC {
public:
    explicit ErrorLogNoValid(const std::string & w = "Fitxer de log no vàlid")
        : ErrorTFC(w)
    {
        // buit
    }
};

class ErrorDestiNoAssociat : public ErrorTFC {
public:
    explicit ErrorDestiNoAssociat(const std::string & w = "Destí de logging desconegut")
        : ErrorTFC(w)
    {
        // buit
    }
};

// MISSATGES DE LOGGING

enum NivellLog {
    NivellDebug = 1,
    NivellInfo,
    NivellWarning,
    NivellError,
    NIVELL_PER_DEFECTE_LOG = NivellDebug, // FIXME
    NIVELL_MES_SILENCIOS = NivellError,
    NIVELL_MES_VERBOS = NivellDebug,
    NIVELL_PER_DEFECTE_MISSATGE = NivellWarning
};

// Forward declarations
class Log;
class MissatgeLog;
class ManipuladorParametritzat;
class DestiLogging;

MissatgeLog log();

void commit(MissatgeLog & ml);

MissatgeLog& rollback(MissatgeLog & ml);

std::shared_ptr<ManipuladorParametritzat> nivell(NivellLog n);

class MissatgeLog {
public:
    template<typename T> MissatgeLog& operator<<(const T & t) {
        oss_ << t;
        return *this;
    }

    MissatgeLog& operator<<(NivellLog n) {
        nivell(n);
        return *this;
    }

    MissatgeLog& operator<<(MissatgeLog&(*manipulador)(MissatgeLog&)) {
        return manipulador(*this);
    }

    MissatgeLog& operator<<(const std::shared_ptr<ManipuladorParametritzat> &);

    void operator<<(void(*finalitzador)(MissatgeLog&)) {
        finalitzador(*this);
    }

    MissatgeLog& operator<<(std::ostream&(*tt)(std::ostream&)) {
        oss_ << tt;
        return *this;
    }

    std::string str() const { return oss_.str(); }

    NivellLog nivell() const { return nivell_; }

    void nivell(NivellLog n) { nivell_ = n; }
private:
    MissatgeLog()
        : nivell_(NIVELL_PER_DEFECTE_MISSATGE), oss_()
    {
        // buit
    }
    MissatgeLog(const MissatgeLog & m)
        : nivell_(m.nivell_), oss_(m.oss_.str())
    {
        // buit
    }

    // Construcció
    friend MissatgeLog log();
    // Detalls d'implementació en forma de manipuladors:
    friend void commit(MissatgeLog &ml);
    friend MissatgeLog& rollback(MissatgeLog & ml);

    NivellLog nivell_; 
    std::ostringstream oss_; 
};

class Log {
public:
    static Log& singleton();

    void associa(std::ostream & os, NivellLog n = NIVELL_PER_DEFECTE_LOG);

    void associa(const boost::filesystem::path & f, NivellLog n = NIVELL_PER_DEFECTE_LOG)
                                                                       throw (ErrorLogNoValid);

    void desassocia(std::ostream & os);

    void imprimeix(const MissatgeLog & ml);

    NivellLog nivell_sortida(const std::ostream & d) const
                                                        throw (ErrorDestiNoAssociat);
    NivellLog nivell_sortida(const boost::filesystem::path & d) const
                                                        throw (ErrorDestiNoAssociat);
    void nivell_sortida(const std::ostream & d, NivellLog nn)
                                                        throw (ErrorDestiNoAssociat);
    void nivell_sortida(const boost::filesystem::path & d, NivellLog nn)
                                                        throw (ErrorDestiNoAssociat);

    void nivell_sortida(NivellLog nn);

protected:
    Log()
        : destins_()
    {
        // buit
    }

    static std::string marca_de_temps();
private:
    Log(const Log & l) { throw ErrorNoImplementat(FITXER_I_LINIA_); }

    Log& operator=(const Log &) {
        throw ErrorNoImplementat(FITXER_I_LINIA_);
        return *this;
    }

    std::vector< std::shared_ptr<DestiLogging> > destins_; 
};

} // ns tfc

#endif // _TFCWEB_LOG_H_

// vim:set ts=4 et ai: //