utils.h

Veure la documentació d'aquest fitxer.

#if !defined(_UTILS_H_)
#define _UTILS_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"

#include <istream>
#include <sstream>
#include <string>
#include <ostream>
#include <boost/bind.hpp>
#include <boost/date_time.hpp>
#include <boost/filesystem.hpp>
#include <boost/function.hpp>

namespace tfc {

// Forward declarations
template<typename T, typename TDesti> class Te_Operador_Insercio;
template<typename T, typename TOrigen> class Te_Operador_Extraccio;

namespace utils {

// Definició en forma de signatura C:
typedef std::ios_base&(manipulador_ios_base_t)(std::ios_base&);
// Definició amb boost::function:
typedef boost::function<std::ostream& (std::ostream&)> manipulador_ostream_t;

} // ns utils

} // ns tfc

std::ostream& operator<<(std::ostream & os, tfc::utils::manipulador_ostream_t fn);

namespace tfc {

namespace utils {

template<typename T> std::string to_string(const T & obj,
                                           manipulador_ios_base_t base = std::dec)
{
    Te_Operador_Insercio<T, std::ostringstream>();
    std::ostringstream ss;
    ss << base << obj;
    return ss.str();
}

template<typename T> T from_string(const std::string & s,
                                   manipulador_ios_base_t base = std::dec)
{
    Te_Operador_Extraccio<T, std::istringstream>();
    T ret;
    std::istringstream ss(s);
    ss >> base >> ret;
    return ret;
}
 // FIXME: Massa general? Usar basic_string? http://www.sgi.com/tech/stl/basic_string.html
template<typename Str> const typename Str::value_type final(const Str & s) {
    assert( s.size() > 0 ); // PRECONDICIÓ
    return *(--s.end());
}

bool es_llegible(const boost::filesystem::path & p) throw ();

bool es_canonic(const boost::filesystem::path & p) throw ();

std::string lpad(const std::string & s, size_t mida, char f = ' ');

std::string rpad(const std::string & s, size_t mida, char f = ' ');

std::string formata_data(const boost::posix_time::ptime & t, const std::string & fmt);

// Nota: La interpretació de dates textuals no s'ha generalitzat, principalment
// perquè Boost Date Time no inclou lectura de fusos horaris estàndards
// vegeu llegeix_data_http() per el cas concret del format utilitzat en HTTP

std::string formata_data(const std::time_t t, const std::string & fmt);

namespace impl {

// Cal una implementació amb nom no polimòrfic per què el compilador
// la interpreti correctament en les funcions generadores que utilitzen
// boost::bind (vegeu les utils::each_shl())
// XXX: parametritzar Separador potser és excessiu
template<typename Iterador, typename Separador = std::string>
std::ostream& each_shl(std::ostream& os,
                       Iterador ini, Iterador fi,
                       const Separador & sep)
{
   while (ini != (fi-1)) { // Fins el penúltim element, l'imprimim seguit del separador
       os << *ini << sep;
       ini++;
   }
   return os << *ini; // Últim element, sense separador
}

} // ns impl

template<typename Iterador, typename Separador = std::string>
std::ostream& each_shl(std::ostream& os,
                       Iterador ini, Iterador fi,
                       const Separador & sep = "\n") {
    return impl::each_shl(os, ini, fi, sep);
}

template<typename Iterador, typename Separador = std::string>
manipulador_ostream_t each_shl(Iterador ini, Iterador fi, const Separador & sep = "\n") {
    // No compila: return boost::bind<std::ostream&>(&each_shl<Iterador>, _1, ini, fi);
    return boost::bind<std::ostream&>(&impl::each_shl<Iterador>, _1, ini, fi, sep);
}

template<typename Contenidor, typename Separador = std::string>
manipulador_ostream_t each_shl(const Contenidor & c, const Separador & sep = "\n") {
    return each_shl(c.begin(), c.end(), sep);
    // typedef typename Contenidor::const_iterator const_iterator;
    // return boost::bind<std::ostream&>(&impl::each_shl<const_iterator>, _1, c.begin(), c.end());
}


inline std::string formata_data(const std::string & fmt) {
    return formata_data(boost::posix_time::second_clock::universal_time(), fmt);
}

} // ns tfc::utils

// Constraints
//
// La tècnica de les constraints està explicada pel propi Bjarne Stroustrup a:
// <http://www2.research.att.com/~bs/bs_faq2.html#constraints>
//
// Són construccions evaluables en la compilació que impossen restriccions en
// els tipus de les plantilles (prevenint la compilació si els tipus passats no
// compleixen la condició impossada). Un cop evaluades no generen codi.
//

template<typename T>
class Es_Pair_De_Strings {
    static void constraint(T & t) {
        const std::string first = t.first;
        const std::string second = t.second;
    }
public:
    Es_Pair_De_Strings() {
        UNUSED void (*p_ct)(T&) = constraint;
    }
};

template<typename T>
class Es_Pot_Cridar_Sense_Arguments {
    static void constraint(T & t) {
        t();
    }
public:
    Es_Pot_Cridar_Sense_Arguments() {
        UNUSED void (*p_ct)(T&) = constraint;
    }
};

template<typename T, typename TDesti = std::ostream>
class Te_Operador_Insercio {
    static void constraint(T & t, TDesti & desti) {
        desti << t;
    }
public:
    Te_Operador_Insercio() {
        UNUSED void (*p_ct)(T&, TDesti&) = constraint;
    }
};

template<typename T, typename TOrigen = std::istream>
class Te_Operador_Extraccio {
    static void constraint(T & t, TOrigen & origen) {
        origen >> t;
    }
public:
    Te_Operador_Extraccio() {
        UNUSED void (*p_ct)(T&, TOrigen&) = constraint;
    }
};

} // ns tfc

#endif // _UTILS_H_

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