VariantValidator.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2019 Infoscitex, a DCS Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef VARIANTVALIDATOR_HPP
#define VARIANTVALIDATOR_HPP
 
#include "usmtf_export.h"
 
#include <string>
#include <tuple>
#include <typeindex>
#include <unordered_map>
 
#include "FFIRN_Validator.hpp"
 
// Variadic aware check to assert all Types are FFIRN_Validators
namespace
{
// code from
// https://stackoverflow.com/questions/13562823/parameter-pack-aware-stdis-base-of
template<bool... b>
struct static_all_of;
 
// implementation: recurse, if the first argument is true
template<bool... tail>
struct static_all_of<true, tail...> : static_all_of<tail...>
{
};
 
// end recursion if first argument is false -
template<bool... tail>
struct static_all_of<false, tail...> : std::false_type
{
};
 
// - or if no more arguments
template<>
struct static_all_of<> : std::true_type
{
};
} // namespace
 
namespace usmtf
{
template<typename... Types>
class VariantValidator : public FFIRN_Validator
{
   static_assert(static_all_of<std::is_base_of<FFIRN_Validator, Types>::value...>::value,
                 "Invalid Type, Must be an FFIRN_Validator");
 
public:
   VariantValidator() = default;
   // By design once a passed validator is found, there is no way to copy the ptr that is to an internal
   // data structure
   VariantValidator(const VariantValidator& aOther)  = delete;
   VariantValidator(const VariantValidator&& aOther) = delete;
   VariantValidator operator=(const VariantValidator& aOther) = delete;
   VariantValidator operator=(const VariantValidator&& aOther) = delete;

   bool ParseAndValidate(const usmtf::Field& aField) override
   {
      bool res = ParseAndValidateP<0, sizeof...(Types)>{}(*this, aField);
      ClearErrorsIfValid(res);
      return res;
   }

   template<typename T>
   T* IsMatch() const
   {
      return dynamic_cast<T*>(mValidator);
   }

   bool HasMatch() const { return mValidator != nullptr; }
 
private:
   template<int N, int TypeCount>
   struct ParseAndValidateP
   {
      bool operator()(VariantValidator<Types...>& aValidator, const Field& aField)
      {
         auto& ref = std::get<N>(aValidator.mTypeInstances);
         if (ref.ParseAndValidate(aField))
         {
            aValidator.mValidator = &ref;
            return true;
         }
         else
         {
            aValidator.AddErrors(ref.GetErrors());
         }
         return ParseAndValidateP<N + 1, TypeCount>{}(aValidator, aField);
      }
   };
 
   template<int N>
   struct ParseAndValidateP<N, N>
   {
      bool operator()(VariantValidator<Types...>& aValidator, const Field& aField) { return false; }
   };
 
   FFIRN_Validator*     mValidator = nullptr;
   std::tuple<Types...> mTypeInstances;
};
} // namespace usmtf
 
#endif