#include <boost/intrusive_ptr.hpp>

[Steven T. Hatton]

I'm trying to create an baseclass that will serve as a parent for reference
counted objects handled by boost::intrusive_ptr<>. The documentation
didn't provide much in the way of describing what the functions
intrusive_ptr_add_ref and intrusive_ptr_release should do, nor even what
their signatures should be. There is one comment that has me a bit unsure
about whether my approach is a good one:"On compilers that support
argument-dependent lookup, intrusive_ptr_add_ref and intrusive_ptr_release
should be defined in the namespace that corresponds to their parameter;
otherwise, the definitions need to go in namespace boost."

Note that my baseclass is util::Referenced, and my functions are
util::intrusive_ptr_add_ref, and util::intrusive_ptr_release. My hope is
that I can derive from these in other namespaces and rely on the fact that
the baseclass is in util to avoid the unspecified problems that would arise
if the parameter is not in a namespace corresponding to the functions.


/***************************************************************************
* Copyright (C) 2005 by Steven T. Hatton *
* (e-mail address removed) *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef UTIL_REFERENCED_IF_H
#define UTIL_REFERENCED_IF_H

#include <boost/intrusive_ptr.hpp>
#include <boost/mem_fn.hpp>
namespace util {

class Referenced_IF {
friend void intrusive_ptr_add_ref(const Referenced_IF* r);
friend void intrusive_ptr_release(const Referenced_IF* r);

mutable unsigned _r;
void increment() const { ++_r; }
void decrement() const { if(!--_r) delete this; }

protected:
virtual ~Referenced_IF() {}
};

typedef boost::intrusive_ptr<Referenced_IF> iref_ptr;

inline void intrusive_ptr_add_ref(const Referenced_IF* r)
{ r->increment(); }
inline void intrusive_ptr_release(const Referenced_IF* r)
{ r->decrement(); }

}
#endif

//---------------------------------------------------------

The following seems to work. Can anybody see anything blatantly wrong with
it?


#ifndef CONTROL_SIGNALLISTENER_IF_H
#define CONTROL_SIGNALLISTENER_IF_H

#include <util/Referenced_IF.h>
namespace control {

class SignalListener_IF: public util::Referenced_IF {
public:
virtual void signal()=0;
protected:
virtual ~SignalListener_IF() {}
};
}

#endif

//---------------------------------------------------------
#ifndef SIGNALGENERATOR_IF_HH
#define SIGNALGENERATOR_IF_HH

#include <list>
#include <algorithm>
#include <functional>

#include "SignalListener_IF.h"

namespace control {

/*!\brief The SignalGenerator_IF class template provides an interface for
signal generators.

SignalGenerator_IF maintains a list of \c SignalListener_IF observers,
and notifies them
when an event occurs.
*/
class SignalGenerator_IF {

public:
typedef SignalListener_IF Listener_T;
typedef boost::intrusive_ptr<SignalListener_IF> Listener_ptr_T;

/*!
Adds \a listener to the list of observers. Does nothing if \a listener
is already present.
*/
void attachListener(Listener_T* listener) {
using namespace std;
Listener_ptr_T lptr(listener);
if(find(_listeners.begin(), _listeners.end(), listener) ==
_listeners.end())
_listeners.push_back(listener);
}

/*!
Removes \a listener from the list of observers. Does nothing if \a
listener is not present.
*/
void detachListener(Listener_T* listener)
{ _listeners.remove(listener); }

protected:
/*!
Derived classes should call this to notify all listeners that an event
has occurred.
*/
void _generateSignal() { std::for_each(_listeners.begin(),
_listeners.end(), boost::mem_fn(&Listener_T::signal)); }

std::list<Listener_ptr_T> _listeners;
};
}

#endif

 

[Panjandrum]

Clearly OT! Why don't you ask at Boost?

 

[Steven T. Hatton]

Clearly OT! Why don't you ask at Boost?

That's the first time I ever heard that boost was OT on this news group.

 

[Panjandrum]

That's the first time I ever heard that boost was OT on this news group.

From: ===Welcome to comp.lang.c++! Read this first.

"First of all, please keep in mind that comp.lang.c++ is a group for
discussion of general issues of the C++ programming language, as
defined by the ANSI/ISO language standard. If you have a problem that
is specific to a particular system or compiler, you are much more
likely to get complete and accurate answers in a group that specializes
in your platform."

 

[Steven T. Hatton]

From: ===Welcome to comp.lang.c++! Read this first.

"First of all, please keep in mind that comp.lang.c++ is a group for
discussion of general issues of the C++ programming language, as
defined by the ANSI/ISO language standard. If you have a problem that
is specific to a particular system or compiler, you are much more
likely to get complete and accurate answers in a group that specializes
in your platform."

http://tinyurl.com/8k4fl

http://www.boost.org/libs/smart_ptr/smart_ptr.htm