blob: 9d32314f77cb0dba6a793748ab1f4ec6ec9a0cd3 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
//
// Copyright 2010 Ettus Research LLC
//
#ifndef INCLUDED_WAX_HPP
#define INCLUDED_WAX_HPP
#include <boost/any.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/pointer_cast.hpp>
#include <iostream>
/*!
* WAX - it's a metaphor!
*
* The WAX framework allows object to have generic/anytype properties.
* These properties can be addressed through generic/anytype identifiers.
* A property of a WAX object may even be another WAX object.
*
* When a property is a WAX object, the returned value must be an obj pointer.
* A WAX object provides two types of pointers: obj::ptr and obj::sptr.
* The choice of pointer vs smart pointer depends on the owner of the memory.
*
* Proprties may be referenced though the [] overloaded operator.
* The [] operator returns a special proxy that allows for assigment.
* Also, the [] operators may be chained as in the folowing examples:
* my_obj[prop1][prop2][prop3] = value
* value = my_obj[prop1][prop2][prop3]
*
* Any value returned from an access operation is of wax::type.
* To use this value, it must be cast with wax::cast<new_type>(value).
*/
namespace wax{
//general typedefs
typedef boost::any type;
typedef boost::bad_any_cast bad_cast;
//dummy class declarations
class obj; class proxy;
/*!
* WAX object base class:
* A wax object subclass should override the set and get methods.
* The magic of operator chaining is handled by the [] operator.
*/
class obj{
public:
//obj pointer typedefs
typedef boost::shared_ptr<obj> sptr;
typedef obj* ptr;
//cast derived pointer to obj base class pointer
template <class T> static sptr cast(boost::shared_ptr<T> r){
return boost::static_pointer_cast<obj>(r);
}
template <class T> static ptr cast(T *r){
return dynamic_cast<ptr>(r);
}
//structors
obj(void);
virtual ~obj(void);
//public interface
proxy operator[](const type &key);
private:
//private interface
virtual void get(const type &key, type &val) = 0;
virtual void set(const type &key, const type &val) = 0;
};
/*!
* WAX proxy class:
* Allows the obj [] operator to return a proxy result.
* This result can be assigned to via the = operator.
* Or this result can be called again with the [] operator.
*/
class proxy{
public:
//destructors
~proxy(void);
//overloaded
type operator()(void);
proxy operator[](const type &key);
proxy operator=(const type &key);
private:
//typedefs for callables from the object that built this proxy
typedef boost::function<void(const type &)> setter_t;
typedef boost::function<void(type &)> getter_t;
//private contructor
proxy(getter_t, setter_t);
//access to private contructor
friend proxy obj::operator[](const type &key);
getter_t d_getter;
setter_t d_setter;
};
/*!
* Cast a wax::type into the desired type
* Usage wax::cast<new_type>(my_value).
*
* \param val the any type to cast
* \return data of the desired type
* \throw wax::bad_cast when the cast fails
*/
template<typename T> T cast(const type & val){
//special case to handle the proxy
if (val.type() == typeid(proxy)){
return cast<T>(boost::any_cast<proxy>(val)());
}
//do the type cast
return boost::any_cast<T>(val);
}
} //namespace wax
//ability to use types with stream operators
std::ostream& operator<<(std::ostream &os, const wax::type &x);
#endif /* INCLUDED_WAX_HPP */
|
