model.h

/*
 *  Copyright (c) 2005    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INCLUDED_SCOPIRA_CORE_MODEL_H__
#define __INCLUDED_SCOPIRA_CORE_MODEL_H__

#include <assert.h>

#include <vector>
#include <map>

#include <scopira/tool/object.h>
#include <scopira/tool/reactor.h>
#include <scopira/tool/iterator.h>
#include <scopira/tool/export.h>

namespace scopira
{
  namespace core
  {
    class model_ptr_base;
    template <class T> class model_ptr;

    class model_i;

    class project_i;  //fwd

    class view_i;   // fwd

    typedef scopira::tool::iterator_g<model_i*> model_iterator;
  }
}

class scopira::core::model_ptr_base
{
  protected:
    model_i *dm_model;
  public:
    model_ptr_base(void)
      : dm_model(0) { }

    model_i * const & get_model_ptr(void) const { return dm_model; }
};

template <class T> class scopira::core::model_ptr : public scopira::core::model_ptr_base
{
  public:
    typedef T data_type;

  protected:
    view_i *dm_ins;
    T *dm_ptr;

  public:
    model_ptr(view_i *ins)
      : dm_ins(ins), dm_ptr(0) { assert(ins); }
    ~model_ptr()
      { set(0); }

    void set(T* o) {
      if (o) {
        o->add_ref();
        o->add_view(dm_ins);
      }
      if (dm_ptr) {
        dm_ptr->remove_view(dm_ins);
        dm_ptr->sub_ref();
      }
      dm_ptr = o;
      dm_model = o;   // double concrete magic [NOTE]
    }
    model_ptr & operator = (T *o)
      { set(o); return *this; }

    model_ptr & operator = (const model_ptr<T> &o)
      { set(o.dm_ptr); return *this; }
    bool operator == (const model_ptr<T> &rhs) const
      { return dm_ptr == rhs.dm_ptr; }
    bool operator != (const model_ptr<T> &rhs) const
      { return dm_ptr != rhs.dm_ptr; }
    bool operator < (const model_ptr<T> &rhs) const
      { return dm_ptr < rhs.dm_ptr; }

     //oflow_i & print(oflow_i &o) const
       //{ if (dm_ptr) dm_ptr->print(o); /*else o<<"(null)";*/ return o; }

    // do save and load like the above?

    T* get(void) const
      { return dm_ptr; }
    //T* get(void)
      //{ return dm_ptr; }

    T& ref(void) const
      { assert(dm_ptr); return *dm_ptr; }
    //T& ref(void)
      //{ assert(dm_ptr); return *dm_ptr; }

    T* operator ->(void) const
      { assert(dm_ptr); return dm_ptr; }
    //T* operator ->(void)
      //{ assert(dm_ptr); return dm_ptr; }

    T & operator *(void) const
      { assert(dm_ptr); return *dm_ptr; }

    bool is_null(void) const { return dm_ptr == 0; }
};

class scopira::core::model_i : public virtual scopira::tool::object
{
  private:
    typedef std::vector<view_i*> view_list;
    typedef std::vector<scopira::tool::rename_reactor_i*> rename_list;
    typedef std::map<std::string, scopira::tool::count_ptr<model_i> > archive_cache_t;

    mutable view_list dm_views;
    mutable rename_list dm_rename_reactors;
    std::string dm_title;
    project_i *dm_owner;

    // mutable? mutex locked?
    archive_cache_t dm_archive_cache;

  public:
    SCOPIRA_EXPORT virtual bool load(scopira::tool::iobjflow_i& in);
    SCOPIRA_EXPORT virtual void save(scopira::tool::oobjflow_i& out) const;

    SCOPIRA_EXPORT virtual void set_title(const std::string &newtitle);

    virtual bool is_project(void) const { return false; }

    const std::string & get_title(void) const { return dm_title; }

    SCOPIRA_EXPORT void add_view(view_i *ins) const;
    SCOPIRA_EXPORT void remove_view(view_i *ins) const;
    SCOPIRA_EXPORT void notify_views(view_i *src);

    SCOPIRA_EXPORT void add_rename_reactor(tool::rename_reactor_i *r) const;
    SCOPIRA_EXPORT void remove_rename_reactor(tool::rename_reactor_i *r) const;

    SCOPIRA_EXPORT virtual void set_project(project_i *newowner);

    project_i * get_project(void) const { return dm_owner; }

    SCOPIRA_EXPORT void set_tagged_model(const std::string &name, model_i *what);

    template <class W>
      bool get_tagged_model(const std::string &name, W &out) {
        typedef typename W::data_type data_type;   // just to make sure they dont pass us a simple *T
        scopira::tool::count_ptr<scopira::core::model_i> mm;
        if (!get_tagged_model_impl(name, mm))
          return false;
        out = dynamic_cast<data_type*>(mm.get());
        return mm.is_null() || out.get();   // success is if the data was null OR the cast worked
      }

  protected:
    SCOPIRA_EXPORT model_i(void);
    SCOPIRA_EXPORT model_i(const std::string &title);
    SCOPIRA_EXPORT model_i(const model_i &src);
    SCOPIRA_EXPORT virtual ~model_i();

  private:
    SCOPIRA_EXPORT bool get_tagged_model_impl(const std::string &name,
        scopira::tool::count_ptr<scopira::core::model_i> &out);
};

#endif