C:/nobackup/private/physical_svn/trunk/include/physical/detail/format_impl.hpp

Go to the documentation of this file.

/*=============================================================================
    physical quantities / units / constants
    Copyright (c) 2006, 2007 Martin Schulz
    http://physical.sourceforge.net
  
    This is private code by Martin Schulz.
  
    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

#ifndef PHYSICAL_FORMAT_IMPL
#define PHYSICAL_FORMAT_IMPL

#include "physical/format.hpp"

#include "physical/formatspec.hpp"
#include <sstream>

namespace physical {

        namespace format {

                namespace detail {

         template<class UnitSystem>
                        std::ostream& single_dimension(std::ostream& os, 
                                enum UnitSystem::baseunit bu, const std::string& symbol, bool& first, DynamicPhysical<UnitSystem> q) {
                                int e = q.exponents.exponents[bu];
                                if(e) {
                                        if (!first) os << "*";
                                        os << symbol;
                                        if (e!=1) os << '^' << e;
                                        first=false;
                                };
                                return os;
                        };

         template<class UnitSystem>
                        std::ostream& automatic_dimension(std::ostream& os, DynamicPhysical<UnitSystem> q) {
                                assert(q.exponents.exponents.size() == UnitSystem::number_baseunits);
                                bool first=true;
                                os << "[";
                                single_dimension(os, UnitSystem::meter,         "m",    first, q);
                                single_dimension(os, UnitSystem::kilogram,      "kg",   first, q);
                                single_dimension(os, UnitSystem::second,        "s",    first, q);
                                single_dimension(os, UnitSystem::ampere,        "A",    first, q);
                                single_dimension(os, UnitSystem::kelvin,        "K",    first, q);
                                single_dimension(os, UnitSystem::mol,           "mol",  first, q);
                                single_dimension(os, UnitSystem::candela,       "cd",   first, q);
                                if (first) os << "1";
                                os << "]";
                                return os;
                        };

         template<class UnitSystem>
                        std::ostream& automatic_quantity(std::ostream& os, DynamicPhysical<UnitSystem> q) {
                                os << q.numerical_value;
                                return automatic_dimension(os, q);
                        };

         template<class UnitSystem>
                        std::string automatic_dimension_string(DynamicPhysical<UnitSystem> q) {
                                std::ostringstream os;
                                automatic_dimension(os, q);
                                return os.str();
                        };

         template<class UnitSystem>
                        std::ostream& format_to_spec(std::ostream& os, DynamicPhysical<UnitSystem> quantity, FormatSpec<UnitSystem> spec){
                                
                                if (spec.unit.exponents != quantity.exponents) {
                                        // Use automatically generated unit string.
                                        // Or better throw IncompatibleUnitException?
                                        os << quantity.numerical_value << "[";
                                        detail::automatic_dimension(os, quantity);
                                        os << "]";

                                } else {
                                        // the (hopefully) usual case

                                        const DynamicPhysical<UnitSystem> &a = quantity;        
                                        const FormatSpec<UnitSystem>::unit_type &u = spec.unit;
                                        const DynamicPhysical<UnitSystem> x = a/u;      
                                        
                                        os.precision(spec.precision);
                                        os << x.numerical_value << "[" << spec.unitname <<"]";
                                };
                                return os;
                        }



                } // namespace detail
        
        }; // namespace format

}; // namespace physical

#endif // PHYSICAL_FORMAT_IMPL

---

hosted on