---

asciinet.H

Go to the documentation of this file.

/*
 * Copyright 2000, 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 ASCII_NET_H
#define ASCII_NET_H

#include "event/event.H"
#include "net/network.H"

class token;
class DllImpExp cmd_line_pattern {  // this is a command line pattern: ie, DELETE <str> 
    str_ptr       _name;
    ARRAY<token*> _tokens;
    static ARRAY<cmd_line_pattern *> *_pats;

   public:
    static ARRAY<cmd_line_pattern *> &patterns()   { if (!_pats) 
                          _pats = new ARRAY<cmd_line_pattern *>;
                        return *_pats; }
                     cmd_line_pattern(Cstr_ptr &n):_name(n) { patterns() += this; }

     void            operator+=(token *t) { _tokens += t; }
     void            add_int    (Cstr_ptr &);
     void            add_str    (Cstr_ptr &);
     void            add_strlist(Cstr_ptr &);
     void            add_real   (Cstr_ptr &);

     token          *get_token  (Cstr_ptr &n);
     int             get_int    (Cstr_ptr &);
     Cstr_ptr       &get_str    (Cstr_ptr &);
     Cstr_list      &get_strlist(Cstr_ptr &);
     double          get_real   (Cstr_ptr &);


     Cstr_ptr       &name()         const { return _name; }
const ARRAY<token*> &tokens()       const { return _tokens; }
     bool            convert(str_list &t);
};


//
// EVENTascii - is a generic ASCII text EVENT
//   EVENTascii's are used to send text strings through the EVENT
// distribution mechanism.
//
MAKE_PTR_SUBC(EVENTascii, EVENT);
class EVENTascii : public EVENT {
  protected:
   ostream *_ostr;
   Cstr_ptr _msg;

       /* ------- EVENT methods ----------- */ 
   virtual bool compare(cEVENTptr &/*e*/) const { return true; }

  public:
                EVENTascii(Cstr_ptr &m,
                           ostream *ostr= 0,
                           cEVENTsource *s=0)
                   :EVENT(s), _ostr(ostr), _msg(m) { }

   virtual void debug(ostream &o)     const { o << class_name() 
                                                << "(" << _msg << ")"; }
         Cstr_ptr &text()             const { return _msg; }
         ostream *ostr()                 { return _ostr; }

       /* ------- TYPEDOBJ methods ----------- */ 
   DEFINE_DERIVED_TYPE(EVENTascii, EVENT, cEVENTptr);
   static EVENTasciiptr cast(cEVENTptr &e) { return EVENTascii::isa(e) ? 
                                                 (EVENTascii *)&*e : 0; }
};


//
// EVENTpattern - the event of a command line that matches a lexical pattern
//   EVENTpattern's are used to indicate that a lexical pattern has been
// matched.  These patterns are part of an extensible command line grammar.
//
MAKE_PTR_SUBC(EVENTpattern, EVENT);
class DllImpExp EVENTpattern : public EVENT {
  protected:
   ostream          *_ostr;
   cmd_line_pattern *_pat;

       /* ------- EVENT methods ----------- */ 
   virtual bool compare(cEVENTptr &e) const;

  public:
                EVENTpattern(cmd_line_pattern *p,
                             ostream          *ostr = 0,
                             cEVENTsource     *s=0)
                   : EVENT(s), _ostr(ostr), _pat(p){}

   cmd_line_pattern *pattern()             const { return _pat; }
            ostream *ostr()                      { return _ostr; }
   virtual void debug(ostream &o)     const;

       /* ------- TYPEDOBJ methods ----------- */ 
   DEFINE_DERIVED_TYPE(EVENTpattern, EVENT, cEVENTptr);
   static EVENTpatternptr cast(cEVENTptr &e) { return EVENTpattern::isa(e) ? 
                                                 (EVENTpattern *)&*e : 0; }
};


class DllImpExp ASCIIstream : public NetStream {
  public:
   ASCIIstream(int port, const char *name) : NetStream(port, name) {}
   ASCIIstream(int fd, struct sockaddr_in *a):NetStream(fd, a) {}

   virtual void sample();
   virtual void flush_data (void) { flush(); }
};

class ASCIInet : public Network {
   protected:
      static ASCIInet *_instance;
      NetStream *new_stream(int fd, struct sockaddr_in *a) {
         return new ASCIIstream(fd, a); 
      }
      NetStream *new_stream(int port, const char *host) {
    return Network::new_stream(port, host);
      }
   public:
      ASCIInet() {
    assert(!_instance);  // (allow only one instance..)
    _instance = this;
      }
  
  static ASCIInet *instance() { return _instance; }
};

#include "event/event.H"
#include "std/main_obs.H"
#include "config/config.H"
#include "fsa/fsa.H"


class ASCIInet_creator : public MAINobs {
public:

  ASCIInet_creator() { MAINobservers().obs(this); }

  void notify(const MAINobs::data &) {
    int port = CONFIGval("GLUE_ASCII_PORT", 8888, false);
    cerr << "... ASCIInet_creator: starting on port: " << port << endl;
    (new ASCIInet)->start(port); }
};

#endif // for the legacy option

---