ReqHandler.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2014 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
 
#ifndef GZ_TRANSPORT_REQHANDLER_HH_
#define GZ_TRANSPORT_REQHANDLER_HH_
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
#include <google/protobuf/message.h>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#include <condition_variable>
#include <functional>
#include <memory>
#include <string>
#include <utility>
 
#include "gz/transport/config.hh"
#include "gz/transport/Export.hh"
#include "gz/transport/TransportTypes.hh"
#include "gz/transport/Uuid.hh"
 
namespace zenoh
{
  // Forward declaration.
  class Session;
}
 
namespace gz::transport
{
  // Inline bracket to help doxygen filtering.
  inline namespace GZ_TRANSPORT_VERSION_NAMESPACE {
  //
  class IReqHandlerPrivate;
 
  class GZ_TRANSPORT_VISIBLE IReqHandler
  {
    public: explicit IReqHandler(const std::string &_nUuid);
 
    public: virtual ~IReqHandler();
 
    public: virtual void NotifyResult(const std::string &_rep,
                                      const bool _result) = 0;
 
    public: virtual bool Serialize(std::string &_buffer) const = 0;
 
    public: virtual std::string ReqTypeName() const = 0;
 
    public: virtual std::string RepTypeName() const = 0;
 
    public: std::string HandlerUuid() const;
 
    public: std::string NodeUuid() const;
 
    public: std::string Response() const
    {
      return this->rep;
    }
 
    public: bool Result() const
    {
      return this->result;
    }
 
    public: bool Requested() const;
 
    public: void Requested(const bool _value);
 
    public: template<typename Lock> bool WaitUntil(Lock &_lock,
                                                  const unsigned int _timeout)
    {
      auto now = std::chrono::steady_clock::now();
      return this->condition.wait_until(_lock,
        now + std::chrono::milliseconds(_timeout),
        [this]
        {
          return this->repAvailable;
        });
    }
 
#ifdef HAVE_ZENOH
    public: void CreateZenohGet(std::shared_ptr<zenoh::Session> _session,
                                const std::string &_service);
#endif
 
#ifdef _WIN32
// Disable warning C4251 which is triggered by
// std::*
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
    protected: std::unique_ptr<IReqHandlerPrivate> dataPtr;
 
    protected: std::condition_variable_any condition;
 
    protected: std::string rep;
#ifdef _WIN32
#pragma warning(pop)
#endif
 
    protected: bool result;
 
    public: bool repAvailable;
  };
 
  template <typename Req, typename Rep> class ReqHandler
    : public IReqHandler
  {
    // Documentation inherited.
    public: explicit ReqHandler(const std::string &_nUuid)
      : IReqHandler(_nUuid)
    {
    }
 
    public: std::shared_ptr<Rep> CreateMsg(const std::string &_data) const
    {
      // Instantiate a specific protobuf message
      auto msgPtr = std::make_shared<Rep>();
 
      // Create the message using some serialized data
      if (!msgPtr->ParseFromString(_data))
      {
        std::cerr << "ReqHandler::CreateMsg() error: ParseFromString failed"
                  << std::endl;
      }
 
      return msgPtr;
    }
 
    public: void SetCallback(const std::function <void(
      const Rep &_rep, const bool _result)> &_cb)
    {
      this->cb = _cb;
    }
 
    public: void SetMessage(const Req *_reqMsg)
    {
      if (!_reqMsg)
      {
        std::cerr << "ReqHandler::SetMessage() _reqMsg is null" << std::endl;
        return;
      }
 
      this->reqMsg.CopyFrom(*_reqMsg);
    }
 
    public: void SetResponse(const Rep *_repMsg)
    {
      (void)_repMsg;
    }
 
    // Documentation inherited
    public: bool Serialize(std::string &_buffer) const
    {
      if (!this->reqMsg.SerializeToString(&_buffer))
      {
        std::cerr << "ReqHandler::Serialize(): Error serializing the request"
                  << std::endl;
        return false;
      }
 
      return true;
    }
 
    // Documentation inherited.
    public: void NotifyResult(const std::string &_rep, const bool _result)
    {
      // Execute the callback (if existing).
      if (this->cb)
      {
        // Instantiate the specific protobuf message associated to this topic.
        auto msg = this->CreateMsg(_rep);
 
        this->cb(*msg, _result);
      }
      else
      {
        this->rep = _rep;
        this->result = _result;
      }
 
      this->repAvailable = true;
      this->condition.notify_one();
    }
 
    // Documentation inherited.
    public: virtual std::string ReqTypeName() const
    {
      return std::string(Req().GetTypeName());
    }
 
    // Documentation inherited.
    public: virtual std::string RepTypeName() const
    {
      return std::string(Rep().GetTypeName());
    }
 
    private: Req reqMsg;
 
    private: std::function<void(const Rep &_rep, const bool _result)> cb;
  };
 
  template <> class ReqHandler<google::protobuf::Message,
                               google::protobuf::Message>
    : public IReqHandler
  {
    // Documentation inherited.
    public: explicit ReqHandler(const std::string &_nUuid)
      : IReqHandler(_nUuid)
    {
    }
 
    public: void SetMessage(const google::protobuf::Message *_reqMsg)
    {
      if (!_reqMsg)
      {
        std::cerr << "ReqHandler::SetMessage() _reqMsg is null" << std::endl;
        return;
      }
 
      this->reqMsg.reset(_reqMsg->New());
      this->reqMsg->CopyFrom(*_reqMsg);
    }
 
    public: void SetResponse(const google::protobuf::Message *_repMsg)
    {
      if (!_repMsg)
      {
        std::cerr << "ReqHandler::SetResponse() _repMsg is null" << std::endl;
        return;
      }
 
      this->repMsg.reset(_repMsg->New());
      this->repMsg->CopyFrom(*_repMsg);
    }
 
    // Documentation inherited
    public: bool Serialize(std::string &_buffer) const
    {
      if (!this->reqMsg)
      {
        std::cerr << "ReqHandler::Serialize() reqMsg is null" << std::endl;
        return false;
      }
 
      if (!this->reqMsg->SerializeToString(&_buffer))
      {
        std::cerr << "ReqHandler::Serialize(): Error serializing the request"
                  << std::endl;
        return false;
      }
 
      return true;
    }
 
    // Documentation inherited.
    public: void NotifyResult(const std::string &_rep, const bool _result)
    {
      this->rep = _rep;
      this->result = _result;
 
      this->repAvailable = true;
      this->condition.notify_one();
    }
 
    // Documentation inherited.
    public: virtual std::string ReqTypeName() const
    {
      if (this->reqMsg)
        return std::string(this->reqMsg->GetTypeName());
      else
      {
        std::cerr << "ReqHandler::ReqTypeName() Warning: Using ReqTypeName() "
                  << "without type information" << std::endl;
        return "";
      }
    }
 
    public: virtual std::string RepTypeName() const
    {
      if (this->repMsg)
        return std::string(this->repMsg->GetTypeName());
      else
      {
        std::cerr << "ReqHandler::RepTypeName() Warning: Using RepTypeName() "
                  << "without type information" << std::endl;
        return "";
      }
    }
 
    private: std::unique_ptr<google::protobuf::Message> reqMsg;
 
    private: std::unique_ptr<google::protobuf::Message> repMsg;
  };
  }
}
 
#endif