Siena C++ API documentation (v. 0.4.3)

---

Siena.h

// -*- C++ -*-
//
//  This file is part of Siena, a wide-area event notification system.
//  See http://www.cs.colorado.edu/serl/siena/
//
//  Author: Antonio Carzaniga <[email protected]>
//  See the file AUTHORS for full details. 
//
//  Copyright (C) 1998-2001 University of Colorado
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 2
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
//  USA, or send email to [email protected].
//
//
// $Id: Siena.h,v 1.1 2003/07/09 20:17:31 carzanig Exp $
// 
#ifndef _Siena_h
#define _Siena_h

#include <sienaconf.h>

#include <sys/types.h>

#ifdef HAVE_STDINT_H
#include <stdint.h>
#else
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#endif

#include <vector>
#include <map>
#include <exception>
#include <string>

using namespace std;

#ifdef WITH_DATE
#include <siena/Date.h>
#endif
#include <siena/SienaId.h>

#ifdef HAVE_CXX_NAMESPACE

namespace Siena {
#endif

class SienaBase;
class SienaPush;
class SienaPull;
class Notifiable;
class AttributeValue;
class Notification;
class AttributeConstraint;
class Filter;
class Pattern;
class NotificationSequence;

class BadType;

class SienaBase {
public:
    virtual void        publish(const Notification &e)                  = 0;

    virtual void        advertise(const Filter &f, const SienaId &);

    virtual void        unadvertise(const Filter &, const SienaId &);
    virtual void        unadvertise(const SienaId &);

    virtual void        shutdown();
};

class SienaPush: public SienaBase {
public:
    virtual void        subscribe(const Filter &f, Notifiable *n)       = 0;
    virtual void        subscribe(const Pattern &p, Notifiable *n);

    virtual void        unsubscribe(const Filter &f, Notifiable *n)     = 0;
    virtual void        unsubscribe(const Pattern &p, Notifiable *n);
    virtual void        unsubscribe(Notifiable *)                       = 0;

    virtual void        suspend(Notifiable *n)                          = 0;
    virtual void        resume(Notifiable *)                            = 0;
};

class SienaPull: public SienaBase {
public:
    virtual void        subscribe(const Filter &f)                      = 0;
    virtual void        subscribe(const Pattern &p);

    virtual void        unsubscribe(const Filter &f)                    = 0;
    virtual void        unsubscribe(const Pattern &p);
    virtual void        unsubscribe()                                   = 0;

    virtual void        suspend()                                       = 0;
    virtual void        resume()                                        = 0;

    virtual Notification *              get_notification()              = 0;
    virtual NotificationSequence *      get_notification_sequence()     = 0;
};

class Notifiable {
 public:
    virtual void        notify(Notification &e)                         = 0;

    virtual void        notify(NotificationSequence &s)                 = 0;
};

enum SXType {
    SX_null                     = 0,
    SX_string                   = 1,
    SX_integer                  = 2,
    SX_bool                     = 3,
    SX_date                     = 4,
    SX_double                   = 5,
};

extern const string     SXTypeDescription[];

class AttributeValue {
 public:
    
                        AttributeValue();
                        AttributeValue(const AttributeValue &v);
                        AttributeValue(const string &);
                        AttributeValue(const char *);
                        AttributeValue(int);
                        AttributeValue(short);
                        AttributeValue(long);
                        AttributeValue(bool);
                        AttributeValue(double);
#ifdef WITH_DATE
                        AttributeValue(const Date &);
#endif
                        ~AttributeValue();

    SXType              type()                                  const;

    int32_t &           int_value();

    bool &              bool_value();

    string &            string_value();

    double &            double_value();
#ifdef WITH_DATE

    Date &              date_value();
#endif

    const int32_t &     int_value()                             const;
    const bool &        bool_value()                            const;
    const string &      string_value()                          const;
    const double &      double_value()                          const;
#ifdef WITH_DATE

    const Date &        date_value()                            const;
#endif

                        operator long ()                        const;

                        operator int ()                 const;

                        operator short ()                       const;

                        operator string ()                      const;
                        operator bool ()                        const;
                        operator double ()                      const;
#ifdef WITH_DATE

                        operator Date ()                        const;
#endif

    AttributeValue &    operator = (const AttributeValue &);
    AttributeValue &    operator = (const string &);
    AttributeValue &    operator = (const char *);
    AttributeValue &    operator = (int);
    AttributeValue &    operator = (short);
    AttributeValue &    operator = (long);
    AttributeValue &    operator = (bool);
    AttributeValue &    operator = (double);
#ifdef WITH_DATE

    AttributeValue &    operator = (const Date &);
#endif

    bool                operator == (const AttributeValue &)    const;
    bool                operator < (const AttributeValue &)     const;

 protected:
    SXType              sxtype;
    union {
        string *        str;
        int32_t         num;
        bool            bln;
        double          dbl;
#ifdef WITH_DATE
        Date *          date;
#endif
    };
};

class Notification : public map<string, AttributeValue> {
 public:
                        Notification();
                        Notification(const Notification &);

    Notification &      operator = (const string &);
};

enum SXOperator {
    SX_eq               = 1, 
    SX_lt               = 2, 
    SX_gt               = 3, 
    SX_ge               = 4, 
    SX_le               = 5, 
    SX_sf               = 7,
    SX_pf               = 6,
    SX_any              = 8, 
    SX_ne               = 9, 
    SX_ss               = 10 
};

extern const string     SXOperatorDescription[];

extern bool             apply_operator(SXOperator op, 
                                       const AttributeValue & x, 
                                       const AttributeValue & y);

class AttributeConstraint {
 public:
    SXOperator  op;
    AttributeValue      value;

                        AttributeConstraint();
                        AttributeConstraint(const AttributeValue & v);

                        AttributeConstraint(SXOperator o,
                                            const AttributeValue & v);
                        AttributeConstraint(const AttributeConstraint & c);

    AttributeConstraint &       operator = (const AttributeConstraint & c);

    AttributeConstraint &       operator = (const AttributeValue & v);

    bool                operator == (const AttributeConstraint & c) const;

    bool                apply_to(const AttributeValue & v);
};

class Filter : public multimap<string, AttributeConstraint> {
 public:
                        Filter();
                        Filter(const Filter &);

    Filter &            operator = (const string &);

    bool                operator == (const Filter &)            const;

    iterator            add_constraint(const string &, 
                                       SXOperator, const AttributeValue &);

    iterator            add_constraint(const string &, 
                                       const AttributeConstraint &);

    Filter &            reduce();
};

class Pattern: public vector<Filter> {
//
// a Pattern is simply a list of (event) filters. This might be
// changed in the future, requiring a more complex data structure
//
 public:
                        Pattern();
                        Pattern(const Pattern &);
};

class NotificationSequence: public vector<Notification> {
//
// a Pattern is simply a list of (event) filters. This might be
// changed in the future, requiring a more complex data structure
//
 public:
                        NotificationSequence();
                        NotificationSequence(const NotificationSequence &);
};

class SienaException: public exception {
    virtual const char *        what()                          const throw ();
};

class ServiceUnavailable: public exception {
    virtual const char *        what()                          const throw ();
};

class NotificationModelException: public SienaException {
    virtual const char *        what()                          const throw ();
};

class BadType: public NotificationModelException {
 public:
    SXType                      type;

                                BadType(SXType);

    virtual const char *        what()                          const throw ();
};

class BadOperator: virtual public NotificationModelException {
public:
    SXOperator          op;
                                BadOperator(SXOperator); 

    virtual const char *        what()                          const throw ();
};

class NullFilter: virtual public NotificationModelException {
public:
    string                      name;
    AttributeConstraint         af1;
    AttributeConstraint         af2;

                                NullFilter(const AttributeConstraint &,
                                           const AttributeConstraint &);
                                NullFilter(const string &,
                                           const AttributeConstraint &,
                                           const AttributeConstraint &);

    virtual                     ~NullFilter() throw() {};

    virtual const char *        what()                          const throw ();
};

#ifndef NO_INLINE
#include <siena/Siena.icc>
#endif

#ifdef HAVE_CXX_NAMESPACE
};
#endif

#endif

---

Copyright © 2001 University of Colorado.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License". This documentation is authored and maintained by Antonio Carzaniga