sysio::trace_api::compressed_file_impl Struct Reference

Collaboration diagram for sysio::trace_api::compressed_file_impl:

Public Member Functions
	~compressed_file_impl ()
void	read (char *d, size_t n, fc::cfile &file)
void	seek (long loc, fc::cfile &file)

Public Attributes
z_stream	strm
std::vector< uint8_t >	compressed_buffer = std::vector<uint8_t>(compressed_buffer_size)
std::vector< uint8_t >	read_buffer = std::vector<uint8_t>(read_buffer_size)
size_t	remaining_read_buffer = 0
bool	initialized = false
size_t	file_size = 0

Static Public Attributes
static constexpr size_t	read_buffer_size = 4*1024
static constexpr size_t	compressed_buffer_size = 4*1024

Detailed Description

Definition at line 22 of file compressed_file.cpp.

Constructor & Destructor Documentation

~compressed_file_impl()

sysio::trace_api::compressed_file_impl::~compressed_file_impl ( )

inline

Definition at line 26 of file compressed_file.cpp.

   {
      if (initialized) {
         inflateEnd(&strm);
         initialized = false;
      }
   }

Member Function Documentation

read()

void sysio::trace_api::compressed_file_impl::read ( char * d, size_t n, fc::cfile & file )

inline

Definition at line 34 of file compressed_file.cpp.

   {
      if (!initialized) {
         if (Z_OK != inflateInit2(&strm, raw_zlib_window_bits)) {
            throw std::runtime_error("failed to initialize decompression");
         }
 
         remaining_read_buffer = 0;
         strm.avail_in = 0;
         initialized = true;
      }
 
      size_t written = 0;
 
      // consume the left over from the last read if there is any
      if (remaining_read_buffer > 0) {
         auto to_read = std::min(remaining_read_buffer, n);
         std::memcpy(d, read_buffer.data(), to_read );
         remaining_read_buffer -= to_read;
         written += to_read;
 
         if ( remaining_read_buffer > 0 ) {
            std::memmove(read_buffer.data(), read_buffer.data() + to_read, remaining_read_buffer);
            return;
         }
      }
 
 
      // decompress more chunks
      while (written < n) {
         if ( strm.avail_in == 0 ) {
            size_t remaining = file_size - file.tellp();
            size_t to_read = std::min((size_t)compressed_buffer.size(), remaining);
            file.read(reinterpret_cast<char*>(compressed_buffer.data()), to_read);
            strm.avail_in = to_read;
            strm.next_in = compressed_buffer.data();
         }
 
         do {
            strm.avail_out = read_buffer.size();
            strm.next_out = read_buffer.data();
            auto ret = inflate(&strm, Z_NO_FLUSH);
 
            if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR) {
               throw compressed_file_error("Error decompressing: " + std::string(strm.msg));
            }
 
 
 
            auto bytes_decompressed = read_buffer.size() - strm.avail_out;
            if (bytes_decompressed > 0) {
               auto to_copy = std::min(bytes_decompressed, n - written);
               std::memcpy(d + written, read_buffer.data(), to_copy);
               written += to_copy;
 
               if (bytes_decompressed > to_copy) {
                  // move remaining to the front of the buffer
                  std::memmove(read_buffer.data(), read_buffer.data() + to_copy, bytes_decompressed - to_copy);
                  remaining_read_buffer = bytes_decompressed - to_copy;
               }
            }
 
            if (written < n && ret == Z_STREAM_END) {
               throw std::ios_base::failure("Attempting to read past the end of a compressed file");
            }
 
            if (ret == Z_BUF_ERROR) {
               // need more input
               if (strm.avail_in != 0) {
                  throw compressed_file_error("Error decompressing cannot continue processing input");
               }
               break;
            }
 
         } while (strm.avail_out == 0 && written < n);
      }
   }

Here is the caller graph for this function:

seek()

void sysio::trace_api::compressed_file_impl::seek ( long loc, fc::cfile & file )

inline

Definition at line 112 of file compressed_file.cpp.

                                        {
      if (initialized) {
         inflateEnd(&strm);
         initialized = false;
      }
 
      long remaining = loc;
 
      // read in the seek point map
      file.seek_end(-expected_seek_point_count_size);
      seek_point_count_type seek_point_count = 0;
      file.read(reinterpret_cast<char*>(&seek_point_count), sizeof(seek_point_count));
 
      if (seek_point_count > 0) {
         int seek_map_size = sizeof(seek_point_entry) * seek_point_count;
         file.seek_end(-expected_seek_point_count_size - seek_map_size);
 
         std::vector<seek_point_entry> seek_point_map(seek_point_count);
         file.read(reinterpret_cast<char*>(seek_point_map.data()), seek_point_map.size() * sizeof(seek_point_entry));
 
         // seek to the neareast seek point
         auto iter = std::lower_bound(seek_point_map.begin(), seek_point_map.end(), (uint64_t)loc, []( const auto& lhs, const auto& rhs ){
            return std::get<0>(lhs) < rhs;
         });
 
         // special case when there is a seek point that is exact
         if ( iter != seek_point_map.end() && std::get<0>(*iter) == loc ) {
            file.seek(std::get<1>(*iter));
            return;
         }
 
         // special case when this is before the first seek point
         if ( iter == seek_point_map.begin() ) {
            file.seek(0);
         } else {
            // if lower bound wasn't exact iter will be one past the seek point we need
            const auto& seek_pt = *(iter - 1);
            file.seek(std::get<1>(seek_pt));
            remaining -= std::get<0>(seek_pt);
         }
      } else {
         file.seek(0);
      }
 
      // read up to the expected offset
      if (remaining > 0) {
         auto pre_read_buffer = std::vector<char>(remaining);
         read(pre_read_buffer.data(), pre_read_buffer.size(), file);
      }
   }

Here is the call graph for this function:

Member Data Documentation

compressed_buffer

std::vector<uint8_t> sysio::trace_api::compressed_file_impl::compressed_buffer = std::vector<uint8_t>(compressed_buffer_size)

Definition at line 164 of file compressed_file.cpp.

compressed_buffer_size

size_t sysio::trace_api::compressed_file_impl::compressed_buffer_size = 4*1024

staticconstexpr

Definition at line 24 of file compressed_file.cpp.

file_size

size_t sysio::trace_api::compressed_file_impl::file_size = 0

Definition at line 168 of file compressed_file.cpp.

initialized

bool sysio::trace_api::compressed_file_impl::initialized = false

Definition at line 167 of file compressed_file.cpp.

read_buffer

std::vector<uint8_t> sysio::trace_api::compressed_file_impl::read_buffer = std::vector<uint8_t>(read_buffer_size)

Definition at line 165 of file compressed_file.cpp.

read_buffer_size

size_t sysio::trace_api::compressed_file_impl::read_buffer_size = 4*1024

staticconstexpr

Definition at line 23 of file compressed_file.cpp.

remaining_read_buffer

size_t sysio::trace_api::compressed_file_impl::remaining_read_buffer = 0

Definition at line 166 of file compressed_file.cpp.

strm

z_stream sysio::trace_api::compressed_file_impl::strm

Definition at line 163 of file compressed_file.cpp.

---

The documentation for this struct was generated from the following file:

• plugins/trace_api_plugin/compressed_file.cpp