buffer.h

Go to the documentation of this file.

// Copyright (C) 2021 Christian Brommer and Martin Scheiber, Control of Networked Systems, University of Klagenfurt,
// Austria.
//
// All rights reserved.
//
// This software is licensed under the terms of the BSD-2-Clause-License with
// no commercial use allowed, the full terms of which are made available
// in the LICENSE file. No license in patents is granted.
//
// You can contact the authors at <christian.brommer@ieee.org>
// and <martin.scheiber@ieee.org>.
 
#ifndef BUFFER_H
#define BUFFER_H
 
#include <mars/sensors/sensor_abs_class.h>
#include <mars/time.h>
#include <mars/type_definitions/buffer_entry_type.h>
#include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <set>
#include <vector>
 
namespace mars
{
class Buffer
{
public:
  Buffer();
 
  Buffer(const int& size);
 
  void set_max_buffer_size(const int& size);
 
  void set_keep_last_sensor_handle(const bool& value);
 
  int get_max_buffer_size() const;
 
  void ResetBufferData();
 
  bool IsEmpty() const;
 
  inline int get_length() const
  {
    return static_cast<int>(data_.size());
  }
 
  void PrintBufferEntries() const;
 
  bool get_latest_entry(BufferEntryType* entry) const;
 
  bool get_latest_state(BufferEntryType* entry) const;
 
  bool get_oldest_state(BufferEntryType* entry) const;
 
  bool get_oldest_core_state(BufferEntryType* entry) const;
 
  bool get_latest_init_state(BufferEntryType* entry) const;
 
  bool get_latest_sensor_handle_state(const std::shared_ptr<SensorAbsClass>& sensor_handle,
                                      BufferEntryType* entry) const;
 
  bool get_latest_sensor_handle_state(const std::shared_ptr<SensorAbsClass>& sensor_handle, BufferEntryType* entry,
                                      int* index) const;
 
  bool get_oldest_sensor_handle_state(const std::shared_ptr<SensorAbsClass>& sensor_handle,
                                      BufferEntryType* entry) const;
 
  bool get_latest_sensor_handle_measurement(const std::shared_ptr<SensorAbsClass>& sensor_handle,
                                            BufferEntryType* entry) const;
 
  bool get_sensor_handle_measurements(const std::shared_ptr<SensorAbsClass>& sensor_handle,
                                      std::vector<const BufferEntryType*>* entries) const;
 
  bool get_closest_state(const Time& timestamp, BufferEntryType* entry) const;
  bool get_closest_state(const Time& timestamp, BufferEntryType* entry, int* index) const;
 
  bool get_entry_at_idx(const int& index, BufferEntryType* entry) const;
 
  bool RemoveSensorFromBuffer(const std::shared_ptr<SensorAbsClass>& sensor_handle);
 
  int AddEntrySorted(const BufferEntryType& new_entry, const bool& after = true);
 
  int FindClosestTimestamp(const Time& timestamp) const;
 
  bool ClearStatesStartingAtIdx(const int& idx);
 
  bool IsSorted() const;
 
  bool OverwriteDataAtIndex(const BufferEntryType& new_entry, const int& index);
 
  bool get_intermediate_entry_pair(const std::shared_ptr<SensorAbsClass>& sensor_handle, BufferEntryType* imu_state,
                                   BufferEntryType* sensor_state) const;
 
  bool CheckForLastSensorHandleWithState(const std::shared_ptr<SensorAbsClass>& sensor_handle) const;
 
  int RemoveOverflowEntrys();
 
private:
  std::deque<BufferEntryType> data_;
 
  int max_buffer_size_{ 2000 };
 
  bool keep_last_sensor_handle_{ true };
 
  bool verbose_{ false };  
};
}  // namespace mars
 
#endif  // BUFFER_H