//   Read the documentation to learn more about C++ code generator
//   versioning.
//	  %X% %Q% %Z% %W%

#ifndef RESPONSECONTAINER_H
#define RESPONSECONTAINER_H 1
#include <utility>

// Reference
#include <XSUtil/Utils/Reference.h>
// Response
#include <XSModel/Data/Detector/Response.h>
// RMF
#include <XSModel/Data/Detector/RMF.h>
// ResponseTypes
#include <XSModel/GlobalContainer/ResponseTypes.h>
// ResponseParam
#include <XSModel/Parameter/ResponseParam.h>

class DummyResponse;

namespace XSContainer {



    class ResponseContainer 
    {

      public:
          ResponseContainer (DummyResponse* dummy);
          ~ResponseContainer();

          //	Additional Public Declarations
          static ResponseContainer* Instance (DummyResponse* dummy);
          void addToList (const string& name, Response* newResponse);
          void clear (bool deleteObj = true);
          void addToList (const RefCountPtr<RMF>& newRMF);
          const Response* responseList (const string& name, size_t index) const;
          Response* responseList (const string& name, size_t index);
          size_t numberOfResponses () const;
          void removeByToken (const std::vector<Response*>& doomed, size_t sourceNum = 0);
          void removeByToken (const RefCountPtr<RMF>& doomed) throw ();
          Response* swapResponses (Response* inResponse, Response* outResponse);
          void clearParameters ();
          const RMFMap& RMFmap () const;
          void RMFmap (const RMFMap& value);
          ResponseMap& responseList ();
          const ResponseParamMap& parameterMap () const;

        // Additional Public Declarations

      protected:
        // Additional Protected Declarations

      private:
          void responseList (const string& name, Response* value);
          void RMFmap (const string& name, const RefCountPtr<RMF>& rmf);
          Response* internalFind (const string& name, size_t index) const;
          //	Intended to be called from ResponseParam destructor.
          void removeFromParamMap (size_t respIndex, const ResponseParam* param) throw ();
          //	Intended to be called from ResponseParam constructor.
          void addToParamMap (size_t respIndex, ResponseParam* param);
          void removeFromParamMap (const Response* resp);
          void addToParamMap (Response* resp);

        // Additional Private Declarations
          // Allow ResponseParam to add and remove itself from the parameterMap:
          friend ResponseParam::ResponseParam(const string& initString, Response* responseParent, Response::ResponseParType parType);
          friend ResponseParam::~ResponseParam();
      private: //## implementation
        // Data Members for Class Attributes
          static ResponseContainer* s_instance;

        // Data Members for Associations
          RMFMap m_RMFmap;
          ResponseMap m_responseList;
          ResponseParamMap m_parameterMap;

        // Additional Implementation Declarations

    };

    // Class XSContainer::ResponseContainer 

    inline const RMFMap& ResponseContainer::RMFmap () const
    {
      return m_RMFmap;
    }

    inline void ResponseContainer::RMFmap (const RMFMap& value)
    {
      m_RMFmap = value;
    }

    inline const ResponseParamMap& ResponseContainer::parameterMap () const
    {
      return m_parameterMap;
    }

} // namespace XSContainer


#endif