CoralUtilities Namespace Reference

Functions
bool	compressBlob (const char *, coral::Blob &)
bool	writeBlobFromString (const std::string_view, coral::Blob &)
bool	writeBlobFromJson (const nlohmann::json &, coral::Blob &)
bool	writeBlobFromTTree (TTree *, coral::Blob &)
bool	uncompressBlob (const coral::Blob &, std::unique_ptr< unsigned char[]> &, unsigned long &)
bool	readBlobAsString (const coral::Blob &, std::string &)
bool	readBlobAsJson (const coral::Blob &, nlohmann::json &)
bool	readBlobAsTTree (const coral::Blob &blob, std::unique_ptr< TTree > &tree, const std::string_view name="tree")
	Interprets the coral::Blob as a TTree instance. More...

Function Documentation

compressBlob()

bool CoralUtilities::compressBlob	(	const char *	in,
		coral::Blob &	out
	)

Definition at line 20 of file blobaccess.cxx.

                                                  {
    uLongf comprLen = compressBound(strlen(in));
    coral::Blob blob;
    blob.resize(comprLen);
    unsigned char* ptr = static_cast<unsigned char*>(blob.startingAddress());
    compress(ptr, &comprLen, reinterpret_cast<const unsigned char*>(in), strlen(in));
    blob.resize(comprLen);
    out = blob;
    return true;
}

readBlobAsJson()

bool CoralUtilities::readBlobAsJson	(	const coral::Blob &	blob,
		nlohmann::json &	out
	)

Definition at line 94 of file blobaccess.cxx.

                                                             {
    std::string str = "";
    if(!readBlobAsString(blob, str)) return false;
    try {
        out = nlohmann::json::parse(str);
    }
    catch(const std::exception& e) {
        std::cout << "ATTENTION: Cannot unpack Blob object as JSON!" << std::endl;
        return false;
    }
    return true;
}

readBlobAsString()

bool CoralUtilities::readBlobAsString	(	const coral::Blob &	blob,
		std::string &	out
	)

Definition at line 85 of file blobaccess.cxx.

                                                            {
    std::unique_ptr<unsigned char[]> bf {};
    uLongf len = 0;
    if(!uncompressBlob(blob, bf, len)) return false;
    const char* cstring = reinterpret_cast<const char*>(bf.get()); // need to cast to char*
    out.assign(cstring, len); // copy over to C++ string
    return true;
}

readBlobAsTTree()

bool CoralUtilities::readBlobAsTTree	(	const coral::Blob &	blob,
		std::unique_ptr< TTree > &	tree,
		const std::string_view	name = "tree"
	)

Interprets the coral::Blob as a TTree instance.

If the parsing was successful, the parsed tree pointer is assigned to an object and true is returned. Otherwise, the unique_ptr is set to nullptr with false

Parameters

blob	Coral database blob to interpret
tree	Reference to the unique_ptr to which the TTree is interpreted
name	Name of the TTree inside the memory blob

Definition at line 107 of file blobaccess.cxx.

                                               {
    const char* cstring = reinterpret_cast<const char*>(blob.startingAddress());
    std::string sb{};
    sb.assign(cstring, blob.size());
    std::vector<unsigned char> bdata = CxxUtils::base64_decode(sb);
    TMemFile f("buffer", reinterpret_cast<char*>(bdata.data()), bdata.size()); 
    TTree* t{nullptr};
    f.GetObject(name.data(), t);
    if(!t) {
        out.reset();
        return false;
    }
    t->LoadBaskets();
    t->SetDirectory(0);
    f.Close();
    out.reset(t);
    return true;
}

uncompressBlob()

bool CoralUtilities::uncompressBlob	(	const coral::Blob &	blob,
		std::unique_ptr< unsigned char[]> &	out,
		unsigned long &	len
	)

Definition at line 61 of file blobaccess.cxx.

                                                                                                    {
    uLongf uncompLen = 50000;
    std::unique_ptr<unsigned char[]> uncompBuf(new unsigned char[uncompLen+1]);
    uLongf actualLen{0};
    while(true) {
        actualLen = uncompLen;
        int res(uncompress(uncompBuf.get(), &actualLen, reinterpret_cast<const unsigned char*>(blob.startingAddress()), static_cast<uLongf>(blob.size())));
        if(res == Z_OK       ) break;
        if(res == Z_BUF_ERROR) { // double buffer if it was not big enough
            uncompLen *= 2;
            std::cout << "ATTENTION: Increasing buffer to " << uncompLen << std::endl;
            uncompBuf.reset(new unsigned char[uncompLen+1]);
            continue;
        }
        // something else is wrong
        uncompBuf.reset();
        return false;
    }
    uncompBuf.get()[actualLen]=0; // append 0 to terminate string
    out = std::move(uncompBuf);
    len = actualLen;
    return true;
}

writeBlobFromJson()

bool CoralUtilities::writeBlobFromJson	(	const nlohmann::json &	in,
		coral::Blob &	out
	)

Definition at line 35 of file blobaccess.cxx.

                                                               {
    return writeBlobFromString(in.dump(), out);
}

writeBlobFromString()

bool CoralUtilities::writeBlobFromString	(	const std::string_view	in,
		coral::Blob &	out
	)

Definition at line 31 of file blobaccess.cxx.

                                                                  {
    return compressBlob(in.data(), out);
}

writeBlobFromTTree()

bool CoralUtilities::writeBlobFromTTree	(	TTree *	tree,
		coral::Blob &	out
	)

Definition at line 39 of file blobaccess.cxx.

                                                     {
    TMemFile fout("buffer","recreate");
    fout.cd();
    tree->CloneTree(-1, "fast")->Write();
    fout.Write();
    uLongf comprLen = fout.GetSize();
    unsigned char *buffer = new unsigned char[comprLen];
    fout.CopyTo(buffer, comprLen);
    coral::Blob blob; 
    blob.resize(comprLen);
    char* ptr = reinterpret_cast<char*>(blob.startingAddress()); 
    *ptr = *const_cast<char*>(CxxUtils::base64_encode(buffer, comprLen).c_str());
    out = blob;
    return true;
}