discoverer.hpp

Go to the documentation of this file.

//  Copyright (c) 2009 STFC
// 
//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef SAGA_PACKAGES_SD_DISCOVERER_HPP

#define SAGA_PACKAGES_SD_DISCOVERER_HPP

// include dependent spec sections
#include <saga/saga/util.hpp>
#include <saga/saga/base.hpp>
#include <saga/saga/types.hpp>
#include <saga/saga/session.hpp>
#include <saga/saga/call.hpp> 
#include <saga/saga/exception.hpp>
#include <saga/saga/url.hpp>

#include <saga/saga/packages/sd/config.hpp>
#include <saga/saga/packages/sd/service_description.hpp>

namespace saga
{
  namespace sd {

  class SAGA_SD_PACKAGE_EXPORT discoverer 
       : public saga::object
  {

   public:

   private:
      // factory
      SAGA_CALL_CREATE_PRIV_2(session const&, saga::url)

      SAGA_CALL_PRIV_2 (list_services, std::string, std::string)
      SAGA_CALL_PRIV_3 (list_services, std::string, std::string, std::string)

   protected:
      TR1::shared_ptr <saga::impl::discoverer> get_impl_sp (void) const;
      saga::impl::discoverer* get_impl (void) const;
      friend class saga::impl::discoverer;
      explicit discoverer(saga::impl::discoverer* impl)
         SAGA_THROW_SPEC(throw(saga::not_implemented,
                               saga::incorrect_url,
                               saga::does_not_exist,
                               saga::authorization_failed,
                               saga::authentication_failed,
                               saga::timeout,
                               saga::no_success));

   public:
     explicit discoverer(saga::url loc = saga::url())
         SAGA_THROW_SPEC(throw(saga::not_implemented,
                               saga::incorrect_url,
                               saga::does_not_exist,
                               saga::authorization_failed,
                               saga::authentication_failed,
                               saga::timeout,
                               saga::no_success));

      explicit discoverer(session const& s, saga::url loc = saga::url())
         SAGA_THROW_SPEC(throw(saga::not_implemented,
                               saga::incorrect_url,
                               saga::does_not_exist,
                               saga::authorization_failed,
                               saga::authentication_failed,
                               saga::timeout,
                               saga::no_success));

      // explicit discoverer(saga::object const& o); // is this ctor necessary?
      ~discoverer (void) SAGA_THROW_SPEC(throw());

      static discoverer create(session const& s, saga::url loc = saga::url())
         SAGA_THROW_SPEC(throw(saga::not_implemented,
                               saga::incorrect_url,
                               saga::does_not_exist,
                               saga::authorization_failed,
                               saga::authentication_failed,
                               saga::timeout,
                               saga::no_success))
      {
          return discoverer(s, loc);
      }
      SAGA_CALL_CREATE_2_DEF_1(session const&, saga::url, saga::url())

    /*saga*
     * discoverer factory.  Constructs a discoverer object using
     * a default session and the given URL.
     * 
     * @param loc      URL to use.
     *
     * @throws not_implemented
     *                 if the discoverer class is not implemented
     *                 by the SAGA implementation at all.
     * @throws incorrect_url
     *                 if an implementation cannot handle the specified
     *                 protocol, or that access to the specified entity
     *                 via the given protocol is impossible.
     * @throws does_not_exist
     *                 if the url is syntactically valid, but no service
     *                 can be contacted at that URL.
     * @throws authorization_failed
     *                 if none of the available contexts of the used
     *                 session could be used for successful authorization.
     *                 That error indicates that the resource could not be
     *                 accessed at all, and not that an operation was not
     *                 available due to restricted permissions.
     * @throws authentication_failed
     *                 if none of the available session contexts could
     *                 successfully be used for authentication.
     * @throws timeout
     *                 if a remote operation did not complete
     *                 successfully because the network communication
     *                 or the remote service timed out.
     * @throws no_success
     *                 if no result can be returned because of
     *                 information system or other internal problems.
     */
      static discoverer create(saga::url loc = saga::url())
         SAGA_THROW_SPEC(throw(saga::not_implemented,
                               saga::incorrect_url,
                               saga::not_implemented,
                               saga::authorization_failed,
                               saga::authentication_failed,
                               saga::timeout,
                               saga::no_success))
      {
          return discoverer(loc);
      }

      template <typename Tag>
      static saga::task create(saga::url loc = saga::url())
      {
         return create<Tag>(saga::detail::get_the_session(), loc);
      }

      // default operator=() and copy ctor
      discoverer& operator= (saga::object const& o) 
          SAGA_THROW_SPEC(throw());

      // public methods for the service discoverer

      std::vector<saga::sd::service_description>
         list_services(std::string service_filter, 
                       std::string data_filter,
                       std::string authz_filter)
            SAGA_THROW_SPEC(throw(saga::bad_parameter,
                  saga::authorization_failed,
                  saga::authentication_failed,
                  saga::timeout,
                  saga::no_success))
      {
         saga::task t = list_servicespriv(service_filter,
                                          data_filter, 
                                          authz_filter,
                                          saga::task_base::Sync());
         return t.get_result<std::vector<saga::sd::service_description> >();
      }
      SAGA_CALL_PUB_3_DEF_0 (list_services, std::string, std::string, std::string)

    
      std::vector<saga::sd::service_description>
         list_services(std::string service_filter, 
                       std::string data_filter)
            SAGA_THROW_SPEC(throw(saga::bad_parameter,
                  saga::authorization_failed,
                  saga::authentication_failed,
                  saga::timeout,
                  saga::no_success))
      {
         saga::task t = list_servicespriv(service_filter,
                                          data_filter, 
                                          saga::task_base::Sync());
         return t.get_result<std::vector<saga::sd::service_description> >();
      }
      SAGA_CALL_PUB_2_DEF_0 (list_services, std::string, std::string)
  }; // discoverer
 } // namespace sd
}  // namespace saga
#endif