CRegisteredCallbacks.hpp

/* This file is part of sUtil, a random collection of utilities.

sUtil is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.

Alternatively, 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.

sUtil 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 Lesser General Public
License and a copy of the GNU General Public License along with
sUtil. If not, see <http://www.gnu.org/licenses/>.
 */
/* \file CRegisteredCallbacks.hpp
 *
 *  Created on: Sep 13, 2011
 *
 *  Copyright (C) 2011, Samir Menon <smenon@stanford.edu>
 */

#ifndef CREGISTEREDCALLBACKS_HPP_
#define CREGISTEREDCALLBACKS_HPP_

#include <sutil/CSingleton.hpp>
#include <sutil/CMappedList.hpp>

#include <vector>
#ifdef DEBUG
#include <iostream>
#endif

namespace sutil
{
  // These are forward declarations. Read the class comments for details.
  template <typename Idx> class CCallbackSuperBase;
  template <typename Idx, typename ArgumentTuple, typename Data> class CCallbackBase;
  template <typename Idx> class CRegisteredCallbacks;

  namespace callbacks
  {
    template<typename Idx, typename ArgumentTuple, typename Data=bool >
    bool call(const Idx& arg_callback_name, ArgumentTuple& args)
    {
      CCallbackSuperBase<Idx>** mapped_callback =
          CRegisteredCallbacks<Idx>::getCallbacks()->at(arg_callback_name);

      if(0 == mapped_callback) {  return false; } //Function not found.

      CCallbackBase<Idx, ArgumentTuple, Data>* callback =
          dynamic_cast<CCallbackBase<Idx, ArgumentTuple, Data>*>(*mapped_callback);

      if(NULL == callback)
      { return false; }

      callback->call(args); //The actual function call

      return true; //Everything worked out
    }

    template< typename CallbackClass, typename Idx,
    typename ArgumentTuple, typename Data=bool >
    bool add(const Idx& arg_callback_name)
    {
      CallbackClass f;
      return f.sutil::CCallbackBase<Idx, ArgumentTuple, Data>::
      registerCallback(arg_callback_name);
    }

    template< typename CallbackClass, typename Idx,
    typename ArgumentTuple, typename Data>
    bool add(const Idx& arg_callback_name, Data* arg_data)
    {
      CallbackClass f;
      return f.sutil::CCallbackBase<Idx, ArgumentTuple, Data>::
          registerCallback(arg_callback_name, arg_data);
    }

    template<typename Idx>
    bool list(std::vector<Idx>& idxlist)
    { typedef CMappedPointerList<Idx,CCallbackSuperBase<Idx>,true> map;
      map* m = CRegisteredCallbacks<Idx>::getCallbacks();
      if(NULL == m) { return false; }
      typename map::iterator it,ite;
      idxlist.clear();
      for(it = m->begin(), ite = m->end();it!=ite;++it)
      { idxlist.push_back(!it); }//Add the index to the vector
      return true;
    }
  }

  template <typename Idx>
  class CRegisteredCallbacks : private CSingleton<CMappedPointerList<Idx,CCallbackSuperBase<Idx>,true> >
  {
    //A typedef for easy use;
    typedef CSingleton<CMappedPointerList<Idx,CCallbackSuperBase<Idx>,true> > singleton;

    //So that the base class can call the register function
    friend class CCallbackSuperBase<Idx>;

  public:
    static bool callbackRegistered(const Idx& arg_callback_name)
    {
      CCallbackSuperBase<Idx>** mapped_callback = singleton::getData()->at(arg_callback_name);
      if(0 == mapped_callback) { return false; }
      return true;
    }

    static bool resetCallbacks()
    { return singleton::resetData(); }

    static CMappedPointerList<Idx,CCallbackSuperBase<Idx>,true>* getCallbacks()
    { return singleton::getData();  }

  private:
    static bool registerCallback(const Idx& arg_callback_name,
        CCallbackSuperBase<Idx>* arg_callback_object)
    {
      if(callbackRegistered(arg_callback_name))
      {
#ifdef DEBUG
        std::cerr<<"\nCRegisteredCallbacks::registerCallback() Warning :"
            <<" The passed callback is already registered.";
#endif
        return false;
      }

      // Creates an object that points to the passed callback object
      CCallbackSuperBase<Idx>** t = singleton::getData()->
          create(arg_callback_name,arg_callback_object);
      if(0 == t)
      {
#ifdef DEBUG
        std::cerr<<"\nCRegisteredCallbacks::registerCallback() Error :"
            <<" Failed to create callback in the callback mapped list.";
#endif
        return false;
      }

      return true;
    }

    CRegisteredCallbacks();

    CRegisteredCallbacks(const CRegisteredCallbacks&);

    CRegisteredCallbacks& operator= (const CRegisteredCallbacks&);
  };

  template <typename Idx>
  class CCallbackSuperBase
  {
  public:
    virtual ~CCallbackSuperBase(){}

  protected:
    CCallbackSuperBase(){}

    virtual bool registerCallbackSuper(
        const Idx &arg_callback_name,
        CCallbackSuperBase* arg_obj)
    {
      return CRegisteredCallbacks<Idx>::
          registerCallback(arg_callback_name,arg_obj);
    }

  private:
    CCallbackSuperBase(const CCallbackSuperBase&);
    CCallbackSuperBase& operator= (const CCallbackSuperBase&);
  };

  template <typename Idx, typename ArgumentTuple, typename Data=bool>
  class CCallbackBase : public CCallbackSuperBase<Idx>
  {
  public:
    virtual void call(ArgumentTuple& args) = 0;

    virtual CCallbackBase<Idx, ArgumentTuple, Data>* createObject()=0;

    virtual bool registerCallback(
        const Idx& arg_callback_name,
        Data* arg_data = 0)
    {
      bool flag;
      flag = CRegisteredCallbacks<Idx>::callbackRegistered(arg_callback_name);

      if(flag)//Callback already registered. Do nothing and return false.
      { return false; }
      else
      {
        //Duplicate this object and register the new one with the singleton
        CCallbackBase<Idx,ArgumentTuple,Data>* obj = createObject();

        //Set up data for this function object
        if(0 != arg_data)
        { obj->data_ = arg_data; }

        flag = CCallbackSuperBase<Idx>::registerCallbackSuper(
            arg_callback_name,
            dynamic_cast<CCallbackSuperBase<Idx>*>(obj) );
        if(!flag)
        { delete obj; return false; }
      }
      return true;
    }

    virtual ~CCallbackBase(){}

  protected:
    CCallbackBase() : data_(NULL){}

    Data* data_;

  private:
    CCallbackBase(const CCallbackBase&);
    CCallbackBase& operator= (const CCallbackBase&);
  };
}

#endif /* CREGISTEREDCALLBACKS_HPP_ */

---

Generated on Sun Sep 14 2014 02:35:55 for SCL by   1.8.6