SampledSensor.h

#pragma once
 
#include "SampleClock.h"
#include "SensorFrame.h"
#include "SensorNoise.h"
 
#include <fhsim/simobject/SimObject.h>
#include <string>
 
class PrintDuringExec;
 
namespace environment
{
class EnvironmentProvider;
}
 
class SampledSensor
{
public:
   SampledSensor(ISimObjectCreator* creator, std::string kind, std::string name);
 
   SampledSensor(std::string kind, std::string name, const double mountOffset[3], const double mountDirection[3],
         double period, unsigned int seed);
 
   void SetSamplePeriod(double period);
 
   bool HasPorts() const { return m_hasPorts; }
 
   unsigned int Seed() const { return m_seed; }
 
   environment::EnvironmentProvider* SetUpEnvironment(ISimObjectCreator* creator);
 
   environment::EnvironmentProvider* Environment() const { return m_environment; }
 
   template<typename Measure>
   int ForEachDueSample(const double t, Measure&& measure)
   {
      int samples = 0;
      while (m_clock.Due(t)) {
         measure();
         samples++;
      }
      return samples;
   }
 
   const SensorFrame& Frame() const { return m_frame; }
 
   SensorNoise& Noise() { return m_noise; }
 
   const SensorNoise& Noise() const { return m_noise; }
 
   double NextSampleTime() const { return m_clock.NextSampleTime(); }
 
   const std::string& Name() const { return m_name; }
 
   std::string Label() const { return m_kind + " '" + m_name + "'"; }
 
   void Warn(const std::string& text) const;
 
   void Info(const std::string& text) const;
 
private:
   std::string      m_kind;               
   std::string      m_name;               
   SensorFrame      m_frame;              
   SampleClock      m_clock;              
   unsigned int     m_seed = 0;           
   SensorNoise      m_noise;              
   PrintDuringExec* m_print    = nullptr; 
   bool             m_hasPorts = false;   
 
   environment::EnvironmentProvider* m_environment = nullptr; 
};