EventImp.cc

Go to the documentation of this file.

// **************************************************************************
// **************************************************************************
#include "EventImp.h"

#include <sstream>

#include "Time.h"
#include "WindowLog.h"
#include "Description.h"

using namespace std;

// --------------------------------------------------------------------------
//
//
EventImp::EventImp(const EventImp &cmd) : fAllowedStates(cmd.fAllowedStates),
    fFunction(cmd.fFunction)
{
}

// --------------------------------------------------------------------------
//
//
void EventImp::AddAllowedState(int state)
{
    if (state>=0)
        fAllowedStates.push_back(state);
}

// --------------------------------------------------------------------------
//
//
void EventImp::AddAllowedStates(const string &states)
{
    stringstream stream(states);

    const bool sep = stream.str().find(',')==string::npos;

    string buffer;
    while (getline(stream, buffer, sep ? ' ' : ','))
        AddAllowedState(stoi(buffer));
}

// --------------------------------------------------------------------------
//
//
bool EventImp::IsStateAllowed(int state) const
{
    // States with negative values are internal states and are
    // never allowed
    // if (state<0)
    //    return false;

    // In case no allowed state is explicitly set
    // all positive states are allowed
    if (fAllowedStates.size()==0)
        return true;

    return find(fAllowedStates.begin(), fAllowedStates.end(), state)!=fAllowedStates.end();
}

// --------------------------------------------------------------------------
//
string EventImp::GetString() const
{
    size_t s = GetSize()-1;
    while (s>0 && GetText()[s]==0)
        s--;

    return std::string(GetText(), s+1);
}

// --------------------------------------------------------------------------
//
void EventImp::Print(ostream &out, bool strip) const
{
    if (GetDescription().empty())
        return;

    out << " -";

    const string str = GetName();
    if (!str.empty())
        out << kBold << str.substr(strip?str.find_first_of('/')+1:0) << kReset << "-";

    const string fmt = GetFormat();

    if (!str.empty() && !fmt.empty())
        out << " ";

    if (!fmt.empty())
        out << "[" << fmt << "]";

    vector<Description> v = Description::SplitDescription(GetDescription());

    if (!GetDescription().empty())
    {
        out << kBold;
        for (vector<Description>::const_iterator j=v.begin()+1;
             j!=v.end(); j++)
            out << " <" << j->name << ">";
        out << kReset;
    }

    for (unsigned int i=0; i<fAllowedStates.size(); i++)
        out << " " << fAllowedStates[i];

    const Time tm = GetTime();

    const bool t = tm!=Time::None && tm!=Time(1970,1,1);
    const bool s = GetSize()>0;

    if (s || t)
        out << "(";
    if (t)
        out << tm.GetAsStr("%H:%M:%S.%f");
    if (s && t)
        out << "/";
    if (s)
        out << "size=" << GetSize();
    if (s || t)
        out << ")";
    out << endl;

    if (GetDescription().empty())
    {
        out << endl;
        return;
    }

    out << "     " << v[0].comment << endl;

    for (vector<Description>::const_iterator j=v.begin()+1;
         j!=v.end(); j++)
    {
        out << "      ||" << kGreen << j->name;
        if (!j->comment.empty())
            out << kReset << ": " << kBlue << j->comment;
        if (!j->unit.empty())
            out << kYellow << " [" << j->unit << "]";
        out << endl;
    }
    out << endl;
}

// --------------------------------------------------------------------------
//
//
void EventImp::Print(bool strip) const
{
    Print(cout, strip);
}

string EventImp::GetTimeAsStr(const char *fmt) const
{
    return GetTime().GetAsStr(fmt);
}

uint64_t EventImp::GetJavaDate() const
{
    return GetTime().JavaDate();
}