Merge branch 'topic/robin/input-threads-merge'

* topic/robin/input-threads-merge: (130 commits)
  And now it even compiles after my earlier changes.
  A set of input framework refactoring, cleanup, and polishing.
  another small memory leak in ascii reader:
  and another small memory leak when using streaming reads.
  fix another memory lead (when updating tables).
  Input framework merge in progress.
  filters have been called streams for eternity. And I always was too lazy to change it everywhere...
  reactivate network_time check in threading manager. previously this line made all input framework tests fail - it works now. Some of the other recent changes of the threading manager must have fixed that problem.
  fix up the executeraw test - now it works for the first time and does not always fail
  baselines for the autostart removal.
  remove last remnants of autostart, which has been removed for quite a while.
  make input framework source (hopefully) adhere to the usual indentation style. No functional changes.
  fix two memory leaks which occured when one used filters.
  update description to current interface.
  rename a couple of structures and make the names in manager fit the api more.
  fix memory leak in tables and vectors that are read into tables
  fix missing get call for heart beat in benchmark reader.
  fix heart_beat_interval -- initialization in constructor does not work anymore (probably due to change in init ordering?)
  fix memory leak for tables... nearly completely.
  fix a couple more leaks. But - still leaking quite a lot with tables.
  ...

src/input/ReaderFrontend.h

@@ -0,0 +1,131 @@
+// See the file "COPYING" in the main distribution directory for copyright.
+
+#ifndef INPUT_READERFRONTEND_H
+#define INPUT_READERFRONTEND_H
+
+#include "ReaderBackend.h"
+
+#include "threading/MsgThread.h"
+#include "threading/SerialTypes.h"
+
+namespace input {
+
+class Manager;
+
+/**
+ * Bridge class between the input::Manager and backend input threads. The
+ * Manager instantiates one \a ReaderFrontend for each open input stream.
+ * Each frontend in turns instantiates a ReaderBackend-derived class
+ * internally that's specific to the particular input format. That backend
+ * spawns a new thread, and it receives messages from the frontend that
+ * correspond to method called by the manager.
+ */
+class ReaderFrontend {
+public:
+	/**
+	 * Constructor.
+	 *
+	 * type: The backend writer type, with the value corresponding to the
+	 * script-level \c Input::Reader enum (e.g., \a READER_ASCII). The
+	 * frontend will internally instantiate a ReaderBackend of the
+	 * corresponding type.
+	 *
+	 * Frontends must only be instantiated by the main thread.
+	 */
+	ReaderFrontend(bro_int_t type);
+
+	/**
+	 * Destructor.
+	 *
+	 * Frontends must only be destroyed by the main thread.
+	 */
+	virtual ~ReaderFrontend();
+
+	/**
+	 * Initializes the reader.
+	 *
+	 * This method generates a message to the backend reader and triggers
+	 * the corresponding message there. If the backend method fails, it
+	 * sends a message back that will asynchronously call Disable().
+	 *
+	 * See ReaderBackend::Init() for arguments.
+	 *
+	 * This method must only be called from the main thread.
+	 */
+	void Init(string arg_source, ReaderMode mode, const int arg_num_fields, const threading::Field* const* fields);
+
+	/**
+	 * Force an update of the current input source. Actual action depends
+	 * on the opening mode and on the input source.
+	 *
+	 * This method generates a message to the backend reader and triggers
+	 * the corresponding message there.
+	 *
+	 * This method must only be called from the main thread.
+	 */
+	void Update();
+
+	/**
+	 * Finalizes reading from this stream.
+	 *
+	 * This method generates a message to the backend reader and triggers
+	 * the corresponding message there. This method must only be called
+	 * from the main thread.
+	 */
+	void Close();
+
+	/**
+	 * Disables the reader frontend. From now on, all method calls that
+	 * would normally send message over to the backend, turn into no-ops.
+	 * Note though that it does not stop the backend itself, use Finish()
+	 * to do that as well (this method is primarily for use as callback
+	 * when the backend wants to disable the frontend).
+	 *
+	 * Disabled frontends will eventually be discarded by the
+	 * input::Manager.
+	 *
+	 * This method must only be called from the main thread.
+	 */
+	void SetDisable()	{ disabled = true; }
+
+	/**
+	 * Returns true if the reader frontend has been disabled with
+	 * SetDisable().
+	 */
+	bool Disabled()	{ return disabled; }
+
+	/**
+	 * Returns a descriptive name for the reader, including the type of
+	 * the backend and the source used.
+	 *
+	 * This method is safe to call from any thread.
+	 */
+	string Name() const;
+
+protected:
+	friend class Manager;
+
+	/**
+	 * Returns the source as passed into the constructor.
+	 */
+	const string& Source() const	{ return source; };
+
+	/**
+	 * Returns the name of the backend's type.
+	 */
+	const string& TypeName() const	{ return ty_name; }
+
+private:
+	ReaderBackend* backend;	// The backend we have instanatiated.
+	string source;
+	string ty_name;		// Backend type, set by manager.
+	bool disabled;		// True if disabled.
+	bool initialized;	// True if initialized.
+};
+
+}
+
+
+#endif /* INPUT_READERFRONTEND_H */
+
+