Log.cc

Veure la documentació d'aquest fitxer.

/*
 * 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/>.
 */

#include "Log.h"
#include "utils.h"

#include <algorithm>
#include <functional>
#include <iostream>
#include <boost/lexical_cast.hpp>

using namespace std;
using boost::lexical_cast;
namespace fs = boost::filesystem;

namespace tfc {

//
// Missatges de logging
//

MissatgeLog log() {
    return MissatgeLog();
}

//
// Destins de logging
//


// Definició completa de la classe base
class DestiLogging {
public:
    DestiLogging(NivellLog nivell = NIVELL_PER_DEFECTE_LOG)
        : nivell_(nivell)
    {
        // buit
    }
    virtual ~DestiLogging() {}
    virtual ostream& os() = 0;
    virtual NivellLog nivell() const {
        return nivell_;
    }
    virtual void nivell(NivellLog nivell) {
        nivell_ = nivell;
    }
    // TODO: Aquesta implementació (en base a les classes derivades) no m'agrada, però
    //       com que només es tracta de classes d'implementació la considero acceptable
    virtual bool coincideix(const fs::path &) const {
        return false;
    }
    virtual bool coincideix(const ostream &) const {
        return false;
    }
private:
    NivellLog nivell_;
};

} // ns tfc

namespace {

using namespace tfc;

struct FunctorCanviNivell {
    const NivellLog nivell;
    void operator()(shared_ptr<DestiLogging> & dl) {
        dl->nivell(nivell);
    }
    FunctorCanviNivell(NivellLog n) : nivell(n) {}
};

template<typename TImpl>
struct FunctorCoincideix {
    const TImpl & i_;
    bool operator()(const shared_ptr<DestiLogging> & dl) const {
        return dl->coincideix(i_);
    }
    FunctorCoincideix(const TImpl & i) : i_(i) {}
};

class DestiFitxer : public tfc::DestiLogging {
public:
    DestiFitxer(const fs::path & f, tfc::NivellLog nivell = tfc::NIVELL_PER_DEFECTE_LOG)
        : tfc::DestiLogging(nivell), ruta_(f), of_()
    {
        using namespace tfc;
        // TODO: writeable!
        assert( !fs::exists(f) || fs::is_regular_file(f) );
        if (fs::exists(f) && !fs::is_regular_file(f)) {
            throw ErrorLogNoValid("El fitxer de log "+f.string()+" no es pot escriure");
        }
        of_.open(f.string().c_str(), ios_base::out|ios_base::app);
        if (!of_.good()) {
            throw ErrorLogNoValid("Error en obrir el fitxer de log "+f.string());
        }
    }

    virtual ~DestiFitxer() {
        of_.close();
    }

    virtual ostream& os() {
        return of_;
    }
    virtual bool coincideix(const fs::path & f) const {
        return ( f == ruta_ );
    }
private:
    const fs::path ruta_;
    ofstream of_;
};

class DestiOstream : public tfc::DestiLogging {
public:
    DestiOstream(ostream & o, tfc::NivellLog nivell = tfc::NIVELL_PER_DEFECTE_LOG)
        : tfc::DestiLogging(nivell), os_(o)
    {
        // buit
    }
    virtual ~DestiOstream() {}
    virtual ostream& os() {
        return os_;
    }
    virtual bool coincideix(const ostream & os) const {
        return ( &os == &os_ );
    }
private:
    ostream & os_;
};

} // ns anònim

namespace tfc {

void Log::associa(ostream & os, NivellLog n) {
    destins_.push_back(shared_ptr<DestiLogging>(new DestiOstream(os, n)));
}

void Log::associa(const fs::path & p, NivellLog n) throw (ErrorLogNoValid) {
    destins_.push_back(shared_ptr<DestiLogging>(new DestiFitxer(p, n)));
    // DestiFitxer -> throws ErrorLogNoValid
}

void Log::desassocia(ostream &) {
    throw ErrorNoImplementat(FITXER_I_LINIA_); // FIXME: Implementar
}

// Implementació de Log::nivell_sortida(<T>, NivellLog)
template<typename TIt, typename TImpl>
  void nivell_sortida_i(TIt beg, TIt end, const TImpl & d, NivellLog nn)
                                                throw (ErrorDestiNoAssociat)
{
    auto it = find_if(beg, end, FunctorCoincideix<TImpl>(d));
    if (it == end) {
        throw ErrorDestiNoAssociat();
    }
    (*it)->nivell(nn);
}

// Implementació de nivell_sortida(<T>)
template<typename TIt, typename TImpl>
  NivellLog nivell_sortida_i(TIt beg, TIt end, const TImpl & d)
                                                throw (ErrorDestiNoAssociat)
{
    auto it = find_if(beg, end, FunctorCoincideix<TImpl>(d));
    if (it == end) {
        throw ErrorDestiNoAssociat();
    }
    return (*it)->nivell();
}

void Log::nivell_sortida(const ostream & d, NivellLog nn) throw (ErrorDestiNoAssociat) {
    nivell_sortida_i(destins_.begin(), destins_.end(), d, nn);
}

void Log::nivell_sortida(const fs::path & d, NivellLog nn) throw (ErrorDestiNoAssociat) {
    nivell_sortida_i(destins_.begin(), destins_.end(), d, nn);
}

NivellLog Log::nivell_sortida(const ostream & d) const throw (ErrorDestiNoAssociat) {
    return nivell_sortida_i(destins_.begin(), destins_.end(), d);
}

NivellLog Log::nivell_sortida(const fs::path & d) const throw (ErrorDestiNoAssociat) {
    return nivell_sortida_i(destins_.begin(), destins_.end(), d);
}

void Log::nivell_sortida(NivellLog nn) {
    for_each(destins_.begin(), destins_.end(), FunctorCanviNivell(nn));
}

// static
string Log::marca_de_temps() {
    return utils::formata_data("%Y-%m-%d %H:%M:%S");
}

// static
Log& Log::singleton() {
    static Log l;
    return l;
}

// Impressió atòmica: Preparem la cadena a part i quan està llesta la imprimim
void Log::imprimeix(const MissatgeLog & ml) {
    struct FunctorCommit {
        const NivellLog nivell;
        const string str;
        void operator()(shared_ptr<DestiLogging> & desti) {
            if (nivell >= desti->nivell()) {
                desti->os() << str << flush;
            }
        }
        FunctorCommit(NivellLog n, const string & s) : nivell(n), str(s) {}
    };
    if (ml.str().empty()) {
        return;
    }
    ostringstream buffer;
    buffer << "[" << marca_de_temps() << "] " << ml.str() << "\n";
    FunctorCommit fc(ml.nivell(),buffer.str());
    // XXX: No compila en G++ 4.4. Probablement part dels problemes què G++ 4.4 té amb
    //      les classes definides dins de funcions quan es passen a plantilles:
    // for_each(destins_.begin(), destins_.end(), fc);
    for (auto it=destins_.begin(); it != destins_.end(); ++it) {
        fc(*it);
    }
}

//
// Manipuladors de logging
//

void commit(MissatgeLog & ml) {
    Log::singleton().imprimeix(ml);
}

MissatgeLog& rollback(MissatgeLog & ml) {
    ml.oss_.str("");
    return ml;
}

// Interfície comuna de parametritzats
class ManipuladorParametritzat {
public:
    virtual MissatgeLog& operator()(MissatgeLog &) const = 0;
};

class CanviNivellMissatge : public ManipuladorParametritzat {
public:
    CanviNivellMissatge(NivellLog n) : nivell(n) { }

    virtual MissatgeLog& operator()(MissatgeLog & ml) const {
        ml.nivell(nivell);
        return ml;
    }
private:
    const NivellLog nivell;
};

// Generador inserible
std::shared_ptr<ManipuladorParametritzat> nivell(NivellLog n) {
    std::shared_ptr<ManipuladorParametritzat> p(new CanviNivellMissatge(n));
    return p;
}

MissatgeLog& MissatgeLog::operator<<(const std::shared_ptr<ManipuladorParametritzat> & manip) {
    const ManipuladorParametritzat * pmanip = manip.get();
    return (*pmanip)(*this);
}

} // ns tfc

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