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

data_archive.h
1 /* file: data_archive.h */
2 /*******************************************************************************
3 * Copyright 2014-2017 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 
730  InputDataArchive(daal::data_management::CompressorImpl *compressor) : _finalized(false),
731  _errors(new services::ErrorCollection())
732  {
733  _arch = new CompressedDataArchive(compressor);
734  archiveHeader();
735  }
736 
737  ~InputDataArchive()
738  {
739  delete _arch;
740  }
741 
745  void archiveHeader()
746  {
747  int headerValues[8] =
748  {
749  0x4441414C,
750  __INTEL_DAAL__,
751  __INTEL_DAAL_MINOR__,
752  __INTEL_DAAL_UPDATE__,
753  0, 0, 0, 0
754  };
755 
756  _arch->setMajorVersion (headerValues[1]);
757  _arch->setMinorVersion (headerValues[2]);
758  _arch->setUpdateVersion(headerValues[3]);
759  for(size_t i = 0; i < 8; i++)
760  {
761  _arch->write( (byte *)&headerValues[i], sizeof(int) );
762  }
763  }
764 
768  void archiveFooter()
769  {
770  _finalized = true;
771  }
772 
776  void segmentHeader( int tag = 0 )
777  {
778  _arch->write( (byte *)&tag, sizeof(int) );
779  }
780 
784  void segmentFooter()
785  {
786  }
787 
793  template<typename T>
794  void set(T &val)
795  {
796  _arch->write( (byte *)&val, sizeof(T) );
797  }
798 
804  template<typename T>
805  void set(daal::services::Collection<T> &val)
806  {
807  size_t size = val.size();
808  _arch->write( (byte *)&size, sizeof(size_t) );
809  for(size_t i = 0; i < size; i++)
810  {
811  _arch->write( (byte *) & (val[i]), sizeof(T) );
812  }
813  }
814 
821  template<typename T>
822  void set(T *ptr, size_t size)
823  {
824  _arch->write( (byte *)ptr, size * sizeof(T) );
825  }
826 
833  template<typename T>
834  void setObj(T *ptr, size_t size = 1)
835  {
836  for( size_t i = 0; i < size; i++ )
837  {
838  ptr[i].serializeImpl( this );
839  }
840  }
841 
846  void setSingleObj(SerializationIface **ptr)
847  {
848  int isNull = (*ptr == 0);
849  set(isNull);
850 
851  if(!isNull)
852  {
853  (*ptr)->serialize( *this );
854  }
855  }
856 
861  template<typename T>
862  void setSharedPtrObj(services::SharedPtr<T> &obj)
863  {
864  data_management::SerializationIface *ptr = obj.get();
865  setSingleObj(&ptr);
866  }
867 
872  services::SharedPtr<byte> getArchiveAsArraySharedPtr()
873  {
874  if(!_finalized) { archiveFooter(); }
875  return _arch->getArchiveAsArraySharedPtr();
876  }
877 
883  DAAL_DEPRECATED byte *getArchiveAsArray()
884  {
885  if(!_finalized) { archiveFooter(); }
886  return _arch->getArchiveAsArray();
887  }
888 
895  DAAL_DEPRECATED void getArchiveAsArray( const byte **ptr, size_t *size )
896  {
897  if(!_finalized) { archiveFooter(); }
898 
899  *ptr = (byte *)_arch->getArchiveAsArray();
900  *size = _arch->getSizeOfArchive();
901  }
902 
907  size_t getSizeOfArchive()
908  {
909  if(!_finalized) { archiveFooter(); }
910 
911  return _arch->getSizeOfArchive();
912  }
913 
919  DAAL_DEPRECATED std::string getArchiveAsString()
920  {
921  if(!_finalized) { archiveFooter(); }
922 
923  return _arch->getArchiveAsString();
924  }
925 
932  size_t copyArchiveToArray( byte *ptr, size_t maxLength )
933  {
934  if(!_finalized) { archiveFooter(); }
935 
936  return _arch->copyArchiveToArray( ptr, maxLength );
937  }
938 
943  const DataArchive &getDataArchive()
944  {
945  return *static_cast<DataArchive *>(_arch);
946  }
947 
952  services::SharedPtr<services::ErrorCollection> getErrors()
953  {
954  return _errors;
955  }
956 
957 protected:
958  DataArchiveIface *_arch;
959  bool _finalized;
960  services::SharedPtr<services::ErrorCollection> _errors;
961 };
962 
967 class OutputDataArchive : public Base
968 {
969 public:
973  OutputDataArchive( InputDataArchive &arch ) : _errors(new services::ErrorCollection())
974  {
975  _arch = new DataArchive(arch.getDataArchive());
976  archiveHeader();
977  }
978 
982  OutputDataArchive( byte *ptr, size_t size ) : _errors(new services::ErrorCollection())
983  {
984  _arch = new DataArchive(ptr, size);
985  archiveHeader();
986  }
987 
991  OutputDataArchive( daal::data_management::DecompressorImpl *decompressor, byte *ptr, size_t size ) :
992  _errors(new services::ErrorCollection())
993  {
994  _arch = new DecompressedDataArchive(decompressor);
995  _arch->write(ptr, size);
996  archiveHeader();
997  }
998 
999  ~OutputDataArchive()
1000  {
1001  delete _arch;
1002  }
1003 
1007  void archiveHeader() const
1008  {
1009  int headerValues[8];
1010 
1011  for(size_t i = 0; i < 8; i++)
1012  {
1013  _arch->read( (byte *)&headerValues[i], sizeof(int) );
1014  }
1015 
1016  _arch->setMajorVersion (headerValues[1]);
1017  _arch->setMinorVersion (headerValues[2]);
1018  _arch->setUpdateVersion(headerValues[3]);
1019  }
1020 
1024  void archiveFooter() const
1025  {
1026  }
1027 
1031  int segmentHeader() const
1032  {
1033  int tag = 0;
1034  _arch->read( (byte *)&tag, sizeof(int) );
1035  return tag;
1036  }
1037 
1041  void segmentFooter() const {}
1042 
1048  template<typename T>
1049  void set(T &val) const
1050  {
1051  _arch->read( (byte *)&val, sizeof(T) );
1052  }
1053 
1059  template<typename T>
1060  void set(daal::services::Collection<T> &val) const
1061  {
1062  size_t size = 0;
1063  _arch->read( (byte *)&size, sizeof(size_t) );
1064  val.clear();
1065  for(size_t i = 0; i < size; i++)
1066  {
1067  T v;
1068  _arch->read( (byte *)&v, sizeof(T) );
1069  val.push_back(v);
1070  }
1071  }
1072 
1079  template<typename T>
1080  void set(T *ptr, size_t size) const
1081  {
1082  _arch->read( (byte *)ptr, size * sizeof(T) );
1083  }
1084 
1091  template<typename T>
1092  void setObj(T *ptr, size_t size = 1) const
1093  {
1094  for( size_t i = 0; i < size; i++ )
1095  {
1096  ptr[i].deserializeImpl( this );
1097  }
1098  }
1099 
1104  void setSingleObj(SerializationIface **ptr) const
1105  {
1106  int isNull = 0;
1107  set(isNull);
1108 
1109  if(isNull)
1110  {
1111  *ptr = 0;
1112  return;
1113  }
1114 
1115  const int serTag = segmentHeader();
1116 
1117  *ptr = Factory::instance().createObject(serTag);
1118  if(!*ptr)
1119  {
1120  this->_errors->add(services::Error::create(
1121  services::ErrorObjectDoesNotSupportSerialization, services::SerializationTag, serTag));
1122  return;
1123  }
1124 
1125  (*ptr)->deserializeImpl( this );
1126 
1127  segmentFooter();
1128  }
1129 
1134  template<typename T>
1135  void setSharedPtrObj(services::SharedPtr<T> &obj) const
1136  {
1137  data_management::SerializationIface *ptr;
1138  setSingleObj(&ptr);
1139  if(this->_errors->size() != 0) { return; }
1140  if(ptr)
1141  {
1142  obj = services::SharedPtr<T>(static_cast<T *>(ptr));
1143  }
1144  else
1145  {
1146  obj = services::SharedPtr<T>();
1147  }
1148  }
1149 
1154  services::SharedPtr<SerializationIface> getAsSharedPtr() const
1155  {
1156  const int serTag = segmentHeader();
1157  services::SharedPtr<SerializationIface> ptr(Factory::instance().createObject(serTag));
1158  if(!ptr)
1159  {
1160  this->_errors->add(services::Error::create(
1161  services::ErrorObjectDoesNotSupportSerialization, services::SerializationTag, serTag));
1162  return services::SharedPtr<SerializationIface>();
1163  }
1164  ptr->deserializeImpl( this );
1165  segmentFooter();
1166  return ptr;
1167  }
1168 
1173  int getMajorVersion() const
1174  {
1175  return _arch->getMajorVersion();
1176  }
1177 
1182  int getMinorVersion() const
1183  {
1184  return _arch->getMinorVersion();
1185  }
1186 
1191  int getUpdateVersion() const
1192  {
1193  return _arch->getUpdateVersion();
1194  }
1195 
1200  services::SharedPtr<services::ErrorCollection> getErrors()
1201  {
1202  return _errors;
1203  }
1204 
1205 protected:
1206  DataArchiveIface *_arch;
1207  services::SharedPtr<services::ErrorCollection> _errors;
1208 };
1211 } // namespace interface1
1212 using interface1::DataArchiveIface;
1213 using interface1::DataArchive;
1214 using interface1::CompressedDataArchive;
1215 using interface1::DecompressedDataArchive;
1216 using interface1::InputDataArchive;
1217 using interface1::OutputDataArchive;
1218 
1219 }
1220 }
1221 
1222 #endif
daal::data_management::interface1::DataArchive::getSizeOfArchive
size_t getSizeOfArchive() const DAAL_C11_OVERRIDE
Definition: data_archive.h:344
daal::data_management::interface1::InputDataArchive::getArchiveAsString
DAAL_DEPRECATED std::string getArchiveAsString()
Definition: data_archive.h:919
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive(daal::data_management::CompressorImpl *compressor)
Definition: data_archive.h:730
daal::data_management::interface1::InputDataArchive::InputDataArchive
InputDataArchive()
Definition: data_archive.h:721
daal::data_management::interface1::InputDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:952
daal::data_management::interface1::InputDataArchive::archiveFooter
void archiveFooter()
Definition: data_archive.h:768
daal::data_management::interface1::OutputDataArchive::getErrors
services::SharedPtr< services::ErrorCollection > getErrors()
Definition: data_archive.h:1200
daal::data_management::interface1::InputDataArchive::set
void set(daal::services::Collection< T > &val)
Definition: data_archive.h:805
daal::data_management::interface1::InputDataArchive::setSharedPtrObj
void setSharedPtrObj(services::SharedPtr< T > &obj)
Definition: data_archive.h:862
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::getArchiveAsArray
DAAL_DEPRECATED byte * getArchiveAsArray()
Definition: data_archive.h:883
daal::data_management::interface1::InputDataArchive::setSingleObj
void setSingleObj(SerializationIface **ptr)
Definition: data_archive.h:846
daal::data_management::interface1::OutputDataArchive::set
void set(daal::services::Collection< T > &val) const
Definition: data_archive.h:1060
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::set
void set(T *ptr, size_t size) const
Definition: data_archive.h:1080
daal::services::ErrorObjectDoesNotSupportSerialization
Definition: error_indexes.h:411
daal::data_management::interface1::OutputDataArchive::getAsSharedPtr
services::SharedPtr< SerializationIface > getAsSharedPtr() const
Definition: data_archive.h:1154
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::OutputDataArchive::getUpdateVersion
int getUpdateVersion() const
Definition: data_archive.h:1191
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::OutputDataArchive::setSharedPtrObj
void setSharedPtrObj(services::SharedPtr< T > &obj) const
Definition: data_archive.h:1135
daal::data_management::interface1::OutputDataArchive::segmentHeader
int segmentHeader() const
Definition: data_archive.h:1031
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::OutputDataArchive::archiveFooter
void archiveFooter() const
Definition: data_archive.h:1024
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:872
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::OutputDataArchive::setObj
void setObj(T *ptr, size_t size=1) const
Definition: data_archive.h:1092
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::InputDataArchive::set
void set(T *ptr, size_t size)
Definition: data_archive.h:822
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:745
daal::data_management::interface1::OutputDataArchive::segmentFooter
void segmentFooter() const
Definition: data_archive.h:1041
daal::data_management::interface1::InputDataArchive::getDataArchive
const DataArchive & getDataArchive()
Definition: data_archive.h:943
daal::data_management::interface1::DataArchive
Implements the abstract DataArchiveIface interface.
Definition: data_archive.h:220
daal::data_management::interface1::InputDataArchive::set
void set(T &val)
Definition: data_archive.h:794
daal::data_management::interface1::DataBlock::setPtr
virtual void setPtr(byte *ptr) DAAL_C11_OVERRIDE
Definition: data_block.h:164
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:907
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::data_management::interface1::OutputDataArchive::getMinorVersion
int getMinorVersion() const
Definition: data_archive.h:1182
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::set
void set(T &val) const
Definition: data_archive.h:1049
daal::data_management::interface1::OutputDataArchive
Provides methods to restore an object from its serialized counterpart and access the restored object...
Definition: data_archive.h:967
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::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::OutputDataArchive::setSingleObj
void setSingleObj(SerializationIface **ptr) const
Definition: data_archive.h:1104
daal::data_management::interface1::OutputDataArchive::getMajorVersion
int getMajorVersion() const
Definition: data_archive.h:1173
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::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:566
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::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:991
daal::data_management::interface1::InputDataArchive::copyArchiveToArray
size_t copyArchiveToArray(byte *ptr, size_t maxLength)
Definition: data_archive.h:932
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:982
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::InputDataArchive::segmentHeader
void segmentHeader(int tag=0)
Definition: data_archive.h:776
daal::data_management::interface1::DataArchiveIface::getMajorVersion
virtual int getMajorVersion()=0
daal::algorithms::implicit_als::training::offset
Definition: implicit_als_training_types.h:174
daal::Base
Base class for Intel(R) Data Analytics Acceleration Library objects
Definition: base.h:65
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:973
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::InputDataArchive::segmentFooter
void segmentFooter()
Definition: data_archive.h:784
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::archiveHeader
void archiveHeader() const
Definition: data_archive.h:1007
daal::data_management::interface1::InputDataArchive::getArchiveAsArray
DAAL_DEPRECATED void getArchiveAsArray(const byte **ptr, size_t *size)
Definition: data_archive.h:895
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:834
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.