CRegisteredPrintables.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 CRegisteredPrintables.hpp
 *
 *  Created on: Sep 20, 2011
 *
 *  Copyright (C) 2011, Samir Menon <smenon@stanford.edu>
 */

#ifndef CREGISTEREDPRINTABLES_HPP_
#define CREGISTEREDPRINTABLES_HPP_

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

#include <string>

namespace sutil
{
  template<typename ObjectType>
  void printToStream(std::ostream&, const ObjectType&);

  // Forward declarations. Anything that subclasses this is printable on
  // stl streams. Ie. Supports the 'stream<<object' operator style.
  class SPrintableBase;

  // This helps the map to work properly through typical object orientation.
  // And saves you from writing redundant code for every type.
  template<typename ObjectType> class SPrintable;

  typedef sutil::CSingleton<CMappedPointerList<std::string,SPrintableBase,true> > CRegisteredPrintables;

  namespace printables
  {
    const SPrintableBase* get(const std::string& arg_name)
    {
      SPrintableBase** ret = CRegisteredPrintables::getData()->at(arg_name);
      if(NULL == ret) { return NULL;  }
      return static_cast<const SPrintableBase*>(*ret);
    }

    template<typename ObjectType>
    bool add(const std::string& arg_name,
        const ObjectType& arg_obj)
    {
      SPrintable<ObjectType> tmp_printable_object(arg_obj);
      SPrintableBase** obj = CRegisteredPrintables::getData()->create(arg_name);
      if(NULL == obj){  return false; }
      *obj = tmp_printable_object.createObject();
      return true;
    }

    bool reset() { return CRegisteredPrintables::resetData(); }
  }

  class SPrintableBase
  {
  public:
    virtual ~SPrintableBase(){}

    virtual void printDataToStream(std::ostream& arg_stream) const =0;

    virtual SPrintableBase* createObject() const =0;

    //The only way you can overload << (it is a global function)
    friend std::ostream& operator<<(std::ostream& outstr, const SPrintableBase& me);

  protected:
    SPrintableBase(){}
  private:
    SPrintableBase(const SPrintableBase&);
    SPrintableBase& operator =(const SPrintableBase&);
  };

  std::ostream& operator<<(std::ostream& out, const SPrintableBase& me)
  { me.printDataToStream(out); return out; }

  template<typename ObjectType>
  class SPrintable : public SPrintableBase
  {
  public:
    SPrintable(const ObjectType& arg_data) :
      SPrintableBase(), data_(arg_data) {}

    virtual void printDataToStream(std::ostream& ostr) const
    { printToStream<ObjectType>(ostr, data_); }

    virtual SPrintableBase* createObject() const
    { return new SPrintable<ObjectType>(data_); }

    const ObjectType& data_;

  private: //To enforce implementers to pass an object (which is then registered)
    SPrintable();
    SPrintable(const SPrintable&);
    SPrintable& operator=(const SPrintable&);
  };
}

#endif /* CREGISTEREDPRINTABLES_HPP_ */