From 1e710ceab3a81ad3519982c0b7e78ba67276cad7 Mon Sep 17 00:00:00 2001
From: Artem Pavlenko <artem@mapnik.org>
Date: Fri, 26 Jan 2007 15:50:39 +0000
Subject: [PATCH] to_string() : added specialization for double values with
 increased precision.

---
 include/mapnik/value.hpp | 552 ++++++++++++++++++++-------------------
 1 file changed, 285 insertions(+), 267 deletions(-)

diff --git a/include/mapnik/value.hpp b/include/mapnik/value.hpp
index 9b1f33e79..87772b060 100644
--- a/include/mapnik/value.hpp
+++ b/include/mapnik/value.hpp
@@ -28,425 +28,443 @@
 #include <iostream>
 #include <string>
 #include <sstream>
+#include <iomanip>
 
 // boost
 #include <boost/variant.hpp>
 
 namespace mapnik  {
-    typedef boost::variant<int,double,std::string> value_base;
-    
-    namespace impl {
-        struct equals
-            : public boost::static_visitor<bool>
-        {
+   typedef boost::variant<int,double,std::string> value_base;
+   
+   namespace impl {
+      struct equals
+	 : public boost::static_visitor<bool>
+      {
             template <typename T, typename U>
-            bool operator() (const T &, const U & ) const
-            {
-                return false;
-            }
+	    bool operator() (const T &, const U & ) const
+	    {
+	       return false;
+	    }
 	
             template <typename T>
             bool operator() (T lhs, T rhs) const
-            {
-                return lhs == rhs;
-            }
+	    {
+	       return lhs == rhs;
+	    }
 	
             bool operator() (int lhs, double rhs) const
-            {
-                return  lhs == rhs;
-            }
+	    {
+	       return  lhs == rhs;
+	    }
 	
             bool operator() (double lhs, int rhs) const
-            {
-                return  lhs == rhs;
-            }
+	    {
+	       return  lhs == rhs;
+	    }
 	
             bool operator() (std::string const& lhs, 
                              std::string const& rhs) const
-            {
-                return  lhs == rhs;
-            }
-        };
-    
-        struct greater_than
-            : public boost::static_visitor<bool>
-        {
+	    {
+	       return  lhs == rhs;
+	    }
+      };
+      
+      struct greater_than
+	 : public boost::static_visitor<bool>
+      {
             template <typename T, typename U>
             bool operator()( const T &, const U & ) const
-            {
-                return false;
-            }
+	    {
+	       return false;
+	    }
 	
             template <typename T>
             bool operator()( T lhs, T rhs ) const
-            {
-                return lhs > rhs;
-            }
+	    {
+	       return lhs > rhs;
+	    }
 	
             bool operator() (int lhs, double rhs) const
-            {
-                return  lhs > rhs;
-            }
+	    {
+	       return  lhs > rhs;
+	    }
 	
             bool operator() (double lhs, int rhs) const
-            {
-                return  lhs > rhs;
-            }
+	    {
+	       return  lhs > rhs;
+	    }
 	
             bool operator() (std::string const& lhs, std::string const& rhs) const
-            {
-                return  lhs > rhs;
-            }
-        };
+	    {
+	       return  lhs > rhs;
+	    }
+      };
     
-        struct greater_or_equal
-            : public boost::static_visitor<bool>
-        {	
+      struct greater_or_equal
+	 : public boost::static_visitor<bool>
+      {	
             template <typename T, typename U>
             bool operator()( const T &, const U & ) const
-            {
-                return false;
-            }
+	    {
+	       return false;
+	    }
 	
             template <typename T>
             bool operator() (T lhs, T rhs) const
-            {
-                return lhs >= rhs;
-            }
+	    {
+	       return lhs >= rhs;
+	    }
       
             bool operator() (int lhs, double rhs) const
-            {
-                return  lhs >= rhs;
-            }
+	    {
+	       return  lhs >= rhs;
+	    }
 	
             bool operator() (double lhs, int rhs) const
-            {
-                return  lhs >= rhs;
-            }
+	    {
+	       return  lhs >= rhs;
+	    }
 	
             bool operator() (std::string const& lhs, std::string const& rhs ) const
-            {
-                return lhs >= rhs;
-            }
-        };
+	    {
+	       return lhs >= rhs;
+	    }
+      };
     
-        struct less_than
-            : public boost::static_visitor<bool>
-        {	
+      struct less_than
+	 : public boost::static_visitor<bool>
+      {	
             template <typename T, typename U>
             bool operator()( const T &, const U & ) const
-            {
-                return false;
-            }
+	    {
+	       return false;
+	    }
 	
             template <typename T>
             bool operator()( T  lhs,T  rhs) const
-            {
-                return lhs < rhs;
-            }
+	    {
+	       return lhs < rhs;
+	    }
 	
             bool operator() (int lhs, double rhs) const
-            {
-                return  lhs < rhs;
-            }
+	    {
+	       return  lhs < rhs;
+	    }
 	   
             bool operator() (double lhs, int rhs) const
-            {
-                return  lhs < rhs;
-            }
+	    {
+	       return  lhs < rhs;
+	    }
 	
             bool operator()( std::string const& lhs, 
                              std::string const& rhs ) const
-            {
-                return lhs < rhs;
-            }
-        };
+	    {
+	       return lhs < rhs;
+	    }
+      };
 
-        struct less_or_equal
-            : public boost::static_visitor<bool>
-        {	
+      struct less_or_equal
+	 : public boost::static_visitor<bool>
+      {	
             template <typename T, typename U>
             bool operator()( const T &, const U & ) const
-            {
-                return false;
-            }
+	    {
+	       return false;
+	    }
 	
             template <typename T>
             bool operator()(T lhs, T rhs ) const
-            {
-                return lhs <= rhs;
-            }
+	    {
+	       return lhs <= rhs;
+	    }
 	    
             bool operator() (int lhs, double rhs) const
-            {
-                return  lhs <= rhs;
-            }
+	    {
+	       return  lhs <= rhs;
+	    }
 	
             bool operator() (double lhs, int rhs) const
-            {
-                return  lhs <= rhs;
-            }
+	    {
+	       return  lhs <= rhs;
+	    }
 	
             template <typename T>
             bool operator()( std::string const& lhs, 
                              std::string const& rhs ) const
-            {
-                return lhs <= rhs;
-            }
-        };
+	    {
+	       return lhs <= rhs;
+	    }
+      };
     
-        template <typename V>
-        struct add : public boost::static_visitor<V>
-        { 
+      template <typename V>
+      struct add : public boost::static_visitor<V>
+      { 
             typedef V value_type;
             template <typename T1, typename T2>
             value_type operator() (T1 const& lhs, T2 const&) const
-            {
-                return lhs;
-            }
+	    {
+	       return lhs;
+	    }
             template <typename T>
             value_type operator() (T lhs, T rhs) const
-            {
-                return lhs + rhs ;
-            }
+	    {
+	       return lhs + rhs ;
+	    }
 	
             value_type operator() (std::string const& lhs , 
                                    std::string const& rhs ) const
-            {
-                return lhs + rhs;
-            }
+	    {
+	       return lhs + rhs;
+	    }
 	
             value_type operator() (double lhs, int rhs) const
-            {
-                return lhs + rhs;
-            }
+	    {
+	       return lhs + rhs;
+	    }
 	
             value_type operator() (int lhs, double rhs) const
-            {
-                return lhs + rhs;
-            }
-        };
-        template <typename V>
-        struct sub : public boost::static_visitor<V>
-        { 
+	    {
+	       return lhs + rhs;
+	    }
+      };
+      template <typename V>
+      struct sub : public boost::static_visitor<V>
+      { 
             typedef V value_type;
             template <typename T1, typename T2>
             value_type operator() (T1 const& lhs, T2 const&) const
-            {
-                return lhs;
-            }
+	    {
+	       return lhs;
+	    }
 
             template <typename T>
             value_type operator() (T  lhs, T rhs) const
-            {
-                return lhs - rhs ;
-            }
+	    {
+	       return lhs - rhs ;
+	    }
 
             value_type operator() (std::string const& lhs,
                                    std::string const& ) const
-            {
-                return lhs;
-            }
+	    {
+	       return lhs;
+	    }
         	
             value_type operator() (double lhs, int rhs) const
-            {
-                return lhs - rhs;
-            }
+	    {
+	       return lhs - rhs;
+	    }
 	
             value_type operator() (int lhs, double rhs) const
-            {
-                return lhs - rhs;
-            }
-        };
+	    {
+	       return lhs - rhs;
+	    }
+      };
     
-        template <typename V>
-        struct mult : public boost::static_visitor<V>
-        { 
+      template <typename V>
+      struct mult : public boost::static_visitor<V>
+      { 
             typedef V value_type;
             template <typename T1, typename T2>
             value_type operator() (T1 const& lhs , T2 const& ) const
-            {
-                return lhs;
-            }
+	    {
+	       return lhs;
+	    }
             template <typename T>
             value_type operator() (T lhs, T rhs) const
-            {
-                return lhs * rhs;
-            }
+	    {
+	       return lhs * rhs;
+	    }
 	
             value_type operator() (std::string const& lhs,
                                    std::string const& ) const
-            {
-                return lhs;
-            }	
+	    {
+	       return lhs;
+	    }	
 	
             value_type operator() (double lhs, int rhs) const
-            {
-                return lhs * rhs;
-            }
+	    {
+	       return lhs * rhs;
+	    }
 	
             value_type operator() (int lhs, double rhs) const
-            {
-                return lhs * rhs;
-            }
-        };
+	    {
+	       return lhs * rhs;
+	    }
+      };
 
-        template <typename V>
-        struct div: public boost::static_visitor<V>
-        { 
+      template <typename V>
+      struct div: public boost::static_visitor<V>
+      { 
             typedef V value_type;
             template <typename T1, typename T2>
             value_type operator() (T1 const& lhs, T2 const&) const
-            {
-                return lhs;
-            }
+	    {
+	       return lhs;
+	    }
 	    
             template <typename T>
             value_type operator() (T lhs, T rhs) const
-            {
-                return lhs / rhs;
-            }
+	    {
+	       return lhs / rhs;
+	    }
 	
             value_type operator() (std::string const& lhs,
                                    std::string const&) const
-            {
-                return lhs;
-            }
+	    {
+	       return lhs;
+	    }
 	
             value_type operator() (double lhs, int rhs) const
-            {
-                return lhs / rhs;
-            }
+	    {
+	       return lhs / rhs;
+	    }
 	
             value_type operator() (int lhs, double rhs) const
-            {
-                return lhs / rhs;
-            }
-        };
+	    {
+	       return lhs / rhs;
+	    }
+      };
     
-        struct to_string : public boost::static_visitor<std::string>
-        {
+      struct to_string : public boost::static_visitor<std::string>
+      {
+                
             template <typename T>
             std::string operator() (T val) const
-            {
-                std::stringstream ss;
-                ss << val;
-                return ss.str();
-            } 
+	    {
+               std::stringstream ss;
+	       ss << val;
+	       return ss.str();
+	    }
+            // specializations 
             std::string const& operator() (std::string const& val) const
+	    {
+	       return val;
+	    }
+            
+            std::string operator() (double val) const
             {
-                return val;
+               std::stringstream ss;
+	       ss << std::setprecision(16) << val;
+	       return ss.str();
             }
-        };
+      };
 	
-        struct to_expression_string : public boost::static_visitor<std::string>
-        {
+      struct to_expression_string : public boost::static_visitor<std::string>
+      {
+            std::string operator() (std::string const& val) const
+	    {
+	       return "'" + val + "'";
+	    } 
+
             template <typename T>
             std::string operator() (T val) const
+	    {
+	       std::stringstream ss;
+	       ss << val;
+	       return ss.str();
+	    }
+            
+            std::string operator() (double val) const
             {
-                std::stringstream ss;
-                ss << val;
-                return ss.str();
-            } 
-            std::string operator() (std::string const& val) const
-            {
-                return "'" + val + "'";
+               std::stringstream ss;
+	       ss << std::setprecision(16) << val;
+	       return ss.str();
             }
-        };
-    }
+      };
+   }
     
-    class value
-    {
-        value_base base_;
-        friend const value operator+(value const&,value const&);
-        friend const value operator-(value const&,value const&);
-        friend const value operator*(value const&,value const&);
-        friend const value operator/(value const&,value const&);
+   class value
+   {
+	 value_base base_;
+	 friend const value operator+(value const&,value const&);
+	 friend const value operator-(value const&,value const&);
+	 friend const value operator*(value const&,value const&);
+	 friend const value operator/(value const&,value const&);
         
-    public:
-        value ()
+      public:
+	 value ()
             : base_(0) {}
 	
-        template <typename T> value(T _val_)
+	 template <typename T> value(T _val_)
             : base_(_val_) {}
 
-        bool operator==(value const& other) const
-        {
-            return boost::apply_visitor(impl::equals(),base_,other.base_);
-        }
+	 bool operator==(value const& other) const
+	 {
+	    return boost::apply_visitor(impl::equals(),base_,other.base_);
+	 }
 
-        bool operator!=(value const& other) const
-        {
-            return !(boost::apply_visitor(impl::equals(),base_,other.base_));
-        }
+	 bool operator!=(value const& other) const
+	 {
+	    return !(boost::apply_visitor(impl::equals(),base_,other.base_));
+	 }
 	
-        bool operator>(value const& other) const
-        {
-            return boost::apply_visitor(impl::greater_than(),base_,other.base_);
-        }
+	 bool operator>(value const& other) const
+	 {
+	    return boost::apply_visitor(impl::greater_than(),base_,other.base_);
+	 }
 
-        bool operator>=(value const& other) const
-        {
-            return boost::apply_visitor(impl::greater_or_equal(),base_,other.base_);
-        }
+	 bool operator>=(value const& other) const
+	 {
+	    return boost::apply_visitor(impl::greater_or_equal(),base_,other.base_);
+	 }
 
-        bool operator<(value const& other) const
-        {
-            return boost::apply_visitor(impl::less_than(),base_,other.base_);
-        }
+	 bool operator<(value const& other) const
+	 {
+	    return boost::apply_visitor(impl::less_than(),base_,other.base_);
+	 }
 
-        bool operator<=(value const& other) const
-        {
-            return boost::apply_visitor(impl::less_or_equal(),base_,other.base_);
-        }
-        value_base const& base() const
-        {
-            return base_;
-        }
+	 bool operator<=(value const& other) const
+	 {
+	    return boost::apply_visitor(impl::less_or_equal(),base_,other.base_);
+	 }
+	 value_base const& base() const
+	 {
+	    return base_;
+	 }
 
-        std::string to_expression_string() const
-        {
-            return boost::apply_visitor(impl::to_expression_string(),base_);
-        }
+	 std::string to_expression_string() const
+	 {
+	    return boost::apply_visitor(impl::to_expression_string(),base_);
+	 }
 
-        std::string to_string() const
-        {
-            return boost::apply_visitor(impl::to_string(),base_);
-        }
-    };
+	 std::string to_string() const
+	 {
+	    return boost::apply_visitor(impl::to_string(),base_);
+	 }
+   };
     
-    inline const value operator+(value const& p1,value const& p2)
-    {
+   inline const value operator+(value const& p1,value const& p2)
+   {
 
-        return value(boost::apply_visitor(impl::add<value>(),p1.base_, p2.base_));
-    }
+      return value(boost::apply_visitor(impl::add<value>(),p1.base_, p2.base_));
+   }
 
-    inline const value operator-(value const& p1,value const& p2)
-    {
+   inline const value operator-(value const& p1,value const& p2)
+   {
 
-        return value(boost::apply_visitor(impl::sub<value>(),p1.base_, p2.base_));
-    }
+      return value(boost::apply_visitor(impl::sub<value>(),p1.base_, p2.base_));
+   }
 
-    inline const value operator*(value const& p1,value const& p2)
-    {
+   inline const value operator*(value const& p1,value const& p2)
+   {
 
-        return value(boost::apply_visitor(impl::mult<value>(),p1.base_, p2.base_));
-    }
+      return value(boost::apply_visitor(impl::mult<value>(),p1.base_, p2.base_));
+   }
 
-    inline const value operator/(value const& p1,value const& p2)
-    {
+   inline const value operator/(value const& p1,value const& p2)
+   {
 
-        return value(boost::apply_visitor(impl::div<value>(),p1.base_, p2.base_));
-    }
+      return value(boost::apply_visitor(impl::div<value>(),p1.base_, p2.base_));
+   }
 
-    template <typename charT, typename traits>
-    inline std::basic_ostream<charT,traits>& 
-    operator << (std::basic_ostream<charT,traits>& out,
-                 value const& v)
-    {
-    	out << v.base();
-    	return out; 
-    }
+   template <typename charT, typename traits>
+   inline std::basic_ostream<charT,traits>& 
+   operator << (std::basic_ostream<charT,traits>& out,
+		value const& v)
+   {
+      out << v.base();
+      return out; 
+   }
 }
 
 #endif //VALUE_HPP