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

data_archive.h
1 /* file: data_archive.h */
2 /*******************************************************************************
3 * Copyright 2014-2018 Intel Corporation
4 * All Rights Reserved.
5 *
6 * If this software was obtained under the Intel Simplified Software License,
7 * the following terms apply:
8 *
9 * The source code, information and material ("Material") contained herein is
10 * owned by Intel Corporation or its suppliers or licensors, and title to such
11 * Material remains with Intel Corporation or its suppliers or licensors. The
12 * Material contains proprietary information of Intel or its suppliers and
13 * licensors. The Material is protected by worldwide copyright laws and treaty
14 * provisions. No part of the Material may be used, copied, reproduced,
15 * modified, published, uploaded, posted, transmitted, distributed or disclosed
16 * in any way without Intel's prior express written permission. No license under
17 * any patent, copyright or other intellectual property rights in the Material
18 * is granted to or conferred upon you, either expressly, by implication,
19 * inducement, estoppel or otherwise. Any license under such intellectual
20 * property rights must be express and approved by Intel in writing.
21 *
22 * Unless otherwise agreed by Intel in writing, you may not remove or alter this
23 * notice or any other notice embedded in Materials by Intel or Intel's
24 * suppliers or licensors in any way.
25 *
26 *
27 * If this software was obtained under the Apache License, Version 2.0 (the
28 * "License"), the following terms apply:
29 *
30 * You may not use this file except in compliance with the License. You may
31 * obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
32 *
33 *
34 * Unless required by applicable law or agreed to in writing, software
35 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
36 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
37 *
38 * See the License for the specific language governing permissions and
39 * limitations under the License.
40 *******************************************************************************/
41 
42 /*
43 //++
44 // Declaration and implementation of classes that support serialization and deserialization methods
45 //--
46 */
47 
48 #ifndef __DATA_ARCHIVE_H__
49 #define __DATA_ARCHIVE_H__
50 
51 #include "services/base.h"
52 #include "services/library_version_info.h"
53 #include "services/daal_memory.h"
54 #include "services/collection.h"
55 #include "data_management/data/data_block.h"
56 #include "data_management/data/data_utils.h"
57 #include "data_management/data/factory.h"
58 #include "data_management/data/data_serialize.h"
59 #include "data_management/data/data_collection.h"
60 #include "data_management/compression/compression_stream.h"
61 
62 namespace daal
63 {
64 namespace data_management
65 {
66 
67 namespace interface1
68 {
78 class DataArchiveIface : public Base
79 {
80 public:
81  virtual ~DataArchiveIface() {}
82 
88  virtual void write(byte *ptr, size_t size) = 0;
89 
95  virtual void read(byte *ptr, size_t size) = 0;
96 
101  virtual size_t getSizeOfArchive() const = 0;
102 
107  virtual services::SharedPtr<byte> getArchiveAsArraySharedPtr() const = 0;
108 
114  DAAL_DEPRECATED_VIRTUAL virtual byte *getArchiveAsArray() { return NULL; }
115 
121  DAAL_DEPRECATED_VIRTUAL virtual std::string getArchiveAsString() = 0;
122 
129  virtual size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const = 0;
130 
135  virtual void setMajorVersion(int majorVersion) = 0;
136 
141  virtual void setMinorVersion(int minorVersion) = 0;
142 
147  virtual void setUpdateVersion(int updateVersion) = 0;
148 
153  virtual int getMajorVersion() = 0;
154 
159  virtual int getMinorVersion() = 0;
160 
165  virtual int getUpdateVersion() = 0;
166 };
167 
173 class DataArchiveImpl : public DataArchiveIface
174 {
175 public:
176  DataArchiveImpl() : _majorVersion(0), _minorVersion(0), _updateVersion(0) {}
177 
178  virtual ~DataArchiveImpl() {}
179 
180  void setMajorVersion(int majorVersion) DAAL_C11_OVERRIDE
181  {
182  _majorVersion = majorVersion;
183  }
184 
185  void setMinorVersion(int minorVersion) DAAL_C11_OVERRIDE
186  {
187  _minorVersion = minorVersion;
188  }
189 
190  void setUpdateVersion(int updateVersion) DAAL_C11_OVERRIDE
191  {
192  _updateVersion = updateVersion;
193  }
194 
195  int getMajorVersion() DAAL_C11_OVERRIDE
196  {
197  return _majorVersion;
198  }
199 
200  int getMinorVersion() DAAL_C11_OVERRIDE
201  {
202  return _minorVersion;
203  }
204 
205  int getUpdateVersion() DAAL_C11_OVERRIDE
206  {
207  return _updateVersion;
208  }
209 
210 protected:
211  int _majorVersion;
212  int _minorVersion;
213  int _updateVersion;
214 };
215 
220 class DataArchive: public DataArchiveImpl
221 {
222 public:
226  DataArchive() : minBlockSize(1024 * 16), minBlocksNum(16), _errors(new services::ErrorCollection())
227  {
228  blockPtr = 0;
229  blockAllocatedSize = 0;
230  blockOffset = 0;
231  arraysSize = 0;
232  currentWriteBlock = -1;
233 
234  currentReadBlock = 0;
235  currentReadBlockOffset = 0;
236 
237  serializedBuffer = 0;
238 
239  addBlock( minBlockSize );
240  }
241 
245  DataArchive( const DataArchive &arch ) : minBlockSize(1024 * 16), minBlocksNum(16)
246  {
247  blockPtr = 0;
248  blockAllocatedSize = 0;
249  blockOffset = 0;
250  arraysSize = 0;
251  currentWriteBlock = -1;
252 
253  currentReadBlock = 0;
254  currentReadBlockOffset = 0;
255 
256  serializedBuffer = 0;
257 
258  size_t size = arch.getSizeOfArchive();
259  addBlock( size );
260  arch.copyArchiveToArray( blockPtr[currentWriteBlock], size );
261 
262  blockOffset[currentWriteBlock] += size;
263  }
264 
270  DataArchive( byte *ptr, size_t size ) : minBlockSize(1024 * 16), minBlocksNum(16)
271  {
272  blockPtr = 0;
273  blockAllocatedSize = 0;
274  blockOffset = 0;
275  arraysSize = 0;
276  currentWriteBlock = -1;
277 
278  currentReadBlock = 0;
279  currentReadBlockOffset = 0;
280 
281  serializedBuffer = 0;
282 
283  addBlock( size );
284 
285  daal::services::daal_memcpy_s(blockPtr[currentWriteBlock], size, ptr, size);
286 
287  blockOffset[currentWriteBlock] += size;
288  }
289 
290  ~DataArchive()
291  {
292  int i;
293  for(i = 0; i <= currentWriteBlock; i++)
294  {
295  daal::services::daal_free( blockPtr[i] );
296  }
297  daal::services::daal_free( blockPtr );
298  daal::services::daal_free( blockAllocatedSize );
299  daal::services::daal_free( blockOffset );
300  if( serializedBuffer )
301  {
302  daal::services::daal_free( serializedBuffer );
303  }
304  }
305 
306  void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
307  {
308  size_t alignedSize = alignValueUp(size);
309  if( blockAllocatedSize[currentWriteBlock] < blockOffset[currentWriteBlock] + alignedSize )
310  {
311  addBlock(alignedSize);
312  }
313 
314  size_t offset = blockOffset[currentWriteBlock];
315 
316  daal::services::daal_memcpy_s(&(blockPtr[currentWriteBlock][offset]), alignedSize, ptr, size);
317  for (size_t i = size; i < alignedSize; i++)
318  {
319  blockPtr[currentWriteBlock][offset + i] = 0;
320  }
321 
322  blockOffset[currentWriteBlock] += alignedSize;
323  }
324 
325  void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
326  {
327  size_t alignedSize = alignValueUp(size);
328  if( blockOffset[currentReadBlock] < currentReadBlockOffset + alignedSize )
329  {
330  this->_errors->add(services::ErrorDataArchiveInternal);
331  return;
332  }
333 
334  daal::services::daal_memcpy_s(ptr, size, &(blockPtr[currentReadBlock][currentReadBlockOffset]), size);
335 
336  currentReadBlockOffset += alignedSize;
337  if( blockOffset[currentReadBlock] == currentReadBlockOffset )
338  {
339  currentReadBlock++;
340  currentReadBlockOffset = 0;
341  }
342  }
343 
344  size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
345  {
346  int i;
347  size_t size = 0;
348  for(i = 0; i <= currentWriteBlock; i++)
349  {
350  size += blockOffset[i];
351  }
352  return size;
353  }
354 
355  services::SharedPtr<byte> getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
356  {
357  size_t length = getSizeOfArchive();
358 
359  if( length == 0 ) { return services::SharedPtr<byte>(); }
360 
361  services::SharedPtr<byte> serializedBufferPtr((byte *)daal::services::daal_malloc( length ), services::ServiceDeleter());
362  if( !serializedBufferPtr ) { return services::SharedPtr<byte>(); }
363 
364  copyArchiveToArray(serializedBufferPtr.get(), length);
365 
366  return serializedBufferPtr;
367  }
368 
369  byte *getArchiveAsArray() DAAL_C11_OVERRIDE
370  {
371  if( serializedBuffer ) { return serializedBuffer; }
372 
373  size_t length = getSizeOfArchive();
374 
375  if( length == 0 ) { return 0; }
376 
377  serializedBuffer = (byte *)daal::services::daal_malloc( length );
378  if( serializedBuffer == 0 ) { return 0; }
379 
380  copyArchiveToArray(serializedBuffer, length);
381 
382  return serializedBuffer;
383  }
384 
385  std::string getArchiveAsString() DAAL_C11_OVERRIDE
386  {
387  size_t length = getSizeOfArchive();
388  char *buffer = (char *)getArchiveAsArray();
389 
390  return std::string( buffer, length );
391  }
392 
393  size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const DAAL_C11_OVERRIDE
394  {
395  size_t length = getSizeOfArchive();
396 
397  if( length == 0 || length > maxLength ) { return length; }
398 
399  int i;
400  size_t offset = 0;
401  for(i = 0; i <= currentWriteBlock; i++)
402  {
403  size_t blockSize = blockOffset[i];
404 
405  daal::services::daal_memcpy_s(&(ptr[offset]), blockSize, blockPtr[i], blockSize);
406 
407  offset += blockSize;
408  }
409 
410  return length;
411  }
412 
417  services::SharedPtr<services::ErrorCollection> getErrors()
418  {
419  return _errors;
420  }
421 
422 protected:
423 
424  void addBlock( size_t minNewSize )
425  {
426  if( currentWriteBlock + 1 == arraysSize )
427  {
428  byte **oldBlockPtr = blockPtr ;
429  size_t *oldBlockAllocatedSize = blockAllocatedSize;
430  size_t *oldBlockOffset = blockOffset ;
431 
432  blockPtr = (byte **)daal::services::daal_malloc(sizeof(byte *) * (arraysSize + minBlocksNum));
433  blockAllocatedSize = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (arraysSize + minBlocksNum));
434  blockOffset = (size_t *)daal::services::daal_malloc(sizeof(size_t) * (arraysSize + minBlocksNum));
435 
436  if( blockPtr == 0 || blockAllocatedSize == 0 || blockOffset == 0 ) { return; }
437 
438  daal::services::daal_memcpy_s(blockPtr, arraysSize * sizeof(byte *), oldBlockPtr, arraysSize * sizeof(byte *));
439  daal::services::daal_memcpy_s(blockAllocatedSize, arraysSize * sizeof(size_t), oldBlockAllocatedSize, arraysSize * sizeof(size_t));
440  daal::services::daal_memcpy_s(blockOffset, arraysSize * sizeof(size_t), oldBlockOffset, arraysSize * sizeof(size_t));
441 
442  daal::services::daal_free(oldBlockPtr );
443  daal::services::daal_free(oldBlockAllocatedSize);
444  daal::services::daal_free(oldBlockOffset );
445 
446  arraysSize += minBlocksNum;
447  }
448 
449  currentWriteBlock++;
450 
451  size_t allocationSize = (minBlockSize > minNewSize) ? minBlockSize : minNewSize;
452 
453  blockPtr [currentWriteBlock] = (byte *)daal::services::daal_malloc(allocationSize);
454  blockAllocatedSize[currentWriteBlock] = allocationSize;
455  blockOffset [currentWriteBlock] = 0;
456  }
457 
458  inline size_t alignValueUp(size_t value)
459  {
460  if (_majorVersion == 2016 && _minorVersion == 0 && _updateVersion == 0)
461  {
462  return value;
463  }
464 
465  size_t alignm1 = DAAL_MALLOC_DEFAULT_ALIGNMENT - 1;
466 
467  size_t alignedValue = value + alignm1;
468  alignedValue &= ~alignm1;
469  return alignedValue;
470  }
471 
472  services::SharedPtr<services::ErrorCollection> _errors;
473 
474 private:
475  int minBlocksNum;
476  size_t minBlockSize;
477 
478  byte **blockPtr;
479  size_t *blockAllocatedSize;
480  size_t *blockOffset;
481 
482  int arraysSize;
483 
484  int currentWriteBlock;
485 
486  int currentReadBlock;
487  size_t currentReadBlockOffset;
488 
489  byte *serializedBuffer;
490 };
491 
497 class CompressedDataArchive : public DataArchiveImpl
498 {
499 public:
500 
505  CompressedDataArchive(daal::data_management::CompressorImpl *compressor) : minBlockSize(1024 * 64),
506  _errors(new services::ErrorCollection())
507  {
508  compressionStream = new daal::data_management::CompressionStream(compressor, minBlockSize);
509  serializedBuffer = 0;
510  }
511 
513  ~CompressedDataArchive()
514  {
515  if( serializedBuffer )
516  {
517  daal::services::daal_free( serializedBuffer );
518  }
519  delete compressionStream;
520  }
521 
522  void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
523  {
524  DataBlock wBlock;
525  wBlock.setPtr(ptr);
526  wBlock.setSize(size);
527  compressionStream->push_back(&wBlock);
528  }
529 
530  void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE {}
531 
532  size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
533  {
534  return compressionStream->getCompressedDataSize();
535  }
536 
537  byte *getArchiveAsArray() DAAL_C11_OVERRIDE
538  {
539  if( serializedBuffer ) { return serializedBuffer; }
540 
541  size_t length = getSizeOfArchive();
542 
543  if( length == 0 ) { return 0; }
544 
545  serializedBuffer = (byte *)daal::services::daal_malloc( length );
546  if( serializedBuffer == 0 ) { return 0; }
547 
548  compressionStream->copyCompressedArray(serializedBuffer, length);
549  return serializedBuffer;
550  }
551 
552  services::SharedPtr<byte> getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
553  {
554  size_t length = getSizeOfArchive();
555 
556  if( length == 0 ) { return services::SharedPtr<byte>(); }
557 
558  services::SharedPtr<byte> serializedBufferPtr((byte *)daal::services::daal_malloc( length ), services::ServiceDeleter());
559  if( serializedBufferPtr ) { return services::SharedPtr<byte>(); }
560 
561  copyArchiveToArray(serializedBufferPtr.get(), length);
562 
563  return serializedBufferPtr;
564  }
565 
566  std::string getArchiveAsString() DAAL_C11_OVERRIDE
567  {
568  size_t length = getSizeOfArchive();
569  char *buffer = (char *)getArchiveAsArray();
570 
571  return std::string( buffer, length );
572  }
573 
574  size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const DAAL_C11_OVERRIDE
575  {
576  size_t length = getSizeOfArchive();
577 
578  if( length == 0 || length > maxLength ) { return length; }
579 
580  compressionStream->copyCompressedArray(ptr, length);
581  return length;
582  }
583 
588  services::SharedPtr<services::ErrorCollection> getErrors()
589  {
590  return _errors;
591  }
592 
593 private:
594  size_t minBlockSize;
595  byte *serializedBuffer;
596  daal::data_management::CompressionStream *compressionStream;
597  services::SharedPtr<services::ErrorCollection> _errors;
598 };
599 
605 class DecompressedDataArchive : public DataArchiveImpl
606 {
607 public:
608 
613  DecompressedDataArchive(daal::data_management::DecompressorImpl *decompressor) : minBlockSize(1024 * 64),
614  _errors(new services::ErrorCollection())
615  {
616  decompressionStream = new daal::data_management::DecompressionStream(decompressor, minBlockSize);
617  serializedBuffer = 0;
618  }
619 
621  ~DecompressedDataArchive()
622  {
623  if( serializedBuffer )
624  {
625  daal::services::daal_free( serializedBuffer );
626  }
627  delete decompressionStream;
628  }
629 
630  void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
631  {
632  DataBlock wBlock;
633  wBlock.setPtr(ptr);
634  wBlock.setSize(size);
635  decompressionStream->push_back(&wBlock);
636  }
637 
638  void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
639  {
640  decompressionStream->copyDecompressedArray(ptr, size);
641  }
642 
643  size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
644  {
645  return decompressionStream->getDecompressedDataSize();
646  }
647 
648  byte *getArchiveAsArray() DAAL_C11_OVERRIDE
649  {
650  if( serializedBuffer ) { return serializedBuffer; }
651 
652  size_t length = getSizeOfArchive();
653 
654  if( length == 0 ) { return 0; }
655 
656  serializedBuffer = (byte *)daal::services::daal_malloc( length );
657  if( serializedBuffer == 0 ) { return 0; }
658 
659  decompressionStream->copyDecompressedArray(serializedBuffer, length);
660  return serializedBuffer;
661  }
662 
663  services::SharedPtr<byte> getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
664  {
665  size_t length = getSizeOfArchive();
666 
667  if( length == 0 ) { return services::SharedPtr<byte>(); }
668 
669  services::SharedPtr<byte> serializedBufferPtr((byte *)daal::services::daal_malloc( length ), services::ServiceDeleter());
670  if( serializedBufferPtr ) { return services::SharedPtr<byte>(); }
671 
672  copyArchiveToArray(serializedBufferPtr.get(), length);
673 
674  return serializedBufferPtr;
675  }
676 
677  std::string getArchiveAsString() DAAL_C11_OVERRIDE
678  {
679  size_t length = getSizeOfArchive();
680  char *buffer = (char *)getArchiveAsArray();
681 
682  return std::string( buffer, length );
683  }
684 
685  size_t copyArchiveToArray( byte *ptr, size_t maxLength ) const DAAL_C11_OVERRIDE
686  {
687  size_t length = getSizeOfArchive();
688 
689  if( length == 0 || length > maxLength ) { return length; }
690 
691  decompressionStream->copyDecompressedArray(ptr, length);
692  return length;
693  }
694 
699  services::SharedPtr<services::ErrorCollection> getErrors()
700  {
701  return _errors;
702  }
703 
704 private:
705  size_t minBlockSize;
706  byte *serializedBuffer;
707  daal::data_management::DecompressionStream *decompressionStream;
708  services::SharedPtr<services::ErrorCollection> _errors;
709 };
710 
715 class InputDataArchive : public Base
716 {
717 public:
721  InputDataArchive() : _finalized(false), _errors(new services::ErrorCollection())
722  {
723  _arch = new DataArchive;
724  archiveHeader();
725  }
726 
732  InputDataArchive(DataArchiveIface * arch) : _finalized(false), _errors(new services::ErrorCollection())
733  {
734  _arch = arch;
735  archiveHeader();
736  }
737 
741  InputDataArchive(daal::data_management::CompressorImpl *compressor) : _finalized(false),
742  _errors(new services::ErrorCollection())
743  {
744  _arch = new CompressedDataArchive(compressor);
745  archiveHeader();
746  }
747 
748  ~InputDataArchive()
749  {
750  delete _arch;
751  }
752 
756  void archiveHeader()
757  {
758  int headerValues[8] =
759  {
760  0x4441414C,
761  __INTEL_DAAL__,
762  __INTEL_DAAL_MINOR__,
763  __INTEL_DAAL_UPDATE__,
764  0, 0, 0, 0
765  };
766 
767  _arch->setMajorVersion (headerValues[1]);
768  _arch->setMinorVersion (headerValues[2]);
769  _arch->setUpdateVersion(headerValues[3]);
770  for(size_t i = 0; i < 8; i++)
771  {
772  _arch->write( (byte *)&headerValues[i], sizeof(int) );
773  }
774  }
775 
779  void archiveFooter()
780  {
781  _finalized = true;
782  }
783 
787  void segmentHeader( int tag = 0 )
788  {
789  _arch->write( (byte *)&tag, sizeof(int) );
790  }
791 
795  void segmentFooter()
796  {
797  }
798 
804  template<typename T>
805  void set(T &val)
806  {
807  _arch->write( (byte *)&val, sizeof(T) );
808  }
809 
815  template<typename T>
816  void set(daal::services::Collection<T> &val)
817  {
818  size_t size = val.size();
819  _arch->write( (byte *)&size, sizeof(size_t) );
820  for(size_t i = 0; i < size; i++)
821  {
822  _arch->write( (byte *) & (val[i]), sizeof(T) );
823  }
824  }
825 
832  template<typename T>
833  void set(T *ptr, size_t size)
834  {
835  _arch->write( (byte *)ptr, size * sizeof(T) );
836  }
837 
844  template<typename T>
845  void setObj(T *ptr, size_t size = 1)
846  {
847  for( size_t i = 0; i < size; i++ )
848  {
849  ptr[i].serializeImpl( this );
850  }
851  }
852 
857  void setSingleObj(SerializationIface **ptr)
858  {
859  int isNull = (*ptr == 0);
860  set(isNull);
861 
862  if(!isNull)
863  {
864  (*ptr)->serialize( *this );
865  }
866  }
867 
872  template<typename T>
873  void setSharedPtrObj(services::SharedPtr<T> &obj)
874  {
875  data_management::SerializationIface *ptr = obj.get();
876  setSingleObj(&ptr);
877  }
878 
883  services::SharedPtr<byte> getArchiveAsArraySharedPtr()
884  {
885  if(!_finalized) { archiveFooter(); }
886  return _arch->getArchiveAsArraySharedPtr();
887  }
888 
894  DAAL_DEPRECATED byte *getArchiveAsArray()
895  {
896  if(!_finalized) { archiveFooter(); }
897  return _arch->getArchiveAsArray();
898  }
899 
906  DAAL_DEPRECATED void getArchiveAsArray( const byte **ptr, size_t *size )
907  {
908  if(!_finalized) { archiveFooter(); }
909 
910  *ptr = (byte *)_arch->getArchiveAsArray();
911  *size = _arch->getSizeOfArchive();
912  }
913 
918  size_t getSizeOfArchive()
919  {
920  if(!_finalized) { archiveFooter(); }
921 
922  return _arch->getSizeOfArchive();
923  }
924 
930  DAAL_DEPRECATED std::string getArchiveAsString()
931  {
932  if(!_finalized) { archiveFooter(); }
933 
934  return _arch->getArchiveAsString();
935  }
936 
943  size_t copyArchiveToArray( byte *ptr, size_t maxLength )
944  {
945  if(!_finalized) { archiveFooter(); }
946 
947  return _arch->copyArchiveToArray( ptr, maxLength );
948  }
949 
954  const DataArchive &getDataArchive()
955  {
956  return *static_cast<DataArchive *>(_arch);
957  }
958 
963  services::SharedPtr<services::ErrorCollection> getErrors()
964  {
965  return _errors;
966  }
967 
968 protected:
969  DataArchiveIface *_arch;
970  bool _finalized;
971  services::SharedPtr<services::ErrorCollection> _errors;
972 };
973 
978 class OutputDataArchive : public Base
979 {
980 public:
984  OutputDataArchive( InputDataArchive &arch ) : _errors(new services::ErrorCollection())
985  {
986  _arch = new DataArchive(arch.getDataArchive());
987  archiveHeader();
988  }
989 
995  OutputDataArchive( DataArchiveIface * arch ) : _errors(new services::ErrorCollection())
996  {
997  _arch = arch;
998  archiveHeader();
999  }
1000 
1004  OutputDataArchive( byte *ptr, size_t size ) : _errors(new services::ErrorCollection())
1005  {
1006  _arch = new DataArchive(ptr, size);
1007  archiveHeader();
1008  }
1009 
1013  OutputDataArchive( daal::data_management::DecompressorImpl *decompressor, byte *ptr, size_t size ) :
1014  _errors(new services::ErrorCollection())
1015  {
1016  _arch = new DecompressedDataArchive(decompressor);
1017  _arch->write(ptr, size);
1018  archiveHeader();
1019  }
1020 
1021  ~OutputDataArchive()
1022  {
1023  delete _arch;
1024  }
1025 
1029  void archiveHeader() const
1030  {
1031  int headerValues[8];
1032 
1033  for(size_t i = 0; i < 8; i++)
1034  {
1035  _arch->read( (byte *)&headerValues[i], sizeof(int) );
1036  }
1037 
1038  _arch->setMajorVersion (headerValues[1]);
1039  _arch->setMinorVersion (headerValues[2]);
1040  _arch->setUpdateVersion(headerValues[3]);
1041  }
1042 
1046  void archiveFooter() const
1047  {
1048  }
1049 
1053  int segmentHeader() const
1054  {
1055  int tag = 0;
1056  _arch->read( (byte *)&tag, sizeof(int) );
1057  return tag;
1058  }
1059 
1063  void segmentFooter() const {}
1064 
1070  template<typename T>
1071  void set(T &val) const
1072  {
1073  _arch->read( (byte *)&val, sizeof(T) );
1074  }
1075 
1081  template<typename T>
1082  void set(daal::services::Collection<T> &val) const
1083  {
1084  size_t size = 0;
1085  _arch->read( (byte *)&size, sizeof(size_t) );
1086  val.clear();
1087  for(size_t i = 0; i < size; i++)
1088  {
1089  T v;
1090  _arch->read( (byte *)&v, sizeof(T) );
1091  val.push_back(v);
1092  }
1093  }
1094 
1101  template<typename T>
1102  void set(T *ptr, size_t size) const
1103  {
1104  _arch->read( (byte *)ptr, size * sizeof(T) );
1105  }
1106 
1113  template<typename T>
1114  void setObj(T *ptr, size_t size = 1) const
1115  {
1116  for( size_t i = 0; i < size; i++ )
1117  {
1118  ptr[i].deserializeImpl( this );
1119  }
1120  }
1121 
1126  void setSingleObj(SerializationIface **ptr) const
1127  {
1128  int isNull = 0;
1129  set(isNull);
1130 
1131  if(isNull)
1132  {
1133  *ptr = 0;
1134  return;
1135  }
1136 
1137  const int serTag = segmentHeader();
1138 
1139  *ptr = Factory::instance().createObject(serTag);
1140  if(!*ptr)
1141  {
1142  this->_errors->add(services::Error::create(
1143  services::ErrorObjectDoesNotSupportSerialization, services::SerializationTag, serTag));
1144  return;
1145  }
1146 
1147  (*ptr)->deserializeImpl( this );
1148 
1149  segmentFooter();
1150  }
1151 
1156  template<typename T>
1157  void setSharedPtrObj(services::SharedPtr<T> &obj) const
1158  {
1159  data_management::SerializationIface *ptr;
1160  setSingleObj(&ptr);
1161  if(this->_errors->size() != 0) { return; }
1162  if(ptr)
1163  {
1164  obj = services::SharedPtr<T>(static_cast<T *>(ptr));
1165  }
1166  else
1167  {
1168  obj = services::SharedPtr<T>();
1169  }
1170  }
1171 
1176  services::SharedPtr<SerializationIface> getAsSharedPtr() const
1177  {
1178  const int serTag = segmentHeader();
1179  services::SharedPtr<SerializationIface> ptr(Factory::instance().createObject(serTag));
1180  if(!ptr)
1181  {
1182  this->_errors->add(services::Error::create(
1183  services::ErrorObjectDoesNotSupportSerialization, services::SerializationTag, serTag));
1184  return services::SharedPtr<SerializationIface>();
1185  }
1186  ptr->deserializeImpl( this );
1187  segmentFooter();
1188  return ptr;
1189  }
1190 
1195  int getMajorVersion() const
1196  {
1197  return _arch->getMajorVersion();
1198  }
1199 
1204  int getMinorVersion() const
1205  {
1206  return _arch->getMinorVersion();
1207  }
1208 
1213  int getUpdateVersion() const
1214  {
1215  return _arch->getUpdateVersion();
1216  }
1217 
1222  services::SharedPtr<services::ErrorCollection> getErrors()
1223  {
1224  return _errors;
1225  }
1226 
1227 protected:
1228  DataArchiveIface *_arch;
1229  services::SharedPtr<services::ErrorCollection> _errors;
1230 };
1233 } // namespace interface1
1234 using interface1::DataArchiveIface;
1235 using interface1::DataArchive;
1236 using interface1::CompressedDataArchive;
1237 using interface1::DecompressedDataArchive;
1238 using interface1::InputDataArchive;
1239 using interface1::OutputDataArchive;
1240 
1241 }
1242 }
1243 
1244 #endif
daal::data_management::interface1::DataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:344
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive(daal::data_management::CompressorImpl *compressor)
Definition: data_archive.h:741
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive()
Definition: data_archive.h:721
daal::data_management::interface1::OutputDataArchive::segmentFooter
void segmentFooter() const
Definition: data_archive.h:1063
daal::data_management::interface1::InputDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:963
daal::data_management::interface1::InputDataArchive::archiveFooter
void archiveFooter()
Definition: data_archive.h:779
daal::data_management::interface1::OutputDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:1222
daal::data_management::interface1::InputDataArchive::setSharedPtrObj
void setSharedPtrObj(services::SharedPtr< T > &obj)
Definition: data_archive.h:873
daal::data_management::interface1::CompressedDataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr() const DAAL_C11_OVERRIDE
Definition: data_archive.h:552
daal::data_management::interface1::DataArchiveIface::setUpdateVersion
virtual void setUpdateVersion(int updateVersion)=0
daal
Definition: algorithm_base_common.h:57
daal::data_management::interface1::InputDataArchive
Provides methods to create an archive data object (serialized) and access this object.
Definition: data_archive.h:715
daal::data_management::interface1::InputDataArchive::setSingleObj
void setSingleObj(SerializationIface **ptr)
Definition: data_archive.h:857
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:355
daal::data_management::interface1::OutputDataArchive::setSingleObj
void setSingleObj(SerializationIface **ptr) const
Definition: data_archive.h:1126
daal::services::ErrorObjectDoesNotSupportSerialization
Definition: error_indexes.h:418
daal::data_management::interface1::CompressedDataArchive::write
void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:522
daal::data_management::interface1::CompressedDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:588
daal::data_management::interface1::DecompressedDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:699
daal::data_management::interface1::DataArchiveImpl::getMinorVersion
int getMinorVersion() DAAL_C11_OVERRIDE
Definition: data_archive.h:200
daal::data_management::interface1::DataBlock::setSize
virtual void setSize(size_t size) DAAL_C11_OVERRIDE
Definition: data_block.h:174
daal::data_management::interface1::DataArchive::DataArchive
DataArchive()
Definition: data_archive.h:226
daal::data_management::interface1::CompressedDataArchive::CompressedDataArchive
CompressedDataArchive(daal::data_management::CompressorImpl *compressor)
Definition: data_archive.h:505
daal::data_management::interface1::DataArchive::getArchiveAsString
std::string getArchiveAsString() DAAL_C11_OVERRIDE
Definition: data_archive.h:385
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:417
daal::data_management::interface1::DecompressedDataArchive::getArchiveAsArray
byte * getArchiveAsArray() DAAL_C11_OVERRIDE
Definition: data_archive.h:648
daal::data_management::interface1::InputDataArchive::getArchiveAsArraySharedPtr
services::SharedPtr< byte > getArchiveAsArraySharedPtr()
Definition: data_archive.h:883
daal::services::SerializationTag
Definition: error_indexes.h:83
daal::data_management::interface1::DataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength) const DAAL_C11_OVERRIDE
Definition: data_archive.h:393
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:114
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:185
daal::data_management::interface1::DataArchive::DataArchive
DataArchive(byte *ptr, size_t size)
Definition: data_archive.h:270
daal::data_management::interface1::DataArchiveImpl::getMajorVersion
int getMajorVersion() DAAL_C11_OVERRIDE
Definition: data_archive.h:195
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::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:78
daal::data_management::interface1::InputDataArchive::archiveHeader
void archiveHeader()
Definition: data_archive.h:756
daal::data_management::interface1::InputDataArchive::getDataArchive
const DataArchive & getDataArchive()
Definition: data_archive.h:954
daal::data_management::interface1::CompressorImpl
Base class for the Compressor.
Definition: compression.h:251
daal::data_management::interface1::DataArchive
Implements the abstract DataArchiveIface interface.
Definition: data_archive.h:220
daal::data_management::interface1::DataBlock::setPtr
virtual void setPtr(byte *ptr) DAAL_C11_OVERRIDE
Definition: data_block.h:164
daal::services::interface1::SharedPtr
Shared pointer that retains shared ownership of an object through a pointer. Several SharedPtr object...
Definition: daal_shared_ptr.h:187
daal::data_management::interface1::OutputDataArchive::archiveHeader
void archiveHeader() const
Definition: data_archive.h:1029
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:918
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:530
daal::data_management::interface1::DataArchive::write
void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:306
daal::services::interface1::SharedPtr::get
T * get() const
Definition: daal_shared_ptr.h:332
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:497
daal::data_management::interface1::OutputDataArchive::getMajorVersion
int getMajorVersion() const
Definition: data_archive.h:1195
daal::data_management::interface1::OutputDataArchive
Provides methods to restore an object from its serialized counterpart and access the restored object...
Definition: data_archive.h:978
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:685
daal::data_management::interface1::DecompressedDataArchive::read
void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:638
daal::data_management::interface1::OutputDataArchive::archiveFooter
void archiveFooter() const
Definition: data_archive.h:1046
daal::data_management::interface1::CompressedDataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength) const DAAL_C11_OVERRIDE
Definition: data_archive.h:574
daal::data_management::interface1::DataArchive::DataArchive
DataArchive(const DataArchive &arch)
Definition: data_archive.h:245
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:173
daal::data_management::interface1::DecompressedDataArchive::write
void write(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:630
daal::data_management::interface1::CompressionStream
CompressionStream class compresses input raw data by blocks.
Definition: compression_stream.h:81
daal::services::daal_free
DAAL_EXPORT void daal_free(void *ptr)
daal::data_management::interface1::OutputDataArchive::setObj
void setObj(T *ptr, size_t size=1) const
Definition: data_archive.h:1114
daal::services::interface1::ServiceDeleter
Implementation of DeleterIface to destroy a pointer by the daal_free function.
Definition: daal_shared_ptr.h:110
daal::data_management::interface1::CompressedDataArchive::getArchiveAsString
std::string getArchiveAsString() DAAL_C11_OVERRIDE
Definition: data_archive.h:566
daal::data_management::interface1::OutputDataArchive::getMinorVersion
int getMinorVersion() const
Definition: data_archive.h:1204
daal::data_management::interface1::DecompressedDataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:643
daal::data_management::interface1::DecompressedDataArchive::DecompressedDataArchive
DecompressedDataArchive(daal::data_management::DecompressorImpl *decompressor)
Definition: data_archive.h:613
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:663
daal::services::interface1::Error::create
static SharedPtr< Error > create(ErrorID id)
daal::data_management::interface1::Factory::createObject
SerializationIface * createObject(int objectId)
daal::services::ErrorDataArchiveInternal
Definition: error_indexes.h:127
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:1013
daal::data_management::interface1::InputDataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength)
Definition: data_archive.h:943
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:1004
daal::data_management::interface1::CompressedDataArchive::getArchiveAsArray
byte * getArchiveAsArray() DAAL_C11_OVERRIDE
Definition: data_archive.h:537
daal::data_management::interface1::DecompressedDataArchive::getArchiveAsString
std::string getArchiveAsString() DAAL_C11_OVERRIDE
Definition: data_archive.h:677
daal::algorithms::math::abs::value
Definition: abs_types.h:112
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(DataArchiveIface *arch)
Definition: data_archive.h:995
daal::data_management::interface1::OutputDataArchive::segmentHeader
int segmentHeader() const
Definition: data_archive.h:1053
daal::data_management::interface1::InputDataArchive::segmentHeader
void segmentHeader(int tag=0)
Definition: data_archive.h:787
daal::data_management::interface1::DataArchiveIface::getMajorVersion
virtual int getMajorVersion()=0
daal::Base
Base class for Intel(R) Data Analytics Acceleration Library objects
Definition: base.h:65
daal::data_management::interface1::SerializationIface::deserializeImpl
virtual services::Status deserializeImpl(const interface1::OutputDataArchive *archive)=0
daal::data_management::interface1::DecompressorImpl
Base class for the Decompressor.
Definition: compression.h:277
daal::data_management::interface1::OutputDataArchive::getUpdateVersion
int getUpdateVersion() const
Definition: data_archive.h:1213
daal::data_management::interface1::DataArchive::getArchiveAsArray
byte * getArchiveAsArray() DAAL_C11_OVERRIDE
Definition: data_archive.h:369
daal::data_management::interface1::OutputDataArchive::OutputDataArchive
OutputDataArchive(InputDataArchive &arch)
Definition: data_archive.h:984
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:605
daal::data_management::interface1::CompressedDataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:532
daal::data_management::interface1::SerializationIface
Abstract interface class that defines the interface for serialization and deserialization.
Definition: data_serialize.h:76
daal::data_management::interface1::DataArchiveImpl::setUpdateVersion
void setUpdateVersion(int updateVersion) DAAL_C11_OVERRIDE
Definition: data_archive.h:190
daal::data_management::interface1::OutputDataArchive::getAsSharedPtr
services::SharedPtr< SerializationIface > getAsSharedPtr() const
Definition: data_archive.h:1176
daal::data_management::interface1::InputDataArchive::segmentFooter
void segmentFooter()
Definition: data_archive.h:795
daal::data_management::interface1::DecompressionStream
DecompressionStream class decompresses compressed input data by blocks.
Definition: compression_stream.h:170
daal::data_management::interface1::DataArchive::read
void read(byte *ptr, size_t size) DAAL_C11_OVERRIDE
Definition: data_archive.h:325
daal::data_management::interface1::DataArchiveImpl::getUpdateVersion
int getUpdateVersion() DAAL_C11_OVERRIDE
Definition: data_archive.h:205
daal::data_management::interface1::DataArchiveIface::copyArchiveToArray
virtual size_t copyArchiveToArray(byte *ptr, size_t maxLength) const =0
daal::data_management::interface1::OutputDataArchive::setSharedPtrObj
void setSharedPtrObj(services::SharedPtr< T > &obj) const
Definition: data_archive.h:1157
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive(DataArchiveIface *arch)
Definition: data_archive.h:732
daal::services::interface1::Collection
Class that implements functionality of the Collection container.
Definition: collection.h:69
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:109
daal::data_management::interface1::InputDataArchive::setObj
void setObj(T *ptr, size_t size=1)
Definition: data_archive.h:845
daal::data_management::interface1::DataArchiveImpl::setMajorVersion
void setMajorVersion(int majorVersion) DAAL_C11_OVERRIDE
Definition: data_archive.h:180

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