Click here to Skip to main content
14,450,027 members

Kigs Framework Introduction (4/8) - Methods

Rate this:
5.00 (2 votes)
Please Sign up or sign in to vote.
5.00 (2 votes)
13 Feb 2020MIT
A multi purpose, cross-platform, free and Open Source C++ framework. This article will focus on CoreModifiable methods.
This article demonstrates the use of CoreModifiable methods - how to declare them, how to define them and how to call them. CoreModifiable methods are an important mechanism used by signal / slot management and notification among others.

Kigs Logo

Table of Contents

Introduction

Check Already Published in this Series section to know what was seen before.

In this article, we will focus on CoreModifiable methods. CoreModifiable methods are methods that can be called by their name without knowing the exact type of the called instance.

Fast Access Fixed Prototype Methods

Fixed prototype is:

bool    methodName(CoreModifiable* sender,
        kstl::vector<CoreModifiableAttribute*>& params,void* privateParams);

Parameters are:

  • CoreModifiable* sender: caller class
  • kstl::vector<CoreModifiableAttribute*>& params: vector of CoreModifiableAttribute* parameters
  • void* privateParams: a possible user defined private param

Return value is a bool value. Meaning of the return value is user defined.

Helper macros can be used to declare a member method: DECLARE_METHOD, DECLARE_VIRTUAL_METHOD, DECLARE_PURE_VIRTUAL_METHOD.

// declare member method called "GiveInfos"
DECLARE_METHOD(GiveInfos);

Helper macro DEFINE_METHOD is then used to define method:

// define member method named GiveInfos on SimpleClass
DEFINE_METHOD(SimpleClass, GiveInfos)
{
    
    std::cout << "SimpleClass GiveInfos method called on 
                 " << getName() << " instance" << std::endl;
    std::cout << "-- sender : " << sender->getName() << std::endl;

    for (auto p : params)
    {
#ifdef KEEP_NAME_AS_STRING
        std::string v;
        if (p->getValue(v))
        {
            std::cout << "-- parameter : " << p->getID()._id_name << 
                         " value is : " << v << std::endl;
        }
        else
        {
            std::cout << "-- parameter : " << p->getID()._id_name << 
                         " value cannot be evaluated as string" << std::endl;
        }
#else
        std::string v;
        if (p->getValue(v))
        {
            std::cout << "-- parameter : " << p->getID()._id << 
                         " value is : " << v << std::endl;
        }
        else
        {
            std::cout << "-- parameter : " << p->getID()._id << 
                         " value cannot be evaluated as string" << std::endl;
        }
#endif
    }

    if(privateParams)
        std::cout << "-- private parameter is not null" << std::endl;
    else
        std::cout << "-- private parameter is null" << std::endl;

    return true;
}

Fast Call

Then method can be called with "CallMethod" like this:

// create dynamic attribute on this
AddDynamicAttribute<maFloat, float>("FloatParam", 12.0f);

// create CoreModifiableAttribute without owner
CoreModifiableAttribute* intParam = new maInt("IntParam", 15);

// create a parameter vector
std::vector<CoreModifiableAttribute*> params;
// push dynamic attribute "FloatParam" on vector
params.push_back(getAttribute("FloatParam"));
// push intParam
params.push_back(intParam);
    
// call GiveInfos on instance1 with params vector, no private parameter, and sender is this  
bool result = instance1->CallMethod("GiveInfos", params, nullptr, this);
std::cout << "GiveInfos returns " << (result?"true":"false") << std::endl << std::endl;

// call GiveInfos on instance1 with this instance (Sample4) as parameter, 
// no private params and no sender
// so the received parameter vector will be all the CoreModifiable attributes owned by this
result = instance1->CallMethod("GiveInfos", this, nullptr, nullptr);
std::cout << "GiveInfos returns " << (result ? "true" : "false") << std::endl << std::endl;

Slower Simple Call

The SimpleCall template method automatically encodes parameters in vector:

// "SimpleCall" on instance2:
result = instance2->SimpleCall("GiveInfos", 32,64,5);
std::cout << "GiveInfos returns " << (result ? "true" : "false") << std::endl << std::endl;

Returned Value

Returned value can be pushed on parameter vector with helper macro PUSH_RETURN_VALUE.
When called using CallMethod, the returned value and allocated parameters must be deleted after the call (or a memory leaks will occur).

// call GiveInfos on instance2 with params vector, no private parameter and sender is this  
int paramsCount = params.size();
result = instance2->CallMethod("GiveInfos", params, nullptr, this);
if (params.size() > paramsCount)
{
    // return values added
    while(paramsCount<params.size())
    {
        std::string v;
        if(params.back()->getValue(v))
            std::cout << "GiveInfos returned value = " << v << std::endl;

        delete params.back();
        params.pop_back();
    }
}
std::cout << "GiveInfos returns " << (result ? "true" : "false") << std::endl << std::endl;

With SimpleCall, the returned value can be managed automatically with template parameter:

// "SimpleCall" on instance2:
float floatresult = instance2->SimpleCall<float>("GiveInfos", 32,64,5);
std::cout << "GiveInfos returns " << floatresult << std::endl << std::endl;

Slower Access Wrapped Methods

Any member method can be wrapped as a CoreModifiable method. In class declaration:

float Multiply(float v1, float v2)
{
    return v1 * v2;
}
// Multiply method can be called with SimpleCall
WRAP_METHODS(Multiply);

Then Multiply method can be called like this:

float floatresult = instance2->SimpleCall<float>("Multiply", 32, 5);
std::cout << "instance2 Multiply returns " << floatresult << std::endl << std::endl;

Dynamic Methods

CoreModifiable inherited instances can be enhanced with dynamic method.

A dynamic method can be defined like this:

// declare a dynamic method named addValues which can be added to any CoreModifiable instance
DEFINE_DYNAMIC_METHOD(CoreModifiable, addValues)
{
    float result = 0.0f;
    for (auto p : params)
    {
        float v;
        if (p->getValue(v))
        {
            result += v;
        }
    }
    PUSH_RETURN_VALUE(result);
    return true;
}

Then at run time, add this method to a given instance, and call it with SimpleCall:

// now add addValues method on instance2, calling name is also addValues
instance2->INSERT_DYNAMIC_METHOD(addValues, addValues);
floatresult = instance2->SimpleCall<float>("addValues", 32, 5);
std::cout << "instance2 addValues returns " << floatresult << std::endl << std::endl;

This mechanism can be used to decorate instances with a specific behaviour.

Find all the sample code from this article in Sample4 project (browse the code).

Already Published in this Series

  1. Kigs Framework Introduction (1/8) - Overview
  2. Kigs Framework Introduction (2/8) - CoreModifiable
  3. Kigs Framework Introduction (3/8) - Attributes
  4. Kigs Framework Introduction (4/8) - Methods

History

  • 13th February, 2020: Initial version

License

This article, along with any associated source code and files, is licensed under The MIT License

Share

About the Author

Stephane Capo
Chief Technology Officer Assoria
France France
I created Assoria company in 2007.
I supervise and participate in the development of Kigs framework, projects realized by Assoria as well as NEXT-BIM software.

Comments and Discussions

 
-- There are no messages in this forum --
Article
Posted 13 Feb 2020

Tagged as

Stats

821 views
1 bookmarked