Choreonoid  1.5
PolymorphicReferencedArray.h
Go to the documentation of this file.
1 
5 #ifndef CNOID_UTIL_POLYMORPHIC_REFERENCED_ARRAY_H
6 #define CNOID_UTIL_POLYMORPHIC_REFERENCED_ARRAY_H
7 
8 #include "Referenced.h"
9 #include <vector>
10 
11 namespace cnoid {
12 
13 template <class BaseReferencedType = Referenced>
15 {
16 public:
18  virtual bool try_push_back(BaseReferencedType* obj) = 0;
19  virtual BaseReferencedType* get_element(size_t i) = 0;
20  virtual const BaseReferencedType* get_element(size_t i) const = 0;
21  virtual size_t get_size() const = 0;
22  virtual void clear_elements() = 0;
23 };
24 
25 
26 template <class ReferencedType, class BaseReferencedType = Referenced, class PointerType = ReferencedType*>
28 {
29  typedef std::vector<PointerType> Container;
30  Container elements;
31 
32 public:
34  typedef typename Container::value_type value_type;
35  typedef typename Container::iterator iterator;
36  typedef typename Container::const_iterator const_iterator;
37  typedef typename Container::reference reference;
38  typedef typename Container::const_reference const_reference;
39 
41 
42  template <class RhsReferencedType, class RhsPointerType>
45  (*this) << rhs;
46  }
47 
49 
50  virtual bool try_push_back(BaseReferencedType* obj) {
51  if(ReferencedType* p = dynamic_cast<ReferencedType*>(obj)){
52  push_back(p);
53  return true;
54  }
55  return false;
56  }
57 
58  bool operator==(const PolymorphicReferencedArray& rhs) const {
59  if(size() == rhs.size()){
60  return std::equal(begin(), end(), rhs.begin());
61  }
62  return false;
63  }
64 
65  bool operator!=(const PolymorphicReferencedArray& rhs) const {
66  return !operator==(rhs);
67  }
68 
69  template <class RetReferencedType, class RetPointerType>
70  PolymorphicReferencedArray& operator<<(const PolymorphicReferencedArray<RetReferencedType, BaseReferencedType, RetPointerType>& rhs) {
71  for(std::size_t i=0; i < rhs.size(); ++i){
72  try_push_back(rhs[i]);
73  }
74  return *this;
75  }
76 
77  template <class RetReferencedType, class RetPointerType>
79  size_t orgSize = size();
81  typename ArgType::iterator p = another.begin();
82  while(p != another.end()){
83  if(ReferencedType* element = dynamic_cast<ReferencedType*>(p->get())){
84  push_back(element);
85  p = another.erase(p);
86  } else{
87  ++p;
88  }
89  }
90  return (size() > orgSize);
91  }
92 
93  template <class RetReferencedType> PolymorphicReferencedArray extract() {
95  iterator p = begin();
96  while(p != end()){
97  if(RetReferencedType* element = dynamic_cast<RetReferencedType*>(p->get())){
98  extracted.push_back(element);
99  p = erase(p);
100  } else{
101  ++p;
102  }
103  }
104  return extracted;
105  }
106 
107  bool empty() const {
108  return elements.empty();
109  }
110 
111  void reserve(size_t size) {
112  elements.reserve(size);
113  }
114 
115  void resize(size_t size) {
116  elements.resize(size);
117  }
118 
119  std::size_t size() const {
120  return elements.size();
121  }
122 
123  virtual size_t get_size() const {
124  return size();
125  }
126 
127  iterator begin() {
128  return elements.begin();
129  }
130 
131  const_iterator begin() const {
132  return elements.begin();
133  }
134 
135  iterator end() {
136  return elements.end();
137  }
138 
139  const_iterator end() const {
140  return elements.end();
141  }
142 
143  PointerType& back() {
144  return elements.back();
145  }
146 
147  const PointerType& back() const {
148  return elements.back();
149  }
150 
151  PointerType& front() {
152  return elements.front();
153  }
154 
155  const PointerType& front() const {
156  return elements.front();
157  }
158 
159  PointerType& operator[](std::size_t i) {
160  return elements[i];
161  }
162 
163  const PointerType& operator[](std::size_t i) const {
164  return elements[i];
165  }
166 
167  virtual BaseReferencedType* get_element(size_t i) {
168  return elements[i];
169  }
170 
171  virtual const BaseReferencedType* get_element(size_t i) const {
172  return elements[i];
173  }
174 
175  void clear(){
176  elements.clear();
177  }
178 
179  virtual void clear_elements() {
180  clear();
181  }
182 
183  void push_back(const PointerType& obj){
184  elements.push_back(obj);
185  }
186 
187  void pop_back(){
188  elements.pop_back();
189  }
190 
191  iterator erase(iterator pos){
192  return elements.erase(pos);
193  }
194 };
195 
196 }
197 
198 #endif
const PointerType & front() const
Definition: PolymorphicReferencedArray.h:155
const PointerType & operator[](std::size_t i) const
Definition: PolymorphicReferencedArray.h:163
Container::iterator iterator
Definition: PolymorphicReferencedArray.h:35
void push_back(const PointerType &obj)
Definition: PolymorphicReferencedArray.h:183
virtual ~PolymorphicReferencedArrayBase()
Definition: PolymorphicReferencedArray.h:17
void pop_back()
Definition: PolymorphicReferencedArray.h:187
const PointerType & back() const
Definition: PolymorphicReferencedArray.h:147
void clear()
Definition: PolymorphicReferencedArray.h:175
PolymorphicReferencedArray()
Definition: PolymorphicReferencedArray.h:40
Container::value_type value_type
Definition: PolymorphicReferencedArray.h:34
virtual size_t get_size() const =0
PolymorphicReferencedArrayBase< BaseReferencedType > ArrayBase
Definition: PolymorphicReferencedArray.h:33
virtual bool try_push_back(BaseReferencedType *obj)=0
iterator end()
Definition: PolymorphicReferencedArray.h:135
PointerType & operator[](std::size_t i)
Definition: PolymorphicReferencedArray.h:159
virtual void clear_elements()
Definition: PolymorphicReferencedArray.h:179
virtual BaseReferencedType * get_element(size_t i)=0
std::size_t size() const
Definition: PolymorphicReferencedArray.h:119
Container::const_reference const_reference
Definition: PolymorphicReferencedArray.h:38
iterator erase(iterator pos)
Definition: PolymorphicReferencedArray.h:191
virtual BaseReferencedType * get_element(size_t i)
Definition: PolymorphicReferencedArray.h:167
bool extractFrom(PolymorphicReferencedArray< RetReferencedType, BaseReferencedType, RetPointerType > &another)
Definition: PolymorphicReferencedArray.h:78
bool empty() const
Definition: PolymorphicReferencedArray.h:107
bool operator==(const PolymorphicReferencedArray &rhs) const
Definition: PolymorphicReferencedArray.h:58
Container::const_iterator const_iterator
Definition: PolymorphicReferencedArray.h:36
virtual ~PolymorphicReferencedArray()
Definition: PolymorphicReferencedArray.h:48
Defines the minimum processing for performing pasing file for STL.
Definition: AbstractSceneLoader.h:9
virtual const BaseReferencedType * get_element(size_t i) const
Definition: PolymorphicReferencedArray.h:171
const_iterator begin() const
Definition: PolymorphicReferencedArray.h:131
Definition: PolymorphicReferencedArray.h:14
bool operator==(ref_ptr< T > const &a, ref_ptr< U > const &b)
Definition: Referenced.h:230
iterator begin()
Definition: PolymorphicReferencedArray.h:127
void resize(size_t size)
Definition: PolymorphicReferencedArray.h:115
bool operator!=(const PolymorphicReferencedArray &rhs) const
Definition: PolymorphicReferencedArray.h:65
Definition: PolymorphicReferencedArray.h:27
virtual bool try_push_back(BaseReferencedType *obj)
Definition: PolymorphicReferencedArray.h:50
virtual size_t get_size() const
Definition: PolymorphicReferencedArray.h:123
PointerType & back()
Definition: PolymorphicReferencedArray.h:143
PointerType & front()
Definition: PolymorphicReferencedArray.h:151
const_iterator end() const
Definition: PolymorphicReferencedArray.h:139
PolymorphicReferencedArray extract()
Definition: PolymorphicReferencedArray.h:93
void reserve(size_t size)
Definition: PolymorphicReferencedArray.h:111
PolymorphicReferencedArray(const PolymorphicReferencedArray< RhsReferencedType, BaseReferencedType, RhsPointerType > &rhs)
Definition: PolymorphicReferencedArray.h:43
Container::reference reference
Definition: PolymorphicReferencedArray.h:37