TableVersion.cc

#include "otsdaq/TableCore/TableVersion.h"
 
using namespace ots;
 
const unsigned int TableVersion::INVALID = -1;
const unsigned int TableVersion::DEFAULT = 0;
const unsigned int TableVersion::SCRATCH = ~(1 << 31);  // highest positive integer
 
//==============================================================================
TableVersion::TableVersion(unsigned int version) : version_(version) {}
TableVersion::TableVersion(char* const& versionStr)
{
    if(!versionStr)
        version_ = TableVersion::INVALID;
    else
        sscanf(versionStr, "%u", &version_);
}
TableVersion::TableVersion(const std::string& versionStr)
    : TableVersion((char*)versionStr.c_str())
{
}
 
//==============================================================================
TableVersion::~TableVersion(void) {}
 
//==============================================================================
unsigned int TableVersion::version(void) const { return version_; }
 
//==============================================================================
std::string TableVersion::toString(void) const
{
    // represent invalid/temporary versions as negative number strings
    return (isTemporaryVersion() || isInvalid()) ? std::to_string((int)version_)
                                                 : std::to_string(version_);
}
 
//==============================================================================
TableVersion& TableVersion::operator=(const unsigned int version)
{
    version_ = version;
    return *this;
}
 
//==============================================================================
TableVersion& TableVersion::operator*=(const unsigned int a)
{
    version_ *= a;
    return *this;
}
//==============================================================================
TableVersion& TableVersion::operator*=(const TableVersion a)
{
    version_ *= a.version_;
    return *this;
}
//==============================================================================
TableVersion& TableVersion::operator+=(const TableVersion a)
{
    version_ += a.version_;
    return *this;
}
//==============================================================================
TableVersion& TableVersion::operator-=(const TableVersion a)
{
    version_ -= a.version_;
    return *this;
}
//==============================================================================
TableVersion& TableVersion::operator/=(const TableVersion a)
{
    version_ /= a.version_;
    return *this;
}
 
//==============================================================================
bool TableVersion::operator==(unsigned int version) const
{
    return (version_ == version);
}
bool TableVersion::operator==(const TableVersion& version) const
{
    return (version_ == version.version_);
}
 
//==============================================================================
bool TableVersion::operator!=(unsigned int version) const
{
    return (version_ != version);
}
bool TableVersion::operator!=(const TableVersion& version) const
{
    return (version_ != version.version_);
}
 
//==============================================================================
bool TableVersion::operator<(const TableVersion& version) const
{
    return (version_ < version.version_);
}
 
//==============================================================================
bool TableVersion::operator>(const TableVersion& version) const
{
    return (version_ > version.version_);
}
 
//==============================================================================
bool TableVersion::isInvalid() const
{
    return (version_ == TableVersion::INVALID ||
            (version_ > TableVersion::SCRATCH &&
             version_ < INVALID - NUM_OF_TEMP_VERSIONS));  // unused reserved block
}
 
//==============================================================================
bool TableVersion::isTemporaryVersion() const
{
    return (version_ >= INVALID - NUM_OF_TEMP_VERSIONS && version_ != INVALID);
}
 
//==============================================================================
bool TableVersion::isScratchVersion() const
{
    return (version_ == TableVersion::SCRATCH);
}
 
//==============================================================================
bool TableVersion::isMockupVersion() const { return (version_ == TableVersion::INVALID); }
 
//==============================================================================
TableVersion TableVersion::getNextVersion(const TableVersion& version)
{
    TableVersion retVersion(version.version_ + 1);  // DEFAULT := INVALID + 1
    return (!retVersion.isInvalid() && !retVersion.isTemporaryVersion()) ? retVersion
                                                                         : TableVersion();
}
 
//==============================================================================
TableVersion TableVersion::getNextTemporaryVersion(const TableVersion& version)
{
    TableVersion retVersion(version.isTemporaryVersion() ? (version.version_ - 1)
                                                         : (INVALID - 1));
    return retVersion.isTemporaryVersion() ? retVersion : TableVersion();
}