libcvd-members
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[libcvd-members] gvars3 main.cc gvars3/default.h gvars3/gv3_impl...


From: Edward Rosten
Subject: [libcvd-members] gvars3 main.cc gvars3/default.h gvars3/gv3_impl...
Date: Wed, 22 Apr 2009 09:55:46 +0000

CVSROOT:        /cvsroot/libcvd
Module name:    gvars3
Changes by:     Edward Rosten <edrosten>        09/04/22 09:55:46

Modified files:
        .              : main.cc 
        gvars3         : default.h gv3_implementation.hh gvars3.h 

Log message:
        Fix for Vector<-1>

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/gvars3/main.cc?cvsroot=libcvd&r1=1.15&r2=1.16
http://cvs.savannah.gnu.org/viewcvs/gvars3/gvars3/default.h?cvsroot=libcvd&r1=1.1&r2=1.2
http://cvs.savannah.gnu.org/viewcvs/gvars3/gvars3/gv3_implementation.hh?cvsroot=libcvd&r1=1.14&r2=1.15
http://cvs.savannah.gnu.org/viewcvs/gvars3/gvars3/gvars3.h?cvsroot=libcvd&r1=1.24&r2=1.25

Patches:
Index: main.cc
===================================================================
RCS file: /cvsroot/libcvd/gvars3/main.cc,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -b -r1.15 -r1.16
--- main.cc     1 Feb 2008 14:57:35 -0000       1.15
+++ main.cc     22 Apr 2009 09:55:45 -0000      1.16
@@ -25,9 +25,10 @@
 
 #include <gvars3/GUI_readline.h>
 #include <unistd.h>
-#include <TooN/numerics.h>
+#include <TooN/TooN.h>
 
 using namespace std;
+using namespace TooN;
 
 bool bDone;
 

Index: gvars3/default.h
===================================================================
RCS file: /cvsroot/libcvd/gvars3/gvars3/default.h,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -b -r1.1 -r1.2
--- gvars3/default.h    20 Apr 2009 17:05:28 -0000      1.1
+++ gvars3/default.h    22 Apr 2009 09:55:46 -0000      1.2
@@ -23,13 +23,13 @@
 #define GV3_INC_DEFUALT_H
 #include <gvars3/config.h>
 
+#include <memory> 
 #ifdef GVARS3_HAVE_TOON
 #include <TooN/TooN.h>
 #endif
 
 namespace GVars3
 {
-
 template<class C> struct DefaultValue
 {
        static inline const C val()
@@ -38,6 +38,12 @@
        }
 };
 
+template<class C> struct IsAwkward
+{
+       static const int is=0;
+};
+
+
 #ifdef GVARS3_HAVE_TOON
 template<> struct DefaultValue<TooN::Vector<-1> >
 {
@@ -46,7 +52,75 @@
                return TooN::makeVector(0);
        }
 };
+
+template<> struct IsAwkward<TooN::Vector<-1> >
+{
+       static const int is=1;
+};
 #endif
+
+template<class C, int PainInTheNeck = IsAwkward<C>::is> struct ValueHolder
+{
+       C val;
+       C& get() 
+       { 
+               return val; 
+       }
+       
+       const C& get() const 
+       { 
+               return val; 
+       }
+
+       ValueHolder(const C& c)
+       :val(c)
+       {}
+
+       void set(const C& c)
+       {
+               val = c;
+       }
+
+       C* ptr() { return &val; }
+};
+
+
+template<class C> struct ValueHolder<C, 1>
+{
+       std::auto_ptr<C> val;
+
+       C& get()
+       { 
+               return *val; 
+       }
+       const C& get() const 
+       { 
+               return *val; 
+       }
+
+       ValueHolder()
+       :val(new C(DefaultValue<C>::val()))
+       {}
+
+       ValueHolder(const ValueHolder& c)
+       :val(new C(c.get()))
+       {}
+
+       ValueHolder(const C& c)
+       :val(new C(c))
+       {}
+
+       void set(const C& c)
+       {
+               val = std::auto_ptr<C>(new C(c));
+       }
+
+       C* ptr()
+       {
+               return val.get();
+       }
+};
+
 }
 
 #endif

Index: gvars3/gv3_implementation.hh
===================================================================
RCS file: /cvsroot/libcvd/gvars3/gvars3/gv3_implementation.hh,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -b -r1.14 -r1.15
--- gvars3/gv3_implementation.hh        20 Apr 2009 17:05:28 -0000      1.14
+++ gvars3/gv3_implementation.hh        22 Apr 2009 09:55:46 -0000      1.15
@@ -5,13 +5,13 @@
 };
 
 // TODO: Make the specialisation for matrices as well. 
-template<class T> T* GV3::register_new_gvar(const std::string& name, const T& 
default_val, int flags)
+template<class T> ValueHolder<T>* GV3::register_new_gvar(const std::string& 
name, const T& default_val, int flags)
 {
        std::map<std::string, std::string>::iterator i;
 
        i = unmatched_tags.find(name);
 
-       T* d;
+       ValueHolder<T>* d;
 
        registered_type_and_trait[name] = std::pair<BaseMap*, 
int>(&TypedMap<T>::instance(), flags);
 
@@ -27,7 +27,7 @@
                if(!(flags & SILENT))
                        std::cerr << "? GV3::Register: " << type_name<T>() << " 
" << name << " undefined. Defaults to " << serialize::to_string(default_val) << 
std::endl;
 
-               d = &safe_replace(name, default_val);
+               d = safe_replace(name, default_val);
        }
        else
        {
@@ -42,7 +42,7 @@
                        throw gvar_was_not_defined();
                }
 
-               d = &safe_replace(name, value);
+               d = safe_replace(name, value);
 
                unmatched_tags.erase(i);
        }
@@ -51,19 +51,22 @@
 }
 
 
-template<class T> T* GV3::get_by_val(const std::string& name, const T& 
default_val, int flags)
+template<class T> ValueHolder<T>* GV3::get_by_val(const std::string& name, 
const T& default_val, int flags)
 {
-  T* d = attempt_get<T>(name);
-  if(!d)
-    d = register_new_gvar(name, default_val, flags);
+       ValueHolder<T>* d = attempt_get<T>(name);
+       if(d)
   return d;
+       else
+               return  register_new_gvar(name, default_val, flags);
 }
 
-template<class T> T* GV3::get_by_str(const std::string& name, const 
std::string& default_val, int flags)
+template<class T> ValueHolder<T>* GV3::get_by_str(const std::string& name, 
const std::string& default_val, int flags)
 {
-  T* d = attempt_get<T>(name);
-  if(d!=NULL) return d;
-  
+       ValueHolder<T>* d = attempt_get<T>(name);
+       if(d)
+               return d;
+       else
+       {
   std::istringstream is(default_val);
   T def = serialize::from_stream<T>(is);
   int e = serialize::check_stream(is);
@@ -71,21 +74,27 @@
   parse_warning(e, type_name<T>(), name, default_val);
   
   return register_new_gvar(name, def, flags);
+       }
 }
 
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Public interface
+//
 template<>inline std::string& GV3::get<std::string>(const std::string& name, 
std::string default_val, int flags)
 {
-       return *get_by_val(name, default_val, flags);
+       return get_by_val(name, default_val, flags)->get();
 }
 
 template<class T> T& GV3::get(const std::string& name, std::string 
default_val, int flags)
 {
-       return *get_by_str<T>(name, default_val, flags);
+       return get_by_str<T>(name, default_val, flags)->get();
 }
 
 template<class T> T& GV3::get(const std::string& name, const T& default_val, 
int flags)
 {
-       return *get_by_val(name, default_val, flags);
+       return get_by_val(name, default_val, flags)->get();
 }
 
 

Index: gvars3/gvars3.h
===================================================================
RCS file: /cvsroot/libcvd/gvars3/gvars3/gvars3.h,v
retrieving revision 1.24
retrieving revision 1.25
diff -u -b -r1.24 -r1.25
--- gvars3/gvars3.h     21 Apr 2009 18:34:08 -0000      1.24
+++ gvars3/gvars3.h     22 Apr 2009 09:55:46 -0000      1.25
@@ -61,21 +61,22 @@
   gvar2() {data=NULL;}      // Debugging comfort feature, makes unregistered 
vars more obvious.
   T& operator*()
     {
-      return *data;
+                       return data->get();
     }
   
   const T & operator*() const 
   {
-     return *data;
+                       return data->get();
   }
   
   T* operator->()
     {
-      return data;
+                       return data->ptr();
     }
+
   const T * operator->() const 
   {
-    return data;
+                       return data->ptr();
   }
 
   bool IsRegistered() const
@@ -84,7 +85,7 @@
   }
    
  protected:
-  T* data;
+               ValueHolder<T>* data;
 };
 
 // Bit-masks for gvar registration:
@@ -139,9 +140,9 @@
                                }
 
                                //Get a data member     
-                               T* get(const std::string& n)
+                               ValueHolder<T>* get(const std::string& n)
                                {
-                                       typename std::map<std::string, 
T>::iterator i;
+                                       DataIter i;
 
                                        i = data.find(n);
 
@@ -151,34 +152,30 @@
                                                return &(i->second);
                                }
                                
-                               //Replace a member using erase then reinsert
-                               T& safe_replace(const std::string& n, const T& 
t)
+                               ValueHolder<T>* safe_replace(const std::string& 
n, const T& t)
                                {
-                                       typename std::map<std::string, 
T>::iterator i, j;
+                                       DataIter i, j;
                                        //Keep track of the neighboring point
                                        //to pass as a hint to insert.
                                        i = data.find(n);
 
-                                       *i = t;
-                                       return *i;
-                                       /*
-                                       j=i;
+                                       if(i == data.end())
+                                       {
+                                               return 
&(data.insert(make_pair(n, t)).first->second);
 
-                                       if(i != data.end())
+                                       }
+                                       else
                                        {
-                                               j++;
-                                               data.erase(i);
+                                               i->second.set(t);
+                                               return &(i->second);
                                        }
 
-                                       data.insert(j, make_pair(n, t));
-
-                                       return data.insert(j, make_pair(n, 
t))->second;*/
                                }
 
                                //Create a data member
-                               T* create(const std::string& n)
+                               ValueHolder<T>* create(const std::string& n)
                                {
-                                       return data.insert(make_pair(n, 
DefaultValue<T>::val()))->second;
+                                       return &(data.insert(make_pair(n, 
DefaultValue<T>::val()))->second);
                                }
                        
                                virtual int set_from_string(const std::string& 
name, const std::string& val)
@@ -194,12 +191,12 @@
 
                                virtual std::string get_as_string(const 
std::string& name)
                                {       
-                                       typename std::map<std::string, 
T>::iterator i = data.find(name);
+                                       DataIter i = data.find(name);
 
                                        if(i == data.end())
                                                i = data.insert(make_pair(name, 
DefaultValue<T>::val())).first;
 
-                                       return serialize::to_string(i->second);
+                                       return 
serialize::to_string(i->second.get());
                                }
 
                                virtual std::string name()
@@ -210,19 +207,21 @@
                                virtual std::vector<std::string> list_tags()
                                {
                                        std::vector<std::string> l;
-                                       for(typename 
std::map<std::string,T>::iterator i=data.begin(); i != data.end(); i++)
+                                       for(DataIter i=data.begin(); i != 
data.end(); i++)
                                                l.push_back(i->first);
                                        return l;
                                }
 
-                               std::map<std::string, T>                data;
+                               std::map<std::string, ValueHolder<T> >          
data;
+                               typedef typename std::map<std::string, 
ValueHolder<T> >::iterator DataIter;
+
                };
 
                template<class T> friend class TypedMap;
 
-               template<class T> static T* attempt_get(const std::string& name)
+               template<class T> static ValueHolder<T>* attempt_get(const 
std::string& name)
                {
-                       T* d = TypedMap<T>::instance().get(name);
+                       ValueHolder<T>* d = TypedMap<T>::instance().get(name);
                        
                        if(!d)   //Data not present in map of the correct type
                        {
@@ -241,7 +240,7 @@
                        return d;
                }
 
-               template<class T> static T& safe_replace(const std::string& 
name, const T& t)
+               template<class T> static ValueHolder<T>* safe_replace(const 
std::string& name, const T& t)
                {
                        return TypedMap<T>::instance().safe_replace(name, t);
                }
@@ -253,9 +252,9 @@
                static std::list<BaseMap*>                              maps;
 
                
-               template<class T> static T* get_by_val(const std::string& name, 
const T& default_val, int flags);
-               template<class T> static T* get_by_str(const std::string& name, 
const std::string& default_val, int flags);
-               template<class T> static T* register_new_gvar(const std::string 
&name, const T& default_val, int flags);
+               template<class T> static ValueHolder<T>* get_by_val(const 
std::string& name, const T& default_val, int flags);
+               template<class T> static ValueHolder<T>* get_by_str(const 
std::string& name, const std::string& default_val, int flags);
+               template<class T> static ValueHolder<T>* 
register_new_gvar(const std::string &name, const T& default_val, int flags);
 
        public:
                //Get references by name




reply via email to

[Prev in Thread] Current Thread [Next in Thread]