ns-3.8参考手册：2010年五月的ns-3项目指南

ns3_manual

5星 · 超过95%的资源需积分: 9 107 浏览量更新于2024-08-01 收藏 2.07MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

资源详情

资源推荐

Chapter 3: Callbacks ns-3 manual

A functor is the outgrowth of something invented in the 1960s called a closure. It is

basically just a packaged-up function call, possibly with some state.

A functor has two parts, a speciﬁc part and a generic part, related through inheritance.

The calling code (the code that executes the callback) will execute a generic overloaded

operator () of a generic functor to cause the callback to be called. The called code (the

code that wants to be called back) will have to provide a specialized implementation of the

operator () that performs the class-speciﬁc work that caused the close-coupling problem

above.

With the speciﬁc functor and its overloaded operator () created, the called code then

gives the specialized code to the module that will execute the callback (the calling code).

The calling code will take a generic functor as a parameter, so an implicit cast is done

in the function call to convert the speciﬁc functor to a generic functor. This means that

the calling module just needs to understand the generic functor type. It is decoupled from

the calling code completely.

The information one needs to make a speciﬁc functor is the object pointer and the

pointer-to-method address.

The essence of what needs to happen is that the system declares a generic part of the

functor,

template <typename T>

class Functor

{

public:

virtual void operator() (T arg) = 0;

};

The caller deﬁnes a speciﬁc part of the functor that really is just there to implement the

speciﬁc operator() method,

template <typename T, typename ARG>

class SpecificFunctor : public Functor

{

public:

SpecificFunctor(T* p, int (T::*_pmi)(ARG arg))

{

m_p = p;

m_pmi = pmi;

}

virtual int operator() (ARG arg)

{

(*m_p.*m_pmi)(arg);

}

private:

void (T::*m_pmi)(ARG arg);

T* m_p;

};

12ns-3.6 3 May 2010

Chapter 3: Callbacks ns-3 manual

N.B. The previous code is not real ns-3 code. It is simplistic example code used only to

illustrate the concepts involved and to help you understand the system more. Do not expect

to ﬁnd this code anywhere in the ns-3 tree

Notice that there are two variables deﬁned in the class above. The m

p variable is the

object pointer and m pmi is the variable containing the address of the function to execute.

Notice that when operator() is called, it in turn calls the method provided with the

object pointer using the C++ PMI syntax.

To use this, one could then declare some model code that takes a generic functor as a

parameter

void LibraryFunction (Functor functor);

The code that will talk to the model would build a speciﬁc functor and pass it to

LibraryFunction,

MyClass myClass;

SpecificFunctor<MyClass, int> functor (&myclass, MyClass::MyMethod);

When LibraryFunction is done, it executes the callback using the operator() on the

generic functor it was passed, and in this particular case, provides the integer argument:

void

LibraryFunction (Functor functor)

{

// Execute the library function

functor(1234);

}

Notice that LibraryFunction is completely decoupled from the speciﬁc type of the

client. The connection is made through the Functor polymorphism.

The Callback API in ns-3 implements object-oriented callbacks using the functor mech-

anism. This callback API, being based on C++ templates, is type-safe; that is, it performs

static type checks to enforce proper signature compatibility between callers and callees. It

is therefore more type-safe to use than traditional function pointers, but the syntax may

look imposing at ﬁrst. This section is designed to walk you through the Callback system so

that you can be comfortable using it in ns-3.

3.3 Using the Callback API

The Callback API is fairly minimal, providing only two services:

• callback type declaration: a way to declare a type of callback with a given signature,

and,

• callback instantiation: a way to instantiate a template-generated forwarding callback

which can forward any calls to another C++ class member method or C++ function.

This is best observed via walking through an example, based on samples/main-

callback.cc.

13ns-3.6 3 May 2010

Chapter 3: Callbacks ns-3 manual

3.3.1 Using the Callback API with static functions

Consider a function:

static double

CbOne (double a, double b)

{

std::cout << "invoke cbOne a=" << a << ", b=" << b << std::endl;

return a;

}

Consider also the following main program snippet:

int main (int argc, char *argv[])

{

// return type: double

// first arg type: double

// second arg type: double

Callback<double, double, double> one;

}

This is an example of a C-style callback – one which does not include or need a this

pointer. The function template Callback is essentially the declaration of the variable

containing the pointer-to-function. In the example above, we explicitly showed a pointer to

a function that returned an integer and took a single integer as a parameter, The Callback

template function is a generic version of that – it is used to declare the type of a callback.

Note1: Readers unfamiliar with C++ templates may consult this reference.

The Callback template requires one mandatory argument (the return type of the func-

tion to be assigned to this callback) and up to ﬁve optional arguments, which each specify

the type of the arguments (if your particular callback function has more than ﬁve arguments,

then this can be handled by extending the callback implementation).

So in the above example, we have a declared a callback named "one" that will eventually

hold a function pointer. The signature of the function that it will hold must return double

and must support two double arguments. If one tries to pass a function whose signature

does not match the declared callback, the compilation will fail.

Now, we need to tie together this callback instance and the actual target function

(CbOne). Notice above that CbOne has the same function signature types as the callback–

this is important. We can pass in any such properly-typed function to this callback. Let’s

look at this more closely:

static double CbOne (double a, double b) {}

^ ^ ^

| ---| ------|

| | |

Callback<double, double, double> one;

You can only bind a function to a callback if they have the matching signature. The

ﬁrst template argument is the return type, and the additional template arguments are the

types of the arguments of the function signature.

Now, let’s bind our callback "one" to the function that matches its signature:

14ns-3.6 3 May 2010

Chapter 3: Callbacks ns-3 manual

virtual int operator() (ARG arg)

{

(*m_p.*m_pmi)(arg);

}

And so we needed to provide the two variables (m_p and m_pmi) when we made the

speciﬁc functor. The line,

two = MakeCallback (&MyCb::CbTwo, &cb);

does precisely that. In this case,

When two () is invoked,

int result = two (1.0);

I will result in a call the CbTwo member function (method) on the object pointed to by

&cb.

3.3.3 Building Null Callbacks

It is possible for callbacks to be null; hence it may be wise to check before using them.

There is a special construct for a null callback, which is preferable to simply passing "0" as

an argument; it is the MakeNullCallback<> construct:

two = MakeNullCallback<int, double> ();

NS_ASSERT (two.IsNull ());

Invoking a null callback is just like invoking a null function pointer: it will crash at

runtime.

3.4 Bound Callbacks

A very useful extension to the functor concept is that of a Bound Callback. Previously it

was mentioned that closures were originally function calls packaged up for later execution.

Notice that in all of the Callback descriptions above, there is no way to package up any pa-

rameters for use later – when the Callback is called via operator(). All of the parameters

are provided by the calling function.

What if it is desired to allow the client function (the one that provides the callback)

to provide some of the parameters? Alexandrescu calls the process of allowing a client

to specify one of the parameters binding. One of the parameters of operator() has been

bound (ﬁxed) by the client.

Some of our pcap tracing code provides a nice example of this. There is a function that

needs to be called whenever a packet is received. This function calls an object that actually

writes the packet to disk in the pcap ﬁle format. The signature of one of these functions

will be,

static void SniffEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet);

The static keyword means this is a static function which does not need a this pointer,

so it will be using C-style callbacks. We don’t want the calling code to have to know about

anything but the Packet. What we want there is just a call that looks like,

m_promiscSnifferTrace (m_currentPkt);

16ns-3.6 3 May 2010

剩余179页未读，继续阅读

yhpresario

粉丝: 0
资源: 1

ns-3.8参考手册：2010年五月的ns-3项目指南

ns-3 教程+手册（tutorial+manual）

ns3-manual

ns-3-manual_ns3_

ns3 manual and tutorial_ns3_wirelessnetwork_Simulation_

ns2说明文件ns_manual2007

_____NS-V1000_____.zip_AIZ_directlzi_manual_omron v1000

VanetMobiSim_1_0__Manual.rar_vanetmobisim

VanetMobiSim_1_0__Manual.rar_Windows编程_Windows_Unix_

VanetMobiSim_1_0__Manual.rar_CanuMobiSim_The Network_vehicular a

ns2-manual.pdf.gz_linux manual

ns-3 manual

tbdml_manual_15.pdf

NS3 manual

ns2-manual.rar_ns2

ns-3-manual_r3.21

samco-NS_samco-NS_

ns2manual.zip_网络_Windows_Unix_

最新资源

_NS-V1000_.zip_AIZ_directlzi_manual_omron v1000