In This Package:

ContextRange.cc

Go to the documentation of this file.

// 
//
// ContextRange
//
// ContextRange is delimits/identifies the allowed "context" values
// associated with the associated DBI returned information
//
// Author:  N. Tagg March 2007,
// Adopted from VldRange by R. Hatcher 2000.05.03
//

#include "Context/ContextRange.h"
#include <cassert>
#include <cctype>
#include <string>
#include <algorithm>
#include <cstdio>

//_____________________________________________________________________________
ContextRange::ContextRange()
    : mSiteMask(0)
    , mSimMask(0)
    , mTimeStart(0,0)
    , mTimeEnd(0,0)
{
    // Default constructor
}

//_____________________________________________________________________________
ContextRange::ContextRange(const int siteMask, const int simMask, 
                           const TimeStamp &tstart,
                           const TimeStamp &tend)
                         
    : mSiteMask(siteMask), mSimMask(simMask), 
      mTimeStart(tstart), mTimeEnd(tend)
{
    // normal constructor
}

//_____________________________________________________________________________
ContextRange::~ContextRange()
{
    // delete all the owned sub-objects

}

//_____________________________________________________________________________
std::string ContextRange::AsString(const char* option) const
{
    // Return the ContextRange as a string
    //
    // Result is a pointer to a statically allocated string.
    // User should copy this into their own buffer before calling
    // this method again.
    //
    // option "a": give site/simflag masks as alpha chars
    // option "c": compact (single line)
    // option "s": drop nsec part of times

    std::string opt = option;
    std::transform(opt.begin(),opt.end(),opt.begin(),::tolower);

    bool opt_a = (opt.find("a") != std::string::npos);
    bool opt_c = (opt.find("c") != std::string::npos);
    bool opt_s = (opt.find("s") != std::string::npos);

    static std::string out;
    out="|";

    if (opt_a) 
        out += Site::StringFromMask(mSiteMask);
    else {
        out += "site ";
        char buffer[1024] = {0};
        snprintf(buffer,1024,"%#4.4x",mSiteMask);
        out += buffer;
    }

    out += "|";
   
    if (opt_a) 
        out += SimFlag::StringFromMask(mSimMask);
    else {
        out += "sim ";
        char buffer[1024] = {0};
        snprintf(buffer,1024,"%#4.4x",mSiteMask);
        out += buffer;
    }

    // TimeStamp::AsString returns pointer to statically allocated string
    // one needs to copy this before calling it again in same function call
    static char timeopt[4] = "c  ";
    timeopt[0] = (opt_s ? 's' : 'c');
    if(opt_c)    out += "|";
    else         out += "\n\t";

    out += mTimeStart.AsString(timeopt);

    if(opt_c)    out += "|";
    else         out += "\n\t";

    out += mTimeEnd.AsString(timeopt);
   
    return out;
}

//_____________________________________________________________________________
bool ContextRange::IsCompatible(const Context &cx) const
{
    // compare Context with this ContextRange to see if the
    // the tagged set is compatible

    int site     = (int)cx.GetSite();
    int simflag  = (int)cx.GetSimFlag();

    // account for case where both Context and ContextRange
    // are using "kUnknown" which has no bits set
    if ( ! (site & mSiteMask) &&
         (site      != Site::kUnknown || 
          mSiteMask != Site::kUnknown    ) ) return false;
    if ( ! (simflag  & mSimMask) &&
         (simflag  != SimFlag::kUnknown || 
          mSimMask != SimFlag::kUnknown   ) ) return false;

    // the start time is taken as inclusive, but the end time is exclusive

    if ( cx.GetTimeStamp() <  mTimeStart ) return false;
    if ( cx.GetTimeStamp() >= mTimeEnd   ) return false;

    return true;
}

//_____________________________________________________________________________
bool ContextRange::IsCompatible(const Context *cx) const
{
    // compare Context with this ContextRange to see if the
    // the tagged set is compatible
    assert(cx);
    return IsCompatible(*cx);
}


//_____________________________________________________________________________
void ContextRange::TrimTo(const ContextRange& cx)
{
    // Trim this range to the intersection (ie. more restricted)
    // limits of it's initial value and that of the argument

    mSiteMask &= cx.mSiteMask;
    mSimMask      &= cx.mSimMask;
    if (mTimeStart < cx.mTimeStart) mTimeStart = cx.mTimeStart;
    if (mTimeEnd   > cx.mTimeEnd  ) mTimeEnd   = cx.mTimeEnd;
}

//_____________________________________________________________________________
bool operator==(const ContextRange &lhs, const ContextRange &rhs)
{ return lhs.mTimeStart  == rhs.mTimeStart; }

bool operator!=(const ContextRange &lhs, const ContextRange &rhs)
{ return lhs.mTimeStart  != rhs.mTimeStart; }

bool operator<(const ContextRange &lhs, const ContextRange &rhs)
{ return lhs.mTimeStart  < rhs.mTimeStart; }

bool operator<=(const ContextRange &lhs, const ContextRange &rhs)
{ return lhs.mTimeStart  < rhs.mTimeStart; }

bool operator>(const ContextRange &lhs, const ContextRange &rhs)
{ return lhs.mTimeStart  > rhs.mTimeStart; }

bool operator>=(const ContextRange &lhs, const ContextRange &rhs)
{ return lhs.mTimeStart  > rhs.mTimeStart; }

---