/**
  * {{ namespace }} Function Topic Server implementation
  * $Id$
  * $HeadURL$
  * $Author$
  */

{% autoescape off %}
// filename: {{ namespace_abbr }}_fts_impl.cpp
#include "{{ namespace_abbr }}_fts_impl.h"
#include <DDS/FTS/generic_fts_impl.h>

namespace {{ namespace }}
{
namespace Interface
{
// initializer function
std::shared_ptr<Fts> Fts::create(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector)
{
  return std::make_shared<FtsImpl>(ddsConnector);
}

// FtsImpl
FtsImpl::FtsImpl(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector)
  : Fts()
  , m_ddsConnector(ddsConnector)
  , m_logger(getLogger("Fts"))
{}

FtsImpl::~FtsImpl()
{
  enableAll(false);
}

bool FtsImpl::enableAll(bool enable)
{
  DEBUG_LOG(m_logger) << "FtsImpl::enableAll(" << (enable ? "true" : "false") << ")";
  {% for ft in functionTopics.member %}
  if (!enable{{ ft.name }}(enable))
  {
    ERROR_LOG(m_logger) << "Error initializing function topic {{ ft.name }}";
    return false;
  }
  {% endfor %}
  return true;
}

{% for ft in functionTopics.member %}
//
// Function Topic '{{ ft.name }}'
//
bool FtsImpl::enable{{ ft.name }}(bool enable)
{
  if (enable)
  {
    if (m_fts{{ ft.name }})
    {
      INFO_LOG(m_logger) << "{{ ft.name }} already enabled!";
      return true;
    }
    m_fts{{ ft.name }}.reset(m_ddsConnector->createFTS<FTS::{{ ft.name }}>());
    assert(m_fts{{ ft.name }}.get());
    m_fts{{ ft.name }}->setSubscriberCallback([this] (const rti::core::SampleIdentity &identity, const {{ namespace }}::{{ ft.request }} &request) { this->{{ ft.onRequest }}(identity, request); });
  }
  else
  {
    m_fts{{ ft.name }}.reset();
  }
  return true;
}

bool FtsImpl::{{ ft.replyFlc }}(const rti::core::SampleIdentity &cookie, const {{ ft.replyType }} &reply)
{
  if (!m_fts{{ ft.name }})
  {
    WARNING_LOG(m_logger) << "Error publishing function topic {{ dt.name }} - not enabled";
    Q_ASSERT(false);
    return false;
  }

  return m_fts{{ ft.name }}->sendReply(cookie, reply);
}
{% if ft.isCoreFt %}
bool FtsImpl::{{ ft.replyFlc }}(const rti::core::SampleIdentity &cookie, const Core::FunctionReplyObject &replyObject)
{
  return {{ ft.replyFlc }}(cookie, {{ ft.replyType }}(replyObject.id(), replyObject.str(), replyObject.args(), replyObject.additionalInfo()));
}
{% endif %}


void FtsImpl::set{{ ft.requestHandler }}({{ ft.requestHandler }} *handler)
{
  m_{{ ft.requestHandlerFlc }} = handler;
}

void FtsImpl::{{ ft.onRequest }}(const rti::core::SampleIdentity &cookie,
                                 const {{ namespace }}::{{ ft.request }} &request)
{
  DEBUG_LOG(m_logger) << "{{ ft.onRequest }}";
  if (!m_{{ ft.requestHandlerFlc }})
  {
    WARNING_LOG(m_logger) << "Incoming {{ ft.request }} without registered handler!";
    Q_ASSERT(false);
    return;
  }

  m_{{ ft.requestHandlerFlc }}->{{ ft.onRequest }}(cookie, request);
}

{% endfor %}

} // namespace Interface
} // namespace {{ namespace }}
{% endautoescape %}