parsed_nmea_sentence_data_interface.h

Go to the documentation of this file.

#ifndef SDK_ECDIS_NMEA_PARSER_PARSED_NMEA_SENTENCE_DATA_INTERFACE_H_
#define SDK_ECDIS_NMEA_PARSER_PARSED_NMEA_SENTENCE_DATA_INTERFACE_H_
#pragma once
 
#include <base/inc/platform.h>
#include <base/inc/sdk_results.h>
#include <base/inc/base_types.h>
#include <base/inc/sdk_component_interface.h>
#include <base/inc/sdk_any_handler.h>
#include <ecdislayer/inc/ecdislayer_const.h>
#include "parsed_nmea_sentence_value_ids.h"
 
SDK_ECDISLAYER_BEGIN_NAMESPACE
 
namespace nmea {
 
FWD_DECL_INTERFACE(IParsedNMEASentenceData);
 
class IParsedNMEASentenceData : public ISDKComponent
{
 public:
   virtual SDKResult SDK_CALLTYPE GetRawValue(
     const NMEASentenceValueID& nmea_sentence_value_id,
     SDKAny& nmea_sentence_value) const throw() = 0;
 
   template< typename T >
   SDKResult GetRawValueT(const NMEASentenceValueID& id, T& out) const throw()
   {
     try
     {
       ScopedAny value;
       SDKResult res = GetRawValue(id, value);
       if (SDK_FAILED(res))
         return res;
       if (ANY_IS_EMPTY(&value))
         return Err_NotExist;
       return value.GetAs< T >(out) ? Ok : Err_InvalidArg;
     }
     catch (...) {}
 
     return Err_UnknownError;
   }
 
   inline DataFieldState GetValueState(
     const NMEASentenceValueID& id) const throw()
   {
     try
     {
       const NMEASentenceValueID state_id = IsDataFieldStateID(id)
         ? id : ValueID2DataFieldStateID(id);
 
       SDKUInt32 val = kDataFieldState_Unknown;
       if (SDK_FAILED(GetRawValueT<SDKUInt32>(state_id, val)))
         return kDataFieldState_Unknown;
 
       return static_cast<DataFieldState>(val);
     }
     catch (...) {}
 
     return kDataFieldState_Unknown;
   }
 
   inline bool IsValueValid(const NMEASentenceValueID& id) const
   { return kDataFieldState_Valid == GetValueState(id); }
 
   inline bool IsValueInvalid(const NMEASentenceValueID& id) const
   { return kDataFieldState_InvalidValue == GetValueState(id); }
 
   inline bool IsValueAbsent(const NMEASentenceValueID& id) const
   { return kDataFieldState_Absent == GetValueState(id); }
 
   inline bool IsValueInvalidFormat(const NMEASentenceValueID& id) const
   { return kDataFieldState_InvalidFormat == GetValueState(id); }
 
   template< typename T >
   inline SDKResult GetValidValue(const NMEASentenceValueID& id, T& out) const
   { 
     if (IsValueID(id))
     {
       // Checking value state
       const DataFieldState state = GetValueState(id);
       if (kDataFieldState_Valid != state && kDataFieldState_Unknown != state)
         return Err_EmptyValue;
     }
 
     return GetRawValueT<T>(id, out); 
   }
 
   template< typename T >
   inline SDKResult GetValidOrInvalidValue(
     const NMEASentenceValueID& id, T& out) const
   { 
     if (IsValueID(id))
     {
       // Checking value state
       const DataFieldState state = GetValueState(id);
       if (kDataFieldState_Valid != state && kDataFieldState_Unknown != state &&
         kDataFieldState_InvalidValue != state)
         return Err_EmptyValue;
     } 
     
     return GetRawValueT<T>(id, out);
   }
 
    template< typename T >
    inline SDKResult GetValueAndStateT(
      const NMEASentenceValueID& id, T& out, bool& is_valid, 
      bool& is_absent) const
    {
      is_absent = true;
      is_valid = false;
      if (IsValueID(id))
      {
        // Checking value state
        const DataFieldState state = GetValueState(id);
        is_absent = (kDataFieldState_Absent == state) || 
          (kDataFieldState_Unknown == state);
        is_valid = kDataFieldState_Valid == state;
        if (is_absent)
          is_valid = false;
        return GetRawValueT<T>(id, out);
      }
      return Err_NotExist;
    }
 
   inline SDKResult GetNMEASentenceValue(
     const NMEASentenceValueID& nmea_sentence_value_id,
     SDKAny& nmea_sentence_value) const
   {
     if (IsValueID(nmea_sentence_value_id))
     {
       // Checking value state
       const DataFieldState state = GetValueState(nmea_sentence_value_id);
       if (kDataFieldState_Valid != state
         && kDataFieldState_Unknown != state)
         return Err_EmptyValue;
     }
 
     return GetRawValue(nmea_sentence_value_id, nmea_sentence_value);
   }
 
   template< typename T >
   inline SDKResult GetNMEASentenceValueT(
     const NMEASentenceValueID& id, T& out) const
   { return GetValidValue(id, out); }
 
   SDK_IMPLEMENT_IID(IParsedNMEASentenceData)
   SDK_END_INTERFACE(IParsedNMEASentenceData)
};
SDK_DECLARE_IID(IParsedNMEASentenceData)
 
} // namespace nmea
 
SDK_ECDISLAYER_END_NAMESPACE
 
#endif // SDK_ECDIS_NMEA_PARSER_PARSED_NMEA_SENTENCE_DATA_INTERFACE_H_