cWidget::WithDataFunctions Class Reference

This class offers functions to parse DataSet and friends. It doesn't parse anything by itself, ProcessDataSet() has to be called by an inherited class. More...

#include <cWidgetBase.h>

Inheritance diagram for cWidget::WithDataFunctions:

[legend]

Collaboration diagram for cWidget::WithDataFunctions:

[legend]

List of all members.

Public Member Functions
bool	Process (tXmlParser::node cur)
	Process a node.
Protected Member Functions
tValue::Set	ProcessDataSet (tXmlParser::node cur)
	Processes a given DataSet tag and returns the resulting set.
Private Member Functions
tValue::Base *	ProcessValue (tXmlParser::node cur)
	Processes a Value node given as its parameter, parses it, and returns a tValue.
tValue::Base *	ProcessMath (tXmlParser::node cur)
	Processes a Math node given as its parameter and returns it.
tValue::Base *	ProcessConditionalCore (tXmlParser::node cur)
	Processes an IfTrue or IfFalse node and returns the resulting Value.
tValue::Base *	ProcessConditional (tXmlParser::node cur)
	Processes a Conditional node given as its parameter and returns it.
tValue::Base *	ProcessAtomicData (tXmlParser::node cur)
	Processes an AtomicData node and returns the result.
void	ProcessDataTags (tXmlParser::node cur, tValue::Base &data)
	Processes the precision="" attributes and friends for a given node and Value.
tValue::Base *	ProcessDataSource (tString const &data)
	Processes and returns a simple data source (like lvalue and rvalue).

---

Detailed Description

This class offers functions to parse DataSet and friends. It doesn't parse anything by itself, ProcessDataSet() has to be called by an inherited class.

Definition at line 115 of file cWidgetBase.h.

---

Member Function Documentation

tValue::Base * cWidget::WithDataFunctions::ProcessValue

(

tXmlParser::node

cur

)

[private]

Processes a Value node given as its parameter, parses it, and returns a tValue.

Definition at line 258 of file cWidgetBase.cpp.

References vValue::Parser::parse().

Referenced by ProcessConditionalCore(), and ProcessDataSet().

                                                              {
#ifndef WIN32
    return tValueParser::parse(cur.GetProp("expr"));
#else
    return 0;
#endif

Here is the call graph for this function:

Here is the caller graph for this function:

tValue::Base * cWidget::WithDataFunctions::ProcessMath

(

tXmlParser::node

cur

)

[private]

Processes a Math node given as its parameter and returns it.

Definition at line 139 of file cWidgetBase.cpp.

References Add, ProcessConditionalCore(), ProcessDataSource(), ProcessDataTags(), and tERR_WARN.

Referenced by ProcessConditionalCore(), and ProcessDataSet().

                                                             {
    tValue::BasePtr lvalue(ProcessDataSource(cur.GetProp("lvalue")));
    tValue::BasePtr rvalue(ProcessDataSource(cur.GetProp("rvalue")));

    for (tXmlParser::node child = cur.GetFirstChild(); child; ++child) {
        tString name = child.GetName();
        if(name == "RValue") {
            rvalue = tValue::BasePtr(ProcessConditionalCore(child));
        } else if(name == "LValue") {
            lvalue = tValue::BasePtr(ProcessConditionalCore(child));
        }
    }

    tValue::Base *val;
    if (cur.GetProp("type") == "sum")
        val = new tValue::Add(lvalue, rvalue);
    else
        if (cur.GetProp("type") == "difference")
            val = new tValue::Subtract(lvalue, rvalue);
        else
            if (cur.GetProp("type") == "product")
                val = new tValue::Multiply(lvalue, rvalue);
            else
                if (cur.GetProp("type") == "quotient")
                    val = new tValue::Divide(lvalue, rvalue);
                else
                {
                    tERR_WARN("Type '" + cur.GetProp("type") + "' unknown!");
                    val = new tValue::Add(lvalue, rvalue);
                }
    ProcessDataTags(cur, *val);
    return val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tValue::Base * cWidget::WithDataFunctions::ProcessConditionalCore

(

tXmlParser::node

cur

)

[private]

Processes an IfTrue or IfFalse node and returns the resulting Value.

Definition at line 232 of file cWidgetBase.cpp.

References ProcessAtomicData(), ProcessConditional(), ProcessMath(), ProcessValue(), and tERR_WARN.

Referenced by ProcessConditional(), and ProcessMath().

                                                                        {
    for (cur = cur.GetFirstChild(); cur; ++cur) {
        tString name = cur.GetName();
        if(name == "AtomicData") {
            return ProcessAtomicData(cur);
        }
        if(name == "Conditional") {
            return ProcessConditional(cur);
        }
        if(name == "Math") {
            return ProcessMath(cur);
        }
        else
            if (name == "Value")
                return ProcessValue(cur);
    }
    tERR_WARN("IfTrue or IfFalse node doesn't contain an AtomicData or Conditional node")
    return new tValue::Base();
}

Here is the call graph for this function:

Here is the caller graph for this function:

tValue::Base * cWidget::WithDataFunctions::ProcessConditional

(

tXmlParser::node

cur

)

[private]

Processes a Conditional node given as its parameter and returns it.

Definition at line 173 of file cWidgetBase.cpp.

References NULL, ProcessConditionalCore(), ProcessDataSource(), and tERR_WARN.

Referenced by ProcessConditionalCore(), and ProcessDataSet().

                                                                    {
    tValue::BasePtr lvalue(ProcessDataSource(cur.GetProp("lvalue")));
    tValue::BasePtr rvalue(ProcessDataSource(cur.GetProp("rvalue")));
    tValue::BasePtr truevalue(new tValue::Base), falsevalue(new tValue::Base);

    tString oper = cur.GetProp("operator");
    tValue::Base *condvalue = NULL;
    if (oper.size() == 2)
    {
        switch (oper[1]) {
    case 't': case 'T':
            switch (oper[0]) {
        case 'g': case 'G':
                condvalue = new tValue::GreaterThan    (lvalue, rvalue);
                break;
        case 'l': case 'L':
                condvalue = new tValue::   LessThan    (lvalue, rvalue);
                break;
            }
            break;
    case 'e': case 'E':
            switch (oper[0]) {
        case 'g': case 'G':
                condvalue = new tValue::GreaterOrEquals(lvalue, rvalue);
                break;
        case 'l': case 'L':
                condvalue = new tValue::   LessOrEquals(lvalue, rvalue);
                break;
        case 'n': case 'N':
                tValue::BasePtr precond(new tValue::Equals(lvalue, rvalue));
                condvalue = new tValue::Not(precond);
                break;
            }
            break;
    case 'q': case 'Q':
            if (oper[0] == 'e' || oper[0] == 'E')
                condvalue = new tValue::         Equals(lvalue, rvalue);
            break;
        }
    }
    if (!condvalue)
    {
        tERR_WARN("Operator '" + oper + "' unknown!");
        condvalue = new tValue::Equals(lvalue, rvalue);
    }
    tValue::BasePtr condvalueP(condvalue);

    for (cur = cur.GetFirstChild(); cur; ++cur) {
        tString name = cur.GetName();
        if(name == "IfTrue") {
            truevalue = tValue::BasePtr(ProcessConditionalCore(cur));
        } else if(name == "IfFalse") {
            falsevalue = tValue::BasePtr(ProcessConditionalCore(cur));
        }
    }

    return new tValue::Condition(condvalueP, truevalue, falsevalue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

tValue::Base * cWidget::WithDataFunctions::ProcessAtomicData

(

tXmlParser::node

cur

)

[private]

Processes an AtomicData node and returns the result.

Definition at line 252 of file cWidgetBase.cpp.

References ProcessDataSource(), and ProcessDataTags().

Referenced by ProcessConditionalCore(), and ProcessDataSet().

                                                                   {
    tValue::Base *ret = ProcessDataSource(cur.GetProp("source"));
    ProcessDataTags(cur, *ret);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cWidget::WithDataFunctions::ProcessDataTags	(	tXmlParser::node	cur,
		tValue::Base &	data
	)			[private]

Processes the precision="" attributes and friends for a given node and Value.

Definition at line 265 of file cWidgetBase.cpp.

References vValue::Expr::Core::Base::SetFill(), vValue::Expr::Core::Base::SetMinsize(), vValue::Expr::Core::Base::SetPrecision(), and tERR_WARN.

Referenced by ProcessAtomicData(), and ProcessMath().

                                                                            {
    int precision, minwidth;
    cur.GetProp("precision", precision);
    cur.GetProp("minwidth", minwidth);
    tString fill = cur.GetProp("fill");
    if(fill.size() != 1) {
        tERR_WARN("Attribute 'fill' has to have a length of 1!");
        fill = "!";
    }
    data.SetPrecision(precision);
    data.SetMinsize(minwidth);
    data.SetFill(fill(0));

Here is the call graph for this function:

Here is the caller graph for this function:

tValue::Base * cWidget::WithDataFunctions::ProcessDataSource

(

tString const &

data

)

[private]

Processes and returns a simple data source (like lvalue and rvalue).

Definition at line 279 of file cWidgetBase.cpp.

References tString::Convert(), cWidget::Base::m_Cockpit, stc_callbacks, stc_forbiddenCallbacks, and tString::ToLower().

Referenced by ProcessAtomicData(), ProcessConditional(), and ProcessMath().

                                                                    {
    //is it an integer?
    int val_int;
    if(data.Convert(val_int)) return new tValue::Int(val_int);
    //is it a float
    float val_float;
    if(data.Convert(val_float)) return new tValue::Float(val_float);

    //is it one of the dynamic callbacks?
    std::map<tString, tValue::Callback<cCockpit>::cb_ptr>::const_iterator iter;
    if((iter = stc_callbacks.find(data.ToLower())) != stc_callbacks.end()) {
        if(stc_forbiddenCallbacks.count(data.ToLower())) return new tValue::Base();
        return new tValue::Callback<cCockpit>(iter->second, m_Cockpit);
    }

    //growing desperate... is this a configuration value maybe?
    tValue::ConfItem *item = new tValue::ConfItem(data);
    if(item->Good())
        return item;
    delete item;

    //Ok, giving up... this has to be a string then.
    return new tValue::String(data);

Here is the call graph for this function:

Here is the caller graph for this function:

tValue::Set cWidget::WithDataFunctions::ProcessDataSet

(

tXmlParser::node

cur

)

[protected]

Processes a given DataSet tag and returns the resulting set.

Parameters:

cur

the node to be parsed as DataSet

Returns:

the resulting data set

Definition at line 97 of file cWidgetBase.cpp.

References ProcessAtomicData(), ProcessConditional(), ProcessMath(), and ProcessValue().

Referenced by cWidget::WithIdData::Process(), and cWidget::WithSingleData::Process().

                                                              {
    tValue::BasePtr
    value(new tValue::Base()),
    minimum(new tValue::Base()),
    maximum(new tValue::Base());
    for (cur = cur.GetFirstChild(); cur; ++cur) {
        tValue::Base *newvalue = 0;
        tString name = cur.GetName();
        if(name == "AtomicData") {
            newvalue = ProcessAtomicData(cur);
        } else if(name == "Conditional") {
            newvalue = ProcessConditional(cur);
        } else if(name == "Math") {
            newvalue = ProcessMath(cur);
        }
        else
            if (name == "Value")
                newvalue = ProcessValue(cur);
        if(newvalue != 0) {
            tString field = cur.GetProp("field");
            if(field == "source") {
                value = tValue::BasePtr(newvalue);
            } else if(field=="minimum") {
                minimum = tValue::BasePtr(newvalue);
            } else if(field=="maximum") {
                maximum = tValue::BasePtr(newvalue);
            }
        }
    }
    // TODO:
    /*
    return tValue::Set(
               value.release(),
               minimum.release(),
               maximum.release());
    */
    return tValue::Set(
               value,
               minimum,
               maximum);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool cWidget::WithDataFunctions::Process

(

tXmlParser::node

cur

)

[virtual]

Process a node.

This needs to be overwritten if the derived class has anyting to parse or can be derived from.

It should try to parse the given node, return true on success or return the result of the Process() function of the widget it's derived from if it fails.

Parameters:

cur

the node that's being attempted to parse

Returns:

true on success, false on failure

Reimplemented from cWidget::Base.

Reimplemented in cWidget::BarGauge, cWidget::Label, cWidget::Rectangle, cWidget::WithSingleData, cWidget::WithIdData, and cWidget::WithTable.

Definition at line 91 of file cWidgetBase.cpp.

References cWidget::Base::Process().

Referenced by cWidget::WithIdData::Process(), and cWidget::WithSingleData::Process().

                                                  {
    return Base::Process(cur);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• src/tron/cockpit/cWidgetBase.h
• src/tron/cockpit/cWidgetBase.cpp

---