Siena Simplification Library Documentation (v. 1.1.4)

ssimp_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.cs.colorado.edu/serl/siena/
//
//  Authors: See the file AUTHORS for full details.
//
//  Copyright (C) 2002-2004 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: ssimp_types.h,v 1.8 2006/05/05 13:53:47 carzanig Exp $
//
#ifndef SIMP_TYPES_H
#define SIMP_TYPES_H

#include <map>
#include <set>
#include <sstream>
#include <string>
#include "siena/simplify.h"

class Constraint : public siena::constraint
{
  class Value
  {
  public:
    Value( bool b )
      : m_type( siena::bool_id ), m_bool( b ),
        m_bytesize( sizeof( siena::type_id ) + sizeof( bool ) ) {}

    Value( double d )
      : m_type( siena::double_id ), m_double( d ),
        m_bytesize( sizeof( siena::type_id ) + sizeof( double ) ) {}

    Value( int i )
      : m_type( siena::int_id ), m_int( i ),
        m_bytesize( sizeof( siena::type_id ) + sizeof( int ) ) {}

    Value( const std::string& s )
      : m_type( siena::string_id ), m_string( s ),
        m_bytesize( sizeof( siena::type_id ) + s.length() ) {}

    Value()
      : m_type( siena::anytype_id ), m_int( 0 ),
        m_bytesize( sizeof( siena::type_id ) ) {}

    Value( const Value& v )
    {
      m_type = v.m_type;
      switch( m_type )
        {
        case siena::bool_id: m_bool = v.m_bool; break;
        case siena::double_id: m_double = v.m_double; break;
        case siena::anytype_id:
        case siena::int_id: m_int = v.m_int; break;
        default: m_string = v.m_string;
        }
      m_bytesize = v.m_bytesize;
    }

    const Value& operator= ( const Value& v )
    {
      m_type = v.m_type;
      switch( m_type )
        {
        case siena::bool_id: m_bool = v.m_bool; break;
        case siena::double_id: m_double = v.m_double; break;
        case siena::anytype_id:
        case siena::int_id: m_int = v.m_int; break;
        default: m_string = v.m_string;
        }
      m_bytesize = v.m_bytesize;
      return (*this);
    }

    bool operator== ( const Value& v ) const
    {
      if( m_type != v.m_type ) { return false; }
      switch( m_type )
        {
        case siena::bool_id: return m_bool == v.m_bool;
        case siena::double_id: return m_double == v.m_double;
        case siena::int_id: return m_int == v.m_int;
        case siena::anytype_id: return true;
        default: return m_string == v.m_string;
        }
    }

    bool operator< ( const Value& v ) const
    {
      if( m_type != v.m_type ) { return m_type < v.m_type; }
      switch( m_type )
        {
        case siena::bool_id: return m_bool < v.m_bool;
        case siena::double_id: return m_double < v.m_double;
        case siena::int_id: return m_int < v.m_int;
        case siena::anytype_id: return false;
        default: return m_string < v.m_string;
        }
    }

    bool operator> ( const Value& v ) const
    {
      if( m_type != v.m_type ) { return m_type > v.m_type; }
      switch( m_type )
        {
        case siena::bool_id: return m_bool > v.m_bool;
        case siena::double_id: return m_double > v.m_double;
        case siena::int_id: return m_int > v.m_int;
        case siena::anytype_id: return false;
        default: return m_string > v.m_string;
        }
    }

    bool operator<= ( const Value& v ) const
    {
      if( m_type != v.m_type ) { return m_type <= v.m_type; }
      switch( m_type )
        {
        case siena::bool_id: return m_bool <= v.m_bool;
        case siena::double_id: return m_double <= v.m_double;
        case siena::int_id: return m_int <= v.m_int;
        case siena::anytype_id: return true;
        default: return m_string <= v.m_string;
        }
    }

    bool operator>= ( const Value& v ) const
    {
      if( m_type != v.m_type ) { return m_type >= v.m_type; }
      switch( m_type )
        {
        case siena::bool_id: return m_bool >= v.m_bool;
        case siena::double_id: return m_double >= v.m_double;
        case siena::int_id: return m_int >= v.m_int;
        case siena::anytype_id: return true;
        default: return m_string >= v.m_string;
        }
    }

    bool operator!= ( const Value& v ) const
    {
      if( m_type != v.m_type ) { return true; }
      switch( m_type )
        {
        case siena::bool_id: return m_bool != v.m_bool;
        case siena::double_id: return m_double != v.m_double;
        case siena::int_id: return m_int != v.m_int;
        case siena::anytype_id: return false;
        default: return m_string != v.m_string;
        }
    }

    size_t bytesize() const { return m_bytesize; }

    siena::type_id m_type;
    union
    {
      bool m_bool;
      double m_double;
      int m_int;
    };
    std::string m_string;
    size_t m_bytesize;
  };

public:
  Constraint( const std::string& name, siena::operator_id op, siena::bool_t b )
    : m_name( name ), m_op( op ), m_value( b ),
      m_bytesize( name.length() + sizeof( siena::operator_id ) + m_value.bytesize() ) {}

  Constraint( const std::string& name, siena::operator_id op, siena::double_t d )
    : m_name( name ), m_op( op ), m_value( d ),
      m_bytesize( name.length() + sizeof( siena::operator_id ) + m_value.bytesize() ) {}

  Constraint( const std::string& name, siena::operator_id op, siena::int_t i )
    : m_name( name ), m_op( op ), m_value( (int)i ),
      m_bytesize( name.length() + sizeof( siena::operator_id ) + m_value.bytesize() ) {}

  Constraint( const std::string& name, siena::operator_id op, const std::string& s )
    : m_name( name ), m_op( op ), m_value( s ),
      m_bytesize( name.length() + sizeof( siena::operator_id ) + m_value.bytesize() ) {}

  Constraint( const std::string& name )
    : m_name( name ), m_op(siena::any_id), m_value(),
      m_bytesize( name.length() + sizeof( siena::operator_id ) ) {}

  Constraint( const Constraint& c )
    : m_name( c.m_name ), m_op( c.m_op ), m_value( c.m_value ),
      m_bytesize( c.m_bytesize ) {}

  const Constraint& operator=( const Constraint& c )
  {
    m_name = c.m_name; m_op = c.m_op;
    m_value = c.m_value; m_bytesize = c.m_bytesize;
    return *this;
  }

  bool operator==( const Constraint& c ) const
  { return m_name == c.m_name && m_op == c.m_op && m_value == c.m_value; }

  bool operator<( const Constraint& c ) const
  {
    if( m_name != c.m_name ) { return m_name < c.m_name; }
    else if( m_op != c.m_op ) { return m_op < c.m_op; }
    else { return m_value < c.m_value; }
  }

  ~Constraint() {}

  siena::bool_t bool_value() const
  { return m_value.m_bool; }

  siena::double_t double_value() const
  { return m_value.m_double; }

  size_t bytesize() const
  { return m_bytesize; }

  siena::int_t int_value() const
  { return m_value.m_int; }

  siena::string_t name() const
  { return siena::string_t( m_name.c_str(), m_name.length() ); }

  siena::operator_id op() const
  { return m_op; }

  std::ostream& sff(std::ostream& out) const;

  std::string str() const;

  siena::string_t string_value() const
  { return siena::string_t( m_value.m_string.c_str(), m_value.m_string.length() ); }

  siena::type_id type() const
  { return m_value.m_type; }

private:
  std::string           m_name;
  siena::operator_id    m_op;
  Value                 m_value;
  size_t                m_bytesize;
};

inline std::ostream& operator<< ( std::ostream& out, const Constraint& c )
{ return out << c.str(); }

template<bool Simplify> class TFilter : public siena::filter
{
public:
  class Iterator : public siena::filter::iterator
  {
  public:
    Iterator( std::set<Constraint>::iterator begin, std::set<Constraint>::iterator end )
      : m_end( end ), m_index( begin ) {}

    ~Iterator() {}

    siena::bool_t bool_value() const
    { return (*m_index).bool_value(); }

    siena::double_t double_value() const
    { return (*m_index).double_value(); }

    siena::int_t int_value() const
    { return (*m_index).int_value(); }

    siena::string_t name() const
    { return (*m_index).name(); }

    bool next()
    {
      if( m_index == m_end || ++m_index == m_end ) { return false; }
      else { return true; }
    }

    siena::operator_id op() const
    { return (*m_index).op(); }

    std::ostream& sff(std::ostream& out) const;

    std::string str() const
    { return (*m_index).str(); }

    siena::string_t string_value() const
    { return (*m_index).string_value(); }

    siena::type_id type() const
    { return (*m_index).type(); }

  private:
    std::set<Constraint>::iterator m_end;
    std::set<Constraint>::iterator m_index;
  };

  TFilter()
    : m_conflicted( false ), m_bytesize( 0 ) {}

  ~TFilter() {}

  TFilter( const TFilter& f )
    : m_conflicted( f.m_conflicted ), m_constraints( f.m_constraints ),
      m_bytesize( f.m_bytesize ) {}

  const TFilter& operator=( const TFilter& f )
  {
    m_conflicted = f.m_conflicted;
    m_constraints = f.m_constraints;
    m_bytesize = f.m_bytesize;
    return (*this);
  }

  bool operator<( const TFilter& f ) const
  { 
    /*
     * not sure that the extra test with the size is necessary...
     */
    if( m_constraints.size() != f.m_constraints.size() )
      { return m_constraints.size() < f.m_constraints.size(); }
    return m_constraints < f.m_constraints;
  }

  bool operator== ( const TFilter& f ) const
  { return m_constraints == f.m_constraints; }

  void add( const Constraint& c )
  {
    if( Simplify )
      {
        // once a filter is conflicted there is no point in adding
        // constraints to it.
        if( m_conflicted )
          {
            return;
          }
        std::set<Constraint>::iterator i = m_constraints.begin(); 
        while ( i != m_constraints.end() )
          {
            if( conflicting( (*i), c ) )
              {
                m_conflicted = true;
                m_constraints.clear();
                m_bytesize = 0;
                return;
              }
            if( siena::covers( c, (*i) ) )
              {
                return;
              }
            if( siena::covers( (*i), c ) )
              {
                m_bytesize -= (*i).bytesize();
                m_constraints.erase( i++ );
              }
            else 
              {
                ++i;
              }
          }
      }
    if( m_constraints.insert( c ).second )
      {
        m_bytesize += c.bytesize();
      }
  }

  Iterator* first() const
  {
    if( m_constraints.empty() )  { return NULL; }
    return new Iterator( m_constraints.begin(), m_constraints.end() );
  }

  const std::set<Constraint>& getConstraints() const
  { return m_constraints; }

  size_t bytesize() const { return m_bytesize; }

  std::ostream& sff(std::ostream& out) const
  {
    std::set<Constraint>::const_iterator i;
    for( i = m_constraints.begin(); i != m_constraints.end(); ++i )
      {
        if( i != m_constraints.begin() )
          {
            out <<  ", ";
          }
        (*i).sff(out);
      }
    return out;
  }

  int size() const { return m_constraints.size(); }

  std::string str() const
  {
    std::ostringstream oss;
    oss << "[Filter: constraints={";
    std::set<Constraint>::const_iterator i;
    for( i = m_constraints.begin(); i != m_constraints.end(); ++i )
      {
        if( i != m_constraints.begin() )
          {
            oss <<  ",";
          }
        oss <<  (*i).str();
      }
    oss << "}]";
    return oss.str();
  }

private:
  bool                  m_conflicted;
  std::set<Constraint>  m_constraints;
  size_t                m_bytesize;
};

template<bool Simplify> inline std::ostream& operator<<( std::ostream& out, const TFilter<Simplify>& f )
{ return out << f.str(); }

typedef TFilter<false> BasicFilter;
typedef TFilter<true> SimplifyingFilter;

template<bool Simplify> class TPredicate : public siena::predicate
{
public:
  typedef TFilter<Simplify> filter_type;
  typedef typename filter_type::Iterator filter_iterator;
  typedef typename std::set<filter_type>::iterator filter_set_iterator;
  typedef typename std::set<filter_type>::const_iterator const_filter_set_iterator;

  class Iterator : public siena::predicate::iterator
  {
  public:
    Iterator( filter_set_iterator begin, filter_set_iterator end )
      : m_end( end ), m_index( begin ) {}

    filter_iterator* first() const
    { return (*m_index).first(); }

    ~Iterator() {}

    bool next()
    {
      if( m_index == m_end || ++m_index == m_end ) { return false; }
      else { return true; }
    }

    std::string str() const
    { return (*m_index).str(); }

  private:
    filter_set_iterator m_end;
    filter_set_iterator m_index;
  };

  TPredicate() : m_bytesize( 0 ) {}

  TPredicate( const TPredicate& p )
    : m_filters( p.m_filters ), m_bytesize( p.m_bytesize ) {}

  ~TPredicate() {}

  const TPredicate& operator= ( const TPredicate& p )
  {
    m_filters = p.m_filters;
    m_bytesize = p.m_bytesize;
    return *this;
  }

  bool operator== ( const TPredicate& p ) const
  { return m_filters == p.m_filters; }

  void add( const TPredicate& p );

  void add( const filter_type& f );

  void clear()
  { m_bytesize = 0; m_filters.clear(); }

  Iterator* first() const
  {
    if( m_filters.empty() ) { return NULL; }
    return new Iterator( m_filters.begin(), m_filters.end() );
  }

  size_t bytesize() const
  { return m_bytesize; }

  const std::set<filter_type>& getFilters() const
  { return m_filters; }

  std::ostream& sff(std::ostream& out) const;

  int size()  const
  { return m_filters.size(); }

  std::string str() const;
private:
  std::set<filter_type> m_filters;
  size_t                m_bytesize;
};

template<bool Simplify> inline void TPredicate<Simplify> :: add( const TPredicate<Simplify>& p )
{
  const_filter_set_iterator i;
  for( i = p.m_filters.begin(); i != p.m_filters.end(); ++i )
    {
      add( *i );
    }
}

template<bool Simplify> inline void TPredicate<Simplify> :: add( const TPredicate<Simplify>::filter_type& f )
{
  if( Simplify )
    {
      // no point in adding empty filters
      if( ! f.size() )
        {
          return;
        }
      filter_set_iterator i = m_filters.begin();
      while ( i != m_filters.end() )
        {
          if( siena::covers( (*i), f ) )
            {
              return;
            }
          if( siena::covers( f, (*i) ) )
            {
              m_bytesize -= (*i).bytesize();
              m_filters.erase( i++ );
            }
          else
            {
              ++i;
            }
        }
    }
  if( m_filters.insert( f ).second )
    {
      m_bytesize += f.bytesize();
    }
}

template<bool Simplify> inline std::ostream& TPredicate<Simplify> :: sff(std::ostream& out) const
{
  const_filter_set_iterator i;
  for( i = m_filters.begin(); i != m_filters.end(); ++i )
    {
      if( i != m_filters.begin() )
        {
          out << std::endl << " | ";
        }
      (*i).sff(out);
    }
  return out;
}

template<bool Simplify> inline std::string TPredicate<Simplify> :: str() const
{
  std::ostringstream oss;
  oss << "[Predicate: bytesize=" << m_bytesize << ",filters={";
  const_filter_set_iterator i;
  for( i = m_filters.begin(); i != m_filters.end(); ++i )
    {
      if( i != m_filters.begin() )
        {
          oss <<  ",";
        }
      oss <<  (*i).str();
    }
  oss << "}]";
  return oss.str();
}

template<bool Simplify> inline std::ostream& operator<<( std::ostream& out, const TPredicate<Simplify>& p )
{ return out << p.str(); }

typedef TPredicate<false> BasicPredicate;

typedef TPredicate<true> SimplifyingPredicate;

class Message : public siena::message
{
public:
  class Value
  {
  public:
    Value(bool b) : type(siena::bool_id), b_value(b) { }
    Value(double d) : type(siena::double_id), d_value(d) { }
    Value(int i) : type(siena::int_id), i_value(i) { }
    Value(std::string s) : type(siena::string_id), s_value(s) { }

    Value( const Value& v )
    {
      type = v.type;
      switch( v.type )
        {
        case siena::bool_id: b_value = v.b_value; break;
        case siena::double_id: d_value = v.d_value; break;
        case siena::int_id: i_value = v.i_value; break;
        default: s_value = v.s_value;
        }
    }

    const Value& operator= ( const Value& v )
    {
      type = v.type;
      switch( v.type )
        {
        case siena::bool_id: b_value = v.b_value; break;
        case siena::double_id: d_value = v.d_value; break;
        case siena::int_id: i_value = v.i_value; break;
        default: s_value = v.s_value;
        }
      return *this;
    }

    size_t bytesize() const;

    std::string str() const;

    siena::type_id type;
    union
    {
      bool b_value;
      double d_value;
      int i_value;
    };
    std::string s_value;
  };

  class Iterator : public siena::message::iterator
  {
    std::map<std::string,Value>::const_iterator m_itr;
    std::map<std::string,Value>::const_iterator m_end;
  public:
    Iterator( std::map<std::string,Value>::const_iterator itr,
              std::map<std::string,Value>::const_iterator end )
      : m_itr( itr ), m_end( end ) {}
    
    ~Iterator() {}

    siena::bool_t bool_value() const
    {
      if( (*m_itr).second.type != siena::bool_id ) { return false; }
      return (*m_itr).second.b_value;
    }

    siena::double_t double_value() const
    {
      if( (*m_itr).second.type != siena::double_id ) { return 0.0; }
      return (*m_itr).second.d_value;
    }

    siena::int_t int_value() const
    {
      if( (*m_itr).second.type != siena::int_id ) { return 0; }
      return (*m_itr).second.i_value;
    }

    siena::string_t string_value() const
    {
      return siena::string_t( (*m_itr).second.s_value.c_str(), 
                              (*m_itr).second.s_value.length() );
    }

    siena::type_id type() const
    { return (*m_itr).second.type; }

    siena::string_t name() const
    { return siena::string_t( (*m_itr).first.c_str(), (*m_itr).first.length() ); }

    bool next()
    {
      if( m_itr == m_end )
        {
          return false;
        }
      return ++m_itr != m_end;
    }
  };

  Message() {}

  Message( const Message& m ) : m_attrMap( m.m_attrMap ) {}

  ~Message() {}

  const Message& operator= ( const Message& m )
  { m_attrMap = m.m_attrMap; return (*this); }

  void add( const std::string& name, bool val )
  {
    m_attrMap.insert(make_pair(name, Value(val)));
  }

  void add( const std::string& name, double val )
  {
    m_attrMap.insert(make_pair(name, Value(val)));
  }

  void add( const std::string& name, int val )
  {
    m_attrMap.insert(make_pair(name, Value(val)));
  }
    
  void add( const std::string& name, const std::string& val )
  {
    m_attrMap.insert(make_pair(name, Value(val)));
  }

  bool contains( const siena::string_t& name ) const
  { return m_attrMap.find( std::string( name.begin, name.length() ) ) != m_attrMap.end(); }

  siena::message::iterator* first() const
  {
    if( m_attrMap.size() == 0 ) { return NULL; }
    return new Message::Iterator( m_attrMap.begin(), m_attrMap.end() );
  }

  siena::attribute* find( const siena::string_t& name ) const
  {
    std::map<std::string,Value>::const_iterator itr = m_attrMap.find( std::string( name.begin, name.length() ) );
    if( itr != m_attrMap.end() )
      {
        return new Message::Iterator( itr, m_attrMap.end() );
      }
    else
      {
        return NULL;
      }
  }

  const std::map<std::string,Value>& getAttributes() const
  { return m_attrMap; }

  size_t bytesize() const;

  int size() const
  { return m_attrMap.size(); }

  std::string str() const;
private:
  std::map<std::string,Value> m_attrMap;
};

inline std::ostream& operator<< ( std::ostream& out, const Message& m )
{ return out << m.str(); }

#endif // SIMP_TYPES_H

Copyright © 2001-2004 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 Matthew J. Rutherford