C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 5

data_collection.h
1 /* file: data_collection.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 #ifndef __DATA_COLLECTION_H__
17 #define __DATA_COLLECTION_H__
18 
19 #include "services/daal_defines.h"
20 #include "data_management/data/data_serialize.h"
21 #include "data_management/data/data_archive.h"
22 #include "services/daal_shared_ptr.h"
23 #include "services/collection.h"
24 
25 namespace daal
26 {
27 namespace data_management
28 {
29 
30 namespace interface1
31 {
38 typedef services::SharedPtr<SerializationIface> SerializationIfacePtr;
39 
45 class DAAL_EXPORT DataCollection : public SerializationIface, private services::Collection<SerializationIfacePtr >
46 {
47 public:
48  DECLARE_SERIALIZABLE_TAG();
49 
50  typedef services::Collection<SerializationIfacePtr> super;
51 
52  DAAL_CAST_OPERATOR(DataCollection);
53 
55  DataCollection();
56 
58  DataCollection(const DataCollection &other);
59 
64  DataCollection(size_t n);
65 
66  virtual ~DataCollection() {};
67 
73  const SerializationIfacePtr &operator[](size_t index) const;
74 
80  SerializationIfacePtr &operator[](size_t index);
81 
87  SerializationIfacePtr &get(size_t index);
88 
94  const SerializationIfacePtr &get(size_t index) const;
95 
100  DataCollection &push_back(const SerializationIfacePtr &x);
101 
106  DataCollection &operator << (const SerializationIfacePtr &x);
107 
112  size_t size() const;
113 
117  void clear();
118 
123  void erase(size_t pos);
124 
129  bool resize(size_t newCapacity);
130 
131  services::Status serializeImpl(interface1::InputDataArchive *arch) DAAL_C11_OVERRIDE
132  {
133  return serialImpl<interface1::InputDataArchive, false>( arch );
134  }
135 
136  services::Status deserializeImpl(const interface1::OutputDataArchive *arch) DAAL_C11_OVERRIDE
137  {
138  return serialImpl<const interface1::OutputDataArchive, true>( arch );
139  }
140 
141  template<typename Archive, bool onDeserialize>
142  services::Status serialImpl(Archive *arch)
143  {
144  size_t size = _size;
145 
146  arch->set(size);
147 
148  if( onDeserialize )
149  {
150  resize(size);
151  }
152 
153  _size = size;
154 
155  for(size_t i = 0; i < _size; i++)
156  {
157  arch->setSharedPtrObj(_array[i]);
158  }
159 
160  return services::Status();
161  }
162 };
163 typedef services::SharedPtr<DataCollection> DataCollectionPtr;
164 
170 template<typename T>
171 class DAAL_EXPORT KeyValueCollection
172 {
173 public:
174  DAAL_CAST_OPERATOR(KeyValueCollection);
175 
177  KeyValueCollection() {}
179  KeyValueCollection(const KeyValueCollection &other) : _keys(other._keys), _values(other._values) {}
180 
181  KeyValueCollection(const services::Collection<size_t> &keys, const services::Collection<services::SharedPtr<T> > &values)
182  {
183  for(size_t i = 0; i < keys.size(); i++)
184  {
185  _keys.push_back(keys[i]);
186  _values.push_back(values[i]);
187  }
188  }
189 
190  virtual ~KeyValueCollection()
191  {}
192 
198  const services::SharedPtr<T> &operator[] (size_t k) const
199  {
200  size_t i;
201  for( i = 0; i < _keys.size(); i++ )
202  {
203  if( _keys[i] == k )
204  {
205  return _values[i];
206  }
207  }
208  return _nullPtr;
209  }
210 
216  services::SharedPtr<T> &operator[] (size_t k);
217 
223  size_t getKeyByIndex(int idx) const
224  {
225  return _keys[idx];
226  }
227 
233  services::SharedPtr<T> &getValueByIndex(int idx)
234  {
235  return _values[idx];
236  }
237 
243  const services::SharedPtr<T> getValueByIndex(int idx) const
244  {
245  return _values[idx];
246  }
247 
252  size_t size() const
253  {
254  return _keys.size();
255  }
256 
260  void clear()
261  {
262  _keys.clear();
263  _values.clear();
264  }
265 
266 protected:
267  services::Collection<size_t> _keys;
268  services::Collection<services::SharedPtr<T> > _values;
269  services::SharedPtr<T> _nullPtr;
270 };
271 
277 template<typename T>
278 class DAAL_EXPORT SerializableKeyValueCollection : public SerializationIface, public KeyValueCollection<T>
279 {
280 public:
281  DECLARE_SERIALIZABLE_TAG();
282 
283  DAAL_CAST_OPERATOR(SerializableKeyValueCollection);
284 
286  SerializableKeyValueCollection() : KeyValueCollection<T>() {}
288  SerializableKeyValueCollection(const SerializableKeyValueCollection &other) : KeyValueCollection<T>(other) {}
289 
290  SerializableKeyValueCollection(const services::Collection<size_t> &keys, const services::Collection<services::SharedPtr<T> > &values) : KeyValueCollection<T>(keys, values) {}
291 
292  virtual ~SerializableKeyValueCollection() {}
293 
295  services::Status serializeImpl(interface1::InputDataArchive *arch) DAAL_C11_OVERRIDE
296  {
297  return serialImpl<interface1::InputDataArchive, false>( arch );
298  }
299 
301  services::Status deserializeImpl(const interface1::OutputDataArchive *arch) DAAL_C11_OVERRIDE
302  {
303  return serialImpl<const interface1::OutputDataArchive, true>( arch );
304  }
305 
307  template<typename Archive, bool onDeserialize>
308  services::Status serialImpl( Archive *arch )
309  {
310  size_t size = this->_values.size();
311 
312  arch->set(size);
313 
314  if( onDeserialize )
315  {
316  this->_values.resize(size);
317  this->_keys.resize(size);
318  }
319 
320  for(size_t i = 0; i < size; i++)
321  {
322  if( onDeserialize )
323  {
324  this->_values.push_back(this->_nullPtr);
325  this->_keys.push_back(0);
326  }
327  arch->setSharedPtrObj(this->_values[i]);
328  arch->set(this->_keys[i]);
329  }
330 
331  return services::Status();
332  }
333 };
334 
335 typedef SerializableKeyValueCollection<SerializationIface> KeyValueDataCollection;
336 typedef services::SharedPtr<KeyValueDataCollection> KeyValueDataCollectionPtr;
337 typedef services::SharedPtr<const KeyValueDataCollection> KeyValueDataCollectionConstPtr;
339 } // namespace interface1
340 using interface1::DataCollection;
341 using interface1::DataCollectionPtr;
342 using interface1::KeyValueCollection;
343 using interface1::SerializableKeyValueCollection;
344 using interface1::KeyValueDataCollection;
345 using interface1::KeyValueDataCollectionPtr;
346 using interface1::KeyValueDataCollectionConstPtr;
347 using interface1::SerializationIfacePtr;
348 
349 }
350 }
351 
352 #endif
daal::data_management::interface1::KeyValueCollection::KeyValueCollection
KeyValueCollection()
Definition: data_collection.h:177
daal::data_management::interface1::DataCollection::deserializeImpl
services::Status deserializeImpl(const interface1::OutputDataArchive *arch) DAAL_C11_OVERRIDE
Definition: data_collection.h:136
daal::data_management::interface1::KeyValueCollection::getValueByIndex
services::SharedPtr< T > & getValueByIndex(int idx)
Definition: data_collection.h:233
daal
Definition: algorithm_base_common.h:31
daal::data_management::interface1::InputDataArchive
Provides methods to create an archive data object (serialized) and access this object.
Definition: data_archive.h:689
daal::data_management::interface1::SerializableKeyValueCollection
Class that provides functionality of a key-value container for objects derived from the Serialization...
Definition: data_collection.h:278
daal::data_management::interface1::DataCollection
Class that provides functionality of Collection container for objects derived from SerializationIface...
Definition: data_collection.h:45
daal::data_management::interface1::KeyValueCollection
Class that provides functionality of a key-value container for objects derived from the T with a key ...
Definition: data_collection.h:171
daal::data_management::interface1::KeyValueCollection::getValueByIndex
const services::SharedPtr< T > getValueByIndex(int idx) const
Definition: data_collection.h:243
daal::data_management::interface1::KeyValueCollection::clear
void clear()
Definition: data_collection.h:260
daal_defines.h
daal::data_management::interface1::SerializableKeyValueCollection::SerializableKeyValueCollection
SerializableKeyValueCollection(const SerializableKeyValueCollection &other)
Definition: data_collection.h:288
daal::data_management::interface1::OutputDataArchive
Provides methods to restore an object from its serialized counterpart and access the restored object...
Definition: data_archive.h:952
daal::data_management::interface1::SerializableKeyValueCollection::SerializableKeyValueCollection
SerializableKeyValueCollection()
Definition: data_collection.h:286
daal::data_management::interface1::DataCollection::serializeImpl
services::Status serializeImpl(interface1::InputDataArchive *arch) DAAL_C11_OVERRIDE
Definition: data_collection.h:131
daal::data_management::interface1::KeyValueCollection::KeyValueCollection
KeyValueCollection(const KeyValueCollection &other)
Definition: data_collection.h:179
daal::data_management::interface1::KeyValueCollection::getKeyByIndex
size_t getKeyByIndex(int idx) const
Definition: data_collection.h:223
daal::data_management::interface1::SerializationIface
Abstract interface class that defines the interface for serialization and deserialization.
Definition: data_serialize.h:50
daal::algorithms::kernel_function::values
Definition: kernel_function_types.h:70
daal::data_management::interface1::KeyValueCollection::size
size_t size() const
Definition: data_collection.h:252

For more complete information about compiler optimizations, see our Optimization Notice.