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

{
    // 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()));
}

Referenced by ZlibDecodeFromBase64Str().

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

{
    // 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()));
}

Referenced by ZlibEncodeToBase64Str().

◆ GetBitSizeStr()

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

Definition at line 104 of file CompressData.cpp.

{
    return std::to_string(sizeof(void *) * 8);
}

◆ GetCompressString()

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

Return a string describing this compression and endianness

Definition at line 99 of file CompressData.cpp.

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

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

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

{
    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;
    }
}

References ASSERTL0, CHUNK, and Nektar::void.

Referenced by ZlibDecodeFromBase64Str().

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

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

References Base64StrToBinaryStr(), and ZlibDecode().

Referenced by Nektar::LibUtilities::FieldIOXml::ImportFieldData(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadCurves(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadEdges(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements1D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements2D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadElements3D(), Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadFaces(), and Nektar::SpatialDomains::MeshGraphXmlCompressed::v_ReadVertices().

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

{
    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;
}

References ASSERTL0, CHUNK, and Nektar::void.

Referenced by ZlibEncodeToBase64Str().

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

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

References BinaryStrToBase64Str(), and ZlibEncode().

Functions

Function Documentation

◆ Base64StrToBinaryStr()

◆ BinaryStrToBase64Str()

◆ GetBitSizeStr()

◆ GetCompressString()

◆ ZlibDecode()

◆ ZlibDecodeFromBase64Str()

◆ ZlibEncode()

◆ ZlibEncodeToBase64Str()