JTools/JSelector.hh

Go to the documentation of this file.

#ifndef __JTOOLS__JSELECTOR__
#define __JTOOLS__JSELECTOR__
 
#include <istream>
#include <ostream>
#include <map>
 
#include "JLang/JSharedPointer.hh"
#include "JLang/JAbstractIO.hh"
#include "JLang/JParameter.hh"
#include "JLang/JClass.hh"
#include "JLang/JType.hh"
#include "JLang/JException.hh"
 
#include "JTools/JDriver.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }
 
namespace JTOOLS {
 
  using JLANG::JSharedPointer;
  using JLANG::JStreamInput;
  using JLANG::JStreamOutput;
  using JLANG::JType;
  using JLANG::JNullPointerException;
 
 
  /**
   * Abstract class of an automatic pointer.
   * This abstract class can be used for loading and storing of objects.
   */
  template<class JBase_t>
  class JAbstractAutoPointer :
    public JSharedPointer<JBase_t>,
    public JStreamInput,
    public JStreamOutput
  {
  public:
    /**
     * Default constructor.
     */
    JAbstractAutoPointer() :
      JSharedPointer<JBase_t>(),
      JStreamInput(),
      JStreamOutput()
    {}
  };
 
 
  /**
   * Template class for loading and storing of objects.
   * This class implements the JAbstractAutoPointer interface.
   */
  template<class JDerived_t, class JBase_t>
  class JAutoPointer :
    public JAbstractAutoPointer<JBase_t>,
    private JDriver<JDerived_t>
  {
  public:
    /**
     * Default constructor.
     */
    JAutoPointer() :
      JAbstractAutoPointer<JBase_t>()
    {}
 
    
    /**
     * Constructor.
     * This class owns the pointer.
     *
     * \param  p             pointer to object
     */
    JAutoPointer(JDerived_t* p) :
      JAbstractAutoPointer<JBase_t>()
    {
      this->reset(p);
    }
 
    
    /**
     * Stream input.
     * This method creates a new object and read the corresponding input data 
     * if the redirect operator >>(isteam&) is defined for this data type.
     *
     * \param  in            input stream
     * \return               input stream
     */
    virtual std::istream& read(std::istream& in) 
    {
      JDerived_t* p = this->load(in);
 
      if (p != NULL) {
        this->reset(p);
      }
 
      return in;
    }
 
    
    /**
     * Stream output.
     * This method writes the corresponding data 
     * if the redirect operator <<(osteam&) is defined for this data type.
     *
     * \param  out           output stream
     * \return               output stream
     */
    virtual std::ostream& write(std::ostream& out) const
    {
      this->store(out, this->get());
 
      return out;
    }  
  };
 
 
  /**
   * Handler class for automatic pointer.
   */
  template<class JBase_t>
  class JAutoElement :
    public JSharedPointer< JAbstractAutoPointer<JBase_t> >
  {
    
    typedef JAbstractAutoPointer<JBase_t>             JAbstractAutoPointer_t;
    typedef JSharedPointer<JAbstractAutoPointer_t>    JSharedPointer_t;
    typedef JAutoElement<JBase_t>                     JAutoElement_t;
 
  public:
    /**
     * Default constructor.
     */
    JAutoElement() :
      JSharedPointer_t()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  type          data type
     */
    template<class JDerived_t>
    JAutoElement(JType<JDerived_t> type) :
      JSharedPointer_t()
    {
      this->set(type);
    }
 
 
    /**
     * Constructor.
     * This class owns the pointer.
     *
     * \param  p             pointer to object
     */
    template<class JDerived_t>
    JAutoElement(JDerived_t* p) :
      JSharedPointer_t()
    {
      this->set(p);
    }
 
 
    /**
     * Set the automatic pointer to the given data type.
     */
    template<class JDerived_t>
    void set()
    {
      this->set(JType<JDerived_t>());
    }
 
 
    /**
     * Set the automatic pointer to the given data type.
     *
     * \param  type          data type
     */
    template<class JDerived_t>
    void set(JType<JDerived_t> type)
    {
      this->reset(new JAutoPointer<JDerived_t, JBase_t>());
    }
 
 
    /**
     * Set the automatic pointer to the given data type.
     *
     * \param  p             pointer to object
     */
    template<class JDerived_t>
    void set(JDerived_t* p)
    {
      this->reset(new JAutoPointer<JDerived_t, JBase_t>(p));
    }
 
 
    /**
     * Assign given data type to the automatic pointer.
     *
     * \param  type          data type
     * \return               this JAutoElement
     */
    template<class JDerived_t>
    JAutoElement& operator=(JType<JDerived_t> type) 
    {
      set(type);
 
      return *this;
    }
 
 
    /**
     * Assign given data type to the automatic pointer.
     *
     * \param  p             pointer to object
     * \return               this JAutoElement
     */
    template<class JDerived_t>
    JAutoElement& operator=(JDerived_t* p)
    {
      set(p);
 
      return *this;
    }
 
    
    /**
     * Stream input.
     *
     * \param  in            input stream
     * \param  element       element
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JAutoElement_t& element) 
    {
      if (element.is_valid())
        return element.get()->read(in);
      else
        return in;
    }  
 
    
    /**
     * Stream output.
     *
     * \param  out           output stream
     * \param  element       element
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JAutoElement_t& element) 
    {
      if (element.is_valid())
        return element.get()->write(out);
      else
        return out;
    }  
  };
 
 
  /**
   * Template selector class.
   * This class can be used to set up a list of keys that are mapped to handlers
   * which create new objects by stream input operations.
   */
  template<class JKey_t, class JBase_t> 
  class JSelector :
    public std::map<JKey_t, JAutoElement<JBase_t> >
  {
  public:
 
    typedef std::map <JKey_t, JAutoElement<JBase_t> >      map_type;
    typedef typename map_type::const_iterator              const_iterator;
    typedef typename map_type::iterator                    iterator;
    typedef typename JLANG::JClass<JKey_t>::argument_type  argument_type;
    typedef typename map_type::value_type                  value_type;
 
 
    /**
     * Default constructor.
     */
    JSelector() :
      map_type()
    {}
 
 
    /**
     * Insert data type at given key.
     *
     * \param  key           key
     * \param  type          data type
     */
    template<class JDerived_t>
    void insert(argument_type key, JType<JDerived_t> type)
    {
      map_type::insert(value_type(key, JAutoElement<JBase_t>(type)));
    }
 
 
    /**
     * Insert data type at given key.
     *
     * \param  key           key
     */
    template<class JDerived_t>
    void insert(argument_type key)
    {
      insert(key, JType<JDerived_t>());
    }
 
 
    /**
     * Insert data type at given key.
     * This object pointed to will become the default value.
     *
     * \param  key           key
     * \param  p             pointer to object
     */
    template<class JDerived_t>
    void insert(argument_type key, JDerived_t* p)
    {
      this->key = key;
 
      map_type::insert(value_type(key, JAutoElement<JBase_t>(p)));
    }
    
 
    /**
     * Get key.
     *
     * \return               key
     */
    JKey_t getKey() const
    {
      return this->key;
    }
 
 
    /**
     * Check validy of given key.
     *
     * \param  key           key
     * \return               true if given key maps to a non-NULL value; else false
     */
    bool is_valid(argument_type key) const
    {
      const_iterator i = this->find(key);
 
      return i != this->end() && i->second.is_valid() && i->second.get()->is_valid();
    }
 
 
    /**
     * Check validy of selected key.
     *
     * \return               true if selected key maps to a valid object; else false
     */
    bool is_valid() const
    {
      return key.isDefined() && is_valid(key);
    }
 
 
    /**
     * Get the object corresponding to the given key.
     *
     * \param  key           key
     * \return               object
     */
    JBase_t& get(argument_type key) const
    {
      const_iterator i = this->find(key);
 
      if (i != this->end() && i->second.is_valid() && i->second.get()->is_valid())
        return *(i->second.get()->get());
      else
        throw JNullPointerException("JSelecor<>: no object.");
    }
 
 
    /**
     * Get the object corresponding to the selected key.
     *
     * \return               selected object
     */
    JBase_t& get() const
    {
      if (key.isDefined())
        return this->get(key);
      else
        throw JNullPointerException("JSelecor<>: no selection.");
    }
 
 
    /**
     * Read selector from input stream.
     *
     * \param  in            input stream
     * \param  selector      selector
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JSelector<JKey_t, JBase_t>& selector)
    {
      if (in >> selector.key) {
 
        typename JSelector<JKey_t, JBase_t>::iterator i = selector.find(selector.key);
 
        if (i != selector.end() && i->second.is_valid())
          in >> i->second;
        else
          in.setstate(std::ios_base::failbit);
      }
      
      return in;
    }
 
 
    /**
     * Write selector to output stream.
     *
     * \param  out           output stream
     * \param  selector      selector
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JSelector<JKey_t, JBase_t>& selector)
    {
      if (selector.key.isDefined()) {
 
        typename JSelector<JKey_t, JBase_t>::const_iterator i = selector.find(selector.key);
        
        if (i != selector.end() && i->second.is_valid()) {
          return out << selector.key << ' ' << *(i->second);
        }
      }
 
      return out;
    }
 
 
  protected:
    JLANG::JParameter<JKey_t> key;
  };
}
 
#endif