C++ API Reference for Intel® Data Analytics Acceleration Library 2018 Update 3

algorithm_types.h
1 /* file: algorithm_types.h */
2 /*******************************************************************************
3 * Copyright 2014-2018 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 /*
17 //++
18 // Implementation of base classes defining algorithm interface.
19 //--
20 */
21 
22 #ifndef __ALGORITHM_TYPES_H__
23 #define __ALGORITHM_TYPES_H__
24 
25 #include "services/daal_defines.h"
26 #include "data_management/data/data_archive.h"
27 #include "data_management/data/data_serialize.h"
28 #include "data_management/data/data_collection.h"
29 #include "services/error_handling.h"
30 
31 namespace daal
32 {
43 namespace algorithms
44 {
45 
49 namespace interface1
50 {
60 struct Parameter
61 {
62  DAAL_NEW_DELETE();
63 
64  Parameter(){}
65  virtual ~Parameter() {}
66 
67  virtual services::Status check() const { return services::Status(); }
68 };
69 
74 class DAAL_EXPORT Argument
75 {
76 public:
77  DAAL_NEW_DELETE();
78 
80  Argument() : idx(0) {}
81 
86  Argument(const size_t n);
87 
88  virtual ~Argument() {};
89 
95  Argument &operator <<(const data_management::SerializationIfacePtr &val)
96  {
97  (*_storage) << val;
98  return *this;
99  }
100 
105  size_t size() const
106  {
107  return _storage->size();
108  }
109 
110 protected:
115  Argument(const Argument& other);
116 
122  const data_management::SerializationIfacePtr &get(size_t index) const;
123 
130  void set(size_t index, const data_management::SerializationIfacePtr &value);
131 
136  void setStorage(const data_management::DataCollectionPtr& storage);
137 
142  static data_management::DataCollectionPtr& getStorage(Argument& a);
143 
148  static const data_management::DataCollectionPtr& getStorage(const Argument& a);
149 
150 
151  template<typename Archive, bool onDeserialize>
152  services::Status serialImpl(Archive *arch)
153  {
154  arch->set(idx);
155  arch->setObj(_storage.get());
156 
157  return services::Status();
158  }
159 
160 private:
161  size_t idx;
162  data_management::DataCollectionPtr _storage;
163 };
164 
169 class SerializableArgument : public data_management::SerializationIface, public Argument
170 {
171 public:
172  DAAL_NEW_DELETE();
173 
175  SerializableArgument() {}
176 
181  SerializableArgument(const size_t n) : Argument(n) {}
182 
183  virtual ~SerializableArgument() {};
184 };
185 
191 class Input : public Argument
192 {
193 public:
194  DAAL_NEW_DELETE();
195 
197  Input() {}
198 
203  Input(const size_t n) : Argument(n) {}
204 
205  virtual ~Input() {};
206 
212  virtual services::Status check(const Parameter *parameter, int method) const { return services::Status(); }
213 
214 protected:
219  Input(const Input& other) : Argument(other){}
220 };
221 
227 class PartialResult : public SerializableArgument
228 {
229 public:
230  DAAL_NEW_DELETE();
231 
233  PartialResult() : _initFlag(false) {};
234 
239  PartialResult(const size_t n) : SerializableArgument(n), _initFlag(false) {}
240 
241  virtual ~PartialResult() {};
242 
246  virtual int getSerializationTag() const { return 0; }
247 
252  bool getInitFlag() { return _initFlag; }
253 
258  void setInitFlag(bool flag) { _initFlag = flag; }
259 
266  virtual services::Status check(const Input *input, const Parameter *parameter, int method) const
267  {
268  return services::Status();
269  }
270 
276  virtual services::Status check(const Parameter *parameter, int method) const { return services::Status(); }
277 
278 private:
279  bool _initFlag;
280 
281 protected:
283  template<typename Archive, bool onDeserialize>
284  services::Status serialImpl(Archive *arch)
285  {
286  Argument::serialImpl<Archive, onDeserialize>(arch);
287 
288  arch->set(_initFlag);
289 
290  return services::Status();
291  }
292  virtual services::Status serializeImpl(data_management::InputDataArchive *archive)
293  {
294  return services::Status();
295  }
296  virtual services::Status deserializeImpl(const data_management::OutputDataArchive *archive)
297  {
298  return services::Status();
299  }
300 };
301 
307 class Result : public SerializableArgument
308 {
309 public:
310  DAAL_NEW_DELETE();
311 
313  Result() {}
314 
319  Result(const size_t n) : SerializableArgument(n) {}
320 
321  virtual ~Result() {};
322 
326  virtual int getSerializationTag() const { return 0; }
327 
334  virtual services::Status check(const Input *input, const Parameter *parameter, int method) const
335  {
336  return services::Status();
337  }
338 
345  virtual services::Status check(const PartialResult *partialResult, const Parameter *parameter, int method) const
346  {
347  return services::Status();
348  }
349 
350 
351 protected:
353  template<typename Archive, bool onDeserialize>
354  services::Status serialImpl(Archive *arch)
355  {
356  Argument::serialImpl<Archive, onDeserialize>(arch);
357 
358  return services::Status();
359  }
360  virtual services::Status serializeImpl(data_management::InputDataArchive *archive)
361  {
362  return services::Status();
363  }
364  virtual services::Status deserializeImpl(const data_management::OutputDataArchive *archive)
365  {
366  return services::Status();
367  }
368 };
369 
374 class DAAL_EXPORT OptionalArgument : public SerializableArgument
375 {
376 public:
377  DECLARE_SERIALIZABLE_TAG();
378 
380  OptionalArgument() : SerializableArgument(0) {}
381 
386  OptionalArgument(const size_t n) : SerializableArgument(n) {}
387 
393  const data_management::SerializationIfacePtr &get(size_t index) const { return SerializableArgument::get(index); }
394 
401  void set(size_t index, const data_management::SerializationIfacePtr &value) { return SerializableArgument::set(index, value); }
402 
403 protected:
405  template<typename Archive, bool onDeserialize>
406  services::Status serialImpl(Archive *arch)
407  {
408  Argument::serialImpl<Archive, onDeserialize>(arch);
409 
410  return services::Status();
411  }
412 
413  services::Status serializeImpl(data_management::InputDataArchive *arch) DAAL_C11_OVERRIDE
414  {
415  serialImpl<data_management::InputDataArchive, false>(arch);
416 
417  return services::Status();
418  }
419 
420  services::Status deserializeImpl(const data_management::OutputDataArchive *arch) DAAL_C11_OVERRIDE
421  {
422  serialImpl<const data_management::OutputDataArchive, true>(arch);
423 
424  return services::Status();
425  }
426 };
427 typedef services::SharedPtr<Input> InputPtr;
428 typedef services::SharedPtr<PartialResult> PartialResultPtr;
429 typedef services::SharedPtr<Result> ResultPtr;
430 typedef services::SharedPtr<OptionalArgument> OptionalArgumentPtr;
431 
433 } // namespace interface1
434 using interface1::Parameter;
435 using interface1::Argument;
436 using interface1::Input;
437 using interface1::InputPtr;
438 using interface1::PartialResult;
439 using interface1::PartialResultPtr;
440 using interface1::Result;
441 using interface1::ResultPtr;
442 using interface1::OptionalArgument;
443 using interface1::OptionalArgumentPtr;
444 
445 }
446 }
447 #endif
daal::algorithms::interface1::Result::getSerializationTag
virtual int getSerializationTag() const
Definition: algorithm_types.h:326
daal::algorithms::interface1::Argument::size
size_t size() const
Definition: algorithm_types.h:105
daal::algorithms::interface1::Input::Input
Input()
Definition: algorithm_types.h:197
daal::algorithms::interface1::Result::check
virtual services::Status check(const Input *input, const Parameter *parameter, int method) const
Definition: algorithm_types.h:334
daal
Definition: algorithm_base_common.h:31
daal::algorithms::interface1::Result
Base class to represent final results of the computation. Algorithm-specific final results are repres...
Definition: algorithm_types.h:307
daal::algorithms::interface1::PartialResult::getSerializationTag
virtual int getSerializationTag() const
Definition: algorithm_types.h:246
daal::algorithms::interface1::Input::Input
Input(const size_t n)
Definition: algorithm_types.h:203
daal::algorithms::interface1::PartialResult
Base class to represent partial results of the computation. Algorithm-specific partial results are re...
Definition: algorithm_types.h:227
daal::algorithms::interface1::OptionalArgument
Base class to represent argument with serialization methods
Definition: algorithm_types.h:374
daal::algorithms::interface1::Result::check
virtual services::Status check(const PartialResult *partialResult, const Parameter *parameter, int method) const
Definition: algorithm_types.h:345
daal_defines.h
daal::algorithms::interface1::Result::Result
Result(const size_t n)
Definition: algorithm_types.h:319
daal::algorithms::interface1::Input::Input
Input(const Input &other)
Definition: algorithm_types.h:219
daal::algorithms::interface1::OptionalArgument::OptionalArgument
OptionalArgument()
Definition: algorithm_types.h:380
daal::algorithms::interface1::Parameter
Base class to represent computation parameters. Algorithm-specific parameters are represented as deri...
Definition: algorithm_types.h:60
daal::algorithms::interface1::OptionalArgument::OptionalArgument
OptionalArgument(const size_t n)
Definition: algorithm_types.h:386
daal::algorithms::interface1::PartialResult::getInitFlag
bool getInitFlag()
Definition: algorithm_types.h:252
daal::algorithms::interface1::PartialResult::check
virtual services::Status check(const Input *input, const Parameter *parameter, int method) const
Definition: algorithm_types.h:266
daal::algorithms::interface1::Result::Result
Result()
Definition: algorithm_types.h:313
daal::algorithms::interface1::Input::check
virtual services::Status check(const Parameter *parameter, int method) const
Definition: algorithm_types.h:212
daal::algorithms::interface1::Argument::get
const data_management::SerializationIfacePtr & get(size_t index) const
daal::algorithms::interface1::Argument::Argument
Argument()
Definition: algorithm_types.h:80
daal::algorithms::interface1::SerializableArgument
Base class to represent argument with serialization methods
Definition: algorithm_types.h:169
daal::algorithms::math::abs::value
Definition: abs_types.h:86
daal::algorithms::interface1::PartialResult::PartialResult
PartialResult(const size_t n)
Definition: algorithm_types.h:239
daal::algorithms::interface1::SerializableArgument::SerializableArgument
SerializableArgument()
Definition: algorithm_types.h:175
daal::algorithms::interface1::PartialResult::PartialResult
PartialResult()
Definition: algorithm_types.h:233
daal::algorithms::interface1::Argument
Base class to represent computation input and output arguments.
Definition: algorithm_types.h:74
daal::algorithms::interface1::SerializableArgument::SerializableArgument
SerializableArgument(const size_t n)
Definition: algorithm_types.h:181
daal::algorithms::interface1::OptionalArgument::set
void set(size_t index, const data_management::SerializationIfacePtr &value)
Definition: algorithm_types.h:401
daal::algorithms::interface1::Input
Base class to represent computation input arguments. Algorithm-specific input arguments are represent...
Definition: algorithm_types.h:191
daal::algorithms::interface1::Argument::set
void set(size_t index, const data_management::SerializationIfacePtr &value)
daal::algorithms::interface1::PartialResult::check
virtual services::Status check(const Parameter *parameter, int method) const
Definition: algorithm_types.h:276
daal::algorithms::interface1::PartialResult::setInitFlag
void setInitFlag(bool flag)
Definition: algorithm_types.h:258

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