#include <Archive.h>

Inheritance diagram for Archive:

Collaboration diagram for Archive:

Public Member Functions
	Archive (const std::string url, const bool plain_text)

virtual	~Archive ()

virtual std::string	archive_error (int err)

virtual bool	read_next_header ()

virtual bool	read_data_block (const void *buff, size_t size, int64_t *offset)

virtual int64_t	get_position_compressed () const

virtual int	open ()

virtual int	close ()

virtual ptrdiff_t	read (const void **buff)

virtual void	init_for_read ()

const std::string	url_part (const int i)

std::string	entryName ()

Static Public Member Functions
static ptrdiff_t	read (struct archive a, void client_data, const void **buff)

static int	open (struct archive a, void client_data)

static int	close (struct archive a, void client_data)

static void	parse_url (const std::string url, std::map< int, std::string > &url_parts)

Protected Attributes
std::string	url

std::map< int, std::string >	url_parts

archive *	ar = 0

archive_entry *	entry

bool	plain_text

Detailed Description

Definition at line 32 of file Archive.h.

Constructor & Destructor Documentation

Archive::Archive	(	const std::string	url,
		const bool	plain_text
	)

inline

! LIBARCHIVE_ENABLE_ALL may trigger exception "detect_column_types error: libarchive error: Missing type keyword in mtree specification" ! on ridiculously simple raw data

Definition at line 34 of file Archive.h.

References ar, parse_url(), and url_parts.

       : url(url), plain_text(plain_text) {
     parse_url(url, url_parts);
 
     if (0 == (ar = archive_read_new())) {
       throw std::runtime_error(std::string("archive_read_new failed!"));
     }
 
 //#define LIBARCHIVE_ENABLE_ALL
 #ifdef LIBARCHIVE_ENABLE_ALL
     // this increases ~800kb code size
     archive_read_support_format_all(ar);
     archive_read_support_filter_all(ar);
     archive_read_support_format_raw(ar);
 #else
     // list supported formats to bypass the mtree exception
     archive_read_support_format_ar(ar);
     archive_read_support_format_cpio(ar);
     archive_read_support_format_empty(ar);
     archive_read_support_format_lha(ar);
     archive_read_support_format_tar(ar);
     archive_read_support_format_xar(ar);
     archive_read_support_format_7zip(ar);
     archive_read_support_format_cab(ar);
     archive_read_support_format_rar(ar);
     archive_read_support_format_iso9660(ar);
     archive_read_support_format_zip(ar);
 
     archive_read_support_filter_bzip2(ar);
     archive_read_support_filter_compress(ar);
     archive_read_support_filter_gzip(ar);
     archive_read_support_filter_lzip(ar);
     archive_read_support_filter_lzma(ar);
     archive_read_support_filter_xz(ar);
     archive_read_support_filter_uu(ar);
     archive_read_support_filter_rpm(ar);
     archive_read_support_filter_lrzip(ar);
     archive_read_support_filter_lzop(ar);
     archive_read_support_filter_grzip(ar);
 #endif
     // libarchive assumes archive formats, so without this bzip2 and gzip won't work!
     // see related issue at https://github.com/libarchive/libarchive/issues/586
     archive_read_support_format_raw(ar);
   }

Here is the call graph for this function:

virtual Archive::~Archive ( )

inlinevirtual

Definition at line 83 of file Archive.h.

References ar.

                      {
     if (ar) {
       archive_read_close(ar);
     }
     if (ar) {
       archive_read_free(ar);
     }
     ar = 0;
   }

Member Function Documentation

virtual std::string Archive::archive_error ( int err )

inlinevirtual

Definition at line 93 of file Archive.h.

References ar, and to_string().

Referenced by read_data_block(), and read_next_header().

                                            {
     auto cstr = archive_error_string(ar);
     return std::string("libarchive error: ") +
            (cstr ? std::string(cstr) : std::to_string(err));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual int Archive::close ( )

inlinevirtual

Definition at line 139 of file Archive.h.

Referenced by heavydb.connection.Connection::__del__(), heavydb.cursor.Cursor::__exit__(), heavydb.connection.Connection::__exit__(), and init_for_read().

                       {
     return ARCHIVE_OK;
   }  // nop

Here is the caller graph for this function:

static int Archive::close	(	struct archive *	a,
		void *	client_data
	)

inlinestatic

Definition at line 160 of file Archive.h.

Referenced by heavydb.connection.Connection::__del__(), heavydb.cursor.Cursor::__exit__(), and heavydb.connection.Connection::__exit__().

                                                          {
     return ((Archive*)client_data)->close();
   }

Here is the caller graph for this function:

std::string Archive::entryName ( )

inline

Definition at line 197 of file Archive.h.

References entry.

                         {
     return std::string(archive_entry_pathname(entry));
   }

virtual int64_t Archive::get_position_compressed ( ) const

inlinevirtual

Definition at line 121 of file Archive.h.

References ar.

Referenced by PosixFileArchive::read_data_block().

                                                   {
     return archive_filter_bytes(ar, -1);
   }

Here is the caller graph for this function:

virtual void Archive::init_for_read ( )

inlinevirtual

Reimplemented in S3Archive, and PosixFileArchive.

Definition at line 146 of file Archive.h.

References ar, close(), open(), and read().

                                {
     // set libarchive callbacks
     archive_read_open(ar, this, Archive::open, Archive::read, Archive::close);
   }

Here is the call graph for this function:

virtual int Archive::open ( )

inlinevirtual

Definition at line 136 of file Archive.h.

Referenced by init_for_read().

                      {
     return ARCHIVE_OK;
   }  // nop

Here is the caller graph for this function:

static int Archive::open	(	struct archive *	a,
		void *	client_data
	)

inlinestatic

Definition at line 156 of file Archive.h.

                                                         {
     return ((Archive*)client_data)->open();
   }

static void Archive::parse_url	(	const std::string	url,
		std::map< int, std::string > &	url_parts
	)

inlinestatic

Definition at line 164 of file Archive.h.

Referenced by Archive(), and import_export::DataStreamSink::import_compressed().

                                                                                 {
     /*
       input example: http://localhost.com/path\?hue\=br\#cool
       output should be:
                     0: http://localhost.com/path?hue=br#cool
                     1: http:
                     2: http
                     3: //localhost.com
                     4: localhost.com
                     5: /path
                     6: ?hue=br
                     7: hue=br
                     8: #cool
                     9: cool
      */
     std::smatch sm;
     std::regex url_regex(R"(^(([^:\/?#]+):)?(//([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?)",
                          std::regex::extended);
     if (!std::regex_match(url, sm, url_regex)) {
       throw std::runtime_error(std::string("malformed url: ") + url);
     }
 
     // sm is only an iterator over local 'url'
     // so have to copy out matched parts
     for (size_t i = 0; i < sm.size(); i++) {
       url_parts[i] = sm[i].str();
     }
   }

Here is the caller graph for this function:

virtual ptrdiff_t Archive::read ( const void ** buff )

inlinevirtual

Definition at line 142 of file Archive.h.

Referenced by init_for_read().

                                             {
     return 0;
   }  // nop

Here is the caller graph for this function:

static ptrdiff_t Archive::read	(	struct archive *	a,
		void *	client_data,
		const void **	buff
	)

inlinestatic

Definition at line 152 of file Archive.h.

                                                                                  {
     return ((Archive*)client_data)->read(buff);
   }

virtual bool Archive::read_data_block	(	const void **	buff,
		size_t *	size,
		int64_t *	offset
	)

inlinevirtual

Reimplemented in PosixFileArchive.

Definition at line 110 of file Archive.h.

References ar, and archive_error().

Referenced by PosixFileArchive::read_data_block().

                                                                                  {
     int rc;
     switch (rc = archive_read_data_block(ar, buff, size, offset)) {
       case ARCHIVE_EOF:
         return false;  // signal caller end of stream
       case ARCHIVE_OK:
         return true;
     }
     throw std::runtime_error(archive_error(rc));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual bool Archive::read_next_header ( )

inlinevirtual

Reimplemented in PosixFileArchive.

Definition at line 99 of file Archive.h.

References ar, archive_error(), and entry.

Referenced by PosixFileArchive::read_next_header().

                                   {
     int rc;
     switch (rc = archive_read_next_header(ar, &entry)) {
       case ARCHIVE_EOF:
         return false;  // signal caller end of stream
       case ARCHIVE_OK:
         return true;
     }
     throw std::runtime_error(archive_error(rc));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

const std::string Archive::url_part ( const int i )

inline

Definition at line 193 of file Archive.h.

References url_parts.

Referenced by PosixFileArchive::init_for_read(), and PosixFileArchive::PosixFileArchive().

                                         {
     return url_parts[i];
   }

Here is the caller graph for this function:

Member Data Documentation

archive* Archive::ar = 0

protected

Definition at line 204 of file Archive.h.

Referenced by Archive(), archive_error(), get_position_compressed(), PosixFileArchive::init_for_read(), init_for_read(), read_data_block(), read_next_header(), and ~Archive().

archive_entry* Archive::entry

protected

Definition at line 205 of file Archive.h.

Referenced by entryName(), and read_next_header().

bool Archive::plain_text

protected

Definition at line 206 of file Archive.h.

Referenced by PosixFileArchive::init_for_read(), PosixFileArchive::read_data_block(), and PosixFileArchive::read_next_header().

std::string Archive::url

protected

Definition at line 202 of file Archive.h.

std::map<int, std::string> Archive::url_parts

protected

Definition at line 203 of file Archive.h.

Referenced by Archive(), and url_part().

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

/home/jenkins-slave/workspace/core-os-doxygen/Archive/Archive.h

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation