Transformacions.h

Veure la documentació d'aquest fitxer.

#if !defined(_TRANSFORMACIONS_H_)
#define _TRANSFORMACIONS_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/>.
 */

#include "portabilitat.h" // zlib.h, ZLIB_CONST

#include <array>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <boost/function.hpp>

namespace tfc {

enum EstatTransformacioInversa {
    TRANSFORMAT, 
    NO_TRANSFORMAT, 
    FORMAT_INCORRECTE 
};

class Transformacio {
public:
    virtual ~Transformacio() {
        // buit
    }

    virtual std::string transforma(const std::string &bloc) const = 0;

    virtual std::string finalitza() const = 0;

    virtual std::string destransforma(const std::string & text_transformat,
                                      EstatTransformacioInversa & estat) const = 0;
};

class AplicadorTransformacioBase {
public:
    typedef boost::function<bool (std::string&)> funcio_extractora;
    typedef boost::function<bool (const std::string&)> funcio_escriptora;

    const funcio_extractora& extractora() const { return extractora_; }
    const funcio_escriptora& escriptora() const { return escriptora_; }

    void aplica();

    virtual ~AplicadorTransformacioBase();
protected:
    AplicadorTransformacioBase(const funcio_extractora & extractora,
                               const funcio_escriptora & escriptora)
        : extractora_(extractora), escriptora_(escriptora)
    {
        // buit
    }
    virtual Transformacio* transformacio() = 0;
private:
    const funcio_extractora extractora_;
    const funcio_escriptora escriptora_;
};

template<typename TTransformacio>
class AplicadorTransformacio : public AplicadorTransformacioBase {
public:
    AplicadorTransformacio(const funcio_extractora & extractora,
                           const funcio_escriptora & escriptora)
        : AplicadorTransformacioBase(extractora,escriptora), trans_()
    {
        // buit
    }
protected:
    virtual Transformacio* transformacio() { return &trans_; }
private:
    TTransformacio trans_;
};

class FuncioExtractoraIstream {
public:
    FuncioExtractoraIstream(std::istream & ist)
        : ist_(ist)
    {
        // buit
    }
    bool operator()(std::string &);
private:
    std::istream & ist_;
    enum {
        MIDA_BUFFER = 4096
    };
    std::array<char, MIDA_BUFFER> buffer_;
};

class FuncioEscriptoraOstream {
public:
    FuncioEscriptoraOstream(std::ostream & ost)
        : ost_(ost)
    {
        // buit
    }
    bool operator()(const std::string &);
private:
    std::ostream & ost_;
};

class TransformacioIdentity : public Transformacio {
public:
    virtual std::string transforma(const std::string & bloc) const { return bloc; }
    virtual std::string finalitza() const { return ""; }
    virtual std::string destransforma(const std::string & text,
                                      EstatTransformacioInversa & ok) const {
        ok = TRANSFORMAT;
        return text;
    }
};

class TransformacioChunked : public Transformacio {
public:
    virtual std::string transforma(const std::string & bloc) const;
    virtual std::string finalitza() const;
    virtual std::string destransforma(const std::string & text_transformat,
                                      EstatTransformacioInversa & estat) const;
};

class TransformacioDeflate : public Transformacio {
public:
    TransformacioDeflate()
        : inicialitzat_(CAP)
    {
        // buit
    }

    virtual std::string transforma(const std::string & bloc) const;
    virtual std::string finalitza() const;
    virtual std::string destransforma(const std::string & text_transformat,
                                      EstatTransformacioInversa & estat) const;
private:
    enum Mode {
        CAP,
        DEFLATE,
        INFLATE
    };
    // http://www.zlib.net/zlib_how.html:
    // "
    // Larger buffer sizes [respecte 16384] would be more efficient,
    // especially for inflate().
    // If the memory is available, buffers sizes on the order of 128K
    // or 256K bytes should be used.
    // "
    enum {
        MIDA_BUFFER_ZLIB = 256<<10
    };

    bool inicialitza(Mode m) const;
    void desinicialitza() const;

    mutable z_stream strm_;
    mutable Mode inicialitzat_;
};

class CadenaTransformacions : public Transformacio {
protected:
    typedef std::shared_ptr<Transformacio> transformacio_ptr;
public:
    CadenaTransformacions() {
        // buit
    }
    CadenaTransformacions(const CadenaTransformacions & ct)
        : cadena_(ct.cadena_)
    {
        // buit
    }
    CadenaTransformacions& operator=(const CadenaTransformacions & ct) {
        cadena_ = ct.cadena_;
        return *this;
    }

    template<typename TTransformacio>
    void afegeix() {
        transformacio_ptr trans(new TTransformacio());
        cadena_.push_back( trans );
    }
    virtual std::string transforma(const std::string & bloc) const;
    virtual std::string finalitza() const;
    virtual std::string destransforma(const std::string & text,
                                      EstatTransformacioInversa & estat) const;
    size_t pasos() const { return cadena_.size(); }
private:
    std::vector<transformacio_ptr> cadena_;
};

} // ns tfc

#endif // _TRANSFORMACIONS_H_

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