table_doc.hpp

/* table_doc.hpp */
/* $Id$ */
#ifndef __table_doc_hpp
#define __table_doc_hpp

#include <string>

namespace hds
{
  class TableDoc
  {
  public:
    
    enum ItemType
      {
    IntegerType = 0, 
    FloatType,       
    DoubleType,      
    StringType,      
    InvalidType      
      };
    
    class AbstractItem
    {
    public:
      
      AbstractItem(const bool ro_flag = false):
    m_ro_flag(ro_flag) {/* nothing to do. */}
      
      virtual ~AbstractItem() {/* nothing to do. */}

      virtual ItemType type() const {return InvalidType;}
      
      bool readOnly() const {return m_ro_flag;}
      
      void setReadOnly(const bool ro_flag) {m_ro_flag = ro_flag;}
      
    private:
      
      bool m_ro_flag;
    };
    
    template <typename T>
    class Item : public AbstractItem
    {
    public:
      
      Item(const bool ro_flag = false):
    AbstractItem(ro_flag) {/* nothing to do. */}
      
      Item(const T &val, const bool ro_flag=false):
    AbstractItem(ro_flag), m_val(val) {/* nothing to do. */}
      
      const T& value() const {return m_val;}
      
      void setValue(const T &val) {m_val = val;}
      
      virtual ItemType type() const {return InvalidType;}
    
    private:
      
      T m_val;
    };
    
    class HdrItem 
    {
    public:
      
      HdrItem(const ItemType items_type,
          const std::string &caption_str = std::string()):
    m_items_type(items_type), 
    m_caption(caption_str) {/* nothing to do. */}
            
      ItemType type() const {return m_items_type;}
      
      void setType(const ItemType items_type) {m_items_type = items_type;}
      
      const std::string& caption() const {return m_caption;}
      
      void setCaption(const std::string &caption_str) {m_caption = caption_str;}
      
    protected:
      
      ItemType m_items_type;
      
      std::string m_caption; 
    };
    
    
    TableDoc(const std::string &name = std::string());
    
    virtual ~TableDoc() {/* nothing to do. */}

    /*
     *  Common polymorphic methods 
     */
        
    virtual size_t rowsNum() const = 0;
    
    virtual size_t colsNum() const = 0;
    
    
    virtual const HdrItem& hdrItem(const size_t col) const = 0;
        
    
    virtual const AbstractItem& item(const size_t row, const size_t col) const = 0;
    
    virtual bool setItem(const size_t row, const size_t col, const AbstractItem &item) = 0;
    
    
    virtual bool insertRow(const size_t cur_row) = 0;
    
    virtual bool removeRow(const size_t row) = 0;
    
    /*
     *  Additional features 
     */
    
    virtual bool canInsertRow(const size_t /*cur_row*/) const {return true;}
    
    virtual bool canRemoveRow(const size_t /*row*/) const {return true;}
    
    const std::string& name() const;
    
  private:
    
    std::string m_name;
  };
  
  // IntegerType table item specialization
  template <> 
  inline TableDoc::ItemType TableDoc::Item<int>::type() const {return IntegerType;}
  template <> 
  inline TableDoc::Item<int>::Item(const bool ro_flag):
    AbstractItem(ro_flag), m_val(0) {/* nothing to do */}
  
  // FloatType table item specialization
  template <> 
  inline TableDoc::ItemType TableDoc::Item<float>::type() const {return FloatType;}
  template <> 
  inline TableDoc::Item<float>::Item(const bool ro_flag):
    AbstractItem(ro_flag), m_val(0.) {/* nothing to do */}
  
  // DoubleType table item specialization
  template <> 
  inline TableDoc::ItemType TableDoc::Item<double>::type() const {return DoubleType;}
  template <> 
  inline TableDoc::Item<double>::Item(const bool ro_flag):
    AbstractItem(ro_flag), m_val(0.) {/* nothing to do */}
  
  // StringType table item specialization
  template <> 
  inline TableDoc::ItemType TableDoc::Item<std::string>::type() const {return StringType;}
  
}; // hds

#endif /* table_doc.hpp */