tjhandler.h

/***************************************************************************
                          tjhandler.h  -  description
                             -------------------
    begin                : Mon Aug 19 2002
    copyright            : (C) 2001 by Thies H. Jochimsen
    email                : jochimse@cns.mpg.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef TJHANDLER_H
#define TJHANDLER_H

#include <tjutils/tjutils.h>
#include <tjutils/tjthread.h>

class HandlerComponent {
 public:
  static const char* get_compName();
};



template<class I> class Handled; // forawrd declaration




template<class I>
class Handler {


 public:

  Handler();

  Handler(const Handler& handler);

  Handler& operator = (const Handler& handler);

  ~Handler();

  const Handler& clear_handledobj() const;

  const Handler& set_handled(I handled) const;

  I get_handled() const;


 private:
  friend class Handled<I>;

  const Handler& handled_remove(Handled<I>* handled) const;

  mutable I handledobj;

};




template<class I>
class Handled {

 public:
  Handled();
  ~Handled();

  bool is_handled() const {return bool(handlers.size());}
  
 private:
  friend class Handler<I>;
  
  const Handled& set_handler(const Handler<I>& handler) const;
  const Handled& erase_handler(const Handler<I>& handler) const;

  mutable STD_list< const Handler<I>* > handlers;
};



class SingletonBase; // forward declaration

// mapping between singletons and labels
typedef STD_map<STD_string, SingletonBase*> SingletonMap;


class SingletonBase {

 public:
  virtual void* get_ptr() const = 0;

  static SingletonMap* get_singleton_map();
  static void set_singleton_map_external(SingletonMap* extmap);

 protected:
  SingletonBase();
  virtual ~SingletonBase() {}

  static STD_string get_singleton_label(SingletonBase* sing_ptr);
  static void* get_external_map_ptr(const STD_string& sing_label);

  static SingletonMap* singleton_map;
  static SingletonMap* singleton_map_external;
};




template<class T>
class LockProxy {

 public:
  LockProxy(volatile T* r, Mutex* m) : presource(const_cast<T*>(r)), pmutex(m) {if(pmutex) pmutex->lock();}
  ~LockProxy() {if(pmutex) pmutex->unlock();}
  T* operator -> () {return presource;}

 private:
  T* presource;
  Mutex* pmutex;
};





template<class T, bool thread_safe> // VxWorks does not support default-template args
class SingletonHandler : public SingletonBase {

 public:

  SingletonHandler() {
    // do nothing because members are already initialized by init()
  }


  void init (const char* unique_label);

  void destroy ();


  void copy(T& destination) const;

  T* unlocked_ptr() {return get_map_ptr();}


  // emulate pointer syntax:

  LockProxy<T> operator -> () {return LockProxy<T>(get_map_ptr(),mutex);}

  const T* operator -> () const {return get_map_ptr();}

  operator bool () const {return (bool)get_map_ptr();}



 private:

  // implement virtual function of SingletonBase
  void* get_ptr() const {return ptr;}

  T* get_map_ptr() const;

  // Use pointers to avoid the need for static initialization
  mutable T* ptr;
  STD_string* singleton_label;
  Mutex* mutex;

};



#endif