ComputingServiceRetriever.h

#ifndef __ARC_COMPUTINGSERVICERETRIEVER_H__
#define __ARC_COMPUTINGSERVICERETRIEVER_H__

#include <list>
#include <string>

#include <arc/UserConfig.h>
#include <arc/compute/Endpoint.h>
#include <arc/compute/EntityRetriever.h>
#include <arc/compute/ExecutionTarget.h>

namespace Arc {
  
class ComputingServiceUniq : public EntityConsumer<ComputingServiceType> {
public:
  void addEntity(const ComputingServiceType& service);
  std::list<ComputingServiceType> getServices() { return services; }
private:
  std::list<ComputingServiceType> services;
  
  static Logger logger;
};


class ComputingServiceRetriever : public EntityConsumer<Endpoint>, public EntityContainer<ComputingServiceType> {
public:

  ComputingServiceRetriever(
    const UserConfig& uc,
    const std::list<Endpoint>& services = std::list<Endpoint>(),
    const std::list<std::string>& rejectedServices = std::list<std::string>(),
    const std::set<std::string>& preferredInterfaceNames = std::set<std::string>(),
    const std::list<std::string>& capabilityFilter = std::list<std::string>(1, Endpoint::GetStringForCapability(Arc::Endpoint::COMPUTINGINFO))
  );


  void wait() { ser.wait(); tir.wait(); }


  void addEndpoint(const Endpoint& service);
      

  void addEntity(const Endpoint& service) { addEndpoint(service); }
  

  void addConsumer(EntityConsumer<ComputingServiceType>& c) { tir.addConsumer(c); };
  

  void removeConsumer(const EntityConsumer<ComputingServiceType>& c) { tir.removeConsumer(c); }
  

  void GetExecutionTargets(std::list<ExecutionTarget>& etList) {
    ExecutionTarget::GetExecutionTargets(*this, etList);
  }


  EndpointStatusMap getAllStatuses() const { EndpointStatusMap s = ser.getAllStatuses(), t = tir.getAllStatuses(); s.insert(t.begin(), t.end()); return s; }

private:
  ServiceEndpointRetriever ser;
  TargetInformationRetriever tir;

  static Logger logger;
};

} // namespace Arc

#endif // __ARC_COMPUTINGSERVICERETRIEVER_H__