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

data_archive.h
1 /* file: data_archive.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 /*
19 //++
20 // Declaration and implementation of classes that support serialization and deserialization methods
21 //--
22 */
23 
24 #ifndef __DATA_ARCHIVE_H__
25 #define __DATA_ARCHIVE_H__
26 
27 #include "services/base.h"
28 #include "services/library_version_info.h"
29 #include "services/daal_memory.h"
30 #include "services/collection.h"
31 
32 #include "data_management/data/data_block.h"
33 #include "data_management/data/factory.h"
34 #include "data_management/data/data_serialize.h"
35 #include "data_management/data/data_collection.h"
36 #include "data_management/features/defines.h"
37 #include "data_management/compression/compression_stream.h"
38 
39 namespace daal
40 {
41 namespace data_management
42 {
43 
44 namespace interface1
45 {
55 class DataArchiveIface : public Base
56 {
57 public:
58  virtual ~DataArchiveIface() {}
59 
65  virtual void write(byte *ptr, size_t size) = 0;
66 
72  virtual void read(byte *ptr, size_t size) = 0;
73 
78  virtual size_t getSizeOfArchive() const = 0;
79 
84  virtual services::SharedPtr<byte> getArchiveAsArraySharedPtr() const = 0;
85 
91  DAAL_DEPRECATED_VIRTUAL virtual byte *getArchiveAsArray() { return NULL; }
92 
98  DAAL_DEPRECATED_VIRTUAL virtual std::string getArchiveAsString() = 0;
99 
106  virtual size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const = 0;
107 
112  virtual void setMajorVersion(int majorVersion) = 0;
113 
118  virtual void setMinorVersion(int minorVersion) = 0;
119 
124  virtual void setUpdateVersion(int updateVersion) = 0;
125 
130  virtual int getMajorVersion() = 0;
131 
136  virtual int getMinorVersion() = 0;
137 
142  virtual int getUpdateVersion() = 0;
143 };
144 
150 class DataArchiveImpl : public DataArchiveIface
151 {
152 public:
153  DataArchiveImpl() : _majorVersion(0), _minorVersion(0), _updateVersion(0) {}
154 
155  virtual ~DataArchiveImpl() {}
156 
157  void setMajorVersion(int majorVersion) DAAL_C11_OVERRIDE
158  {
159  _majorVersion = majorVersion;
160  }
161 
162  void setMinorVersion(int minorVersion) DAAL_C11_OVERRIDE
163  {
164  _minorVersion = minorVersion;
165  }
166 
167  void setUpdateVersion(int updateVersion) DAAL_C11_OVERRIDE
168  {
169  _updateVersion = updateVersion;
170  }
171 
172  int getMajorVersion() DAAL_C11_OVERRIDE
173  {
174  return _majorVersion;
175  }
176 
177  int getMinorVersion() DAAL_C11_OVERRIDE
178  {
179  return _minorVersion;
180  }
181 
182  int getUpdateVersion() DAAL_C11_OVERRIDE
183  {
184  return _updateVersion;
185  }
186 
187 protected:
188  int _majorVersion;
189  int _minorVersion;
190  int _updateVersion;
191 };
192 
197 class DataArchive: public DataArchiveImpl
198 {
199 public:
203  DataArchive() : minBlockSize(1024 * 16), minBlocksNum(16), _errors(new services::ErrorCollection())
204  {
205  blockPtr = 0;
206  blockAllocatedSize = 0;
207  blockOffset = 0;
208  arraysSize = 0;
209  currentWriteBlock = -1;
210 
211  currentReadBlock = 0;
212  currentReadBlockOffset = 0;
213 
214  serializedBuffer = 0;
215 
216  addBlock( minBlockSize );
217  }
218 
222  DataArchive( const DataArchive &arch ) : minBlockSize(1024 * 16), minBlocksNum(16)
223  {
224  blockPtr = 0;
225  blockAllocatedSize = 0;
226  blockOffset = 0;
227  arraysSize = 0;
228  currentWriteBlock = -1;
229 
230  currentReadBlock = 0;
231  currentReadBlockOffset = 0;
232 
233  serializedBuffer = 0;
234 
235  size_t size = arch.getSizeOfArchive();
236  addBlock( size );
237  arch.copyArchiveToArray( blockPtr[currentWriteBlock], size );
238 
239  blockOffset[currentWriteBlock] += size;
240  }
241 
247  DataArchive( byte *ptr, size_t size ) : minBlockSize(1024 * 16), minBlocksNum(16), _errors(new services::ErrorCollection())
248  {
249  blockPtr = 0;
250  blockAllocatedSize = 0;
251  blockOffset = 0;
252  arraysSize = 0;
253  currentWriteBlock = -1;
254 
255  currentReadBlock = 0;
256  currentReadBlockOffset = 0;
257 
258  serializedBuffer = 0;
259 
260  addBlock( size );
261 
262  int result = daal::services::internal::daal_memcpy_s(blockPtr[currentWriteBlock], size, ptr, size);
263  if (result)
264  {
265  this->_errors->add(services::ErrorMemoryCopyFailedInternal);
266  }
267 
268  blockOffset[currentWriteBlock] += size;
269  }
270 
271  ~DataArchive()
272  {
273  int i;
274  for(i = 0; i <= currentWriteBlock; i++)
275  {
276  daal::services::daal_free( blockPtr[i] );
277  blockPtr[i] = NULL;
278  }
279  daal::services::daal_free( blockPtr );
280  daal::services::daal_free( blockAllocatedSize );
281  daal::services::daal_free( blockOffset );
282  if( serializedBuffer )
283  {
284  daal::services::daal_free( serializedBuffer );
285  }
286 
287  blockPtr = NULL;
288  blockAllocatedSize = NULL;
289  blockOffset = NULL;
290  serializedBuffer = NULL;
291  }
292 
293  void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
294  {
295  size_t alignedSize = alignValueUp(size);
296  if( blockAllocatedSize[currentWriteBlock] < blockOffset[currentWriteBlock] + alignedSize )
297  {
298  addBlock(alignedSize);
299  }
300 
301  size_t offset = blockOffset[currentWriteBlock];
302 
303  int result = daal::services::internal::daal_memcpy_s(&(blockPtr[currentWriteBlock][offset]), alignedSize, ptr, size);
304  if (result)
305  {
306  this->_errors->add(services::ErrorMemoryCopyFailedInternal);
307  return;
308  }
309  for (size_t i = size; i < alignedSize; i++)
310  {
311  blockPtr[currentWriteBlock][offset + i] = 0;
312  }
313 
314  blockOffset[currentWriteBlock] += alignedSize;
315  }
316 
317  void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
318  {
319  size_t alignedSize = alignValueUp(size);
320  if( blockOffset[currentReadBlock] < currentReadBlockOffset + alignedSize )
321  {
322  this->_errors->add(services::ErrorDataArchiveInternal);
323  return;
324  }
325 
326  int result = daal::services::internal::daal_memcpy_s(ptr, size, &(blockPtr[currentReadBlock][currentReadBlockOffset]), size);
327  if (result)
328  {
329  this->_errors->add(services::ErrorMemoryCopyFailedInternal);
330  return;
331  }
332 
333  currentReadBlockOffset += alignedSize;
334  if( blockOffset[currentReadBlock] == currentReadBlockOffset )
335  {
336  currentReadBlock++;
337  currentReadBlockOffset = 0;
338  }
339  }
340 
341  size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
342  {
343  int i;
344  size_t size = 0;
345  for(i = 0; i <= currentWriteBlock; i++)
346  {
347  size += blockOffset[i];
348  }
349  return size;
350  }
351 
352  services::SharedPtr<byte> getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
353  {
354  size_t length = getSizeOfArchive();
355 
356  if( length == 0 ) { return services::SharedPtr<byte>(); }
357 
358  services::SharedPtr<byte> serializedBufferPtr((byte *)daal::services::daal_malloc( length ), services::ServiceDeleter());
359  if( !serializedBufferPtr ) { return services::SharedPtr<byte>(); }
360 
361  copyArchiveToArray(serializedBufferPtr.get(), length);
362 
363  return serializedBufferPtr;
364  }
365 
366  byte *getArchiveAsArray() DAAL_C11_OVERRIDE
367  {
368  if( serializedBuffer ) { return serializedBuffer; }
369 
370  size_t length = getSizeOfArchive();
371 
372  if( length == 0 ) { return 0; }
373 
374  serializedBuffer = (byte *)daal::services::daal_malloc( length );
375  if( serializedBuffer == 0 ) { return 0; }
376 
377  copyArchiveToArray(serializedBuffer, length);
378 
379  return serializedBuffer;
380  }
381 
382  std::string getArchiveAsString() DAAL_C11_OVERRIDE
383  {
384  size_t length = getSizeOfArchive();
385  char *buffer = (char *)getArchiveAsArray();
386 
387  return std::string( buffer, length );
388  }
389 
390  size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const DAAL_C11_OVERRIDE
391  {
392  size_t length = getSizeOfArchive();
393 
394  if( length == 0 || length > maxLength ) { return length; }
395 
396  int i;
397  size_t offset = 0;
398  int result = 0;
399  for(i = 0; i <= currentWriteBlock; i++)
400  {
401  size_t blockSize = blockOffset[i];
402 
403  result |= daal::services::internal::daal_memcpy_s(&(ptr[offset]), blockSize, blockPtr[i], blockSize);
404 
405  offset += blockSize;
406  }
407  if (result)
408  {
409  this->_errors->add(services::ErrorMemoryCopyFailedInternal);
410  return 0;
411  }
412 
413  return length;
414  }
415 
420  services::SharedPtr<services::ErrorCollection> getErrors()
421  {
422  return _errors;
423  }
424 
425 protected:
426 
427  void addBlock( size_t minNewSize )
428  {
429  if( currentWriteBlock + 1 == arraysSize )
430  {
431  byte **oldBlockPtr = blockPtr ;
432  size_t *oldBlockAllocatedSize = blockAllocatedSize;
433  size_t *oldBlockOffset = blockOffset ;
434  int result = 0;
435 
436  blockPtr = (byte **)daal::services::daal_malloc(sizeof(byte *) * (arraysSize + minBlocksNum));
437  blockAllocatedSize = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (arraysSize + minBlocksNum));
438  blockOffset = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (arraysSize + minBlocksNum));
439 
440  if( blockPtr == 0 || blockAllocatedSize == 0 || blockOffset == 0 ) { return; }
441 
442  result |= daal::services::internal::daal_memcpy_s(blockPtr, arraysSize * sizeof(byte *), oldBlockPtr, arraysSize * sizeof(byte *));
443  result |= daal::services::internal::daal_memcpy_s(blockAllocatedSize, arraysSize * sizeof(size_t),
444  oldBlockAllocatedSize, arraysSize * sizeof(size_t));
445  result |= daal::services::internal::daal_memcpy_s(blockOffset, arraysSize * sizeof(size_t), oldBlockOffset, arraysSize * sizeof(size_t));
446  if (result)
447  {
448  this->_errors->add(services::ErrorMemoryCopyFailedInternal);
449  return;
450  }
451 
452  daal::services::daal_free(oldBlockPtr );
453  daal::services::daal_free(oldBlockAllocatedSize);
454  daal::services::daal_free(oldBlockOffset );
455 
456  arraysSize += minBlocksNum;
457  }
458 
459  currentWriteBlock++;
460 
461  size_t allocationSize = (minBlockSize > minNewSize) ? minBlockSize : minNewSize;
462 
463  blockPtr [currentWriteBlock] = (byte *)daal::services::daal_malloc(allocationSize);
464  blockAllocatedSize[currentWriteBlock] = allocationSize;
465  blockOffset [currentWriteBlock] = 0;
466  }
467 
468  inline size_t alignValueUp(size_t value)
469  {
470  if (_majorVersion == 2016 && _minorVersion == 0 && _updateVersion == 0)
471  {
472  return value;
473  }
474 
475  size_t alignm1 = DAAL_MALLOC_DEFAULT_ALIGNMENT - 1;
476 
477  size_t alignedValue = value + alignm1;
478  alignedValue &= ~alignm1;
479  return alignedValue;
480  }
481 
482  services::SharedPtr<services::ErrorCollection> _errors;
483 
484 private:
485  int minBlocksNum;
486  size_t minBlockSize;
487 
488  byte **blockPtr;
489  size_t *blockAllocatedSize;
490  size_t *blockOffset;
491 
492  int arraysSize;
493 
494  int currentWriteBlock;
495 
496  int currentReadBlock;
497  size_t currentReadBlockOffset;
498 
499  byte *serializedBuffer;
500 };
501 
507 class CompressedDataArchive : public DataArchiveImpl
508 {
509 public:
510 
515  CompressedDataArchive(daal::data_management::CompressorImpl *compressor) : minBlockSize(1024 * 64),
516  _errors(new services::ErrorCollection())
517  {
518  compressionStream = new daal::data_management::CompressionStream(compressor, minBlockSize);
519  serializedBuffer = 0;
520  }
521 
523  ~CompressedDataArchive()
524  {
525  if( serializedBuffer )
526  {
527  daal::services::daal_free( serializedBuffer );
528  }
529  delete compressionStream;
530  }
531 
532  void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
533  {
534  DataBlock wBlock;
535  wBlock.setPtr(ptr);
536  wBlock.setSize(size);
537  compressionStream->push_back(&wBlock);
538  }
539 
540  void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE {}
541 
542  size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
543  {
544  return compressionStream->getCompressedDataSize();
545  }
546 
547  byte *getArchiveAsArray() DAAL_C11_OVERRIDE
548  {
549  if( serializedBuffer ) { return serializedBuffer; }
550 
551  size_t length = getSizeOfArchive();
552 
553  if( length == 0 ) { return 0; }
554 
555  serializedBuffer = (byte *)daal::services::daal_malloc( length );
556  if( serializedBuffer == 0 ) { return 0; }
557 
558  compressionStream->copyCompressedArray(serializedBuffer, length);
559  return serializedBuffer;
560  }
561 
562  services::SharedPtr<byte> getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
563  {
564  size_t length = getSizeOfArchive();
565 
566  if( length == 0 ) { return services::SharedPtr<byte>(); }
567 
568  services::SharedPtr<byte> serializedBufferPtr((byte *)daal::services::daal_malloc( length ), services::ServiceDeleter());
569  if( !serializedBufferPtr ) { return services::SharedPtr<byte>(); }
570 
571  copyArchiveToArray(serializedBufferPtr.get(), length);
572 
573  return serializedBufferPtr;
574  }
575 
576  std::string getArchiveAsString() DAAL_C11_OVERRIDE
577  {
578  size_t length = getSizeOfArchive();
579  char *buffer = (char *)getArchiveAsArray();
580 
581  return std::string( buffer, length );
582  }
583 
584  size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const DAAL_C11_OVERRIDE
585  {
586  size_t length = getSizeOfArchive();
587 
588  if( length == 0 || length > maxLength ) { return length; }
589 
590  compressionStream->copyCompressedArray(ptr, length);
591  return length;
592  }
593 
598  services::SharedPtr<services::ErrorCollection> getErrors()
599  {
600  return _errors;
601  }
602 
603 private:
604  size_t minBlockSize;
605  byte *serializedBuffer;
606  daal::data_management::CompressionStream *compressionStream;
607  services::SharedPtr<services::ErrorCollection> _errors;
608 };
609 
615 class DecompressedDataArchive : public DataArchiveImpl
616 {
617 public:
618 
623  DecompressedDataArchive(daal::data_management::DecompressorImpl *decompressor) : minBlockSize(1024 * 64),
624  _errors(new services::ErrorCollection())
625  {
626  decompressionStream = new daal::data_management::DecompressionStream(decompressor, minBlockSize);
627  serializedBuffer = 0;
628  }
629 
631  ~DecompressedDataArchive()
632  {
633  if( serializedBuffer )
634  {
635  daal::services::daal_free( serializedBuffer );
636  }
637  delete decompressionStream;
638  }
639 
640  void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
641  {
642  DataBlock wBlock;
643  wBlock.setPtr(ptr);
644  wBlock.setSize(size);
645  decompressionStream->push_back(&wBlock);
646  }
647 
648  void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
649  {
650  decompressionStream->copyDecompressedArray(ptr, size);
651  }
652 
653  size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
654  {
655  return decompressionStream->getDecompressedDataSize();
656  }
657 
658  byte *getArchiveAsArray() DAAL_C11_OVERRIDE
659  {
660  if( serializedBuffer ) { return serializedBuffer; }
661 
662  size_t length = getSizeOfArchive();
663 
664  if( length == 0 ) { return 0; }
665 
666  serializedBuffer = (byte *)daal::services::daal_malloc( length );
667  if( serializedBuffer == 0 ) { return 0; }
668 
669  decompressionStream->copyDecompressedArray(serializedBuffer, length);
670  return serializedBuffer;
671  }
672 
673  services::SharedPtr<byte> getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
674  {
675  size_t length = getSizeOfArchive();
676 
677  if( length == 0 ) { return services::SharedPtr<byte>(); }
678 
679  services::SharedPtr<byte> serializedBufferPtr((byte *)daal::services::daal_malloc( length ), services::ServiceDeleter());
680  if( !serializedBufferPtr ) { return services::SharedPtr<byte>(); }
681 
682  copyArchiveToArray(serializedBufferPtr.get(), length);
683 
684  return serializedBufferPtr;
685  }
686 
687  std::string getArchiveAsString() DAAL_C11_OVERRIDE
688  {
689  size_t length = getSizeOfArchive();
690  char *buffer = (char *)getArchiveAsArray();
691 
692  return std::string( buffer, length );
693  }
694 
695  size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const DAAL_C11_OVERRIDE
696  {
697  size_t length = getSizeOfArchive();
698 
699  if( length == 0 || length > maxLength ) { return length; }
700 
701  decompressionStream->copyDecompressedArray(ptr, length);
702  return length;
703  }
704 
709  services::SharedPtr<services::ErrorCollection> getErrors()
710  {
711  return _errors;
712  }
713 
714 private:
715  size_t minBlockSize;
716  byte *serializedBuffer;
717  daal::data_management::DecompressionStream *decompressionStream;
718  services::SharedPtr<services::ErrorCollection> _errors;
719 };
720 
725 class InputDataArchive : public Base
726 {
727 public:
731  InputDataArchive() : _finalized(false), _errors(new services::ErrorCollection())
732  {
733  _arch = new DataArchive;
734  archiveHeader();
735  }
736 
742  InputDataArchive(DataArchiveIface * arch) : _finalized(false), _errors(new services::ErrorCollection())
743  {
744  _arch = arch;
745  archiveHeader();
746  }
747 
751  InputDataArchive(daal::data_management::CompressorImpl *compressor) : _finalized(false),
752  _errors(new services::ErrorCollection())
753  {
754  _arch = new CompressedDataArchive(compressor);
755  archiveHeader();
756  }
757 
758  ~InputDataArchive()
759  {
760  delete _arch;
761  }
762 
766  void archiveHeader()
767  {
768  int headerValues[8] =
769  {
770  0x4441414C,
771  __INTEL_DAAL__,
772  __INTEL_DAAL_MINOR__,
773  __INTEL_DAAL_UPDATE__,
774  0, 0, 0, 0
775  };
776 
777  _arch->setMajorVersion (headerValues[1]);
778  _arch->setMinorVersion (headerValues[2]);
779  _arch->setUpdateVersion(headerValues[3]);
780  for(size_t i = 0; i < 8; i++)
781  {
782  _arch->write( (byte *)&headerValues[i], sizeof(int) );
783  }
784  }
785 
789  void archiveFooter()
790  {
791  _finalized = true;
792  }
793 
797  void segmentHeader( int tag = 0 )
798  {
799  _arch->write( (byte *)&tag, sizeof(int) );
800  }
801 
805  void segmentFooter()
806  {
807  }
808 
814  template<typename T>
815  void set(T &val)
816  {
817  _arch->write( (byte *)&val, sizeof(T) );
818  }
819 
825  template<typename T>
826  void set(daal::services::Collection<T> &val)
827  {
828  size_t size = val.size();
829  _arch->write( (byte *)&size, sizeof(size_t) );
830  for(size_t i = 0; i < size; i++)
831  {
832  _arch->write( (byte *) & (val[i]), sizeof(T) );
833  }
834  }
835 
842  template<typename T>
843  void set(T *ptr, size_t size)
844  {
845  _arch->write( (byte *)ptr, size * sizeof(T) );
846  }
847 
854  template<typename T>
855  void setObj(T *ptr, size_t size = 1)
856  {
857  for( size_t i = 0; i < size; i++ )
858  {
859  ptr[i].serializeImpl( this );
860  }
861  }
862 
867  void setSingleObj(SerializationIface **ptr)
868  {
869  int isNull = (*ptr == 0);
870  set(isNull);
871 
872  if(!isNull)
873  {
874  (*ptr)->serialize( *this );
875  }
876  }
877 
882  template<typename T>
883  void setSharedPtrObj(services::SharedPtr<T> &obj)
884  {
885  data_management::SerializationIface *ptr = obj.get();
886  setSingleObj(&ptr);
887  }
888 
893  services::SharedPtr<byte> getArchiveAsArraySharedPtr()
894  {
895  if(!_finalized) { archiveFooter(); }
896  return _arch->getArchiveAsArraySharedPtr();
897  }
898 
904  DAAL_DEPRECATED byte *getArchiveAsArray()
905  {
906  if(!_finalized) { archiveFooter(); }
907  return _arch->getArchiveAsArray();
908  }
909 
916  DAAL_DEPRECATED void getArchiveAsArray( const byte **ptr, size_t *size )
917  {
918  if(!_finalized) { archiveFooter(); }
919 
920  *ptr = (byte *)_arch->getArchiveAsArray();
921  *size = _arch->getSizeOfArchive();
922  }
923 
928  size_t getSizeOfArchive()
929  {
930  if(!_finalized) { archiveFooter(); }
931 
932  return _arch->getSizeOfArchive();
933  }
934 
940  DAAL_DEPRECATED std::string getArchiveAsString()
941  {
942  if(!_finalized) { archiveFooter(); }
943 
944  return _arch->getArchiveAsString();
945  }
946 
953  size_t copyArchiveToArray( byte *ptr, size_t maxLength )
954  {
955  if(!_finalized) { archiveFooter(); }
956 
957  return _arch->copyArchiveToArray( ptr, maxLength );
958  }
959 
964  const DataArchive &getDataArchive()
965  {
966  return *static_cast<DataArchive *>(_arch);
967  }
968 
973  services::SharedPtr<services::ErrorCollection> getErrors()
974  {
975  return _errors;
976  }
977 
978 protected:
979  DataArchiveIface *_arch;
980  bool _finalized;
981  services::SharedPtr<services::ErrorCollection> _errors;
982 };
983 
988 class OutputDataArchive : public Base
989 {
990 public:
994  OutputDataArchive( InputDataArchive &arch ) : _errors(new services::ErrorCollection())
995  {
996  _arch = new DataArchive(arch.getDataArchive());
997  archiveHeader();
998  }
999 
1005  OutputDataArchive( DataArchiveIface * arch ) : _errors(new services::ErrorCollection())
1006  {
1007  _arch = arch;
1008  archiveHeader();
1009  }
1010 
1014  OutputDataArchive( byte *ptr, size_t size ) : _errors(new services::ErrorCollection())
1015  {
1016  _arch = new DataArchive(ptr, size);
1017  archiveHeader();
1018  }
1019 
1023  OutputDataArchive( daal::data_management::DecompressorImpl *decompressor, byte *ptr, size_t size ) :
1024  _errors(new services::ErrorCollection())
1025  {
1026  _arch = new DecompressedDataArchive(decompressor);
1027  _arch->write(ptr, size);
1028  archiveHeader();
1029  }
1030 
1031  ~OutputDataArchive()
1032  {
1033  delete _arch;
1034  }
1035 
1039  void archiveHeader() const
1040  {
1041  int headerValues[8];
1042 
1043  for(size_t i = 0; i < 8; i++)
1044  {
1045  _arch->read( (byte *)&headerValues[i], sizeof(int) );
1046  }
1047 
1048  _arch->setMajorVersion (headerValues[1]);
1049  _arch->setMinorVersion (headerValues[2]);
1050  _arch->setUpdateVersion(headerValues[3]);
1051  }
1052 
1056  void archiveFooter() const
1057  {
1058  }
1059 
1063  int segmentHeader() const
1064  {
1065  int tag = 0;
1066  _arch->read( (byte *)&tag, sizeof(int) );
1067  return tag;
1068  }
1069 
1073  void segmentFooter() const {}
1074 
1080  template<typename T>
1081  void set(T &val) const
1082  {
1083  _arch->read( (byte *)&val, sizeof(T) );
1084  }
1085 
1091  template<typename T>
1092  void set(daal::services::Collection<T> &val) const
1093  {
1094  size_t size = 0;
1095  _arch->read( (byte *)&size, sizeof(size_t) );
1096  val.clear();
1097  for(size_t i = 0; i < size; i++)
1098  {
1099  T v;
1100  _arch->read( (byte *)&v, sizeof(T) );
1101  val.push_back(v);
1102  }
1103  }
1104 
1111  template<typename T>
1112  void set(T *ptr, size_t size) const
1113  {
1114  _arch->read( (byte *)ptr, size * sizeof(T) );
1115  }
1116 
1123  template<typename T>
1124  void setObj(T *ptr, size_t size = 1) const
1125  {
1126  for( size_t i = 0; i < size; i++ )
1127  {
1128  ptr[i].deserializeImpl( this );
1129  }
1130  }
1131 
1136  void setSingleObj(SerializationIface **ptr) const
1137  {
1138  int isNull = 0;
1139  set(isNull);
1140 
1141  if(isNull)
1142  {
1143  *ptr = 0;
1144  return;
1145  }
1146 
1147  const int serTag = segmentHeader();
1148 
1149  *ptr = Factory::instance().createObject(serTag);
1150  if(!*ptr)
1151  {
1152  this->_errors->add(services::Error::create(
1153  services::ErrorObjectDoesNotSupportSerialization, services::SerializationTag, serTag));
1154  return;
1155  }
1156 
1157  (*ptr)->deserializeImpl( this );
1158 
1159  segmentFooter();
1160  }
1161 
1166  template<typename T>
1167  void setSharedPtrObj(services::SharedPtr<T> &obj) const
1168  {
1169  data_management::SerializationIface *ptr;
1170  setSingleObj(&ptr);
1171  if(this->_errors->size() != 0) { return; }
1172  if(ptr)
1173  {
1174  obj = services::SharedPtr<T>(static_cast<T *>(ptr));
1175  }
1176  else
1177  {
1178  obj = services::SharedPtr<T>();
1179  }
1180  }
1181 
1186  services::SharedPtr<SerializationIface> getAsSharedPtr() const
1187  {
1188  const int serTag = segmentHeader();
1189  services::SharedPtr<SerializationIface> ptr(Factory::instance().createObject(serTag));
1190  if(!ptr)
1191  {
1192  this->_errors->add(services::Error::create(
1193  services::ErrorObjectDoesNotSupportSerialization, services::SerializationTag, serTag));
1194  return services::SharedPtr<SerializationIface>();
1195  }
1196  ptr->deserializeImpl( this );
1197  segmentFooter();
1198  return ptr;
1199  }
1200 
1205  int getMajorVersion() const
1206  {
1207  return _arch->getMajorVersion();
1208  }
1209 
1214  int getMinorVersion() const
1215  {
1216  return _arch->getMinorVersion();
1217  }
1218 
1223  int getUpdateVersion() const
1224  {
1225  return _arch->getUpdateVersion();
1226  }
1227 
1232  services::SharedPtr<services::ErrorCollection> getErrors()
1233  {
1234  return _errors;
1235  }
1236 
1237 protected:
1238  DataArchiveIface *_arch;
1239  services::SharedPtr<services::ErrorCollection> _errors;
1240 };
1243 } // namespace interface1
1244 using interface1::DataArchiveIface;
1245 using interface1::DataArchive;
1246 using interface1::CompressedDataArchive;
1247 using interface1::DecompressedDataArchive;
1248 using interface1::InputDataArchive;
1249 using interface1::OutputDataArchive;
1250 
1251 }
1252 }
1253 
1254 #endif
daal::data_management::interface1::DataArchiveIface::setMinorVersion
virtual void setMinorVersion(int minorVersion)=0
daal::data_management::interface1::InputDataArchive::segmentHeader
void segmentHeader(int tag=0)
Definition: data_archive.h:797
daal::data_management::interface1::DecompressedDataArchive::getArchiveAsArray
byte * getArchiveAsArray() DAAL_C11_OVERRIDE
Definition: data_archive.h:658
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(daal::data_management::DecompressorImpl *decompressor, byte *ptr, size_t size)
Definition: data_archive.h:1023
daal::data_management::interface1::DataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength) const DAAL_C11_OVERRIDE
Definition: data_archive.h:390
daal::data_management::interface1::DataArchive
Implements the abstract DataArchiveIface interface.
Definition: data_archive.h:197
daal::data_management::interface1::CompressedDataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
Definition: data_archive.h:562
daal::data_management::interface1::Factory::instance
static Factory & instance()
daal::data_management::interface1::OutputDataArchive::set
void set(T &val) const
Definition: data_archive.h:1081
daal::data_management::interface1::DecompressedDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:709
daal::data_management::interface1::DataArchiveIface::getSizeOfArchive
virtual size_t getSizeOfArchive() const =0
daal::data_management::interface1::DataArchive::getArchiveAsString
std::string getArchiveAsString() DAAL_C11_OVERRIDE
Definition: data_archive.h:382
daal::data_management::interface1::DataArchive::DataArchive
DataArchive(byte *ptr, size_t size)
Definition: data_archive.h:247
daal::data_management::interface1::DataArchiveIface::setMajorVersion
virtual void setMajorVersion(int majorVersion)=0
daal::data_management::interface1::DataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:341
daal::data_management::interface1::OutputDataArchive::archiveHeader
void archiveHeader() const
Definition: data_archive.h:1039
daal::data_management::interface1::DataBlock::setPtr
virtual void setPtr(byte *ptr) DAAL_C11_OVERRIDE
Definition: data_block.h:140
daal::data_management::interface1::DataArchiveIface::getMajorVersion
virtual int getMajorVersion()=0
daal::data_management::interface1::OutputDataArchive::set
void set(T *ptr, size_t size) const
Definition: data_archive.h:1112
daal::data_management::interface1::DataArchiveImpl::setMinorVersion
void setMinorVersion(int minorVersion) DAAL_C11_OVERRIDE
Definition: data_archive.h:162
daal::data_management::interface1::OutputDataArchive::getMajorVersion
int getMajorVersion() const
Definition: data_archive.h:1205
daal::Base
Base class for Intel(R) Data Analytics Acceleration Library objects
Definition: base.h:41
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive(DataArchiveIface *arch)
Definition: data_archive.h:742
daal::data_management::interface1::InputDataArchive::getArchiveAsString
DAAL_DEPRECATED std::string getArchiveAsString()
Definition: data_archive.h:940
daal::data_management::interface1::InputDataArchive::setSharedPtrObj
void setSharedPtrObj(services::SharedPtr< T > &obj)
Definition: data_archive.h:883
daal::data_management::interface1::DataArchiveIface::getArchiveAsString
virtual DAAL_DEPRECATED_VIRTUAL std::string getArchiveAsString()=0
daal::data_management::interface1::OutputDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:1232
daal::data_management::interface1::CompressedDataArchive::read
void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:540
daal::data_management::interface1::OutputDataArchive::getUpdateVersion
int getUpdateVersion() const
Definition: data_archive.h:1223
daal::data_management::interface1::DecompressedDataArchive::write
void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:640
daal::data_management::interface1::DataArchiveIface::read
virtual void read(byte *ptr, size_t size)=0
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(InputDataArchive &arch)
Definition: data_archive.h:994
daal::data_management::interface1::InputDataArchive::archiveHeader
void archiveHeader()
Definition: data_archive.h:766
daal::data_management::interface1::InputDataArchive::getDataArchive
const DataArchive & getDataArchive()
Definition: data_archive.h:964
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive(daal::data_management::CompressorImpl *compressor)
Definition: data_archive.h:751
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(byte *ptr, size_t size)
Definition: data_archive.h:1014
daal::data_management::interface1::InputDataArchive::setObj
void setObj(T *ptr, size_t size=1)
Definition: data_archive.h:855
daal::data_management::interface1::CompressedDataArchive::getArchiveAsArray
byte * getArchiveAsArray() DAAL_C11_OVERRIDE
Definition: data_archive.h:547
daal::data_management::interface1::DecompressedDataArchive::DecompressedDataArchive
DecompressedDataArchive(daal::data_management::DecompressorImpl *decompressor)
Definition: data_archive.h:623
daal::data_management::interface1::DataArchive::DataArchive
DataArchive(const DataArchive &arch)
Definition: data_archive.h:222
daal::data_management::interface1::DataArchiveImpl::getMajorVersion
int getMajorVersion() DAAL_C11_OVERRIDE
Definition: data_archive.h:172
daal::data_management::interface1::OutputDataArchive::setSingleObj
void setSingleObj(SerializationIface **ptr) const
Definition: data_archive.h:1136
daal::data_management::interface1::OutputDataArchive::setSharedPtrObj
void setSharedPtrObj(services::SharedPtr< T > &obj) const
Definition: data_archive.h:1167
daal::data_management::interface1::DataArchive::getArchiveAsArray
byte * getArchiveAsArray() DAAL_C11_OVERRIDE
Definition: data_archive.h:366
daal::data_management::interface1::DataArchive::DataArchive
DataArchive()
Definition: data_archive.h:203
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:615
daal::data_management::interface1::InputDataArchive::set
void set(T &val)
Definition: data_archive.h:815
daal::data_management::interface1::DataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:420
daal::data_management::interface1::OutputDataArchive::setObj
void setObj(T *ptr, size_t size=1) const
Definition: data_archive.h:1124
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(DataArchiveIface *arch)
Definition: data_archive.h:1005
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::DataArchiveIface::write
virtual void write(byte *ptr, size_t size)=0
daal::data_management::interface1::DataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
Definition: data_archive.h:352
daal::data_management::interface1::OutputDataArchive::segmentFooter
void segmentFooter() const
Definition: data_archive.h:1073
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:507
daal::data_management::interface1::DataArchiveIface::getMinorVersion
virtual int getMinorVersion()=0
daal::data_management::interface1::DecompressedDataArchive::read
void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:648
daal::data_management::interface1::InputDataArchive::getSizeOfArchive
size_t getSizeOfArchive()
Definition: data_archive.h:928
daal::data_management::interface1::DecompressedDataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:653
daal::data_management::interface1::DataArchiveImpl::setUpdateVersion
void setUpdateVersion(int updateVersion) DAAL_C11_OVERRIDE
Definition: data_archive.h:167
daal::data_management::interface1::DataArchiveIface::copyArchiveToArray
virtual size_t copyArchiveToArray(byte *ptr, size_t maxLength) const =0
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:85
daal::data_management::interface1::OutputDataArchive::getAsSharedPtr
services::SharedPtr< SerializationIface > getAsSharedPtr() const
Definition: data_archive.h:1186
daal::data_management::interface1::OutputDataArchive::segmentHeader
int segmentHeader() const
Definition: data_archive.h:1063
daal::data_management::interface1::DecompressedDataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength) const DAAL_C11_OVERRIDE
Definition: data_archive.h:695
daal::services::daal_memcpy_s
DAAL_DEPRECATED 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:843
daal::data_management::interface1::Factory::createObject
SerializationIface * createObject(int objectId)
daal::data_management::interface1::CompressedDataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength) const DAAL_C11_OVERRIDE
Definition: data_archive.h:584
daal::services::ErrorObjectDoesNotSupportSerialization
Definition: error_indexes.h:409
daal::data_management::interface1::DataArchiveIface::getArchiveAsArraySharedPtr
virtual services::SharedPtr< byte > getArchiveAsArraySharedPtr() const =0
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:55
daal::data_management::interface1::DataArchiveImpl::getUpdateVersion
int getUpdateVersion() DAAL_C11_OVERRIDE
Definition: data_archive.h:182
daal::data_management::interface1::InputDataArchive::segmentFooter
void segmentFooter()
Definition: data_archive.h:805
daal::data_management::interface1::InputDataArchive::set
void set(daal::services::Collection< T > &val)
Definition: data_archive.h:826
daal::data_management::interface1::DataBlock::setSize
virtual void setSize(size_t size) DAAL_C11_OVERRIDE
Definition: data_block.h:150
daal::data_management::interface1::DataArchiveImpl::setMajorVersion
void setMajorVersion(int majorVersion) DAAL_C11_OVERRIDE
Definition: data_archive.h:157
daal::services::daal_malloc
DAAL_EXPORT void * daal_malloc(size_t size, size_t alignment=DAAL_MALLOC_DEFAULT_ALIGNMENT)
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::DataArchiveIface::getArchiveAsArray
virtual DAAL_DEPRECATED_VIRTUAL byte * getArchiveAsArray()
Definition: data_archive.h:91
daal::data_management::interface1::OutputDataArchive::set
void set(daal::services::Collection< T > &val) const
Definition: data_archive.h:1092
daal::services::daal_free
DAAL_EXPORT void daal_free(void *ptr)
daal::data_management::interface1::InputDataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength)
Definition: data_archive.h:953
daal::data_management::interface1::DecompressedDataArchive::getArchiveAsString
std::string getArchiveAsString() DAAL_C11_OVERRIDE
Definition: data_archive.h:687
daal::services::SerializationTag
Definition: error_indexes.h:59
daal::data_management::interface1::InputDataArchive::setSingleObj
void setSingleObj(SerializationIface **ptr)
Definition: data_archive.h:867
daal::data_management::interface1::CompressedDataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:542
daal::services::ErrorMemoryCopyFailedInternal
Definition: error_indexes.h:152
daal::data_management::interface1::InputDataArchive::archiveFooter
void archiveFooter()
Definition: data_archive.h:789
daal::data_management::interface1::CompressedDataArchive::getArchiveAsString
std::string getArchiveAsString() DAAL_C11_OVERRIDE
Definition: data_archive.h:576
daal::data_management::interface1::CompressedDataArchive::write
void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:532
daal::data_management::interface1::CompressedDataArchive::CompressedDataArchive
CompressedDataArchive(daal::data_management::CompressorImpl *compressor)
Definition: data_archive.h:515
daal::data_management::interface1::DataArchiveIface::getUpdateVersion
virtual int getUpdateVersion()=0
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::InputDataArchive::getArchiveAsArray
DAAL_DEPRECATED byte * getArchiveAsArray()
Definition: data_archive.h:904
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive()
Definition: data_archive.h:731
daal::data_management::interface1::DataArchive::read
void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:317
daal::algorithms::math::abs::value
Definition: abs_types.h:88
daal::data_management::interface1::InputDataArchive::getArchiveAsArray
DAAL_DEPRECATED void getArchiveAsArray(const byte **ptr, size_t *size)
Definition: data_archive.h:916
daal::data_management::interface1::DataArchive::write
void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:293
daal::data_management::interface1::DataArchiveImpl::getMinorVersion
int getMinorVersion() DAAL_C11_OVERRIDE
Definition: data_archive.h:177
daal::data_management::interface1::DecompressedDataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
Definition: data_archive.h:673
daal::data_management::interface1::CompressedDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:598
daal::data_management::interface1::OutputDataArchive::getMinorVersion
int getMinorVersion() const
Definition: data_archive.h:1214
daal::data_management::interface1::OutputDataArchive::archiveFooter
void archiveFooter() const
Definition: data_archive.h:1056
daal::data_management::interface1::InputDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:973
daal::data_management::interface1::DataArchiveIface::setUpdateVersion
virtual void setUpdateVersion(int updateVersion)=0
daal::services::ErrorDataArchiveInternal
Definition: error_indexes.h:103
daal::data_management::interface1::InputDataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr()
Definition: data_archive.h:893
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:150

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