GetRecord.h

Go to the documentation of this file.

 
#ifndef _MADARA_KNOWLEDGE_GET_RECORD_H_
#define _MADARA_KNOWLEDGE_GET_RECORD_H_
 
#include <madara/knowledge/KnowledgeRecord.h>
#include <madara/knowledge/KnowledgeCast.h>
#include <madara/utility/StlHelper.h>
 
#include "madara/exceptions/MadaraException.h"
 
namespace madara
{
namespace exceptions
{
class InvalidGetException : public MadaraException
{
public:
  using MadaraException::MadaraException;
};
 
class MissingValueException : public InvalidGetException
{
public:
  using InvalidGetException::InvalidGetException;
};
 
class MismatchedTypeException : public InvalidGetException
{
public:
  using InvalidGetException::InvalidGetException;
};
}
}
 
namespace madara
{
namespace knowledge
{
#ifdef DOXYGEN
 
template<typename T>
inline bool type_match(type<T> t, const KnowledgeRecord& kr);
#else
 
template<typename T>
inline auto type_match(type<T>, const KnowledgeRecord& kr) ->
    typename std::enable_if<std::is_integral<T>::value, bool>::type
{
  return kr.type() == KnowledgeRecord::INTEGER;
}
 
template<typename T>
inline auto type_match(type<T>, const KnowledgeRecord& kr) ->
    typename std::enable_if<std::is_floating_point<T>::value, bool>::type
{
  return kr.type() == KnowledgeRecord::DOUBLE;
}
 
inline bool type_match(type<std::string>, const KnowledgeRecord& kr)
{
  return kr.type() == KnowledgeRecord::STRING;
}
 
template<typename T>
inline auto type_match(type<std::vector<T> >, const KnowledgeRecord& kr) ->
    typename std::enable_if<std::is_integral<T>::value, bool>::type
{
  return kr.type() == KnowledgeRecord::INTEGER_ARRAY;
}
 
template<typename T>
inline auto type_match(type<std::vector<T> >, const KnowledgeRecord& kr) ->
    typename std::enable_if<std::is_floating_point<T>::value, bool>::type
{
  return kr.type() == KnowledgeRecord::DOUBLE_ARRAY;
}
 
#endif  // DOXYGEN
 
template<typename T>
inline T get(const KnowledgeRecord& kr)
{
  if (!kr.exists())
  {
    throw exceptions::MissingValueException("madara::knowledge::get: "
                                            "KnowledgeRecord does not exist");
  }
  if (!type_match(type<T>{}, kr))
  {
    throw exceptions::MismatchedTypeException(
        "madara::knowledge::get: "
        "Expected type does not match the KnowledgeRecord's type (" +
        std::to_string(kr.type()) + ")");
  }
 
  return knowledge_cast<T>(kr);
}
 
}  // namespace knowledge
}  // namespace madara
 
#endif  // _MADARA_KNOWLEDGE_GET_RECORD_H_