html/table.hh

#ifndef HTML_TABLE_HH
#define HTML_TABLE_HH

#include "html/compound.hh"
#include "html/Attrib.hh"
#include <vector>
#include <string>
#include <stdexcept>

namespace html {
  class align;

  class cell : public compound {
  public:
    cell(void);

    virtual ~cell(void);

    cell* clone(void) const;

    const char* getTag(void) const {return "td";}

    void setAlign(const std::string& a);

    void setSave(bool on);
  };

  class table : public object {
  public:
    table(void);

    table(const std::string& title);

    table(const table& x);

    virtual ~table(void);

    table* clone(void) const;

    table& operator=(const table& x);

    void write(writer& out) const;

    int  addColumn(const std::string& title);

    int  addRow(void);

    void eraseRow(int row, int count=1) throw(std::runtime_error);

    void insertData(int row, int col, double x, int wid=-1, int prec=-1) 
                    throw(std::runtime_error);

    void insertData(int row, int col, long x, int wid=-1, int radix=10) 
                    throw(std::runtime_error);

    void insertData(int row, int col, const std::string& txt) 
                    throw(std::runtime_error);

    void insertData(int row, int col, const object& obj) 
                    throw(std::runtime_error);

    void insertRow(int row) throw(std::runtime_error);

    int getNRow(void) const;

    int getNColumn(void) const;

    cell& refHeader(int col) throw(std::runtime_error);

    const cell& refHeader(int col) const throw(std::runtime_error);

    cell& refCell(int row, int col) throw(std::runtime_error);

    const cell& refCell(int row, int col) const throw(std::runtime_error);

    void setBorder(bool On=true);

  private:
    int inxrc(int row, int col) const throw(std::runtime_error);

  private:
    std::string mTitle;
    int mRow;
    typedef std::vector<cell> ColHdr;
    ColHdr    mCTitle;
    attList   mAttrib;
    typedef std::vector<cell*> TableData;
    TableData mData;
  };

}

//======================================  Inline functions
inline int 
html::table::getNColumn(void) const {
    return mCTitle.size();
}

inline int 
html::table::getNRow(void) const {
    return mRow;
}

inline int
html::table::inxrc(int row, int col) const throw(std::runtime_error) {
    if (row >= mRow || row < 0) throw std::runtime_error("Invalid Row.");
    int nCol = getNColumn();
    if (col >= nCol || col < 0) throw std::runtime_error("Invalid Column.");
    return row*nCol + col;
}

inline const html::cell& 
html::table::refCell(int row, int col) const throw(std::runtime_error) {
    return *mData[inxrc(row, col)];
}

inline html::cell& 
html::table::refCell(int row, int col) throw(std::runtime_error) {
    return *mData[inxrc(row, col)];
}

inline const html::cell& 
html::table::refHeader(int col) const throw(std::runtime_error) {
    if (col<0 || col>=getNColumn()) throw std::runtime_error("Invalid Column.");
    return mCTitle[col];
}

inline html::cell& 
html::table::refHeader(int col) throw(std::runtime_error) {
    if (col<0 || col>=getNColumn()) throw std::runtime_error("Invalid Column.");
    return mCTitle[col];
}

#endif  // HTML_TABLE_HH

---