common/formatters.hpp

Go to the documentation of this file.

/*****************************************************************************
** Ifdefs
*****************************************************************************/

#ifndef ECL_CONTAINERS_COMMON_FORMATTERS_HPP_
#define ECL_CONTAINERS_COMMON_FORMATTERS_HPP_

/*****************************************************************************
** Includes
*****************************************************************************/

#include <cmath>
#include <ecl/config/macros.hpp>
#include <ecl/formatters/common.hpp>
#include <ecl/formatters/number.hpp>
#include <ecl/formatters/floats.hpp>

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace ecl {
namespace formatters {

/*****************************************************************************
** Using
*****************************************************************************/

/*****************************************************************************
** Interface [FloatContainerFormatter]
*****************************************************************************/

template <typename Container >
class ECL_LOCAL FloatContainerFormatter {
    public:
        /******************************************
        ** Typedefs
        *******************************************/
        typedef typename Container::value_type value_type; 
        FloatContainerFormatter(const unsigned int p = 2, const int w=-1) :
            old_precision(-1),
            tmp_width(-1),
            prm_width(w),
            width_ptr(&prm_width),
            format(w,p,ecl::RightAlign,ecl::Fixed),
            container(NULL),
            ready_to_format(false)
        {}

                virtual ~FloatContainerFormatter() {}

        FloatContainerFormatter& precision(const unsigned int p) { format.precision(p); return *this; } // Permanent
        FloatContainerFormatter& width(const int w) { prm_width = w; return *this; } // Permanent
        unsigned int precision() const { return format.precision(); }
        FloatContainerFormatter& operator()(const unsigned int p, const int w) { format.precision(p); prm_width = w; return *this; } // Permanent
        FloatContainerFormatter& operator()(const Container &c) { container = &c; ready_to_format = true; return *this; }
        FloatContainerFormatter& operator()(Container &c, const unsigned int p, const int w) {
            container = &c;
            ready_to_format = true;
            old_precision = format.precision();
            format.precision(p);
            tmp_width = w;
            width_ptr = &tmp_width;
            return *this;
        } //temporary

        template <typename OutputStream, typename Container_>
        friend OutputStream& operator << (OutputStream& ostream, FloatContainerFormatter< Container_ > &formatter) ecl_assert_throw_decl(StandardException);

    private:
        long digits(value_type min_coeff, value_type max_coeff);

        int old_precision;
        int tmp_width, prm_width;
        int* width_ptr;
        Format< value_type > format;
        const Container *container;
        bool ready_to_format;
};

template <typename Container >
long FloatContainerFormatter<Container>::digits(value_type min_coeff, value_type max_coeff) {
    long min_digits, max_digits;
    long actual_digits;
    min_digits = static_cast<long> ( ceil(log10(fabs(min_coeff)+1)) );
    max_digits = static_cast<long> ( ceil(log10(fabs(max_coeff)+1)) );
    if ( min_digits < max_digits ) {
        actual_digits = max_digits;
    } else {
        if ( ( min_digits == 0 ) && ( max_digits == 0 ) ) {
            min_digits = 1;
        }
        actual_digits = min_digits;
    }
    if ( min_coeff < 0 ) { actual_digits += 1; }
    actual_digits += 1 + format.precision();
    return actual_digits;
}

/******************************************
** Streamer
*******************************************/

template <typename OutputStream, typename Container_>
OutputStream& operator << (OutputStream& ostream, FloatContainerFormatter< Container_ > &formatter) ecl_assert_throw_decl(StandardException) {
    ecl_assert_throw(formatter.ready_to_format, StandardException(LOC,UsageError,"The formatter cannot print any data - "
            "either there is no data available, or you have tried to use the "
            "formatter more than once in a single streaming operation. "
            "C++ produces unspecified results when functors are used multiply "
            "in the same stream sequence, so this is not permitted here.") );

    if ( *(formatter.width_ptr) == -1 ) {
        /******************************************
        ** Compute min,max coefficients
        *******************************************/
        typename Container_::value_type min_coeff, max_coeff;
        const typename Container_::value_type *cur_coeff;
        min_coeff = (*formatter.container)[0];
        max_coeff = min_coeff;

//        for (size_t i = 1; i < N; ++i ) {
        for ( unsigned int i = 1; i < formatter.container->size(); ++i) {
            cur_coeff = &(*formatter.container)[i];
            if ( *cur_coeff > max_coeff ) { max_coeff = *cur_coeff; }
            if ( *cur_coeff < min_coeff ) { min_coeff = *cur_coeff; }
        }
        /*********************
        ** Set format width
        **********************/
        formatter.format.width(formatter.digits(min_coeff,max_coeff));
    } else {
        formatter.format.width(*(formatter.width_ptr));
    }

    /*********************
    ** Stream
    **********************/
    typename Container_::const_iterator iter;
    ostream << "[ ";
    for ( iter = formatter.container->begin(); iter != formatter.container->end(); ++iter ) {
        ostream << formatter.format(*iter) << " ";
    }
    ostream << "]";

    /*********************
    ** Reset if temporary
    **********************/
    if ( formatter.old_precision != -1 ) {
        formatter.format.precision(formatter.old_precision);
        formatter.old_precision = -1;

    }
    formatter.width_ptr = &(formatter.prm_width);
    formatter.ready_to_format = false;

    ostream.flush();
    return ostream;
}

} // namespace formatters
} // namespace ecl

#endif /* ECL_CONTAINERS_COMMON_FORMATTERS_HPP_ */