inet::MatchableObject Class Reference

Wrapper around a cObject to make it matchable with cMatchExpression. More...

#include <MatchableObject.h>

Inheritance diagram for inet::MatchableObject:

Public Types
enum	Attribute { ATTRIBUTE_FULLNAME, ATTRIBUTE_FULLPATH, ATTRIBUTE_CLASSNAME }

Public Member Functions
	MatchableObject (Attribute defaultAttribute=ATTRIBUTE_FULLPATH, const cObject *object=nullptr)
void	setObject (const cObject *object)
void	setDefaultAttribute (Attribute defaultAttribute)
virtual const char *	getAsString () const override
virtual const char *	getAsString (const char *attribute) const override

Static Protected Member Functions
static void	splitIndex (char *indexedName, int &index)
static bool	findDescriptorField (cClassDescriptor *classDescriptor, const char *attribute, int &fieldId, int &index)

Protected Attributes
Attribute	defaultAttribute
const cObject *	object
cClassDescriptor *	classDescriptor
std::string	attributeValue

Detailed Description

Wrapper around a cObject to make it matchable with cMatchExpression.

Member Enumeration Documentation

Attribute

enum inet::MatchableObject::Attribute

Enumerator
ATTRIBUTE_FULLNAME
ATTRIBUTE_FULLPATH
ATTRIBUTE_CLASSNAME

                   {
        ATTRIBUTE_FULLNAME,
        ATTRIBUTE_FULLPATH,
        ATTRIBUTE_CLASSNAME
    };

Constructor & Destructor Documentation

MatchableObject()

inet::MatchableObject::MatchableObject	(	Attribute	defaultAttribute = ATTRIBUTE_FULLPATH,
		const cObject *	object = nullptr
	)

{
    this->defaultAttribute = defaultAttribute;
    this->object = object;
    classDescriptor = nullptr;
}

Member Function Documentation

findDescriptorField()

bool inet::MatchableObject::findDescriptorField ( cClassDescriptor *  classDescriptor, const char *  attribute, int &  fieldId, int &  index  )

staticprotected

{
    // attribute may be in the form "fieldName[index]"; split the two
    char *fieldNameBuf = new char[strlen(attribute) + 1];
    strcpy(fieldNameBuf, attribute);
    splitIndex(fieldNameBuf, index);
 
    // find field by name
    fieldId = classDescriptor->findField(fieldNameBuf);
    delete[] fieldNameBuf;
    return fieldId != -1;
}

Referenced by getAsString().

getAsString() [1/2]

const char * inet::MatchableObject::getAsString ( ) const

overridevirtual

{
    switch (defaultAttribute) {
        case ATTRIBUTE_FULLPATH:  attributeValue = object->getFullPath(); return attributeValue.c_str();
        case ATTRIBUTE_FULLNAME:  return object->getFullName();
        case ATTRIBUTE_CLASSNAME: return object->getClassName();
        default: throw cRuntimeError("Unknown setting for default attribute");
    }
}

getAsString() [2/2]

const char * inet::MatchableObject::getAsString ( const char *  attribute ) const

overridevirtual

{
    if (!classDescriptor) {
        classDescriptor = object->getDescriptor();
        if (!classDescriptor)
            return nullptr;
    }
 
/*FIXME
    // start tokenizing the path
    cStringTokenizer tokenizer(attribute, ".");
    const char *token;
    void *currentObj = obj;
    cClassDescriptor *currentDesc = desc;
    int currentFieldId = id
    while ((token = tokenizer.nextToken())!=nullptr)
    {
        bool found = findDescriptorField(d, token, fid, index);
        if (!found) return nullptr;
    }
*/
 
    int fieldId;
    int index;
    bool found = findDescriptorField(classDescriptor, attribute, fieldId, index);
    if (!found)
        return nullptr;
 
    attributeValue = classDescriptor->getFieldValueAsString(toAnyPtr(object), fieldId, index);
    return attributeValue.c_str();
}

setDefaultAttribute()

void inet::MatchableObject::setDefaultAttribute ( Attribute  defaultAttribute )

inline

{ this->defaultAttribute = defaultAttribute; }

setObject()

void inet::MatchableObject::setObject

(

const cObject *

object

)

{
    this->object = object;
    classDescriptor = nullptr;
}

splitIndex()

void inet::MatchableObject::splitIndex ( char *  indexedName, int &  index  )

staticprotected

{
    index = 0;
    char *startbracket = strchr(indexedName, '[');
    if (startbracket) {
        char *lastcharp = indexedName + strlen(indexedName) - 1;
        if (*lastcharp != ']')
            throw cRuntimeError("Unmatched '['");
        *startbracket = '\0';
        char *end;
        index = strtol(startbracket + 1, &end, 10);
        if (end != lastcharp)
            throw cRuntimeError("Brackets [] must contain numeric index");
    }
}

Referenced by findDescriptorField().

Member Data Documentation

attributeValue

std::string inet::MatchableObject::attributeValue

mutableprotected

Referenced by getAsString().

classDescriptor

cClassDescriptor* inet::MatchableObject::classDescriptor

mutableprotected

Referenced by findDescriptorField(), getAsString(), MatchableObject(), and setObject().

defaultAttribute

Attribute inet::MatchableObject::defaultAttribute

protected

Referenced by getAsString(), and MatchableObject().

object

const cObject* inet::MatchableObject::object

protected

Referenced by MatchableObject(), and setObject().

---

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

• MatchableObject.h
• MatchableObject.cc