/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/sg/node

Go to the documentation of this file.

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

#ifndef inlib_sg_node
#define inlib_sg_node

#include "../scast"
#include "field"
#include "search_action"
#include "write_action"

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

#include <vector>
#include <string>

namespace inlib {
namespace sg {
class render_action;
class pick_action;
class bbox_action;
class event_action;
}}

namespace inlib {
namespace sg {

class node {
public:
  static const std::string& s_class() {
    static const std::string s_v("inlib::sg::node");
    return s_v;
  }
  virtual void* cast(const std::string& a_class) const {
    if(void* p = inlib::cmp_cast<node>(this,a_class)) {return p;}
    else return 0;
  }
public:
  virtual node* copy() const = 0;
  virtual const std::string& s_cls() const = 0;

  virtual void render(render_action&) {}
  virtual void pick(pick_action&) {}
  virtual void bbox(bbox_action&) {}
  virtual void search(search_action& a_action) {
    if(void* p = cast(a_action.sclass())) {
      a_action.add_obj(p);
      //FIXME : if not ALL : a_action.set_done(true);
    }
  }
  virtual bool write(write_action& a_action) {
    if(!a_action.beg_node(*this)) return false;
    if(!write_fields(a_action)) return false;
    if(!a_action.end_node(*this)) return false;
    return true;
  }
  virtual void event(event_action&) {}
public:
  node(){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  virtual ~node(){
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
protected:
  node(const node&){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  node& operator=(const node&){return *this;}
protected:
  void add_field(field* a_field) {
    m_fields.push_back(a_field); //it does not take ownerhship.
  }
  bool touched() {
    std::vector<field*>::iterator it;
    for(it=m_fields.begin();it!=m_fields.end();++it) {
      if((*it)->touched()) return true;
    }
    return false;
  }
  bool write_fields(write_action& a_action) {
    unsigned int index = 0;
    std::vector<field*>::iterator it;
    for(it=m_fields.begin();it!=m_fields.end();++it,index++) {
      if(!(*it)->write(a_action.buffer())) {
        a_action.out() << "inlib::sg::node::write_fields :"
                       << " field.write() failed"
                       << " for field index " << index
                       << " of node class " << s_cls()
                       << "."
                       << std::endl;
        return false;
      }
    }
    return true;
  }
public:
  void reset_touched() {
    std::vector<field*>::iterator it;
    for(it=m_fields.begin();it!=m_fields.end();++it) {
      (*it)->reset_touched();
    }
  }
/*
  bool equal(const node& a_node) const {
    if(m_fields.size()!=a_node.m_fields.size()) return false;
    std::vector<field*>::iterator it = m_fields.begin();
    std::vector<field*>::iterator ait = a_node.m_fields.begin();
    for(;it!=m_fields.end();++it,++ait) {
      if(!(*it)->equal(*(*ait))) return false;
    }
    return true;
  }
*/
  std::vector<field*>& fields() {return m_fields;}
  const std::vector<field*>& fields() const {return m_fields;}
private:
  std::vector<field*> m_fields;
};

}}

#endif