/Users/mourrain/Devel/mmx/basix/src/dynamic.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : dynamic.cpp
* DESCRIPTION: Dynamic objects, capable of updating themselves automatically
* COPYRIGHT  : (C) 2008  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#include <basix/dynamic.hpp>


namespace mmx {

/******************************************************************************
* Dynamic objects
******************************************************************************/

dynamic_rep::dynamic_rep (const generic& val2):
  val (val2) {}

dynamic_rep::~dynamic_rep () {
  for (nat i=0; i<N(obs); i++)
    obs[i]->destroy ();
  obs= vector<observer> ();
}

void
assign (const dynamic& d, const generic& val) {
  if (val == d->val) return;
  inside (d) -> val= val;
  for (nat i=0; i<N(d->obs); i++)
    d->obs[i]->modify ();
}

void
message (const dynamic& d, const generic& msg) {
  for (nat i=0; i<N(d->obs); i++)
    d->obs[i]->message (msg);
}

void
attach (const dynamic& d, const observer& o) {
  inside (d) -> obs << o;
}

void
detach (const observer& o) {
  vector<observer>& obs= o->ref->obs;
  for (nat i=0; i<N(obs); i++)
    if (hard_eq (obs[i], o)) {
      obs= append (range (obs, 0, i), range (obs, i+1, N(obs)));
      return;
    }
  ERROR ("observer not attached");
}

/******************************************************************************
* Output observers
******************************************************************************/

void (*dynamic_event) (const string& id, const generic& val) = NULL;

string
unique_identifier (const dynamic& g) {
  return "mmx-" * as_string (hard_hash (g));
}

class output_observer_rep: public observer_rep {
public:
  inline output_observer_rep (dynamic_rep* arg): observer_rep (arg) {}
  inline ~output_observer_rep () {}
  inline nat observer_type () const { return OUTPUT_OBSERVER; }
  inline void destroy () const {}
  inline void modify () const {
    if (dynamic_event == NULL) return;
    dynamic_event (unique_identifier (dynamic (ref, true)), ref->val); }
};

observer
output_observer (dynamic_rep* arg) {
  return observer (new output_observer_rep (arg));
}

syntactic
flatten (const dynamic& g) {
  syntactic r=
    apply ("$dynamic", syntactic (unique_identifier (g)), flatten (g->val));
  for (nat i=0; i<N(g->obs); i++)
    if (g->obs[i]->observer_type () == OUTPUT_OBSERVER)
      return r;
  attach (g, output_observer (inside (g)));
  inside (g) -> ref_count++;  // never destroy printed dynamic objects
  return r;
}

/******************************************************************************
* Updaters
******************************************************************************/

class updater;
void destroy (const updater& u);  

class updater_rep: public rep_struct {
public:
  routine fun;
  dynamic_rep* ret;
  vector<dynamic> args;
  vector<observer> obs;

  inline updater_rep (const routine& fun2, dynamic_rep* ret2,
                      const vector<dynamic>& args2):
    fun (fun2), ret (ret2), args (args2) {}
  inline ~updater_rep () {}
  void update () const;

  friend class observer;
};

class updater {
INDIRECT_PROTO (updater, updater_rep)
public:
  inline updater (const routine& fun, dynamic_rep* ret,
                  const vector<dynamic>& args):
    rep (new updater_rep (fun, ret, args)) {}
  friend void destroy (const updater& u);
  friend class updater_rep;
};
INDIRECT_IMPL (updater, updater_rep)

/******************************************************************************
* Observers corresponding to updaters
******************************************************************************/

class argument_observer_rep: public observer_rep {
public:
  updater u;

  inline argument_observer_rep (dynamic_rep* arg, const updater& u2):
    observer_rep (arg), u (u2) {}
  inline ~argument_observer_rep () {}
  inline nat observer_type () const { return ARGUMENT_OBSERVER; }
  inline void destroy () const { mmx::destroy (u); }
  inline void modify () const { u->update (); }
};

observer
argument_observer (dynamic_rep* arg, const updater& u) {
  return observer (new argument_observer_rep (arg, u));
}

class result_observer_rep: public observer_rep {
public:
  updater u;

  inline result_observer_rep (dynamic_rep* res, const updater& u2):
    observer_rep (res), u (u2) {}
  inline ~result_observer_rep () {}
  inline nat observer_type () const { return RESULT_OBSERVER; }
  inline void destroy () const { mmx::destroy (u); }
  inline void modify () const {}
};

observer
result_observer (dynamic_rep* arg, const updater& u) {
  return observer (new result_observer_rep (arg, u));
}

/******************************************************************************
* Main routines for updaters
******************************************************************************/

generic
apply (const routine& fun, const vector<dynamic>& args) {
  vector<generic> a= fill<generic> (N (args));
  for (nat i= 0; i<N(a); i++)
    a[i]= args[i]->val;
  generic r= fun->apply (a);
  return r;
}

void
updater_rep::update () const {
  vector<generic> a= fill<generic> (N (args));
  for (nat i= 0; i<N(a); i++) a[i]= args[i]->val;
  assign (dynamic (ret, true), fun->apply (a));
}

dynamic::dynamic (const routine& fun, const vector<dynamic>& args):
  rep (new dynamic_rep (apply (fun, args)))
{
  updater u (fun, rep, args);
  for (nat i=0; i<N(args); i++) {
    observer arg_obs= argument_observer (inside (args[i]), u);
    attach (args[i], arg_obs);
    inside (u) -> obs << arg_obs;
  }
  observer res_obs= result_observer (rep, u);
  rep->obs << res_obs;
  inside (u) -> obs << res_obs;
}

void
destroy (const updater& u) {
  for (nat i=0; i<N(u->obs); i++) detach (u->obs[i]);
  inside (u) -> args = vector<dynamic> ();
  inside (u) -> obs  = vector<observer> ();
}

} // namespace mmx