SHOGUN  6.1.3
some.h
Go to the documentation of this file.
1 #ifndef __SG_SOME_H__
2 #define __SG_SOME_H__
3 
4 #include <memory>
5 
6 namespace shogun
7 {
8 
15  template <typename T>
16  class Some
17  {
18  public:
19  Some(const Some<T>& other);
20  template <typename R>
21  Some(const Some<R>& other);
22  explicit Some(T* other);
23 
24  Some& operator=(T* other);
25  ~Some();
26 
27  static Some<T> from_raw(T* raw);
28 
35  operator T*() const;
40  T* operator->() const;
41 
47  T* get() const;
48 
49  private:
50  Some();
51  void unref();
52  void ref();
53 
54  private:
55  T* raw = nullptr;
56  };
57 
58  template <typename T>
59  Some<T>::Some() : raw(nullptr)
60  {
61  }
62  template <typename T>
63  Some<T>::Some(const Some<T>& other) : raw(other.raw)
64  {
65  ref();
66  }
67  template <typename T>
68  Some<T>::Some(T* other) : raw(other)
69  {
70  ref();
71  }
72  template <class T>
73  template <class R>
74  Some<T>::Some(const Some<R>& other)
75  {
76  raw = dynamic_cast<T*>(other.get());
77  ref();
78  }
79  template <typename T>
81  {
82  if (raw != other)
83  {
84  unref();
85  raw = other;
86  ref();
87  }
88  return *this;
89  }
90 
91  template <typename T>
93  {
94  unref();
95  }
96  template <typename T>
97  Some<T>::operator T*() const
98  {
99  return raw;
100  }
101  template <typename T>
103  {
104  return raw;
105  }
106  template <class T>
107  T* Some<T>::get() const
108  {
109  return raw;
110  }
111  template <typename T>
112  void Some<T>::ref()
113  {
114  if (raw)
115  (raw)->ref();
116  }
117  template <typename T>
118  void Some<T>::unref()
119  {
120  if (raw)
121  {
122  if ((raw)->unref() == 0)
123  (raw) = NULL;
124  };
125  }
126  template <typename T>
128  {
129  Some<T> result(raw);
130  return result;
131  }
132 
143  template <typename T, class... Args>
144  Some<T> some(Args&&... args)
145  {
146  T* ptr = new T(args...);
147  return Some<T>::from_raw(ptr);
148  }
149 
150  template <class T>
151  inline T wrap(const T& value)
152  {
153  return value;
154  }
155 
156  template <class T>
157  inline Some<T> wrap(T* ptr)
158  {
159  return Some<T>::from_raw(ptr);
160  }
161 
162  template <class T>
163  inline Some<T> wrap(const Some<T>& other)
164  {
165  return other;
166  }
167 };
168 
169 #endif /* __SG_SOME_H__ */
~Some()
Definition: some.h:92
Some< T > some(Args &&...args)
Definition: some.h:144
static Some< T > from_raw(T *raw)
Definition: some.h:127
T wrap(const T &value)
Definition: some.h:151
T * get() const
Definition: some.h:107
T * operator->() const
Definition: some.h:102
all of classes and functions are contained in the shogun namespace
Definition: class_list.h:18
Some & operator=(T *other)
Definition: some.h:80

SHOGUN Machine Learning Toolbox - Documentation