MCCLoader.h

#ifndef __ARC_MCCLOADER_H__
#define __ARC_MCCLOADER_H__

#include <string>
#include <map>
#include <arc/ArcConfig.h>

#include <arc/message/MCC.h>
#include <arc/message/Service.h>
#include <arc/message/Plexer.h>
#include <arc/message/SecHandler.h>

#include <arc/loader/Plugin.h>
#include <arc/loader/Loader.h>

namespace Arc {

  // Internal classes - used in private methods
  class mcc_connectors_t;
  class plexer_connectors_t;

  class ChainContext;


  class MCCLoader: public Loader {
    friend class ChainContext;
   public:
    typedef std::map<std::string, MCC*>        mcc_container_t;
    typedef std::map<std::string, Service*>    service_container_t;
    typedef std::map<std::string, ArcSec::SecHandler*> sechandler_container_t;
    typedef std::map<std::string, Plexer*>     plexer_container_t;

   private:
    bool valid_;

    mcc_container_t mccs_;

    mcc_container_t mccs_exposed_;

    service_container_t services_;

    sechandler_container_t sechandlers_;

    plexer_container_t plexers_;

    bool make_elements(Config& cfg, int level = 0,
                       mcc_connectors_t *mcc_connectors = NULL,
                       plexer_connectors_t *plexer_connectors = NULL);
    MCC* make_component(Config& cfg, XMLNode cn,
                        mcc_connectors_t *mcc_connectors = NULL);

    ChainContext* context_;

   public:
    MCCLoader():valid_(false) {};
    MCCLoader(Config& cfg);
    ~MCCLoader();
    MCC* operator[](const std::string& id);
    MCC* operator[](const char* id) { return operator[](std::string(id)); };

    operator bool(void) { return valid_; };
    bool operator!(void) { return !valid_; };

    bool ReloadElement(Config& cfg);
 };


  class ChainContext {
    friend class MCCLoader;
   private:
    MCCLoader& loader_;
    ChainContext(MCCLoader& loader) : loader_(loader) {};
    ~ChainContext() {};
   public:
    operator PluginsFactory*()    { return loader_.factory_; };
  };

} // namespace Arc

#endif /* __ARC_MCCLOADER_H__ */

---