Endpoint.h

#ifndef __ARC_ENDPOINT_H__
#define __ARC_ENDPOINT_H__

#include <string>
#include <set>
#include <algorithm>
#include <map>

#include <arc/URL.h>
#include <arc/compute/EndpointQueryingStatus.h>

namespace Arc {

class ConfigEndpoint;
class ExecutionTarget;
class Endpoint;
class EndpointQueryingStatus;
class ComputingEndpointAttributes;
  

typedef bool (*EndpointCompareFn)(const Endpoint&, const Endpoint&);


class EndpointStatusMap : public std::map<Endpoint, EndpointQueryingStatus, EndpointCompareFn> {
public:
  EndpointStatusMap();
  EndpointStatusMap(EndpointCompareFn fn) : std::map<Endpoint, EndpointQueryingStatus, EndpointCompareFn>(fn) {}
  EndpointStatusMap(const EndpointStatusMap& m) : std::map<Endpoint, EndpointQueryingStatus, EndpointCompareFn>(m) {}
  ~EndpointStatusMap() {}
};


class Endpoint {
public:
  enum CapabilityEnum {
    REGISTRY,
    COMPUTINGINFO,
    JOBLIST,
    JOBSUBMIT,

    JOBCREATION,
    JOBMANAGEMENT,
    UNSPECIFIED
  };
  

  static std::string GetStringForCapability(Endpoint::CapabilityEnum cap) {
    if (cap == Endpoint::REGISTRY) return "information.discovery.registry";
    if (cap == Endpoint::COMPUTINGINFO) return "information.discovery.resource";
    if (cap == Endpoint::JOBLIST) return "information.discovery.resource";
    if (cap == Endpoint::JOBSUBMIT) return "executionmanagement.jobexecution";
    if (cap == Endpoint::JOBCREATION) return "executionmanagement.jobcreation";
    if (cap == Endpoint::JOBMANAGEMENT) return "executionmanagement.jobmanager";
    return "";
  }
  

  Endpoint(const std::string& URLString = "",
           const std::set<std::string>& Capability = std::set<std::string>(),
           const std::string& InterfaceName = "")
    : URLString(URLString), InterfaceName(InterfaceName), Capability(Capability) {}


  Endpoint(const std::string& URLString,
           const Endpoint::CapabilityEnum cap,
           const std::string& InterfaceName = "")
    : URLString(URLString), InterfaceName(InterfaceName), Capability() { Capability.insert(GetStringForCapability(cap)); }


  Endpoint(const ExecutionTarget& e, const std::string& rsi = "");


  Endpoint(const ComputingEndpointAttributes& cea, const std::string& rsi = "");
  

  Endpoint(const ConfigEndpoint& endpoint) { *this = endpoint; }
  

  bool HasCapability(Endpoint::CapabilityEnum cap) const;
  

  bool HasCapability(const std::string& cap) const;


  std::string str() const;


  std::string getServiceName() const;
  

  bool operator<(const Endpoint& other) const;
  

  static bool ServiceIDCompare(const Endpoint& a, const Endpoint& b);


  Endpoint& operator=(const ConfigEndpoint& e);
  
  std::string URLString;
  std::string InterfaceName;  
  std::string HealthState;
  std::string HealthStateInfo;
  std::string QualityLevel;
  std::set<std::string> Capability;

  std::string RequestedSubmissionInterfaceName;

  std::string ServiceID;


  static std::pair<EndpointStatusMap::const_iterator, EndpointStatusMap::const_iterator> getServiceEndpoints(const Endpoint&, const EndpointStatusMap&);
};

} // namespace Arc

#endif // __ARC_ENDPOINT_H__