/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/ntu/base

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_ntu_base
#define inlib_ntu_base

#ifdef INLIB_MEM
#include "../mem"
#endif

#include "../vmanip"
#include "../vfind"
#include "../typedefs"
#include "../scast"
#include "saida"

#include <string>
#include <vector>
#include <ostream>

namespace inlib {
namespace ntu {

class base_col {
public:
  static const std::string& s_class() {
    static const std::string s_v("inlib::ntu::base_col");
    return s_v;
  }
  virtual void* cast(const std::string& a_class) const {
    if(void* p = cmp_cast<base_col>(this,a_class)) {return p;}
    else return 0;
  }
public:
  virtual base_col* copy() const = 0;
  virtual uint64 num_elems() const = 0;
  virtual bool add() = 0;
  virtual bool reset() = 0;
protected:
  base_col(std::ostream& a_out,const std::string& a_name)
  :m_out(a_out)
  ,m_name(a_name),m_index(0){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
public:
  virtual ~base_col(){
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
protected:
  base_col(const base_col& a_from)
  :m_out(a_from.m_out)
  ,m_name(a_from.m_name)
  ,m_index(a_from.m_index){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  base_col& operator=(const base_col& a_from){
    m_name = a_from.m_name;
    m_index = a_from.m_index;
    return *this;
  }
public:
  std::string name() {return m_name;}
  const std::string& name() const {return m_name;}

  void set_index(uint64 a_index){m_index = a_index;}
protected:
  std::ostream& m_out;
  std::string m_name;
  uint64 m_index;
};

class base_ntu {
public:
  static const std::string& s_class() {
    static const std::string s_v("inlib::ntu::base_ntu");
    return s_v;
  }
  virtual void* cast(const std::string& a_class) const {
    if(void* p = cmp_cast<base_ntu>(this,a_class)) {return p;}
    else return 0;
  }
protected:
  base_ntu(std::ostream& a_out,const std::string& a_title)
  :m_out(a_out),m_title(a_title),m_index(-1){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  virtual ~base_ntu() {
    clear();
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
protected:
  base_ntu(const base_ntu& a_from)
  :m_out(a_from.m_out)
  ,m_title(a_from.m_title),m_index(a_from.m_index)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    std::vector<base_col*>::const_iterator it;
    for(it=a_from.m_cols.begin();it!=a_from.m_cols.end();++it) {
      base_col* column = (*it)->copy();
      if(!column) {
        m_out << s_class() << "::cstor :"
              << " can't copy column."
              << std::endl;
        inlib::clear<base_col>(m_cols);
        m_index = -1;
        return; //throw
      }
      m_cols.push_back(column);
    }
  }
  base_ntu& operator=(const base_ntu& a_from){
    inlib::clear<base_col>(m_cols);
    m_index = a_from.m_index;

    m_title = a_from.m_title;
    std::vector<base_col*>::const_iterator it;
    for(it=a_from.m_cols.begin();it!=a_from.m_cols.end();++it) {
      base_col* column = (*it)->copy();
      if(!column) {
        m_out << s_class << "::operator=() :"
              << " can't copy column."
              << std::endl;
        inlib::clear<base_col>(m_cols);
        m_index = -1;
        return *this;
      }
      m_cols.push_back(column);
    }

    return *this;
  }
public:
  std::ostream& out() {return m_out;}
  const std::vector<base_col*>& cols() const {return m_cols;}

  std::string title() {return m_title;}
  const std::string& title() const {return m_title;}
  void set_title(const std::string& a_title) {m_title = a_title;}

  uint64 rows() const {
    if(m_cols.empty()) return 0;
    return m_cols.front()->num_elems();
  }

  void clear() { //must not be confused with reset().
    inlib::clear<base_col>(m_cols);
    m_index = -1;
  }

  bool reset() { //clear data in columns (but not the column set)
    bool status = true;
    std::vector<base_col*>::iterator it;
    for(it=m_cols.begin();it!=m_cols.end();++it) {
      if(!(*it)->reset()) status = false;
    }
    m_index = -1;
    return status;
  }

  // reading :
  void start() {m_index = -1;set_columns_index(0);}
  bool next() { 
    // a tuple loop is of the form :
    //  tuple.start();
    //  while(tuple.next()) {
    //    ...
    //  }
    if((m_index+1)>=(int64)rows()) return false;
    m_index++;
    set_columns_index(m_index);
    return true;
  }
  int64 row_index() const {return m_index;}

  // filling :
  bool add_row() {
    bool status = true;
    std::vector<base_col*>::iterator it;
    for(it=m_cols.begin();it!=m_cols.end();++it) {
      if(!(*it)->add()) status = false;
    }
    return status;
  }

public:
  base_col* find_column(const std::string& a_name){
    return find_named<base_col>(m_cols,a_name);
  }

  void add_column(base_col* a_col) { //we take ownership.
    m_cols.push_back(a_col);
  }
protected:
  void set_columns_index(uint64 a_index) {
    std::vector<base_col*>::iterator it;
    for(it=m_cols.begin();it!=m_cols.end();++it) {
      (*it)->set_index(a_index);
    }
  }
protected:
  std::ostream& m_out;
  std::string m_title;
  int64 m_index;
  std::vector<base_col*> m_cols;
};

}}

#endif