attributes.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_ATTRIBUTES_H_INCLUDED
#define SIENA_ATTRIBUTES_H_INCLUDED

#include <exception>
#include <string>

namespace siena {
enum OperatorId {
    EQ                  = 1, 
    LT                  = 2, 
    GT                  = 3, 
    SF                  = 4,
    PF                  = 5,
    SS                  = 6,

    ANY                 = 7,
    NE                  = 8,

    RE                  = 9
};

enum TypeId {
    STRING              = 1,    
    INT                 = 2,    
    DOUBLE              = 3,    
    BOOL                = 4,    
    ANYTYPE             = 5     
};

typedef long int        Int;    
typedef double          Double; 
typedef bool            Bool;   
class String {
public:
    const char * begin;
    const char * end;
    
    String() : begin(0), end(0) {}

    String(const char * b, const char * e) : begin(b), end(e) {}

    String(const char * s) 
        : begin(s), end(s) { while(*end != 0) ++end; }

    String(const char * s, int len) : begin(s), end(s + len) {}

    String(const String & x) : begin(x.begin), end(x.end) {}

    String & operator = (const String x) { 
        begin= x.begin; end = x.end; return *this;
    }

    String & 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 & x) const;

    bool operator < (const String & x) const;

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

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

    bool has_prefix (const String & x) const;

    bool has_suffix (const String & x) const;

    bool has_substring (const String & x) const;

    std::string & to_string(std::string & s) const;

    std::string to_string() const;
};

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

    virtual TypeId type() const = 0;

    virtual Int int_value() const = 0;

    virtual String string_value() const = 0;

    virtual Bool bool_value() const = 0;

    virtual Double double_value() const = 0;
};

class Attribute : public Value {
public:
    virtual ~Attribute() {};
    virtual String name() const = 0;
};

class Constraint : public Attribute {
public:
    virtual ~Constraint() {};
    virtual OperatorId op() const = 0;

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

class BadConstraint : public std::exception {
    std::string err_descr;

public:
    BadConstraint(const std::string & e) 
        : err_descr(e) {}

    virtual ~BadConstraint() throw() {}

    virtual const char* what() const throw() {
        return err_descr.c_str();
    }
};

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 &) const = 0;

    virtual bool contains(const String &) 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