Functions
std::string	GetCompressString (void)

std::string	GetBitSizeStr (void)

void	BinaryStrToBase64Str (std::string &compressedDataString, std::string &base64string)

void	Base64StrToBinaryStr (std::string &base64string, std::string &compressedDataString)

template<class T >
int	ZlibEncode (std::vector< T > &in, std::string &out)

template<class T >
int	ZlibEncodeToBase64Str (std::vector< T > &in, std::string &out64)

template<class T >
int	ZlibDecode (std::string &in, std::vector< T > &out)

template<class T >
int	ZlibDecodeFromBase64Str (std::string &in64, std::vector< T > &out)

Function Documentation

◆ Base64StrToBinaryStr()

void Nektar::LibUtilities::CompressData::Base64StrToBinaryStr	(	std::string &	base64string,
		std::string &	compressedDataString
	)

Convert a Base 64 string into a binary string

Convert a string containing base 64 (i.e. from xml file) into a binary string

Definition at line 138 of file CompressData.cpp.

Referenced by ZlibDecode(), and ZlibDecodeFromBase64Str().

         {
             // Convert from base64 to binary.
             typedef boost::archive::iterators::transform_width<
                 boost::archive::iterators::binary_from_base64<
                     std::string::const_iterator>, 8, 6 > binary_t;
             compressedDataString = std::string(binary_t(base64string.begin()),
                                                binary_t(base64string.end()));
         }

◆ BinaryStrToBase64Str()

void Nektar::LibUtilities::CompressData::BinaryStrToBase64Str	(	std::string &	compressedDataString,
		std::string &	base64string
	)

Convert a binary string to Base 64 string

Convert a string containing compressed binary (i.e. from deflate) into a base 64 string

Definition at line 110 of file CompressData.cpp.

Referenced by ZlibEncode(), and ZlibEncodeToBase64Str().

         {
             // If the string length is not divisible by 3,
             // pad it. There is a bug in transform_width
             // that will make it reference past the end
             // and crash.
             switch (compressedDataString.length() % 3)
             {
             case 1:
                 compressedDataString += '\0';
                 /* Falls through. */
             case 2:
                 compressedDataString += '\0';
                 break;
             }
 
             // Convert from binary to base64.
             typedef boost::archive::iterators::base64_from_binary<
                 boost::archive::iterators::transform_width<
                     std::string::const_iterator, 6, 8> > base64_t;
             base64string = std::string(base64_t(compressedDataString.begin()),
                                        base64_t(compressedDataString.end()));
         }

◆ GetBitSizeStr()

std::string Nektar::LibUtilities::CompressData::GetBitSizeStr ( void )

Definition at line 102 of file CompressData.cpp.

         {
             return boost::lexical_cast<std::string>(sizeof(void*)*8);
         }

◆ GetCompressString()

std::string Nektar::LibUtilities::CompressData::GetCompressString ( void )

Return a string describing this compression and endianness

Definition at line 97 of file CompressData.cpp.

References Nektar::LibUtilities::Endianness(), and Nektar::LibUtilities::EndianTypeMap.

         {
             return  "B64Z-"+ EndianTypeMap[Endianness()];
         }

◆ ZlibDecode()

template<class T >

int Nektar::LibUtilities::CompressData::ZlibDecode	(	std::string &	in,
		std::vector< T > &	out
	)

Decompress a zlib-compressed string into a vector of NekDouble values.

Definition at line 155 of file CompressData.h.

References ASSERTL0, Base64StrToBinaryStr(), CHUNK, LIB_UTILITIES_EXPORT, and Nektar::void.

Referenced by ZlibDecodeFromBase64Str().

         {
             int ret;
             unsigned have;
             z_stream strm;
             std::string buffer;
             buffer.resize(CHUNK);
             std::string output;
 
             strm.zalloc = Z_NULL;
             strm.zfree = Z_NULL;
             strm.opaque = Z_NULL;
             strm.avail_in = 0;
             strm.next_in = Z_NULL;
             ret = inflateInit(&strm);
             ASSERTL0(ret == Z_OK, "Error initializing zlib decompression.");
 
             strm.avail_in = (unsigned int)in.size();
             strm.next_in = (unsigned char*)(&in[0]);
 
             do {
                 strm.avail_out = CHUNK;
                 strm.next_out = (unsigned char*)(&buffer[0]);
 
                 ret = inflate(&strm, Z_NO_FLUSH);
 
                 ASSERTL0(ret != Z_STREAM_ERROR, "Stream error occured.");
 
                 switch (ret) {
                     case Z_NEED_DICT:
                         ret = Z_DATA_ERROR;
                         /* Falls through. */
                     case Z_DATA_ERROR:
                     case Z_MEM_ERROR:
                         (void)inflateEnd(&strm);
                         return ret;
                 }
 
                 have = CHUNK - strm.avail_out;
                 output += buffer.substr(0, have);
 
             } while (strm.avail_out == 0);
 
             (void)inflateEnd(&strm);
 
             if (ret == Z_STREAM_END)
             {
                 T* readFieldData = (T*) output.c_str();
                 unsigned int len = (unsigned int)output.size() * sizeof(*output.c_str())
                                                  / sizeof(T);
                 out.assign( readFieldData, readFieldData + len);
                 return Z_OK;
             }
             else
             {
                 return Z_DATA_ERROR;
             }
         }

◆ ZlibDecodeFromBase64Str()

template<class T >

int Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str	(	std::string &	in64,
		std::vector< T > &	out
	)

Decompress a base 64 compressed binary string into a vector of NekDouble values.

Definition at line 231 of file CompressData.h.

References Base64StrToBinaryStr(), and ZlibDecode().

Referenced by Nektar::LibUtilities::FieldIOXml::ImportFieldData(), Nektar::SpatialDomains::MeshGraphXmlCompressed::ReadCurves(), Nektar::SpatialDomains::MeshGraphXmlCompressed::ReadEdges(), Nektar::SpatialDomains::MeshGraphXmlCompressed::ReadElements1D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::ReadElements2D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::ReadElements3D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::ReadFaces(), and Nektar::SpatialDomains::MeshGraphXmlCompressed::ReadVertices().

         {
             std::string in;
             Base64StrToBinaryStr(in64,in);
 
             return ZlibDecode(in,out);
         }

◆ ZlibEncode()

template<class T >

int Nektar::LibUtilities::CompressData::ZlibEncode	(	std::vector< T > &	in,
		std::string &	out
	)

Compress a vector of NekDouble values into a string using zlib.

Definition at line 78 of file CompressData.h.

References ASSERTL0, BinaryStrToBase64Str(), CHUNK, LIB_UTILITIES_EXPORT, and Nektar::void.

Referenced by ZlibEncodeToBase64Str().

         {
             int ret;
             unsigned have;
             std::string buffer;
             buffer.resize(CHUNK);
             z_stream strm;
             unsigned char* input = (unsigned char*)(&in[0]);
 
             /* allocate deflate state */
             strm.zalloc = Z_NULL;
             strm.zfree  = Z_NULL;
             strm.opaque = Z_NULL;
             ret = deflateInit(&strm, Z_DEFAULT_COMPRESSION);
 
             ASSERTL0(ret == Z_OK, "Error initializing Zlib.");
 
             strm.avail_in = (unsigned int)in.size() * sizeof(T) / sizeof(char);
             strm.next_in = input;
 
             // Deflate input until output buffer is no longer full.
             do {
                 strm.avail_out = CHUNK;
                 strm.next_out = (unsigned char*)(&buffer[0]);
 
                 ret = deflate(&strm, Z_FINISH);
 
                 // Deflate can return Z_OK, Z_STREAM_ERROR, Z_BUF_ERROR or
                 // Z_STREAM_END. All, except Z_STREAM_ERROR are ok.
                 ASSERTL0(ret != Z_STREAM_ERROR, "Zlib stream error");
 
                 have = CHUNK - strm.avail_out;
                 out += buffer.substr(0, have);
 
             } while (strm.avail_out == 0);
 
             // Check all input was processed.
             ASSERTL0(strm.avail_in == 0, "Not all input was used.");
 
             // Check stream is complete.
             ASSERTL0(ret == Z_STREAM_END, "Stream not finished");
 
             // Clean-up and return
             (void)deflateEnd(&strm);
             return Z_OK;
         }

◆ ZlibEncodeToBase64Str()

template<class T >

int Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str	(	std::vector< T > &	in,
		std::string &	out64
	)

Compress a vector of NekDouble values into a base64 string.

Definition at line 138 of file CompressData.h.

References BinaryStrToBase64Str(), and ZlibEncode().

         {
             std::string out;
 
             int ok = ZlibEncode(in,out);
 
             BinaryStrToBase64Str(out,out64);
 
             return ok;
         }

Functions

Function Documentation

◆ Base64StrToBinaryStr()

◆ BinaryStrToBase64Str()

◆ GetBitSizeStr()

◆ GetCompressString()

◆ ZlibDecode()

◆ ZlibDecodeFromBase64Str()

◆ ZlibEncode()

◆ ZlibEncodeToBase64Str()