inet::MessageChecker Class Reference

#include <MessageChecker.h>

Inheritance diagram for inet::MessageChecker:

Public Member Functions
	MessageChecker ()

Protected Member Functions
void	initialize () override
void	handleMessage (cMessage *msg) override
void	checkMessage (cMessage *msg)
void	forwardMessage (cMessage *msg)
void	finish () override
void	checkFields (any_ptr object, cClassDescriptor *descriptor, const cXMLElementList &msgPattern) const
void	checkFieldValue (any_ptr object, cClassDescriptor *descriptor, int field, cXMLAttributeMap &attr, int i=0) const
void	checkFieldObject (any_ptr object, cClassDescriptor *descriptor, int field, cXMLAttributeMap &attr, const cXMLElement &pattern, int i=0) const
int	checkFieldArray (any_ptr object, cClassDescriptor *descriptor, int field, cXMLAttributeMap &attr) const
void	checkFieldValueInArray (any_ptr object, cClassDescriptor *descriptor, int field, cXMLAttributeMap &attr) const
void	checkFieldObjectInArray (any_ptr object, cClassDescriptor *descriptor, int field, cXMLAttributeMap &attr, const cXMLElement &pattern) const
void	checkFieldType (any_ptr object, cClassDescriptor *descriptor, int field, cXMLAttributeMap &attrList, int i=0) const
int	findFieldIndex (any_ptr object, cClassDescriptor *descriptor, const std::string &fieldName) const

Protected Attributes
cXMLElementList	m_checkingInfo
cXMLElementList::iterator	m_iterChk
unsigned	forwardedMsg
unsigned	checkedMsg

Constructor & Destructor Documentation

MessageChecker()

inet::MessageChecker::MessageChecker

(

)

    : forwardedMsg(0)
    , checkedMsg(0)
{
}

Member Function Documentation

checkFieldArray()

int inet::MessageChecker::checkFieldArray ( any_ptr  object, cClassDescriptor *  descriptor, int  field, cXMLAttributeMap &  attr  ) const

protected

{
    if (!descriptor->getFieldIsArray(field))
        throw cRuntimeError("The field \"%s\" in message %d isn't an array", attr["name"].data(), forwardedMsg);
 
    // check the size of the field array into the client object
    int size = atol(attr["size"].data());
    int fieldSize = descriptor->getFieldArraySize(object, field);
    if (size != fieldSize)
        throw cRuntimeError("Field array \"%s\" contains %d element(s) (and not %d) in message %d",
                attr["name"].data(), fieldSize, size, forwardedMsg);
 
    return fieldSize;
}

Referenced by checkFieldObjectInArray(), checkFields(), and checkFieldValueInArray().

checkFieldObject()

void inet::MessageChecker::checkFieldObject ( any_ptr  object, cClassDescriptor *  descriptor, int  field, cXMLAttributeMap &  attr, const cXMLElement &  pattern, int  i = 0  ) const

protected

{
    // get the client object associated to the field
    any_ptr obj = descriptor->getFieldStructValuePointer(object, field, i);
 
    // get the client object associated to the field, and its descriptor class
    cClassDescriptor *descr = descriptor->getFieldIsCObject(field) ?
        cClassDescriptor::getDescriptorFor(fromAnyPtr<cObject>(obj)) :
        cClassDescriptor::getDescriptorFor(descriptor->getFieldStructName(field));
 
    checkFields(obj, descr, pattern.getChildren());
}

Referenced by checkFieldObjectInArray(), and checkFields().

checkFieldObjectInArray()

void inet::MessageChecker::checkFieldObjectInArray ( any_ptr  object, cClassDescriptor *  descriptor, int  field, cXMLAttributeMap &  attr, const cXMLElement &  pattern  ) const

protected

{
    int fieldSize = checkFieldArray(object, descriptor, field, attr);
 
    // convert attribute "index" into integer
    int i = atol(attr["index"].data());
 
    if (i >= fieldSize)
        throw cRuntimeError("Field \"%s\" in message %d has no entry for index %d", attr["name"].data(), forwardedMsg, i);
 
    // check field object into the client object
    checkFieldObject(object, descriptor, field, attr, pattern, i);
}

Referenced by checkFields().

checkFields()

void inet::MessageChecker::checkFields ( any_ptr  object, cClassDescriptor *  descriptor, const cXMLElementList &  msgPattern  ) const

protected

{
    // fldPatternList contains the list of fields to be inspected
    cXMLElementList::const_iterator iter = msgPattern.begin();
    while (iter != msgPattern.end()) {
        const cXMLElement& pattern = **iter;
        cXMLAttributeMap attr = pattern.getAttributes();
        std::string patternType(pattern.getTagName());
 
        // find field position into the client object
        int field = findFieldIndex(object, descriptor, attr["name"]);
 
        // check the field type into the client object (if requiered)
        if (containsKey(attr, "type"))
            checkFieldType(object, descriptor, field, attr);
 
        if (patternType == "fieldValue")
            checkFieldValue(object, descriptor, field, attr);
        else if (patternType == "fieldObject")
            checkFieldObject(object, descriptor, field, attr, pattern);
        else if (patternType == "fieldArray")
            checkFieldArray(object, descriptor, field, attr);
        else if (patternType == "fieldValueInArray")
            checkFieldValueInArray(object, descriptor, field, attr);
        else if (patternType == "fieldObjectInArray")
            checkFieldObjectInArray(object, descriptor, field, attr, pattern);
 
        iter++;
    }
}

Referenced by checkFieldObject(), and checkMessage().

checkFieldType()

void inet::MessageChecker::checkFieldType ( any_ptr  object, cClassDescriptor *  descriptor, int  field, cXMLAttributeMap &  attrList, int  i = 0  ) const

protected

{
    std::string type;
 
    if (descriptor->getFieldIsCObject(field))
        type = fromAnyPtr<cObject>(descriptor->getFieldStructValuePointer(object, field, i))->getClassName();
    else
        type = descriptor->getFieldTypeString(field);
 
    if (type != attr["type"])
        throw cRuntimeError("Type mismatch for field \"%s\" in message %d (\"%s\" != \"%s\")",
                attr["name"].data(), forwardedMsg, type.data(), attr["type"].data());
}

Referenced by checkFields().

checkFieldValue()

void inet::MessageChecker::checkFieldValue ( any_ptr  object, cClassDescriptor *  descriptor, int  field, cXMLAttributeMap &  attr, int  i = 0  ) const

protected

{
    // get the field string value from the client object
    std::string value = descriptor->getFieldValueAsString(object, field, i);
 
    // convert the field value into its name of enum value
    if (descriptor->getFieldProperty(field, "enum")) {
        cEnum *enm = cEnum::find(descriptor->getFieldProperty(field, "enum"));
        if (enm)
            value = enm->getStringFor(atol(value.c_str()));
    }
 
    // check field value into the client object
    if (value.find(attr["value"]) != 0) // allow to keep reference values even if
                                        // simtime precision changed...
        throw cRuntimeError("Mismatch: field \"%s\" in the message %d (\"%s\" != \"%s\")",
                attr["name"].data(), forwardedMsg, value.data(), attr["value"].data());
}

Referenced by checkFields(), and checkFieldValueInArray().

checkFieldValueInArray()

void inet::MessageChecker::checkFieldValueInArray ( any_ptr  object, cClassDescriptor *  descriptor, int  field, cXMLAttributeMap &  attr  ) const

protected

{
    int fieldSize = checkFieldArray(object, descriptor, field, attr);
 
    // convert attribute "index" into integer
    int i = atol(attr["index"].data());
 
    if (i >= fieldSize)
        throw cRuntimeError("Field \"%s\" in message %d has no entry for index %d", attr["name"].data(), forwardedMsg, i);
 
    // check field value into the client object
    checkFieldValue(object, descriptor, field, attr, i);
}

Referenced by checkFields().

checkMessage()

void inet::MessageChecker::checkMessage ( cMessage *  msg )

protected

{
    while (m_iterChk != m_checkingInfo.end()) {
        cXMLElement& messagePattern = **m_iterChk;
 
        if (std::string(messagePattern.getTagName()) == "message" && messagePattern.hasAttributes()) {
            int occurence = atol(messagePattern.getAttribute("occurence"));
            if (occurence > 0) {
                if (messagePattern.hasChildren())
                    checkFields(toAnyPtr(msg), msg->getDescriptor(), messagePattern.getChildren());
 
                occurence--;
                std::ostringstream occur_str;
                occur_str << occurence;
                messagePattern.setAttribute("occurence", occur_str.str().data());
                checkedMsg++;
            }
            if (occurence == 0)
                m_iterChk++;
            break;
        }
        else
            m_iterChk++;
    }
}

Referenced by handleMessage().

findFieldIndex()

int inet::MessageChecker::findFieldIndex ( any_ptr  object, cClassDescriptor *  descriptor, const std::string &  fieldName  ) const

protected

{
    std::ostringstream availableFields;
    for (int i = 0; i < descriptor->getFieldCount(); i++) {
        availableFields << descriptor->getFieldName(i) << ", ";
        if (std::string(descriptor->getFieldName(i)) == fieldName)
            return i;
    }
 
    throw cRuntimeError("Unknown field \"%s\" in message %d\nAvailable fields in \"%s\" are : %s"
            , fieldName.data(), forwardedMsg, descriptor->getClassName(), availableFields.str().data());
    return 0;
}

Referenced by checkFields().

finish()

void inet::MessageChecker::finish ( )

overrideprotected

{
    if (forwardedMsg > checkedMsg)
        throw cRuntimeError("%d message(s) has not been checked", forwardedMsg - checkedMsg);
 
    if (m_iterChk != m_checkingInfo.end())
        throw cRuntimeError("Several message(s) have to be checked");
}

forwardMessage()

void inet::MessageChecker::forwardMessage ( cMessage *  msg )

protected

{
    cGate *gateOut = gate("out");
    cChannel *channel = gateOut->getChannel();
    simtime_t now = simTime();
    simtime_t endTransmissionTime = channel->getTransmissionFinishTime();
    simtime_t delayToWait = 0;
    if (endTransmissionTime > now)
        delayToWait = endTransmissionTime - now;
    sendDelayed(msg, delayToWait, "out");
}

Referenced by handleMessage().

handleMessage()

void inet::MessageChecker::handleMessage ( cMessage *  msg )

overrideprotected

{
    forwardedMsg++;
    checkMessage(msg);
    forwardMessage(msg);
}

initialize()

void inet::MessageChecker::initialize ( )

overrideprotected

{
    cXMLElement *root = par("config");
    if (std::string(root->getTagName()) == "checker") {
        m_checkingInfo = root->getChildren();
        m_iterChk = m_checkingInfo.begin();
    }
    forwardedMsg = 0;
    checkedMsg = 0;
    WATCH(forwardedMsg);
    WATCH(checkedMsg);
}

Member Data Documentation

checkedMsg

unsigned inet::MessageChecker::checkedMsg

protected

Referenced by checkMessage(), finish(), and initialize().

forwardedMsg

unsigned inet::MessageChecker::forwardedMsg

protected

Referenced by checkFieldArray(), checkFieldObjectInArray(), checkFieldType(), checkFieldValue(), checkFieldValueInArray(), findFieldIndex(), finish(), handleMessage(), and initialize().

m_checkingInfo

cXMLElementList inet::MessageChecker::m_checkingInfo

protected

Referenced by checkMessage(), finish(), and initialize().

m_iterChk

cXMLElementList::iterator inet::MessageChecker::m_iterChk

protected

Referenced by checkMessage(), finish(), and initialize().

---

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

• MessageChecker.h
• MessageChecker.cc