tjhandler.h

/***************************************************************************
                          tjhandler.h  -  description
                             -------------------
    begin                : Mon Aug 19 2002
    copyright            : (C) 2000-2021 by Thies H. Jochimsen
    email                : thies@jochimsen.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; // forward 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