TableGroupKey.cc

#include "otsdaq/TableCore/TableGroupKey.h"
 
#include "otsdaq/Macros/CoutMacros.h"
 
#include <string.h>   //for strlen
#include <stdexcept>  //for runtime_error
 
using namespace ots;
 
const unsigned int TableGroupKey::INVALID = -1;
const unsigned int TableGroupKey::DEFAULT = 0;
 
//==============================================================================
TableGroupKey::TableGroupKey(unsigned int key) : key_(key) {}
 
//==============================================================================
TableGroupKey::TableGroupKey(char* const& groupString)
{
    if(!groupString)
    {
        key_ = TableGroupKey::INVALID;
        return;
    }
 
    // find last character that is not part of key
    //  key consists of numeric, dash, underscore, and period
    int i = strlen(groupString) - 1;
    for(; i >= 0; --i)
        if((groupString[i] < '0' || groupString[i] > '9') && groupString[i] != '-' &&
           groupString[i] != '_' && groupString[i] != '.')
            break;  // not part of key,... likely a 'v' if using "_v" syntax for version
 
    if(i == (int)strlen(groupString) - 1)  // no key characters found
    {
        key_ = TableGroupKey::DEFAULT;
        return;
    }
    else if(i < 0)  // only key characters found, so assume group key string was given
        i = 0;
    else
        ++i;
 
    // at this point, i is start of key sequence
    sscanf(&groupString[i], "%u", &key_);
}
 
//==============================================================================
TableGroupKey::TableGroupKey(const std::string& groupString)
    : TableGroupKey((char*)groupString.c_str())
{
}
 
//==============================================================================
TableGroupKey::~TableGroupKey(void) {}
 
//==============================================================================
unsigned int TableGroupKey::key(void) const { return key_; }
 
//==============================================================================
bool TableGroupKey::operator==(unsigned int key) const { return (key_ == key); }
bool TableGroupKey::operator==(const TableGroupKey& key) const
{
    return (key_ == key.key_);
}
 
//==============================================================================
TableGroupKey& TableGroupKey::operator*=(const unsigned int a)
{
    key_ *= a;
    return *this;
}
//==============================================================================
TableGroupKey& TableGroupKey::operator*=(const TableGroupKey a)
{
    key_ *= a.key_;
    return *this;
}
//==============================================================================
TableGroupKey& TableGroupKey::operator+=(const TableGroupKey a)
{
    key_ += a.key_;
    return *this;
}
//==============================================================================
TableGroupKey& TableGroupKey::operator-=(const TableGroupKey a)
{
    key_ -= a.key_;
    return *this;
}
//==============================================================================
TableGroupKey& TableGroupKey::operator/=(const TableGroupKey a)
{
    key_ /= a.key_;
    return *this;
}
 
//==============================================================================
std::string TableGroupKey::toString(void) const
{
    // represent invalid/temporary versions as negative number strings
    return (isInvalid()) ? std::to_string((int)key_) : std::to_string(key_);
}
 
//==============================================================================
TableGroupKey& TableGroupKey::operator=(const unsigned int key)
{
    key_ = key;
    return *this;
}
 
//==============================================================================
bool TableGroupKey::operator!=(unsigned int key) const { return (key_ != key); }
bool TableGroupKey::operator!=(const TableGroupKey& key) const
{
    return (key_ != key.key_);
}
 
//==============================================================================
bool TableGroupKey::operator<(const TableGroupKey& key) const
{
    return (key_ < key.key_);
}
 
//==============================================================================
bool TableGroupKey::operator>(const TableGroupKey& key) const
{
    return (key_ > key.key_);
}
 
//==============================================================================
bool TableGroupKey::isInvalid() const { return (key_ == INVALID); }
 
//==============================================================================
TableGroupKey TableGroupKey::getNextKey(const TableGroupKey& key)
{
    TableGroupKey retKey(key.key_ + 1);  // DEFAULT := INVALID + 1
    return retKey;  // if retKey is invalid, then INVALID is returned already
}
 
//==============================================================================
unsigned int TableGroupKey::getDefaultKey(void) { return DEFAULT; }
 
//==============================================================================
unsigned int TableGroupKey::getInvalidKey(void) { return INVALID; }
 
//==============================================================================
std::string TableGroupKey::getFullGroupString(const std::string&   groupName,
                                              const TableGroupKey& key,
                                              const std::string&   preKey /* = "_v" */,
                                              const std::string&   postKey /* = "" */)
{
    if(groupName.size() == 0)
    {
        __SS__
            << ("TableGroupKey::getFullGroupString() Illegal Group Name! The Group Name "
                "was not provided.\n");
        __COUT_ERR__ << ss.str();
        __SS_THROW__;
    }
    else if(groupName.size() == 1)
    {
        __SS__ << ("TableGroupKey::getFullGroupString() Illegal Group Name! The Group "
                   "Name is too short: \"" +
                   groupName + "\"")
               << std::endl;
        __COUT_ERR__ << ss.str();
        __SS_THROW__;
    }
    else
    {
        for(unsigned int i = 0; i < groupName.size(); ++i)
        {
            if(!(  // alphaNumeric
                   (groupName[i] >= 'A' && groupName[i] <= 'Z') ||
                   (groupName[i] >= 'a' && groupName[i] <= 'z') ||
                   (groupName[i] >= '0' && groupName[i] <= '9')))
            {
                __SS__ << ("TableGroupKey::getFullGroupString() Illegal Group Name! "
                           "Group Name must be alpha-numeric: \"" +
                           groupName + "\"")
                       << std::endl;
                __COUT_ERR__ << ss.str();
                __SS_THROW__;
            }
        }
    }
 
    return groupName + preKey + std::to_string(key.key_) + postKey;
}
 
//==============================================================================
void TableGroupKey::getGroupNameAndKey(const std::string& fullGroupString,
                                       std::string&       groupName,
                                       TableGroupKey&     key)
{
    auto i    = fullGroupString.rfind("_v");
    groupName = fullGroupString.substr(0, i);
    key       = TableGroupKey(fullGroupString.substr(i + 2));
}