IndirectChannel.h

Go to the documentation of this file.

#ifndef OPALX_IndirectChannel_HH
#define OPALX_IndirectChannel_HH
 
// ------------------------------------------------------------------------
// $RCSfile: IndirectChannel.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: IndirectChannel
//
// ------------------------------------------------------------------------
// Class category: Channels
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:35 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "Channels/Channel.h"
 
// Class IndirectChannel
// ------------------------------------------------------------------------
//  Template class IndirectChannel allows access to a [b]double[/b] data
//  member of an object.
 
template <class T>
class IndirectChannel : public Channel {
public:
    //  The constructed channel provides access to a member of an object
    //  of class [b]T[/b].  The channel keeps a reference to [b]object[/b]
    //  and the pointers to member [b]getF[/b] and [b]setF[/b].
    //  Values set are transmitted via  object.*setF(value)
    //  and read via  value = object.*getF().
    IndirectChannel(T& object, double (T::*getF)() const, void (T::*setF)(double));
 
    IndirectChannel(const IndirectChannel&);
    virtual ~IndirectChannel();
 
    virtual IndirectChannel* clone() const;
 
    //  If the channel can be read, set [b]value[/b] and return true,
    //  otherwise return false.
    virtual bool get(double&) const;
 
    //  If the channel can be written,
    //  store [b]value[/b] into it and return true,
    //  otherwise return false.
    virtual bool set(double);
 
    //  Return true, if the channel can be written, i.e. if the set
    //  method pointer is not nullptr
    virtual bool isSettable() const;
 
private:
    // Not implemented.
    IndirectChannel();
    const IndirectChannel& operator=(const IndirectChannel&);
 
    // Reference to the object to be set.
    T& itsObject;
 
    // The get and set functions for the channel.
    double (T::*getF)() const;
    void (T::*setF)(double);
};
 
template <class T>
IndirectChannel<T>::IndirectChannel(T& object, double (T::*get)() const, void (T::*set)(double))
    : itsObject(object), getF(get), setF(set) {}
 
template <class T>
IndirectChannel<T>::IndirectChannel(const IndirectChannel& rhs)
    : Channel(), itsObject(rhs.itsObject), getF(rhs.getF), setF(rhs.setF) {}
 
template <class T>
IndirectChannel<T>::~IndirectChannel() {}
 
template <class T>
IndirectChannel<T>* IndirectChannel<T>::clone() const {
    return new IndirectChannel(*this);
}
 
template <class T>
bool IndirectChannel<T>::get(double& value) const {
    value = (itsObject.*getF)();
    return true;
}
 
template <class T>
bool IndirectChannel<T>::set(double value) {
    if (setF != 0) {
        (itsObject.*setF)(value);
        return true;
    } else {
        return false;
    }
}
 
template <class T>
inline bool IndirectChannel<T>::isSettable() const {
    return (setF != 0);
}
 
#endif  // OPALX_IndirectChannel_HH