Skip to content

Commit

Permalink
Fix for Vector<-1>
Browse files Browse the repository at this point in the history
  • Loading branch information
edrosten committed Apr 22, 2009
1 parent e43a827 commit 4faeff1
Show file tree
Hide file tree
Showing 4 changed files with 164 additions and 81 deletions.
76 changes: 75 additions & 1 deletion gvars3/default.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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()
Expand All @@ -38,6 +38,12 @@ template<class C> struct DefaultValue
}
};

template<class C> struct IsAwkward
{
static const int is=0;
};


#ifdef GVARS3_HAVE_TOON
template<> struct DefaultValue<TooN::Vector<-1> >
{
Expand All @@ -46,7 +52,75 @@ template<> struct DefaultValue<TooN::Vector<-1> >
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
55 changes: 32 additions & 23 deletions gvars3/gv3_implementation.hh
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,13 +5,13 @@ template<class T> inline void robust_set_var(std::string& name, const T& value)
};

// 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);

Expand All @@ -27,7 +27,7 @@ template<class T> T* GV3::register_new_gvar(const std::string& name, const T& de
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
{
Expand All @@ -42,7 +42,7 @@ template<class T> T* GV3::register_new_gvar(const std::string& name, const T& de
throw gvar_was_not_defined();
}

d = &safe_replace(name, value);
d = safe_replace(name, value);

unmatched_tags.erase(i);
}
Expand All @@ -51,41 +51,50 @@ template<class T> T* GV3::register_new_gvar(const std::string& name, const T& de
}


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);
return d;
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;

std::istringstream is(default_val);
T def = serialize::from_stream<T>(is);
int e = serialize::check_stream(is);

parse_warning(e, type_name<T>(), name, default_val);

return register_new_gvar(name, def, flags);
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);

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();
}


Expand Down
111 changes: 55 additions & 56 deletions gvars3/gvars3.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -56,35 +56,36 @@ class BaseMap

template<class T> class gvar2
{
friend class GV3;
public:
gvar2() {data=NULL;} // Debugging comfort feature, makes unregistered vars more obvious.
T& operator*()
{
return *data;
}

const T & operator*() const
{
return *data;
}

T* operator->()
{
return data;
}
const T * operator->() const
{
return data;
}

bool IsRegistered() const
{
return data!=NULL;
}

protected:
T* data;
friend class GV3;
public:
gvar2() {data=NULL;} // Debugging comfort feature, makes unregistered vars more obvious.
T& operator*()
{
return data->get();
}

const T & operator*() const
{
return data->get();
}

T* operator->()
{
return data->ptr();
}

const T * operator->() const
{
return data->ptr();
}

bool IsRegistered() const
{
return data!=NULL;
}

protected:
ValueHolder<T>* data;
};

// Bit-masks for gvar registration:
Expand Down Expand Up @@ -139,9 +140,9 @@ class GV3
}

//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);

Expand All @@ -151,34 +152,30 @@ class GV3
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)
Expand All @@ -194,12 +191,12 @@ class GV3

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()
Expand All @@ -210,19 +207,21 @@ class GV3
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
{
Expand All @@ -241,7 +240,7 @@ class GV3
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);
}
Expand All @@ -253,9 +252,9 @@ class GV3
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
Expand Down
Loading

0 comments on commit 4faeff1

Please sign in to comment.