FileAnalysis: refactor add/remove/stop BIFs, add BOF triggers/fields.

The add_action, remove_action, and stop BIFs now go through a queue to
ensure that modifications are made at well-defined times and don't end
up invalidating loop iterators.

src/file_analysis/ActionSet.h

@@ -0,0 +1,104 @@
+#ifndef FILE_ANALYSIS_ACTIONSET_H
+#define FILE_ANALYSIS_ACTIONSET_H
+
+#include <queue>
+
+#include "Action.h"
+#include "Dict.h"
+#include "CompHash.h"
+#include "Val.h"
+
+namespace file_analysis {
+
+class Info;
+declare(PDict,Action);
+
+class ActionSet {
+public:
+
+	ActionSet(Info* arg_info);
+
+	~ActionSet();
+
+	/**
+	 * @return true if action was instantiated/attached, else false.
+	 */
+	bool AddAction(RecordVal* args);
+
+	/**
+	 * @return true if action was able to be instantiated, else false.
+	 */
+	bool QueueAddAction(RecordVal* args);
+
+	/**
+	 * @return false if action didn't exist and so wasn't removed, else true.
+	 */
+	bool RemoveAction(const RecordVal* args);
+
+	/**
+	 * @return true if action exists at time of call, else false;
+	 */
+	bool QueueRemoveAction(const RecordVal* args);
+
+	/**
+	 * Perform all queued modifications to the currently active actions.
+	 */
+	void FlushQueuedModifications();
+
+	IterCookie* InitForIteration() const
+		{ return action_map.InitForIteration(); }
+
+	Action* NextEntry(IterCookie* c)
+		{ return action_map.NextEntry(c); }
+
+protected:
+
+	HashKey* GetKey(const RecordVal* args) const;
+	Action* InstantiateAction(RecordVal* args) const;
+	void InsertAction(Action* act, HashKey* key);
+	bool RemoveAction(ActionTag tag, HashKey* key);
+
+	Info* info;
+	CompositeHash* action_hash; /**< ActionArgs hashes Action map lookup. */
+	PDict(Action) action_map;   /**< Actions indexed by ActionArgs. */
+
+	class Modification {
+	public:
+		virtual ~Modification() {}
+		virtual bool Perform(ActionSet* set) = 0;
+		virtual void Abort() = 0;
+	};
+
+	class Add : public Modification {
+	public:
+		Add(Action* arg_act, HashKey* arg_key)
+			: Modification(), act(arg_act), key(arg_key) {}
+		virtual ~Add() {}
+		virtual bool Perform(ActionSet* set);
+		virtual void Abort() { delete act; delete key; }
+
+	protected:
+		Action* act;
+		HashKey* key;
+	};
+
+	class Remove : public Modification {
+	public:
+		Remove(ActionTag arg_tag, HashKey* arg_key)
+			: Modification(), tag(arg_tag), key(arg_key) {}
+		virtual ~Remove() {}
+		virtual bool Perform(ActionSet* set);
+		virtual void Abort() { delete key; }
+
+	protected:
+		ActionTag tag;
+		HashKey* key;
+	};
+
+	typedef queue<Modification*> ModQueue;
+	ModQueue mod_queue;
+};
+
+} // namespace file_analysiss
+
+#endif