#ifndef TUnpackOptionManager_hxx_seen
#define TUnpackOptionManager_hxx_seen

#include "ITriggerFilter.hxx"

#include <string>

namespace COMET {
  class IUnpackOptionManager;
};


///Class to parse options fed to oaUnpack.  But putting the parser
///class in the oaUnpack library, rather than directly in the event
///loop, it can be made available to any package that depends on
///oaUnpack.  In this way the same interface can be propagated to
///other executables (e.g. CalibGlobal executable) that provide a superset
///of oaUnpack functioanlity.
class COMET::IUnpackOptionManager {
public:
  
  ///Default Constructor
  IUnpackOptionManager() : fTriggerMask(0xFFFF){} 

  ///Virtual D'tor
  virtual ~IUnpackOptionManager(){}

  ///This function encapsulates the SetOption functionality used by
  ///event loops. It should be called by the event loop after they has
  ///done any particular option parsing of their own.  Note that it is
  ///up to the user to ensure that the option stings don't clash.
  bool SetOption(std::string option, std::string value); 

  ///Prints the usage information.  Should be called by the Usage()
  ///method of any event loop that incorporates these options
  void Usage();

  ///Returns a trigger filter object, configured according to the mask
  ///stored by the option manager.  It would be nice to have this
  ///method lock the mask so that any subsequent changes would be
  ///flagged as an error but that will have to wait.
  COMET::ITriggerFilter GetTriggerFilter();

private:
  ///Set the trigger mask based on a command line configuration
  ///string. Returns false, and leaves the mask unchanged if the
  ///option string was not understood.  Note that this does logically go
  ///here as it is the option manager's job to understand the
  ///configuration data, the filter just applies the mask it's given.
  bool SetTriggerMaskFromOption(std::string optval);
  
  ///Remove the top bits of the trigger pattern or mask.  They aren't
  ///meaningful.
  void Truncate(UInt_t pattern) {pattern &= 0xFFFF;}

  ///Utility to checking the existence of a charater in a string,
  ///because the STL way to do it is a pain and makes for hard to read
  ///code. Gggrr.
  inline bool contains(std::string str, char c) {
    return str.find(c) != std::string::npos;
  }
  
  //The mask that defines which triggers will be processed. Used to
  //configure a trigger filter when one is requested.
  UInt_t  fTriggerMask;

};

#endif //TUnpackOptionManager_hxx_seen