types.h

Go to the documentation of this file.

// -*- C++ -*-
//
//  This file is part of Siena, a wide-area event notification system.
//  See http://www.inf.usi.ch/carzaniga/siena/
//
//  Authors: Antonio Carzaniga
//  See the file AUTHORS for full details. 
//
//  Copyright (C) 2002-2003 University of Colorado
//
//  Siena 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 3 of the License, or
//  (at your option) any later version.
//  
//  Siena 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 Siena.  If not, see <http://www.gnu.org/licenses/>.
//
#ifndef SIENA_TYPES_H
#define SIENA_TYPES_H

namespace siena {
enum operator_id {
    eq_id               = 1, 
    lt_id               = 2, 
    gt_id               = 3, 
    sf_id               = 4,
    pf_id               = 5,
    ss_id               = 6,

    any_id              = 7,
    ne_id               = 8,

    re_id               = 9
};

enum type_id {
    string_id           = 1,    
    int_id              = 2,    
    double_id           = 3,    
    bool_id             = 4,    
    anytype_id          = 5     
};

typedef long long int   int_t;          
typedef double          double_t;       
typedef bool            bool_t;         
class string_t {
public:
    class iterator {
        const string_t *s;
        const char *p;
        iterator (const string_t *str, const char *where) :
            s (str), p (where) { }

      public:
        static iterator begin (const string_t &s) {
            return iterator (&s, s.begin);
        }

        static iterator end (const string_t &s) {
            return iterator (&s, s.end);
        }

        iterator (const iterator &i) : s (i.s), p (i.p) { }

        bool operator <(const iterator &i) const {
            return p < i.p;
        }

        bool operator <=(const iterator &i) const {
            return p <= i.p;
        }

        bool operator >(const iterator &i) const {
            return p > i.p;
        }

        bool operator >=(const iterator &i) const {
            return p >= i.p;
        }

        bool operator ==(const iterator &i) const {
            return p == i.p;
        }

        bool operator !=(const iterator &i) const {
            return p != i.p;
        }

        iterator &operator =(const iterator &i) {
            s = i.s;
            p = i.p;
            return *this;
        }

        const char &operator *() const {
            return *p;
        }

        const char &operator [](int n) const {
            return *(p + n);
        }

        iterator &operator += (int n) {
            p += n; return *this;
        }

        iterator operator +(int n) const {
            return iterator (s, p + n);
        }

        iterator &operator ++() {
            ++p; return *this;
        }

        iterator operator ++(int) {
            iterator i = *this; ++p; return i;
        }

        iterator& operator -= (int n) {
            p -= n; return *this;
        }

        iterator operator -(int n) const {
            return iterator (s, p - n);
        }

        int operator -(const iterator &i) const {
            return i.p - p;
        }

        iterator &operator --() {
            --p; return *this;
        }

        iterator operator --(int) {
            iterator i = *this; --p; return i;
        }

        int at_end () const {
            return p == s->end;
        }

        int index () const {
            return p - s->begin;
        }

        void set_index (int index) {
            p = s->begin + index;
        }
    };

    const char * begin;
    const char * end;
    
    string_t() : begin(0), end(0) {}
    string_t(const char * b, const char * e) : begin(b), end(e) {}
    string_t(const char * s) 
        : begin(s), end(s) { while(*end != 0) ++end; }
    string_t(const char * s, int len) : begin(s), end(s + len) {}
    string_t(const string_t & x) : begin(x.begin), end(x.end) {}
    string_t & operator = (const string_t x) { 
        begin= x.begin; end = x.end; return *this;
    }
    string_t & assign(const char * b, const char * e) { 
        begin = b; end = e; return *this;
    }

    unsigned int length() const { return end - begin; }

    const char &operator [] (int x) const { 
        return begin[x];
    }

    bool operator == (const string_t & x) const { 
        if (length() != x.length()) return false;
        const char * i = begin;
        const char * j = x.begin;
        while(i != end)
            if (*i++ != *j++) return false;
        return true;
    }

    bool operator < (const string_t & x) const { 
        const char * i = begin;
        const char * j = x.begin;
        while(i != end) {
            if (j == x.end) return false;
            if (*i < *j) return true;
            if (*i > *j) return false;
            ++i;
            ++j;
        }
        return j != x.end;
    }

    bool operator > (const string_t & x) const { 
        return x < *this;
    }

    bool operator != (const string_t & x) const { 
        return !(*this == x);
    }

    bool has_prefix (const string_t & x) const;

    bool has_suffix (const string_t & x) const;

    bool has_substring (const string_t & x) const;
};

class value {
public:
    virtual                     ~value()                        {};
    virtual type_id             type()                          const = 0;
    virtual int_t               int_value()                     const = 0;
    virtual string_t            string_value()                  const = 0;

    virtual bool_t              bool_value()                    const = 0;
    virtual double_t            double_value()                  const = 0;
};

class attribute : public value {
public:
    virtual                     ~attribute()                    {};
    virtual string_t            name()                          const = 0;
};

class constraint : public attribute {
public:
    virtual                     ~constraint()                   {};
    virtual operator_id         op()                            const = 0;

    virtual bool covers(const attribute & a) const;
};

class message {
public:
    virtual                     ~message()                      {};
    class iterator : public attribute {
    public:
        virtual bool            next()                          = 0;
        virtual                 ~iterator()                     {};
    };

    virtual iterator *          first()                         const = 0;

    virtual attribute *         find(const string_t &)          const = 0;

    virtual bool                contains(const string_t &)      const = 0;
};

class filter {
public:
    virtual                     ~filter()                       {};
    class iterator : public constraint {
    public:
        virtual bool            next()                          = 0;
        virtual                 ~iterator()                     {};
    };
    virtual iterator *          first() const = 0;

    virtual bool covers(const message & m) const;
};

class predicate {
public:
    virtual                     ~predicate()                    {};

    class iterator : public filter {
    public:
        virtual bool            next()                          = 0;
        virtual                 ~iterator()                     {};
    };

    virtual iterator *          first() const = 0;

    virtual bool covers(const message & m) const;
};

} // end namespace siena

#endif