port_info_interface_impl.h

Go to the documentation of this file.

 
#ifndef SDK_NAVBOX_CLIENT_PORT_INFO_INTERFACE_IMPL_H_
#define SDK_NAVBOX_CLIENT_PORT_INFO_INTERFACE_IMPL_H_
#pragma once
 
#include <string>
#include <base/inc/platform.h>
#include <base/inc/sdk_results_enum.h>
#include <base/inc/sdk_component_base.h>
#include <base/inc/sdk_string_handler.h>
#include <base/inc/exception.h>
#include <base/inc/geometry/geometry_base_types_helpers.h>
#include <datalayer/inc/navbox_client/navbox_client_const.h>
#include <datalayer/inc/navbox_client/navbox_client_interfaces.h>
 
SDK_NAVBOX_CLIENT_BEGIN_NAMESPACE
 
class PortInfo : public SDKComponentBaseI< IPortInfo > {
public:
  explicit PortInfo(const std::wstring& name, 
    const std::wstring& country = std::wstring(),
    const std::wstring& vhf_channel_port_control = std::wstring(),
    const std::wstring& vhf_channel_pilots = std::wstring(),
    const std::wstring& pre_departure_notice_to = std::wstring(),
    const std::wstring& vhf_channel = std::wstring(),
    const std::wstring& draught_restrictions = std::wstring(),
    const std::wstring& air_draught_restrictions = std::wstring(),
    const std::wstring& other_restrictions = std::wstring(),
    const std::wstring& guide_to_port_entry = std::wstring(),
    const std::wstring& extra_info = std::wstring(),
    SDKTimeDelta tz = 0,
    const std::wstring& tz_display_name = std::wstring(),
    const GeoPoint& position = GeoPoint(),
    const std::wstring& name_of_berth = std::wstring())
    : m_name(name),
      m_country(country),
      m_vhf_channel_port_control(vhf_channel_port_control),
      m_vhf_channel_pilots(vhf_channel_pilots),
      m_pre_departure_notice_to(pre_departure_notice_to),
      m_vhf_channel(vhf_channel),
      m_draught_restrictions(draught_restrictions),
      m_air_draught_restrictions(air_draught_restrictions),
      m_other_restrictions(other_restrictions),
      m_guide_to_port_entry(guide_to_port_entry),
      m_extra_info(extra_info),
      m_tz(tz),
      m_tz_display_name(tz_display_name),
      m_position(position),
      m_name_of_berth(name_of_berth) {
  }
 
  virtual ~PortInfo() {
  }
 
  virtual SDKResult SDK_CALLTYPE GetName(SDKString& port_name) const throw() {
    try
    {
      port_name = ScopedString(m_name).Detach();
      return m_name.empty() ? Err_NotExist : Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetCountry(
    SDKString& port_country) const throw() {
    try
    {
      port_country = ScopedString(m_country).Detach();
      return m_country.empty() ? Err_NotExist : Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetVHFChannelPortControl(
    SDKString& channel) const throw() {
    try
    {
      channel = ScopedString(m_vhf_channel_port_control).Detach();
      return m_vhf_channel_port_control.empty() ? Err_NotExist : Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetVHFChannelPilots(
    SDKString& channel) const throw() {
    try
    {
      channel = ScopedString(m_vhf_channel_pilots).Detach();
      return m_vhf_channel_pilots.empty() ? Err_NotExist : Ok; 
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetPreDepartureNoticeTo(
    SDKString& channel) const throw() {
    try
    {
      channel = ScopedString(m_pre_departure_notice_to).Detach();
      return m_pre_departure_notice_to.empty() ? Err_NotExist : Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetVHFChannel(
    SDKString& channel) const throw() {
    try
    {
      channel = ScopedString(m_vhf_channel).Detach();
      return m_vhf_channel.empty() ? Err_NotExist : Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetDraughtRestrictions(
    SDKString& draught_restrictions) const throw() {
    try
    {
      draught_restrictions = ScopedString(m_draught_restrictions).Detach();
      return m_draught_restrictions.empty() ? Err_NotExist : Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetAirDraughtRestrictions(
    SDKString& air_draught_restrictions) const throw() {
    try
    {
      air_draught_restrictions = ScopedString(m_air_draught_restrictions).Detach();
      return m_air_draught_restrictions.empty() ? Err_NotExist : Ok;
    }
    SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetOtherRestrictions(
    SDKString& other_restrictions) const throw() {
    try
    {
      other_restrictions = ScopedString(m_other_restrictions).Detach();
      return m_other_restrictions.empty() ? Err_NotExist : Ok;
    }
    SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetGuideToPortEntry(
    SDKString& guide_to_port_entry) const throw() {
    try
    {
      guide_to_port_entry = ScopedString(m_guide_to_port_entry).Detach();
      return m_guide_to_port_entry.empty() ? Err_NotExist : Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetExtraInfo(
    SDKString& extra_info) const throw() {
    try
    {
      extra_info = ScopedString(m_extra_info).Detach();
      return m_extra_info.empty() ? Err_NotExist : Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetTimeZone(SDKTimeDelta& tz) const throw() {
    try
    {
      tz = m_tz;
      return Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetTimeZoneDisplayName(
    SDKString& tz_display_name) const throw() {
    try
    {
      if (m_tz_display_name.empty()) 
        return Err_NotExist;
      tz_display_name = ScopedString(m_tz_display_name).Detach();
      return Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetPosition(
    SDKGeoPoint& position) const throw() {
    try
    {
      position = GeoPoint();
      if (!m_position.IsValid())
        return Err_NotExist;
      position = m_position;
      return Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
  virtual SDKResult SDK_CALLTYPE GetNameOfBerth(
    SDKString& name_of_berth) const throw() {
    try
    {
      name_of_berth = ScopedString(m_name_of_berth).Detach();
      return m_name_of_berth.empty() ? Err_NotExist : Ok;
    } SDK_CATCH_RET(Err_Unexpected)
  }
 
private:
  PortInfo(const PortInfo&);
  void operator=(const PortInfo&);
 
protected:
  const std::wstring m_name;
  const std::wstring m_country;
  const std::wstring m_vhf_channel_port_control;
  const std::wstring m_vhf_channel_pilots;
  const std::wstring m_pre_departure_notice_to;
  const std::wstring m_vhf_channel;
  const std::wstring m_draught_restrictions;
  const std::wstring m_air_draught_restrictions;
  const std::wstring m_other_restrictions;
  const std::wstring m_guide_to_port_entry;
  const std::wstring m_extra_info;
  const SDKTimeDelta m_tz;
  const std::wstring m_tz_display_name;
  const GeoPoint     m_position;
  const std::wstring m_name_of_berth;
};
 
SDK_NAVBOX_CLIENT_END_NAMESPACE
 
#endif // SDK_NAVBOX_CLIENT_PORT_INFO_INTERFACE_IMPL_H_