event.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2010 - 2015 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------


#ifndef dealii__event_h
#define dealii__event_h

#include <deal.II/base/config.h>

#include <vector>
#include <string>
#include <iostream>

DEAL_II_NAMESPACE_OPEN

namespace Algorithms
{
  class Event
  {
  public:
    static Event assign (const char *name);

//      static Event find(const std::string& name);

    Event ();

    void clear();

    void all();

    Event &operator += (const Event &event);

    Event &operator -= (const Event &event);

    bool test (const Event &event) const;

    bool any () const;

    template <class OS>
    void print (OS &os) const;

    template <class OS>
    static void print_assigned (OS &os);

  private:
    bool all_true;

    std::vector<bool> flags;

//TODO: This static field must be guarded by a mutex to be thread-safe!
    static std::vector<std::string> names;
  };

  namespace Events
  {
    extern const Event initial;

    extern const Event remesh;

    extern const Event bad_derivative;

    extern const Event new_time;

    extern const Event new_timestep_size;
  }


//----------------------------------------------------------------------//


  inline
  bool
  Event::any () const
  {
    if (all_true) return true;
    for (std::vector<bool>::const_iterator i=flags.begin();
         i != flags.end(); ++i)
      if (*i) return true;
    return false;
  }


  inline
  bool
  Event::test (const Event &event) const
  {

    // First, test all_true in this
    if (all_true) return true;

    const unsigned int n = flags.size();
    const unsigned int m = event.flags.size();
    const unsigned int n_min = (n<m)?n:m;

    // Now, if all_true set in the
    // other, then all must be true
    // in this
    if (event.all_true)
      {
        // Non existing flags are
        // always assumed false
        if (m > n)
          return false;

        // Test all flags separately
        // and return false if one is
        // not set
        for (std::vector<bool>::const_iterator i=flags.begin();
             i != flags.end(); ++i)
          if (!*i) return false;
        // All flags are set
        return true;
      }

    // Finally, compare each flag
    // separately
    for (unsigned int i=0; i<n_min; ++i)
      if (event.flags[i] && !flags[i])
        return false;
    for (unsigned int i=n_min; i<m; ++i)
      if (event.flags[i])
        return false;
    return true;
  }



  inline
  Event &Event::operator += (const Event &event)
  {
    all_true |= event.all_true;
    if (all_true) return *this;

    if (flags.size() < event.flags.size())
      flags.resize(event.flags.size());
    for (unsigned int i=0; i<event.flags.size(); ++i)
      flags[i] = flags[i] || event.flags[i];

    return *this;
  }


  inline
  Event &Event::operator -= (const Event &event)
  {
    if (!event.any()) return *this;

    all_true = false;
    if (event.all_true)
      {
        for (std::vector<bool>::iterator i=flags.begin();
             i != flags.end(); ++i)
          *i = false;
        return *this;
      }

    if (flags.size() < event.flags.size())
      flags.resize(event.flags.size());
    for (unsigned int i=0; i<event.flags.size(); ++i)
      if (event.flags[i]) flags[i] = false;

    return *this;
  }


  template <class OS>
  inline
  void
  Event::print (OS &os) const
  {
    if (all_true)
      os << " ALL";

    for (unsigned int i=0; i<flags.size(); ++i)
      if (flags[i])
        os << ' ' << names[i];
  }


  template <class OS>
  inline
  void
  Event::print_assigned (OS &os)
  {
    for (unsigned int i=0; i<names.size(); ++i)
      os << i << '\t' << names[i] << std::endl;
  }


  template <class OS>
  OS &operator << (OS &o, const Event &e)
  {
    e.print(o);
    return o;
  }
}

DEAL_II_NAMESPACE_CLOSE

#endif