CosResposta.h

Veure la documentació d'aquest fitxer.

#if !defined(_COS_RESPOSTA_H_)
#define _COS_RESPOSTA_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 "CodisEstatHTTP.h"
#include "Excepcions.h"
#include "Servidor.h"
#include "Transformacions.h"

#include <memory>
#include <string>
#include <vector>
#include <boost/asio.hpp>

namespace tfc {

#if 0

enum ContentEncoding {
    CE_CAP = 0,
    CE_IDENTITY,
    CE_GZIP,
    CE_COMPRESS,
    CE_DEFLATE
};

enum TransferEncoding {
    TE_CAP = 0,
    TE_IDENTITY,
    TE_CHUNKED,
    TE_GZIP,
    TE_COMPRESS,
    TE_DEFLATE
};
#endif

class CosResposta {
public:
    typedef std::pair<std::string, std::string> tipus_capsalera;
    typedef std::vector<tipus_capsalera> tipus_capsaleres;
    typedef std::shared_ptr<Transformacio> transformacio_ptr;
    typedef boost::asio::ip::tcp::socket socket_tcp;

    explicit CosResposta(const PeticioHTTP & peticio)
        : peticio_(peticio),
          deflate_ok_(false), chunked_ok_(false),
          trans_()
    {
        determina_codificacions();
    }

    CosResposta(const CosResposta & cr)
        : peticio_(cr.peticio_),
          deflate_ok_(cr.deflate_ok_),
          chunked_ok_(cr.chunked_ok_),
          te_(cr.te_), ce_(cr.ce_),
          trans_(cr.trans_)
    {

    }

    CosResposta& operator=(const CosResposta & cr) {
        peticio_ = cr.peticio_;
        deflate_ok_ = cr.deflate_ok_;
        chunked_ok_ = cr.chunked_ok_;
        te_ = cr.te_;
        ce_ = cr.ce_;
        trans_ = cr.trans_;
        return *this;
    }

    virtual ~CosResposta() {
        // buit
    }

    virtual void envia(socket_tcp & socket) const
                                throw (std::runtime_error) = 0;

    virtual void envia_eom(socket_tcp & socket) const throw (ErrorEscrivintEnSocket);

    virtual tipus_capsaleres capsaleres() const;

    virtual bool pot_generar_capsaleres() const {
        return false;
    }

    const PeticioHTTP& peticio() const { return peticio_; }

protected:
    virtual size_t envia(socket_tcp & socket,
                         const std::string & buffer) const throw (ErrorEscrivintEnSocket);

    size_t envia_literal(socket_tcp & socket, const std::string & buffer)
                                                const throw (ErrorEscrivintEnSocket);


    bool deflate_ok() const { return deflate_ok_; }

    bool chunked_ok() const { return chunked_ok_; }

    transformacio_ptr transformacio() const { return trans_; }

    const std::string& content_encoding() const { return ce_; }

    const std::string& transfer_encoding() const { return te_; }
private:
    void determina_codificacions();

    PeticioHTTP peticio_; 
    bool deflate_ok_; 
    bool chunked_ok_; 
    std::string te_, 
                ce_; 
    transformacio_ptr trans_; 
};

class RecursDinamic : public CosResposta { // FIXME: Implementació temporal
public:
    explicit RecursDinamic(const PeticioHTTP & p)
        : CosResposta(p)
    {
        // buit
    }
    RecursDinamic(const RecursDinamic & rd)
        : CosResposta(rd)
    {
        // buit
    }
    RecursDinamic& operator=(const RecursDinamic & rd) {
        CosResposta::operator=(rd);
        return *this;
    }

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

    virtual void envia(socket_tcp & socket) const
                        throw (std::runtime_error)
    {
        this->envia(socket, html());
    }
protected:
    using CosResposta::envia; // envia(socket, string)
};

class CosPaginaError : public RecursDinamic {
public:
    CosPaginaError(const PeticioHTTP & p, CodiEstatHTTP error, const std::string & missatge)
        : RecursDinamic(p), error_(error), missatge_(missatge), cache_()
    {
        // buit
    }
    CosPaginaError(const CosPaginaError & cpe)
        : RecursDinamic(cpe), error_(cpe.error_), missatge_(cpe.missatge_), cache_(cpe.cache_)
    {
        // buit
    }

    virtual tipus_capsaleres capsaleres() const;
    virtual std::string html() const;
private:
    CosPaginaError& operator=(const CosPaginaError & cpe) {
        throw ErrorNoImplementat(FITXER_I_LINIA_);
    }
    const CodiEstatHTTP error_;
    const std::string missatge_;
    mutable std::string cache_;
};

class CosTextual : public RecursDinamic {
public:
    CosTextual(const PeticioHTTP & p, const std::string & text)
        : RecursDinamic(p), text_(text)
    {
        // buit
    }
    CosTextual(const CosTextual & c)
        : RecursDinamic(c), text_(c.text_)
    {
        // buit
    }

    virtual string html() const { return text_; }
private:
    CosTextual& operator=(const CosTextual & c) {
        throw ErrorNoImplementat(FITXER_I_LINIA_);
    }
    const std::string text_;
};

} // ns tfc

#endif // _COS_RESPOSTA_H_

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