---

state.H

Go to the documentation of this file.

/*
 * Copyright 1997, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef GLUE_STATE_H
#define GLUE_STATE_H

#include "std/ref.H"
#include "std/list.H"
#include "std/strings.H"
#include "fsa/arc.H"

//
//
//  STATE
//     is a STATE in an FSA.  The STATE may contain multiple
//  Arcs.  Only one Arc out of a STATE will be traversed.
//  When an Event is passed to a state, each Arc will be
//  matched to the Event.  The first Arc that matches the 
//  Event is traversed.
//
//
typedef const class STATE cSTATE;
class STATE {
   protected :
     ARRAY<ARC *>  _arcs;
     str_ptr       _name;

   public : 
                     STATE()                     { }
                     STATE(Cstr_ptr &n):_name(n) { }
     int             is_empty()                  { return !_arcs.num(); }
     void            operator +=(cSTATE &s) {
                        for (int i = 0; i < s._arcs.num(); i++) {
                           int j = 0;
                           for (; j < _arcs.num(); j++)
                              if (*_arcs[j] == *s._arcs[i]) {
                                 *_arcs[j] = *s._arcs[i]; 
                                 break;
                              }
                           if (j == _arcs.num())
                              if (!s._arcs[i]->guarded())
                                 _arcs += s._arcs[i]; 
                              else {
                                 // arcs w/guards come first for priority
                                 // over more general arcs
                                 _arcs.push(s._arcs[i]); 
                              }
                        }
                     }
     void            operator -=(cSTATE  &s) {
                        for (int i = 0; i < s._arcs.num(); i++) {
                           int j = _arcs.num() - 1;
                           for (; j >= 0; j--)
                              if (*_arcs[j] == *s._arcs[i]) {
                                 _arcs.remove(j);
                                 break;
                              }
                        }
                     }
     void            operator -=(ARC *a) { _arcs -= a; }
     void            operator +=(ARC *a) { 
                         if (a->guarded())
                              _arcs.push(a);    // first for priority
                         else _arcs += a; 
                     }
     int             consumes(cEVENTptr &e) const {
                        for (int i = 0; i < _arcs.num(); i++)
                            if (_arcs[i]->match(e))
                               return 1;
                        return 0;
                     }
     void            event(STATE *&next, cEVENTptr &e, STATE *start=0) const {
                        if (e->debug_on())
                           cerr << "\t-> State " << _name << endl;
                        next = (STATE *)this;
                        for (int i = 0; i < _arcs.num(); i++) {
                           if (_arcs[i]->match(e)) {
                              if (e->debug_on()) {
                                 cerr << "\t\tMATCH  "; 
                                 _arcs[i]->debug(cerr); 
                                 cerr << endl;
                              }
                              _arcs[i]->exec(next, e, start);
                              break;
                           } else if (e->debug_on()) {
                              cerr << "\t\t... "; 
                              _arcs[i]->debug(cerr); 
                              cerr << endl;
                           }
                        }
                     }

     void                 clear()      { _arcs.clear(); }
     const ARRAY<ARC *>  &arcs() const { return _arcs; }
           ARRAY<ARC *>  &arcs()       { return _arcs; }

     Cstr_ptr    &name()            const { return _name; }
     void         set_name(Cstr_ptr &n)   { _name = n; }
     int          operator == (cSTATE &) const
        { cerr << "XXX: Dummy STATE_t::operator== got called\n"; return 0; }
};


#endif

---