C++ API Reference for Intel® Data Analytics Acceleration Library 2020 Update 1

data_collection.h
1 /* file: data_collection.h */
2 /*******************************************************************************
3 * Copyright 2014-2020 Intel Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *******************************************************************************/
17 
18 #ifndef __DATA_COLLECTION_H__
19 #define __DATA_COLLECTION_H__
20 
21 #include "services/daal_defines.h"
22 #include "data_management/data/data_serialize.h"
23 #include "data_management/data/data_archive.h"
24 #include "services/daal_shared_ptr.h"
25 #include "services/collection.h"
26 
27 namespace daal
28 {
29 namespace data_management
30 {
31 
32 namespace interface1
33 {
40 typedef services::SharedPtr<SerializationIface> SerializationIfacePtr;
41 
47 class DAAL_EXPORT DataCollection : public SerializationIface, private services::Collection<SerializationIfacePtr >
48 {
49 public:
50  DECLARE_SERIALIZABLE_TAG();
51 
52  typedef services::Collection<SerializationIfacePtr> super;
53 
54  DAAL_CAST_OPERATOR(DataCollection);
55 
57  DataCollection();
58 
60  DataCollection(const DataCollection &other);
61 
66  DataCollection(size_t n);
67 
68  virtual ~DataCollection() {};
69 
75  const SerializationIfacePtr &operator[](size_t index) const;
76 
82  SerializationIfacePtr &operator[](size_t index);
83 
89  SerializationIfacePtr &get(size_t index);
90 
96  const SerializationIfacePtr &get(size_t index) const;
97 
102  DataCollection &push_back(const SerializationIfacePtr &x);
103 
108  DataCollection &operator << (const SerializationIfacePtr &x);
109 
114  size_t size() const;
115 
119  void clear();
120 
125  void erase(size_t pos);
126 
131  bool resize(size_t newCapacity);
132 
133  services::Status serializeImpl(interface1::InputDataArchive *arch) DAAL_C11_OVERRIDE
134  {
135  return serialImpl<interface1::InputDataArchive, false>( arch );
136  }
137 
138  services::Status deserializeImpl(const interface1::OutputDataArchive *arch) DAAL_C11_OVERRIDE
139  {
140  return serialImpl<const interface1::OutputDataArchive, true>( arch );
141  }
142 
143  template<typename Archive, bool onDeserialize>
144  services::Status serialImpl(Archive *arch)
145  {
146  size_t size = _size;
147 
148  arch->set(size);
149 
150  if( onDeserialize )
151  {
152  resize(size);
153  }
154 
155  _size = size;
156 
157  for(size_t i = 0; i < _size; i++)
158  {
159  arch->setSharedPtrObj(_array[i]);
160  }
161 
162  return services::Status();
163  }
164 };
165 typedef services::SharedPtr<DataCollection> DataCollectionPtr;
166 
172 template<typename T>
173 class DAAL_EXPORT KeyValueCollection
174 {
175 public:
176  DAAL_CAST_OPERATOR(KeyValueCollection);
177 
179  KeyValueCollection() {}
181  KeyValueCollection(const KeyValueCollection &other) : _keys(other._keys), _values(other._values) {}
182 
183  KeyValueCollection(const services::Collection<size_t> &keys, const services::Collection<services::SharedPtr<T> > &values)
184  {
185  for(size_t i = 0; i < keys.size(); i++)
186  {
187  _keys.push_back(keys[i]);
188  _values.push_back(values[i]);
189  }
190  }
191 
192  virtual ~KeyValueCollection()
193  {}
194 
200  const services::SharedPtr<T> &operator[] (size_t k) const
201  {
202  size_t i;
203  for( i = 0; i < _keys.size(); i++ )
204  {
205  if( _keys[i] == k )
206  {
207  return _values[i];
208  }
209  }
210  return _nullPtr;
211  }
212 
218  services::SharedPtr<T> &operator[] (size_t k);
219 
225  size_t getKeyByIndex(int idx) const
226  {
227  return _keys[idx];
228  }
229 
235  services::SharedPtr<T> &getValueByIndex(int idx)
236  {
237  return _values[idx];
238  }
239 
245  const services::SharedPtr<T> getValueByIndex(int idx) const
246  {
247  return _values[idx];
248  }
249 
254  size_t size() const
255  {
256  return _keys.size();
257  }
258 
262  void clear()
263  {
264  _keys.clear();
265  _values.clear();
266  }
267 
268 protected:
269  services::Collection<size_t> _keys;
270  services::Collection<services::SharedPtr<T> > _values;
271  services::SharedPtr<T> _nullPtr;
272 };
273 
279 template<typename T>
280 class DAAL_EXPORT SerializableKeyValueCollection : public SerializationIface, public KeyValueCollection<T>
281 {
282 public:
283  DECLARE_SERIALIZABLE_TAG();
284 
285  DAAL_CAST_OPERATOR(SerializableKeyValueCollection);
286 
288  SerializableKeyValueCollection() : KeyValueCollection<T>() {}
290  SerializableKeyValueCollection(const SerializableKeyValueCollection &other) : KeyValueCollection<T>(other) {}
291 
292  SerializableKeyValueCollection(const services::Collection<size_t> &keys, const services::Collection<services::SharedPtr<T> > &values) : KeyValueCollection<T>(keys, values) {}
293 
294  virtual ~SerializableKeyValueCollection() {}
295 
297  services::Status serializeImpl(interface1::InputDataArchive *arch) DAAL_C11_OVERRIDE
298  {
299  return serialImpl<interface1::InputDataArchive, false>( arch );
300  }
301 
303  services::Status deserializeImpl(const interface1::OutputDataArchive *arch) DAAL_C11_OVERRIDE
304  {
305  return serialImpl<const interface1::OutputDataArchive, true>( arch );
306  }
307 
309  template<typename Archive, bool onDeserialize>
310  services::Status serialImpl( Archive *arch )
311  {
312  size_t size = this->_values.size();
313 
314  arch->set(size);
315 
316  if( onDeserialize )
317  {
318  this->_values.resize(size);
319  this->_keys.resize(size);
320  }
321 
322  for(size_t i = 0; i < size; i++)
323  {
324  if( onDeserialize )
325  {
326  this->_values.push_back(this->_nullPtr);
327  this->_keys.push_back(0);
328  }
329  arch->setSharedPtrObj(this->_values[i]);
330  arch->set(this->_keys[i]);
331  }
332 
333  return services::Status();
334  }
335 };
336 
337 typedef SerializableKeyValueCollection<SerializationIface> KeyValueDataCollection;
338 typedef services::SharedPtr<KeyValueDataCollection> KeyValueDataCollectionPtr;
339 typedef services::SharedPtr<const KeyValueDataCollection> KeyValueDataCollectionConstPtr;
341 } // namespace interface1
342 using interface1::DataCollection;
343 using interface1::DataCollectionPtr;
344 using interface1::KeyValueCollection;
345 using interface1::SerializableKeyValueCollection;
346 using interface1::KeyValueDataCollection;
347 using interface1::KeyValueDataCollectionPtr;
348 using interface1::KeyValueDataCollectionConstPtr;
349 using interface1::SerializationIfacePtr;
350 
351 }
352 }
353 
354 #endif
daal::data_management::interface1::SerializableKeyValueCollection::SerializableKeyValueCollection
SerializableKeyValueCollection(const SerializableKeyValueCollection &other)
Definition: data_collection.h:290
daal::data_management::interface1::KeyValueCollection::KeyValueCollection
KeyValueCollection()
Definition: data_collection.h:179
daal::data_management::interface1::SerializableKeyValueCollection
Class that provides functionality of a key-value container for objects derived from the Serialization...
Definition: data_collection.h:280
daal::data_management::interface1::KeyValueCollection::clear
void clear()
Definition: data_collection.h:262
daal_defines.h
daal::data_management::interface1::SerializationIface
Abstract interface class that defines the interface for serialization and deserialization.
Definition: data_serialize.h:52
daal::data_management::interface1::SerializableKeyValueCollection::SerializableKeyValueCollection
SerializableKeyValueCollection()
Definition: data_collection.h:288
daal::algorithms::kernel_function::values
Definition: kernel_function_types.h:72
daal::data_management::interface1::DataCollection::deserializeImpl
services::Status deserializeImpl(const interface1::OutputDataArchive *arch) DAAL_C11_OVERRIDE
Definition: data_collection.h:138
daal::data_management::interface1::DataCollection::serializeImpl
services::Status serializeImpl(interface1::InputDataArchive *arch) DAAL_C11_OVERRIDE
Definition: data_collection.h:133
daal::data_management::interface1::KeyValueCollection::getKeyByIndex
size_t getKeyByIndex(int idx) const
Definition: data_collection.h:225
daal::data_management::interface1::OutputDataArchive
Provides methods to restore an object from its serialized counterpart and access the restored object...
Definition: data_archive.h:988
daal::data_management::interface1::KeyValueCollection::getValueByIndex
services::SharedPtr< T > & getValueByIndex(int idx)
Definition: data_collection.h:235
daal::data_management::interface1::InputDataArchive
Provides methods to create an archive data object (serialized) and access this object.
Definition: data_archive.h:725
daal::data_management::interface1::KeyValueCollection::getValueByIndex
const services::SharedPtr< T > getValueByIndex(int idx) const
Definition: data_collection.h:245
daal::data_management::interface1::KeyValueCollection::size
size_t size() const
Definition: data_collection.h:254
daal::data_management::interface1::DataCollection
Class that provides functionality of Collection container for objects derived from SerializationIface...
Definition: data_collection.h:47
daal::data_management::interface1::KeyValueCollection::KeyValueCollection
KeyValueCollection(const KeyValueCollection &other)
Definition: data_collection.h:181
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:173

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