Introduce some masked tgba.

* src/tgba/tgbamask.cc, src/tgba/tgbamask.hh,
src/tgba/tgbaproxy.cc, src/tgba/tgbaproxy.hh: New files.
* src/tgba/Makefile.am: Add them.
* src/tgbatest/explicit3.cc, src/tgbatest/explicit3.test:
New files.
* src/tgbatest/Makefile.am: Add them.

src/tgba/tgbamask.cc

@@ -0,0 +1,183 @@
+// -*- coding: utf-8 -*-
+// Copyright (C) 2013 Laboratoire de Recherche et Développement
+// de l'Epita (LRDE).
+//
+// This file is part of Spot, a model checking library.
+//
+// Spot 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.
+//
+// Spot 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, see <http://www.gnu.org/licenses/>.
+
+#include "tgbamask.hh"
+#include <vector>
+
+namespace spot
+{
+  namespace
+  {
+    struct transition
+    {
+      const state* dest;
+      bdd cond;
+      bdd acc;
+    };
+    typedef std::vector<transition> transitions;
+
+    struct succ_iter_filtered: public tgba_succ_iterator
+    {
+      ~succ_iter_filtered()
+      {
+	for (first(); !done(); next())
+	  it_->dest->destroy();
+      }
+
+      void first()
+      {
+	it_ = trans_.begin();
+      }
+
+      virtual void next()
+      {
+	++it_;
+      }
+
+      bool done() const
+      {
+	return it_ == trans_.end();
+      }
+
+      state* current_state() const
+      {
+	return it_->dest->clone();
+      }
+
+      bdd current_condition() const
+      {
+	return it_->cond;
+      }
+
+      bdd current_acceptance_conditions() const
+      {
+	return it_->acc;
+      }
+
+      transitions trans_;
+      transitions::const_iterator it_;
+    };
+
+
+    class tgba_mask_keep: public tgba_mask
+    {
+      const state_set& mask_;
+    public:
+      tgba_mask_keep(const tgba* masked,
+		     const state_set& mask,
+		     const state* init)
+	: tgba_mask(masked, init),
+	  mask_(mask)
+      {
+      }
+
+      bool wanted(const state* s) const
+      {
+	state_set::const_iterator i = mask_.find(s);
+	return i != mask_.end();
+      }
+    };
+
+    class tgba_mask_ignore: public tgba_mask
+    {
+      const state_set& mask_;
+    public:
+      tgba_mask_ignore(const tgba* masked,
+		       const state_set& mask,
+		       const state* init)
+	: tgba_mask(masked, init),
+	  mask_(mask)
+      {
+      }
+
+      bool wanted(const state* s) const
+      {
+	state_set::const_iterator i = mask_.find(s);
+	return i == mask_.end();
+      }
+    };
+
+
+  }
+
+
+  tgba_mask::tgba_mask(const tgba* masked,
+		       const state* init)
+    : tgba_proxy(masked),
+      init_(init)
+  {
+    if (!init)
+      init_ = masked->get_init_state();
+  }
+
+  tgba_mask::~tgba_mask()
+  {
+    init_->destroy();
+  }
+
+  state* tgba_mask::get_init_state() const
+  {
+    return init_->clone();
+  }
+
+  tgba_succ_iterator*
+  tgba_mask::succ_iter(const state* local_state,
+		       const state* global_state,
+		       const tgba* global_automaton) const
+  {
+    tgba_succ_iterator* it = original_->succ_iter(local_state,
+						  global_state,
+						  global_automaton);
+
+    succ_iter_filtered* res = new succ_iter_filtered;
+    for (it->first(); !it->done(); it->next())
+      {
+	const state* s = it->current_state();
+	if (!wanted(s))
+	  {
+	    s->destroy();
+	    continue;
+	  }
+	transition t = { s,
+			 it->current_condition(),
+			 it->current_acceptance_conditions() };
+	res->trans_.push_back(t);
+      }
+    delete it;
+    return res;
+  }
+
+
+  const tgba*
+  build_tgba_mask_keep(const tgba* to_mask,
+		       const state_set& to_keep,
+		       const state* init)
+  {
+    return new tgba_mask_keep(to_mask, to_keep, init);
+  }
+
+  const tgba*
+  build_tgba_mask_ignore(const tgba* to_mask,
+			 const state_set& to_ignore,
+			 const state* init)
+  {
+    return new tgba_mask_ignore(to_mask, to_ignore, init);
+  }
+
+}