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

data_archive.h
1 /* file: data_archive.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 /*
17 //++
18 // Declaration and implementation of classes that support serialization and deserialization methods
19 //--
20 */
21 
22 #ifndef __DATA_ARCHIVE_H__
23 #define __DATA_ARCHIVE_H__
24 
25 #include "services/base.h"
26 #include "services/library_version_info.h"
27 #include "services/daal_memory.h"
28 #include "services/collection.h"
29 #include "data_management/data/data_block.h"
30 #include "data_management/data/factory.h"
31 #include "data_management/data/data_serialize.h"
32 #include "data_management/data/data_collection.h"
33 #include "data_management/features/defines.h"
34 #include "data_management/compression/compression_stream.h"
35 
36 namespace daal
37 {
38 namespace data_management
39 {
40 
41 namespace interface1
42 {
52 class DataArchiveIface : public Base
53 {
54 public:
55  virtual ~DataArchiveIface() {}
56 
62  virtual void write(byte *ptr, size_t size) = 0;
63 
69  virtual void read(byte *ptr, size_t size) = 0;
70 
75  virtual size_t getSizeOfArchive() const = 0;
76 
81  virtual services::SharedPtr<byte> getArchiveAsArraySharedPtr() const = 0;
82 
88  DAAL_DEPRECATED_VIRTUAL virtual byte *getArchiveAsArray() { return NULL; }
89 
95  DAAL_DEPRECATED_VIRTUAL virtual std::string getArchiveAsString() = 0;
96 
103  virtual size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const = 0;
104 
109  virtual void setMajorVersion(int majorVersion) = 0;
110 
115  virtual void setMinorVersion(int minorVersion) = 0;
116 
121  virtual void setUpdateVersion(int updateVersion) = 0;
122 
127  virtual int getMajorVersion() = 0;
128 
133  virtual int getMinorVersion() = 0;
134 
139  virtual int getUpdateVersion() = 0;
140 };
141 
147 class DataArchiveImpl : public DataArchiveIface
148 {
149 public:
150  DataArchiveImpl() : _majorVersion(0), _minorVersion(0), _updateVersion(0) {}
151 
152  virtual ~DataArchiveImpl() {}
153 
154  void setMajorVersion(int majorVersion) DAAL_C11_OVERRIDE
155  {
156  _majorVersion = majorVersion;
157  }
158 
159  void setMinorVersion(int minorVersion) DAAL_C11_OVERRIDE
160  {
161  _minorVersion = minorVersion;
162  }
163 
164  void setUpdateVersion(int updateVersion) DAAL_C11_OVERRIDE
165  {
166  _updateVersion = updateVersion;
167  }
168 
169  int getMajorVersion() DAAL_C11_OVERRIDE
170  {
171  return _majorVersion;
172  }
173 
174  int getMinorVersion() DAAL_C11_OVERRIDE
175  {
176  return _minorVersion;
177  }
178 
179  int getUpdateVersion() DAAL_C11_OVERRIDE
180  {
181  return _updateVersion;
182  }
183 
184 protected:
185  int _majorVersion;
186  int _minorVersion;
187  int _updateVersion;
188 };
189 
194 class DataArchive: public DataArchiveImpl
195 {
196 public:
200  DataArchive() : minBlockSize(1024 * 16), minBlocksNum(16), _errors(new services::ErrorCollection())
201  {
202  blockPtr = 0;
203  blockAllocatedSize = 0;
204  blockOffset = 0;
205  arraysSize = 0;
206  currentWriteBlock = -1;
207 
208  currentReadBlock = 0;
209  currentReadBlockOffset = 0;
210 
211  serializedBuffer = 0;
212 
213  addBlock( minBlockSize );
214  }
215 
219  DataArchive( const DataArchive &arch ) : minBlockSize(1024 * 16), minBlocksNum(16)
220  {
221  blockPtr = 0;
222  blockAllocatedSize = 0;
223  blockOffset = 0;
224  arraysSize = 0;
225  currentWriteBlock = -1;
226 
227  currentReadBlock = 0;
228  currentReadBlockOffset = 0;
229 
230  serializedBuffer = 0;
231 
232  size_t size = arch.getSizeOfArchive();
233  addBlock( size );
234  arch.copyArchiveToArray( blockPtr[currentWriteBlock], size );
235 
236  blockOffset[currentWriteBlock] += size;
237  }
238 
244  DataArchive( byte *ptr, size_t size ) : minBlockSize(1024 * 16), minBlocksNum(16)
245  {
246  blockPtr = 0;
247  blockAllocatedSize = 0;
248  blockOffset = 0;
249  arraysSize = 0;
250  currentWriteBlock = -1;
251 
252  currentReadBlock = 0;
253  currentReadBlockOffset = 0;
254 
255  serializedBuffer = 0;
256 
257  addBlock( size );
258 
259  daal::services::daal_memcpy_s(blockPtr[currentWriteBlock], size, ptr, size);
260 
261  blockOffset[currentWriteBlock] += size;
262  }
263 
264  ~DataArchive()
265  {
266  int i;
267  for(i = 0; i <= currentWriteBlock; i++)
268  {
269  daal::services::daal_free( blockPtr[i] );
270  }
271  daal::services::daal_free( blockPtr );
272  daal::services::daal_free( blockAllocatedSize );
273  daal::services::daal_free( blockOffset );
274  if( serializedBuffer )
275  {
276  daal::services::daal_free( serializedBuffer );
277  }
278  }
279 
280  void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
281  {
282  size_t alignedSize = alignValueUp(size);
283  if( blockAllocatedSize[currentWriteBlock] < blockOffset[currentWriteBlock] + alignedSize )
284  {
285  addBlock(alignedSize);
286  }
287 
288  size_t offset = blockOffset[currentWriteBlock];
289 
290  daal::services::daal_memcpy_s(&(blockPtr[currentWriteBlock][offset]), alignedSize, ptr, size);
291  for (size_t i = size; i < alignedSize; i++)
292  {
293  blockPtr[currentWriteBlock][offset + i] = 0;
294  }
295 
296  blockOffset[currentWriteBlock] += alignedSize;
297  }
298 
299  void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
300  {
301  size_t alignedSize = alignValueUp(size);
302  if( blockOffset[currentReadBlock] < currentReadBlockOffset + alignedSize )
303  {
304  this->_errors->add(services::ErrorDataArchiveInternal);
305  return;
306  }
307 
308  daal::services::daal_memcpy_s(ptr, size, &(blockPtr[currentReadBlock][currentReadBlockOffset]), size);
309 
310  currentReadBlockOffset += alignedSize;
311  if( blockOffset[currentReadBlock] == currentReadBlockOffset )
312  {
313  currentReadBlock++;
314  currentReadBlockOffset = 0;
315  }
316  }
317 
318  size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
319  {
320  int i;
321  size_t size = 0;
322  for(i = 0; i <= currentWriteBlock; i++)
323  {
324  size += blockOffset[i];
325  }
326  return size;
327  }
328 
329  services::SharedPtr<byte> getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
330  {
331  size_t length = getSizeOfArchive();
332 
333  if( length == 0 ) { return services::SharedPtr<byte>(); }
334 
335  services::SharedPtr<byte> serializedBufferPtr((byte *)daal::services::daal_malloc( length ), services::ServiceDeleter());
336  if( !serializedBufferPtr ) { return services::SharedPtr<byte>(); }
337 
338  copyArchiveToArray(serializedBufferPtr.get(), length);
339 
340  return serializedBufferPtr;
341  }
342 
343  byte *getArchiveAsArray() DAAL_C11_OVERRIDE
344  {
345  if( serializedBuffer ) { return serializedBuffer; }
346 
347  size_t length = getSizeOfArchive();
348 
349  if( length == 0 ) { return 0; }
350 
351  serializedBuffer = (byte *)daal::services::daal_malloc( length );
352  if( serializedBuffer == 0 ) { return 0; }
353 
354  copyArchiveToArray(serializedBuffer, length);
355 
356  return serializedBuffer;
357  }
358 
359  std::string getArchiveAsString() DAAL_C11_OVERRIDE
360  {
361  size_t length = getSizeOfArchive();
362  char *buffer = (char *)getArchiveAsArray();
363 
364  return std::string( buffer, length );
365  }
366 
367  size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const DAAL_C11_OVERRIDE
368  {
369  size_t length = getSizeOfArchive();
370 
371  if( length == 0 || length > maxLength ) { return length; }
372 
373  int i;
374  size_t offset = 0;
375  for(i = 0; i <= currentWriteBlock; i++)
376  {
377  size_t blockSize = blockOffset[i];
378 
379  daal::services::daal_memcpy_s(&(ptr[offset]), blockSize, blockPtr[i], blockSize);
380 
381  offset += blockSize;
382  }
383 
384  return length;
385  }
386 
391  services::SharedPtr<services::ErrorCollection> getErrors()
392  {
393  return _errors;
394  }
395 
396 protected:
397 
398  void addBlock( size_t minNewSize )
399  {
400  if( currentWriteBlock + 1 == arraysSize )
401  {
402  byte **oldBlockPtr = blockPtr ;
403  size_t *oldBlockAllocatedSize = blockAllocatedSize;
404  size_t *oldBlockOffset = blockOffset ;
405 
406  blockPtr = (byte **)daal::services::daal_malloc(sizeof(byte *) * (arraysSize + minBlocksNum));
407  blockAllocatedSize = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (arraysSize + minBlocksNum));
408  blockOffset = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (arraysSize + minBlocksNum));
409 
410  if( blockPtr == 0 || blockAllocatedSize == 0 || blockOffset == 0 ) { return; }
411 
412  daal::services::daal_memcpy_s(blockPtr, arraysSize * sizeof(byte *), oldBlockPtr, arraysSize * sizeof(byte *));
413  daal::services::daal_memcpy_s(blockAllocatedSize, arraysSize * sizeof(size_t), oldBlockAllocatedSize, arraysSize * sizeof(size_t));
414  daal::services::daal_memcpy_s(blockOffset, arraysSize * sizeof(size_t), oldBlockOffset, arraysSize * sizeof(size_t));
415 
416  daal::services::daal_free(oldBlockPtr );
417  daal::services::daal_free(oldBlockAllocatedSize);
418  daal::services::daal_free(oldBlockOffset );
419 
420  arraysSize += minBlocksNum;
421  }
422 
423  currentWriteBlock++;
424 
425  size_t allocationSize = (minBlockSize > minNewSize) ? minBlockSize : minNewSize;
426 
427  blockPtr [currentWriteBlock] = (byte *)daal::services::daal_malloc(allocationSize);
428  blockAllocatedSize[currentWriteBlock] = allocationSize;
429  blockOffset [currentWriteBlock] = 0;
430  }
431 
432  inline size_t alignValueUp(size_t value)
433  {
434  if (_majorVersion == 2016 && _minorVersion == 0 && _updateVersion == 0)
435  {
436  return value;
437  }
438 
439  size_t alignm1 = DAAL_MALLOC_DEFAULT_ALIGNMENT - 1;
440 
441  size_t alignedValue = value + alignm1;
442  alignedValue &= ~alignm1;
443  return alignedValue;
444  }
445 
446  services::SharedPtr<services::ErrorCollection> _errors;
447 
448 private:
449  int minBlocksNum;
450  size_t minBlockSize;
451 
452  byte **blockPtr;
453  size_t *blockAllocatedSize;
454  size_t *blockOffset;
455 
456  int arraysSize;
457 
458  int currentWriteBlock;
459 
460  int currentReadBlock;
461  size_t currentReadBlockOffset;
462 
463  byte *serializedBuffer;
464 };
465 
471 class CompressedDataArchive : public DataArchiveImpl
472 {
473 public:
474 
479  CompressedDataArchive(daal::data_management::CompressorImpl *compressor) : minBlockSize(1024 * 64),
480  _errors(new services::ErrorCollection())
481  {
482  compressionStream = new daal::data_management::CompressionStream(compressor, minBlockSize);
483  serializedBuffer = 0;
484  }
485 
487  ~CompressedDataArchive()
488  {
489  if( serializedBuffer )
490  {
491  daal::services::daal_free( serializedBuffer );
492  }
493  delete compressionStream;
494  }
495 
496  void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
497  {
498  DataBlock wBlock;
499  wBlock.setPtr(ptr);
500  wBlock.setSize(size);
501  compressionStream->push_back(&wBlock);
502  }
503 
504  void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE {}
505 
506  size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
507  {
508  return compressionStream->getCompressedDataSize();
509  }
510 
511  byte *getArchiveAsArray() DAAL_C11_OVERRIDE
512  {
513  if( serializedBuffer ) { return serializedBuffer; }
514 
515  size_t length = getSizeOfArchive();
516 
517  if( length == 0 ) { return 0; }
518 
519  serializedBuffer = (byte *)daal::services::daal_malloc( length );
520  if( serializedBuffer == 0 ) { return 0; }
521 
522  compressionStream->copyCompressedArray(serializedBuffer, length);
523  return serializedBuffer;
524  }
525 
526  services::SharedPtr<byte> getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
527  {
528  size_t length = getSizeOfArchive();
529 
530  if( length == 0 ) { return services::SharedPtr<byte>(); }
531 
532  services::SharedPtr<byte> serializedBufferPtr((byte *)daal::services::daal_malloc( length ), services::ServiceDeleter());
533  if( !serializedBufferPtr ) { return services::SharedPtr<byte>(); }
534 
535  copyArchiveToArray(serializedBufferPtr.get(), length);
536 
537  return serializedBufferPtr;
538  }
539 
540  std::string getArchiveAsString() DAAL_C11_OVERRIDE
541  {
542  size_t length = getSizeOfArchive();
543  char *buffer = (char *)getArchiveAsArray();
544 
545  return std::string( buffer, length );
546  }
547 
548  size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const DAAL_C11_OVERRIDE
549  {
550  size_t length = getSizeOfArchive();
551 
552  if( length == 0 || length > maxLength ) { return length; }
553 
554  compressionStream->copyCompressedArray(ptr, length);
555  return length;
556  }
557 
562  services::SharedPtr<services::ErrorCollection> getErrors()
563  {
564  return _errors;
565  }
566 
567 private:
568  size_t minBlockSize;
569  byte *serializedBuffer;
570  daal::data_management::CompressionStream *compressionStream;
571  services::SharedPtr<services::ErrorCollection> _errors;
572 };
573 
579 class DecompressedDataArchive : public DataArchiveImpl
580 {
581 public:
582 
587  DecompressedDataArchive(daal::data_management::DecompressorImpl *decompressor) : minBlockSize(1024 * 64),
588  _errors(new services::ErrorCollection())
589  {
590  decompressionStream = new daal::data_management::DecompressionStream(decompressor, minBlockSize);
591  serializedBuffer = 0;
592  }
593 
595  ~DecompressedDataArchive()
596  {
597  if( serializedBuffer )
598  {
599  daal::services::daal_free( serializedBuffer );
600  }
601  delete decompressionStream;
602  }
603 
604  void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
605  {
606  DataBlock wBlock;
607  wBlock.setPtr(ptr);
608  wBlock.setSize(size);
609  decompressionStream->push_back(&wBlock);
610  }
611 
612  void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
613  {
614  decompressionStream->copyDecompressedArray(ptr, size);
615  }
616 
617  size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
618  {
619  return decompressionStream->getDecompressedDataSize();
620  }
621 
622  byte *getArchiveAsArray() DAAL_C11_OVERRIDE
623  {
624  if( serializedBuffer ) { return serializedBuffer; }
625 
626  size_t length = getSizeOfArchive();
627 
628  if( length == 0 ) { return 0; }
629 
630  serializedBuffer = (byte *)daal::services::daal_malloc( length );
631  if( serializedBuffer == 0 ) { return 0; }
632 
633  decompressionStream->copyDecompressedArray(serializedBuffer, length);
634  return serializedBuffer;
635  }
636 
637  services::SharedPtr<byte> getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
638  {
639  size_t length = getSizeOfArchive();
640 
641  if( length == 0 ) { return services::SharedPtr<byte>(); }
642 
643  services::SharedPtr<byte> serializedBufferPtr((byte *)daal::services::daal_malloc( length ), services::ServiceDeleter());
644  if( !serializedBufferPtr ) { return services::SharedPtr<byte>(); }
645 
646  copyArchiveToArray(serializedBufferPtr.get(), length);
647 
648  return serializedBufferPtr;
649  }
650 
651  std::string getArchiveAsString() DAAL_C11_OVERRIDE
652  {
653  size_t length = getSizeOfArchive();
654  char *buffer = (char *)getArchiveAsArray();
655 
656  return std::string( buffer, length );
657  }
658 
659  size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const DAAL_C11_OVERRIDE
660  {
661  size_t length = getSizeOfArchive();
662 
663  if( length == 0 || length > maxLength ) { return length; }
664 
665  decompressionStream->copyDecompressedArray(ptr, length);
666  return length;
667  }
668 
673  services::SharedPtr<services::ErrorCollection> getErrors()
674  {
675  return _errors;
676  }
677 
678 private:
679  size_t minBlockSize;
680  byte *serializedBuffer;
681  daal::data_management::DecompressionStream *decompressionStream;
682  services::SharedPtr<services::ErrorCollection> _errors;
683 };
684 
689 class InputDataArchive : public Base
690 {
691 public:
695  InputDataArchive() : _finalized(false), _errors(new services::ErrorCollection())
696  {
697  _arch = new DataArchive;
698  archiveHeader();
699  }
700 
706  InputDataArchive(DataArchiveIface * arch) : _finalized(false), _errors(new services::ErrorCollection())
707  {
708  _arch = arch;
709  archiveHeader();
710  }
711 
715  InputDataArchive(daal::data_management::CompressorImpl *compressor) : _finalized(false),
716  _errors(new services::ErrorCollection())
717  {
718  _arch = new CompressedDataArchive(compressor);
719  archiveHeader();
720  }
721 
722  ~InputDataArchive()
723  {
724  delete _arch;
725  }
726 
730  void archiveHeader()
731  {
732  int headerValues[8] =
733  {
734  0x4441414C,
735  __INTEL_DAAL__,
736  __INTEL_DAAL_MINOR__,
737  __INTEL_DAAL_UPDATE__,
738  0, 0, 0, 0
739  };
740 
741  _arch->setMajorVersion (headerValues[1]);
742  _arch->setMinorVersion (headerValues[2]);
743  _arch->setUpdateVersion(headerValues[3]);
744  for(size_t i = 0; i < 8; i++)
745  {
746  _arch->write( (byte *)&headerValues[i], sizeof(int) );
747  }
748  }
749 
753  void archiveFooter()
754  {
755  _finalized = true;
756  }
757 
761  void segmentHeader( int tag = 0 )
762  {
763  _arch->write( (byte *)&tag, sizeof(int) );
764  }
765 
769  void segmentFooter()
770  {
771  }
772 
778  template<typename T>
779  void set(T &val)
780  {
781  _arch->write( (byte *)&val, sizeof(T) );
782  }
783 
789  template<typename T>
790  void set(daal::services::Collection<T> &val)
791  {
792  size_t size = val.size();
793  _arch->write( (byte *)&size, sizeof(size_t) );
794  for(size_t i = 0; i < size; i++)
795  {
796  _arch->write( (byte *) & (val[i]), sizeof(T) );
797  }
798  }
799 
806  template<typename T>
807  void set(T *ptr, size_t size)
808  {
809  _arch->write( (byte *)ptr, size * sizeof(T) );
810  }
811 
818  template<typename T>
819  void setObj(T *ptr, size_t size = 1)
820  {
821  for( size_t i = 0; i < size; i++ )
822  {
823  ptr[i].serializeImpl( this );
824  }
825  }
826 
831  void setSingleObj(SerializationIface **ptr)
832  {
833  int isNull = (*ptr == 0);
834  set(isNull);
835 
836  if(!isNull)
837  {
838  (*ptr)->serialize( *this );
839  }
840  }
841 
846  template<typename T>
847  void setSharedPtrObj(services::SharedPtr<T> &obj)
848  {
849  data_management::SerializationIface *ptr = obj.get();
850  setSingleObj(&ptr);
851  }
852 
857  services::SharedPtr<byte> getArchiveAsArraySharedPtr()
858  {
859  if(!_finalized) { archiveFooter(); }
860  return _arch->getArchiveAsArraySharedPtr();
861  }
862 
868  DAAL_DEPRECATED byte *getArchiveAsArray()
869  {
870  if(!_finalized) { archiveFooter(); }
871  return _arch->getArchiveAsArray();
872  }
873 
880  DAAL_DEPRECATED void getArchiveAsArray( const byte **ptr, size_t *size )
881  {
882  if(!_finalized) { archiveFooter(); }
883 
884  *ptr = (byte *)_arch->getArchiveAsArray();
885  *size = _arch->getSizeOfArchive();
886  }
887 
892  size_t getSizeOfArchive()
893  {
894  if(!_finalized) { archiveFooter(); }
895 
896  return _arch->getSizeOfArchive();
897  }
898 
904  DAAL_DEPRECATED std::string getArchiveAsString()
905  {
906  if(!_finalized) { archiveFooter(); }
907 
908  return _arch->getArchiveAsString();
909  }
910 
917  size_t copyArchiveToArray( byte *ptr, size_t maxLength )
918  {
919  if(!_finalized) { archiveFooter(); }
920 
921  return _arch->copyArchiveToArray( ptr, maxLength );
922  }
923 
928  const DataArchive &getDataArchive()
929  {
930  return *static_cast<DataArchive *>(_arch);
931  }
932 
937  services::SharedPtr<services::ErrorCollection> getErrors()
938  {
939  return _errors;
940  }
941 
942 protected:
943  DataArchiveIface *_arch;
944  bool _finalized;
945  services::SharedPtr<services::ErrorCollection> _errors;
946 };
947 
952 class OutputDataArchive : public Base
953 {
954 public:
958  OutputDataArchive( InputDataArchive &arch ) : _errors(new services::ErrorCollection())
959  {
960  _arch = new DataArchive(arch.getDataArchive());
961  archiveHeader();
962  }
963 
969  OutputDataArchive( DataArchiveIface * arch ) : _errors(new services::ErrorCollection())
970  {
971  _arch = arch;
972  archiveHeader();
973  }
974 
978  OutputDataArchive( byte *ptr, size_t size ) : _errors(new services::ErrorCollection())
979  {
980  _arch = new DataArchive(ptr, size);
981  archiveHeader();
982  }
983 
987  OutputDataArchive( daal::data_management::DecompressorImpl *decompressor, byte *ptr, size_t size ) :
988  _errors(new services::ErrorCollection())
989  {
990  _arch = new DecompressedDataArchive(decompressor);
991  _arch->write(ptr, size);
992  archiveHeader();
993  }
994 
995  ~OutputDataArchive()
996  {
997  delete _arch;
998  }
999 
1003  void archiveHeader() const
1004  {
1005  int headerValues[8];
1006 
1007  for(size_t i = 0; i < 8; i++)
1008  {
1009  _arch->read( (byte *)&headerValues[i], sizeof(int) );
1010  }
1011 
1012  _arch->setMajorVersion (headerValues[1]);
1013  _arch->setMinorVersion (headerValues[2]);
1014  _arch->setUpdateVersion(headerValues[3]);
1015  }
1016 
1020  void archiveFooter() const
1021  {
1022  }
1023 
1027  int segmentHeader() const
1028  {
1029  int tag = 0;
1030  _arch->read( (byte *)&tag, sizeof(int) );
1031  return tag;
1032  }
1033 
1037  void segmentFooter() const {}
1038 
1044  template<typename T>
1045  void set(T &val) const
1046  {
1047  _arch->read( (byte *)&val, sizeof(T) );
1048  }
1049 
1055  template<typename T>
1056  void set(daal::services::Collection<T> &val) const
1057  {
1058  size_t size = 0;
1059  _arch->read( (byte *)&size, sizeof(size_t) );
1060  val.clear();
1061  for(size_t i = 0; i < size; i++)
1062  {
1063  T v;
1064  _arch->read( (byte *)&v, sizeof(T) );
1065  val.push_back(v);
1066  }
1067  }
1068 
1075  template<typename T>
1076  void set(T *ptr, size_t size) const
1077  {
1078  _arch->read( (byte *)ptr, size * sizeof(T) );
1079  }
1080 
1087  template<typename T>
1088  void setObj(T *ptr, size_t size = 1) const
1089  {
1090  for( size_t i = 0; i < size; i++ )
1091  {
1092  ptr[i].deserializeImpl( this );
1093  }
1094  }
1095 
1100  void setSingleObj(SerializationIface **ptr) const
1101  {
1102  int isNull = 0;
1103  set(isNull);
1104 
1105  if(isNull)
1106  {
1107  *ptr = 0;
1108  return;
1109  }
1110 
1111  const int serTag = segmentHeader();
1112 
1113  *ptr = Factory::instance().createObject(serTag);
1114  if(!*ptr)
1115  {
1116  this->_errors->add(services::Error::create(
1117  services::ErrorObjectDoesNotSupportSerialization, services::SerializationTag, serTag));
1118  return;
1119  }
1120 
1121  (*ptr)->deserializeImpl( this );
1122 
1123  segmentFooter();
1124  }
1125 
1130  template<typename T>
1131  void setSharedPtrObj(services::SharedPtr<T> &obj) const
1132  {
1133  data_management::SerializationIface *ptr;
1134  setSingleObj(&ptr);
1135  if(this->_errors->size() != 0) { return; }
1136  if(ptr)
1137  {
1138  obj = services::SharedPtr<T>(static_cast<T *>(ptr));
1139  }
1140  else
1141  {
1142  obj = services::SharedPtr<T>();
1143  }
1144  }
1145 
1150  services::SharedPtr<SerializationIface> getAsSharedPtr() const
1151  {
1152  const int serTag = segmentHeader();
1153  services::SharedPtr<SerializationIface> ptr(Factory::instance().createObject(serTag));
1154  if(!ptr)
1155  {
1156  this->_errors->add(services::Error::create(
1157  services::ErrorObjectDoesNotSupportSerialization, services::SerializationTag, serTag));
1158  return services::SharedPtr<SerializationIface>();
1159  }
1160  ptr->deserializeImpl( this );
1161  segmentFooter();
1162  return ptr;
1163  }
1164 
1169  int getMajorVersion() const
1170  {
1171  return _arch->getMajorVersion();
1172  }
1173 
1178  int getMinorVersion() const
1179  {
1180  return _arch->getMinorVersion();
1181  }
1182 
1187  int getUpdateVersion() const
1188  {
1189  return _arch->getUpdateVersion();
1190  }
1191 
1196  services::SharedPtr<services::ErrorCollection> getErrors()
1197  {
1198  return _errors;
1199  }
1200 
1201 protected:
1202  DataArchiveIface *_arch;
1203  services::SharedPtr<services::ErrorCollection> _errors;
1204 };
1207 } // namespace interface1
1208 using interface1::DataArchiveIface;
1209 using interface1::DataArchive;
1210 using interface1::CompressedDataArchive;
1211 using interface1::DecompressedDataArchive;
1212 using interface1::InputDataArchive;
1213 using interface1::OutputDataArchive;
1214 
1215 }
1216 }
1217 
1218 #endif
daal::data_management::interface1::DataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:318
daal::data_management::interface1::InputDataArchive::getArchiveAsString
DAAL_DEPRECATED std::string getArchiveAsString()
Definition: data_archive.h:904
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive(daal::data_management::CompressorImpl *compressor)
Definition: data_archive.h:715
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive()
Definition: data_archive.h:695
daal::data_management::interface1::InputDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:937
daal::data_management::interface1::InputDataArchive::archiveFooter
void archiveFooter()
Definition: data_archive.h:753
daal::data_management::interface1::OutputDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:1196
daal::data_management::interface1::InputDataArchive::set
void set(daal::services::Collection< T > &val)
Definition: data_archive.h:790
daal::data_management::interface1::InputDataArchive::setSharedPtrObj
void setSharedPtrObj(services::SharedPtr< T > &obj)
Definition: data_archive.h:847
daal::data_management::interface1::CompressedDataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
Definition: data_archive.h:526
daal::data_management::interface1::DataArchiveIface::setUpdateVersion
virtual void setUpdateVersion(int updateVersion)=0
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::InputDataArchive::getArchiveAsArray
DAAL_DEPRECATED byte * getArchiveAsArray()
Definition: data_archive.h:868
daal::data_management::interface1::InputDataArchive::setSingleObj
void setSingleObj(SerializationIface **ptr)
Definition: data_archive.h:831
daal::data_management::interface1::OutputDataArchive::set
void set(daal::services::Collection< T > &val) const
Definition: data_archive.h:1056
daal::data_management::interface1::DataArchiveIface::getArchiveAsString
virtual DAAL_DEPRECATED_VIRTUAL std::string getArchiveAsString()=0
daal::data_management::interface1::DataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
Definition: data_archive.h:329
daal::data_management::interface1::OutputDataArchive::set
void set(T *ptr, size_t size) const
Definition: data_archive.h:1076
daal::services::ErrorObjectDoesNotSupportSerialization
Definition: error_indexes.h:397
daal::data_management::interface1::OutputDataArchive::getAsSharedPtr
services::SharedPtr< SerializationIface > getAsSharedPtr() const
Definition: data_archive.h:1150
daal::data_management::interface1::CompressedDataArchive::write
void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:496
daal::data_management::interface1::OutputDataArchive::getUpdateVersion
int getUpdateVersion() const
Definition: data_archive.h:1187
daal::data_management::interface1::CompressedDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:562
daal::data_management::interface1::DecompressedDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:673
daal::data_management::interface1::DataArchiveImpl::getMinorVersion
int getMinorVersion() DAAL_C11_OVERRIDE
Definition: data_archive.h:174
daal::data_management::interface1::DataBlock::setSize
virtual void setSize(size_t size) DAAL_C11_OVERRIDE
Definition: data_block.h:148
daal::data_management::interface1::OutputDataArchive::setSharedPtrObj
void setSharedPtrObj(services::SharedPtr< T > &obj) const
Definition: data_archive.h:1131
daal::data_management::interface1::OutputDataArchive::segmentHeader
int segmentHeader() const
Definition: data_archive.h:1027
daal::data_management::interface1::DataArchive::DataArchive
DataArchive()
Definition: data_archive.h:200
daal::data_management::interface1::CompressedDataArchive::CompressedDataArchive
CompressedDataArchive(daal::data_management::CompressorImpl *compressor)
Definition: data_archive.h:479
daal::data_management::interface1::OutputDataArchive::archiveFooter
void archiveFooter() const
Definition: data_archive.h:1020
daal::data_management::interface1::DataArchive::getArchiveAsString
std::string getArchiveAsString() DAAL_C11_OVERRIDE
Definition: data_archive.h:359
daal::data_management::interface1::DataArchiveIface::read
virtual void read(byte *ptr, size_t size)=0
daal::data_management::interface1::DataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:391
daal::data_management::interface1::DecompressedDataArchive::getArchiveAsArray
byte * getArchiveAsArray() DAAL_C11_OVERRIDE
Definition: data_archive.h:622
daal::data_management::interface1::InputDataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr()
Definition: data_archive.h:857
daal::services::SerializationTag
Definition: error_indexes.h:57
daal::data_management::interface1::DataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength) const DAAL_C11_OVERRIDE
Definition: data_archive.h:367
daal::data_management::interface1::OutputDataArchive::setObj
void setObj(T *ptr, size_t size=1) const
Definition: data_archive.h:1088
daal::data_management::interface1::DataArchiveIface::getSizeOfArchive
virtual size_t getSizeOfArchive() const =0
daal::data_management::interface1::DataArchiveIface::getArchiveAsArray
virtual DAAL_DEPRECATED_VIRTUAL byte * getArchiveAsArray()
Definition: data_archive.h:88
daal::data_management::interface1::DataArchiveIface::getMinorVersion
virtual int getMinorVersion()=0
daal::data_management::interface1::DataArchiveImpl::setMinorVersion
void setMinorVersion(int minorVersion) DAAL_C11_OVERRIDE
Definition: data_archive.h:159
daal::data_management::interface1::DataArchive::DataArchive
DataArchive(byte *ptr, size_t size)
Definition: data_archive.h:244
daal::data_management::interface1::DataArchiveImpl::getMajorVersion
int getMajorVersion() DAAL_C11_OVERRIDE
Definition: data_archive.h:169
daal::services::daal_memcpy_s
DAAL_EXPORT void daal_memcpy_s(void *dest, size_t numberOfElements, const void *src, size_t count)
daal::data_management::interface1::InputDataArchive::set
void set(T *ptr, size_t size)
Definition: data_archive.h:807
daal::data_management::interface1::DataArchiveIface
Abstract interface class that defines methods to access and modify a serialized object. This class declares the most generic access and modification methods.
Definition: data_archive.h:52
daal::data_management::interface1::InputDataArchive::archiveHeader
void archiveHeader()
Definition: data_archive.h:730
daal::data_management::interface1::OutputDataArchive::segmentFooter
void segmentFooter() const
Definition: data_archive.h:1037
daal::data_management::interface1::InputDataArchive::getDataArchive
const DataArchive & getDataArchive()
Definition: data_archive.h:928
daal::data_management::interface1::DataArchive
Implements the abstract DataArchiveIface interface.
Definition: data_archive.h:194
daal::data_management::interface1::InputDataArchive::set
void set(T &val)
Definition: data_archive.h:779
daal::data_management::interface1::DataBlock::setPtr
virtual void setPtr(byte *ptr) DAAL_C11_OVERRIDE
Definition: data_block.h:138
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
daal::data_management::interface1::InputDataArchive::getSizeOfArchive
size_t getSizeOfArchive()
Definition: data_archive.h:892
daal::data_management::interface1::DataArchiveIface::setMajorVersion
virtual void setMajorVersion(int majorVersion)=0
daal::data_management::interface1::CompressedDataArchive::read
void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:504
daal::data_management::interface1::DataArchive::write
void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:280
daal::data_management::interface1::OutputDataArchive::getMinorVersion
int getMinorVersion() const
Definition: data_archive.h:1178
daal::data_management::interface1::CompressedDataArchive
Abstract interface class that defines methods to access and modify a serialized object. This class declares the most generic access and modification methods.
Definition: data_archive.h:471
daal::data_management::interface1::OutputDataArchive::set
void set(T &val) const
Definition: data_archive.h:1045
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::Factory::instance
static Factory & instance()
daal::data_management::interface1::DecompressedDataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength) const DAAL_C11_OVERRIDE
Definition: data_archive.h:659
daal::data_management::interface1::DecompressedDataArchive::read
void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:612
daal::data_management::interface1::CompressedDataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength) const DAAL_C11_OVERRIDE
Definition: data_archive.h:548
daal::data_management::interface1::DataArchive::DataArchive
DataArchive(const DataArchive &arch)
Definition: data_archive.h:219
daal::data_management::interface1::OutputDataArchive::setSingleObj
void setSingleObj(SerializationIface **ptr) const
Definition: data_archive.h:1100
daal::data_management::interface1::OutputDataArchive::getMajorVersion
int getMajorVersion() const
Definition: data_archive.h:1169
daal::data_management::interface1::DataArchiveImpl
Abstract interface class that defines methods to access and modify a serialized object. This class implements the most general serialization methods.
Definition: data_archive.h:147
daal::data_management::interface1::DecompressedDataArchive::write
void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:604
daal::services::daal_free
DAAL_EXPORT void daal_free(void *ptr)
daal::data_management::interface1::CompressedDataArchive::getArchiveAsString
std::string getArchiveAsString() DAAL_C11_OVERRIDE
Definition: data_archive.h:540
daal::data_management::interface1::DecompressedDataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:617
daal::data_management::interface1::DecompressedDataArchive::DecompressedDataArchive
DecompressedDataArchive(daal::data_management::DecompressorImpl *decompressor)
Definition: data_archive.h:587
daal::data_management::interface1::DataArchiveIface::setMinorVersion
virtual void setMinorVersion(int minorVersion)=0
daal::data_management::interface1::DecompressedDataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
Definition: data_archive.h:637
daal::data_management::interface1::Factory::createObject
SerializationIface * createObject(int objectId)
daal::services::ErrorDataArchiveInternal
Definition: error_indexes.h:101
daal::data_management::interface1::DataArchiveIface::write
virtual void write(byte *ptr, size_t size)=0
daal::data_management::interface1::DataArchiveIface::getArchiveAsArraySharedPtr
virtual services::SharedPtr< byte > getArchiveAsArraySharedPtr() const =0
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(daal::data_management::DecompressorImpl *decompressor, byte *ptr, size_t size)
Definition: data_archive.h:987
daal::data_management::interface1::InputDataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength)
Definition: data_archive.h:917
daal::data_management::interface1::DataArchiveIface::getUpdateVersion
virtual int getUpdateVersion()=0
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(byte *ptr, size_t size)
Definition: data_archive.h:978
daal::data_management::interface1::CompressedDataArchive::getArchiveAsArray
byte * getArchiveAsArray() DAAL_C11_OVERRIDE
Definition: data_archive.h:511
daal::data_management::interface1::DecompressedDataArchive::getArchiveAsString
std::string getArchiveAsString() DAAL_C11_OVERRIDE
Definition: data_archive.h:651
daal::algorithms::math::abs::value
Definition: abs_types.h:86
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(DataArchiveIface *arch)
Definition: data_archive.h:969
daal::data_management::interface1::InputDataArchive::segmentHeader
void segmentHeader(int tag=0)
Definition: data_archive.h:761
daal::data_management::interface1::DataArchiveIface::getMajorVersion
virtual int getMajorVersion()=0
daal::algorithms::implicit_als::training::offset
Definition: implicit_als_training_types.h:148
daal::Base
Base class for Intel(R) Data Analytics Acceleration Library objects
Definition: base.h:39
daal::data_management::interface1::DataArchive::getArchiveAsArray
byte * getArchiveAsArray() DAAL_C11_OVERRIDE
Definition: data_archive.h:343
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(InputDataArchive &arch)
Definition: data_archive.h:958
daal::data_management::interface1::DecompressedDataArchive
Abstract interface class that defines methods to access and modify a serialized object. This class declares the most generic access and modification methods.
Definition: data_archive.h:579
daal::data_management::interface1::CompressedDataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:506
daal::data_management::interface1::SerializationIface
Abstract interface class that defines the interface for serialization and deserialization.
Definition: data_serialize.h:50
daal::data_management::interface1::DataArchiveImpl::setUpdateVersion
void setUpdateVersion(int updateVersion) DAAL_C11_OVERRIDE
Definition: data_archive.h:164
daal::data_management::interface1::InputDataArchive::segmentFooter
void segmentFooter()
Definition: data_archive.h:769
daal::data_management::interface1::DataArchive::read
void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:299
daal::data_management::interface1::DataArchiveImpl::getUpdateVersion
int getUpdateVersion() DAAL_C11_OVERRIDE
Definition: data_archive.h:179
daal::data_management::interface1::DataArchiveIface::copyArchiveToArray
virtual size_t copyArchiveToArray(byte *ptr, size_t maxLength) const =0
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive(DataArchiveIface *arch)
Definition: data_archive.h:706
daal::data_management::interface1::OutputDataArchive::archiveHeader
void archiveHeader() const
Definition: data_archive.h:1003
daal::data_management::interface1::InputDataArchive::getArchiveAsArray
DAAL_DEPRECATED void getArchiveAsArray(const byte **ptr, size_t *size)
Definition: data_archive.h:880
daal::data_management::interface1::DataBlock
Class that stores a pointer to a byte array and its size. Not responsible for memory management...
Definition: data_block.h:83
daal::data_management::interface1::InputDataArchive::setObj
void setObj(T *ptr, size_t size=1)
Definition: data_archive.h:819
daal::data_management::interface1::DataArchiveImpl::setMajorVersion
void setMajorVersion(int majorVersion) DAAL_C11_OVERRIDE
Definition: data_archive.h:154

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