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

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 129 of file CompressData.cpp.

Referenced by 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()));
         }

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 102 of file CompressData.cpp.

Referenced by 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';
             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()));
         }

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

Definition at line 94 of file CompressData.cpp.

Referenced by Nektar::LibUtilities::MeshPartition::OutputPartition(), Nektar::LibUtilities::FieldIOXml::v_Write(), Nektar::Utilities::OutputNekpp::WriteXmlCurves(), Nektar::Utilities::OutputNekpp::WriteXmlEdges(), Nektar::Utilities::OutputNekpp::WriteXmlElements(), Nektar::Utilities::OutputNekpp::WriteXmlFaces(), and Nektar::Utilities::OutputNekpp::WriteXmlNodes().

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

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

Return a string describing this compression and endianness

Definition at line 89 of file CompressData.cpp.

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

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

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 168 of file CompressData.h.

References ASSERTL0, CHUNK, 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 = 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;     /* and fall 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 = output.size() * sizeof(*output.c_str())
                                                  / sizeof(T);
                 out.assign( readFieldData, readFieldData + len);
                 return Z_OK;
             }
             else
             {
                 return Z_DATA_ERROR;
             }
         }

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 243 of file CompressData.h.

References Base64StrToBinaryStr(), and ZlibDecode().

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

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 91 of file CompressData.h.

References ASSERTL0, CHUNK, 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 = 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;
         }

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 151 of file CompressData.h.

References BinaryStrToBase64Str(), and ZlibEncode().

Referenced by Nektar::LibUtilities::MeshPartition::OutputPartition(), Nektar::LibUtilities::FieldIOXml::v_Write(), Nektar::Utilities::OutputNekpp::WriteXmlCurves(), Nektar::Utilities::OutputNekpp::WriteXmlEdges(), Nektar::Utilities::OutputNekpp::WriteXmlElements(), Nektar::Utilities::OutputNekpp::WriteXmlFaces(), and Nektar::Utilities::OutputNekpp::WriteXmlNodes().

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

Functions

Function Documentation