C:/nobackup/private/physical_svn/trunk/include/physical/dimension.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_DIMENSION
#define PHYSICAL_DIMENSION

#include "physical/fixedphysical.hpp"
#include "physical/dynamicphysical.hpp"
#include "physical/formatspec.hpp"


namespace physical {

        namespace format {

                template<class T>
                struct type2type {
                        typedef T type;
                };

                // a dimension is a collection of compatible FormatSpecs:
                // FIXME: Needs further discussion
                //
                // i18n: The name of the dimension should only be an internal name (e.g. some english string). 
                // The translation to other languages should be done by the calling method or class.
                class Dimension {
                public:
                        typedef physical::detail::DynamicExponents<SI> exponents_type;

                        Dimension(std::string name, const exponents_type& e)
                                : dimensionname(name), exponents_(e) {};

                        /* How to use that one? 
                                The definition looks promising and is accepted by the compiler, but how can 
                                I actually make use of this templated constructor of an non-template class?
                        template<class Quantity>
                        Dimension(std::string name)
                                : dimensionname(name), exponents_(Quantity::exponents()) {};
                        */

                        /* This templated constructor reqires the instantiation of a quantity 
                                only in order to transport its type. This is nevertheless quite handy 
                                if you already have a FixedPhysical of that kind on hand, e.g. some 
                                unit in the unit namespace.
                                */
                        template<typename T, class Exponents>
                        Dimension(std::string name, const FixedPhysical<SI, T, Exponents>&)
                                : dimensionname(name), exponents_(Exponents()) {};

                        /* This one is more tricky: 
                                I use type2type here in order to create a lightweight instance
                                of type2type instead of more heavyweight quantity.
                        */
                        template<class Quantity>
                        Dimension(std::string name, const type2type<Quantity>&)
                                : dimensionname(name), exponents_(typename Quantity::exponents()) {};

                        Dimension(std::string name, const DynamicPhysical<SI>& q)
                                : dimensionname(name), exponents_(q.exponents) {};

                        // copy constructor and automatic assignement operator are ok.

                        std::string name() const {return dimensionname;};
                                
                        // the set of exponents, to which any formatspec to add must be compatible to.
                        exponents_type exponents() const { return exponents_;};

                        Dimension& add(const FormatSpec<SI>& s) {
                                if ( s.unit.exponents == exponents()) {
                                        specs.push_back(s);
                                } else {
                                        throw IncompatibleUnitException("addition of incompatible formatspec");
                                };
                                return *this;
                        };

                        // FIXME: swap() ? 
                        // FIXME: clear() ? 

                        // the favourite does not belong here. The mapping of Dimensions to favourites 
                        // should be managed by some other entity. 
                        FormatSpec<SI> favourite() const {return specs[0];};

                        // ouah, I dislike that one. But we will need some method to iterate over all FormatSpecs, 
                        // e.g. if we want to set up a dropdown list of available FormatSpecs the user could choose from.
                        // Better provide iterators: begin(), end() 
                        FormatSpec<SI> get(std::size_t i) const {
                                if ( 0<=i && i<specs.size() ) {
                                        return specs[0]; 
                                } else {
                                        throw std::range_error("Dimension: cannot find spec");
                                };
                        }

                private:

                        // Exponents to be used to check for compatibility .
                        // immutable after construction, only by assignment 
                        exponents_type exponents_; 
                        
                        // immutable after construction, only by assignment
                        std::string dimensionname;

                        std::vector<FormatSpec<SI> > specs;
                };


                template<class Quantity>
                struct DimensionDef: public Dimension {
                        DimensionDef(std::string name): Dimension(name, type2type<Quantity>()){};
                };

        }; // namespace format

}; // namespace physical


#endif

---

hosted on