accumulators.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2009 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the dbus-cxx library.                            *
 *                                                                         *
 *   The dbus-cxx library is free software; you can redistribute it and/or *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The dbus-cxx library 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 software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef DBUSCXX_ACCUMULATORS_H
#define DBUSCXX_ACCUMULATORS_H

#include <dbus-cxx/enums.h>

namespace DBus
{

  struct PredicateAccumulatorDefaultTrue {
    typedef bool result_type;

    template <typename T_iterator>
    result_type operator()( T_iterator first, T_iterator last ) const {
      bool result = true;
      while ( first != last ) {
        result = result and( *first );
      }
      return result;
    }
  };

  struct InterruptablePredicateAccumulatorDefaultFalse {
    typedef bool result_type;

    template <typename T_iterator>
    result_type operator()( T_iterator first, T_iterator last ) const {
      while ( first != last ) {
        if ( *first ) return true;
        ++first;
      }
      return false;
    }
  };

  struct MessageHandlerAccumulator {
    typedef HandlerResult result_type;

    template <typename T_iterator>
    result_type operator()( T_iterator first, T_iterator last ) const {
      HandlerResult retval = NOT_HANDLED;
      while ( first != last ) {
        switch ( *first )
        {
          case HANDLED:
            return HANDLED;
          case HANDLER_NEEDS_MEMORY:
            retval = HANDLER_NEEDS_MEMORY;
            // no break because we'll slide through to the next case
          case NOT_HANDLED:
            ++first;
        }
      }
      return retval;
    }
  };

  struct FilterAccumulator {
    typedef FilterResult result_type;

    template <typename T_iterator>
        result_type operator()( T_iterator first, T_iterator last ) const {
      FilterResult retval = DONT_FILTER;
      while ( first != last ) {
        switch ( *first )
        {
          case FILTER:
            return FILTER;
          case FILTER_NEEDS_MEMORY:
            retval = FILTER_NEEDS_MEMORY;
            // no break because we'll slide through to the next case
          case DONT_FILTER:
            ++first;
        }
      }
      return retval;
    }
  };

  struct PredicateAccumulatorDefaultFalse {
    typedef bool result_type;

    template <typename T_iterator>
    result_type operator()( T_iterator first, T_iterator last ) const {
      bool result = false;
      while ( first != last ) {
        result = result or( *first );
        ++first;
      }
      return result;
    }
  };


}

#endif