cl_gcalcli::CpCalendarPoller Class Reference

Component that polls Google Calendar and parses event data. More...

#include <cp_calendar_poller.hpp>

Inheritance diagram for cl_gcalcli::CpCalendarPoller:

Collaboration diagram for cl_gcalcli::CpCalendarPoller:

Public Member Functions
	CpCalendarPoller ()
virtual	~CpCalendarPoller ()=default
void	onInitialize () override
bool	refreshAgenda ()
	Force an immediate agenda refresh.
std::vector< CalendarEvent >	getEvents () const
	Get cached list of calendar events.
std::vector< CalendarEvent >	findEvents (const std::string &pattern, bool use_regex=false) const
	Get events matching a title pattern.
std::vector< CalendarEvent >	getEventsInWindow (std::chrono::system_clock::time_point start, std::chrono::system_clock::time_point end) const
	Get events happening within a time window.
std::vector< CalendarEvent >	getActiveEvents () const
	Get currently active events.
std::chrono::system_clock::time_point	getLastPollTime () const
	Get the time of the last successful poll.
template<typename T >
smacc2::SmaccSignalConnection	onAgendaUpdated (void(T::*callback)(const std::vector< CalendarEvent > &), T *object)
template<typename TOrthogonal , typename TSourceObject >
void	onStateOrthogonalAllocation ()
	Template method for type-safe event posting setup.
Public Member Functions inherited from smacc2::ISmaccComponent
	ISmaccComponent ()
virtual	~ISmaccComponent ()
virtual std::string	getName () const
Public Member Functions inherited from smacc2::ISmaccUpdatable
	ISmaccUpdatable ()
	ISmaccUpdatable (rclcpp::Duration duration)
void	executeUpdate (rclcpp::Node::SharedPtr node)
void	setUpdatePeriod (rclcpp::Duration duration)

Public Attributes
smacc2::SmaccSignal< void(const std::vector< CalendarEvent > &)>	onAgendaUpdated_
std::function< void(const std::vector< CalendarEvent > &)>	postAgendaUpdatedEvent_

Protected Member Functions
void	update () override
	Periodic update for polling (called by SignalDetector)
Protected Member Functions inherited from smacc2::ISmaccComponent
template<typename TOrthogonal , typename TClient >
void	onComponentInitialization ()
template<typename EventType >
void	postEvent (const EventType &ev)
template<typename EventType >
void	postEvent ()
template<typename TOrthogonal , typename TSourceObject >
void	onStateOrthogonalAllocation ()
template<typename TComponent >
void	requiresComponent (TComponent *&requiredComponentStorage, ComponentRequirement requirementType=ComponentRequirement::SOFT)
template<typename TComponent >
void	requiresComponent (std::string name, TComponent *&requiredComponentStorage, ComponentRequirement requirementType=ComponentRequirement::SOFT)
template<typename TClient >
void	requiresClient (TClient *&requiredClientStorage)
template<typename SmaccComponentType , typename TOrthogonal , typename TClient , typename... TArgs>
SmaccComponentType *	createSiblingComponent (TArgs... targs)
template<typename SmaccComponentType , typename TOrthogonal , typename TClient , typename... TArgs>
SmaccComponentType *	createSiblingNamedComponent (std::string name, TArgs... targs)
rclcpp::Node::SharedPtr	getNode ()
rclcpp::Logger	getLogger () const
ISmaccStateMachine *	getStateMachine ()
Protected Member Functions inherited from smacc2::ISmaccUpdatable

Private Member Functions
std::vector< CalendarEvent >	parseTsvOutput (const std::string &output)
	Parse TSV output into CalendarEvent structures.
std::optional< CalendarEvent >	parseTsvLine (const std::string &line)
	Parse a single TSV line into a CalendarEvent.
std::optional< std::chrono::system_clock::time_point >	parseDateTime (const std::string &date_str, const std::string &time_str)
	Parse date and time strings into time_point.
std::string	generateEventId (const CalendarEvent &event)
	Generate a unique ID for an event.

Private Attributes
CpGcalcliConnection *	connection_
std::vector< CalendarEvent >	cached_events_
std::chrono::system_clock::time_point	last_poll_time_
std::chrono::steady_clock::time_point	last_poll_attempt_
bool	initialized_
std::mutex	events_mutex_

Additional Inherited Members
Protected Attributes inherited from smacc2::ISmaccComponent
ISmaccStateMachine *	stateMachine_
ISmaccClient *	owner_

Detailed Description

Component that polls Google Calendar and parses event data.

This component periodically fetches the agenda from Google Calendar using gcalcli's TSV output format and parses it into CalendarEvent structures.

TSV Format: Start_Date | Start_Time | End_Date | End_Time | Title | Location | Description | Calendar

Definition at line 43 of file cp_calendar_poller.hpp.

Constructor & Destructor Documentation

CpCalendarPoller()

cl_gcalcli::CpCalendarPoller::CpCalendarPoller

(

)

Definition at line 24 of file cp_calendar_poller.cpp.

: connection_(nullptr), initialized_(false) {}

~CpCalendarPoller()

virtual cl_gcalcli::CpCalendarPoller::~CpCalendarPoller ( )

virtualdefault

Member Function Documentation

findEvents()

std::vector< CalendarEvent > cl_gcalcli::CpCalendarPoller::findEvents	(	const std::string &	pattern,
		bool	use_regex = false ) const

Get events matching a title pattern.

Parameters

pattern	Pattern to match (regex or exact based on use_regex)
use_regex	If true, use regex matching

Definition at line 109 of file cp_calendar_poller.cpp.

{
  std::lock_guard<std::mutex> lock(events_mutex_);
 
  std::vector<CalendarEvent> matches;
 
  if (use_regex)
  {
    try
    {
      boost::regex regex(pattern, boost::regex::icase);
      for (const auto & event : cached_events_)
      {
        if (boost::regex_search(event.title, regex))
        {
          matches.push_back(event);
        }
      }
    }
    catch (const boost::regex_error & e)
    {
      RCLCPP_ERROR(getLogger(), "[CpCalendarPoller] Invalid regex pattern: %s", e.what());
    }
  }
  else
  {
    for (const auto & event : cached_events_)
    {
      if (event.title.find(pattern) != std::string::npos)
      {
        matches.push_back(event);
      }
    }
  }
 
  return matches;
}

References cached_events_, events_mutex_, and smacc2::ISmaccComponent::getLogger().

Here is the call graph for this function:

generateEventId()

std::string cl_gcalcli::CpCalendarPoller::generateEventId ( const CalendarEvent & event )

private

Generate a unique ID for an event.

Definition at line 384 of file cp_calendar_poller.cpp.

{
  // Generate a unique ID based on title and start time
  auto start_t = std::chrono::system_clock::to_time_t(event.start_time);
  std::stringstream ss;
  ss << event.title << "_" << start_t << "_" << event.calendar_name;
  return ss.str();
}

References cl_gcalcli::CalendarEvent::start_time.

Referenced by parseTsvLine().

Here is the caller graph for this function:

getActiveEvents()

std::vector< CalendarEvent > cl_gcalcli::CpCalendarPoller::getActiveEvents

(

)

const

Get currently active events.

Definition at line 166 of file cp_calendar_poller.cpp.

{
  std::lock_guard<std::mutex> lock(events_mutex_);
 
  std::vector<CalendarEvent> active;
  for (const auto & event : cached_events_)
  {
    if (event.isActiveNow())
    {
      active.push_back(event);
    }
  }
 
  return active;
}

References cached_events_, and events_mutex_.

getEvents()

std::vector< CalendarEvent > cl_gcalcli::CpCalendarPoller::getEvents

(

)

const

Get cached list of calendar events.

Definition at line 103 of file cp_calendar_poller.cpp.

{
  std::lock_guard<std::mutex> lock(events_mutex_);
  return cached_events_;
}

References cached_events_, and events_mutex_.

getEventsInWindow()

std::vector< CalendarEvent > cl_gcalcli::CpCalendarPoller::getEventsInWindow	(	std::chrono::system_clock::time_point	start,
		std::chrono::system_clock::time_point	end ) const

Get events happening within a time window.

Definition at line 148 of file cp_calendar_poller.cpp.

{
  std::lock_guard<std::mutex> lock(events_mutex_);
 
  std::vector<CalendarEvent> matches;
  for (const auto & event : cached_events_)
  {
    // Event overlaps with window if it starts before window end and ends after window start
    if (event.start_time < end && event.end_time > start)
    {
      matches.push_back(event);
    }
  }
 
  return matches;
}

References cached_events_, and events_mutex_.

getLastPollTime()

std::chrono::system_clock::time_point cl_gcalcli::CpCalendarPoller::getLastPollTime

(

)

const

Get the time of the last successful poll.

Definition at line 182 of file cp_calendar_poller.cpp.

{
  std::lock_guard<std::mutex> lock(events_mutex_);
  return last_poll_time_;
}

References events_mutex_, and last_poll_time_.

onAgendaUpdated()

template<typename T >

smacc2::SmaccSignalConnection cl_gcalcli::CpCalendarPoller::onAgendaUpdated ( void(T::* callback )(const std::vector< CalendarEvent > &), T * object )

inline

Definition at line 90 of file cp_calendar_poller.hpp.

  {
    return this->getStateMachine()->createSignalConnection(onAgendaUpdated_, callback, object);
  }

References smacc2::ISmaccStateMachine::createSignalConnection(), and smacc2::ISmaccComponent::getStateMachine().

Referenced by cl_gcalcli::CpCalendarEventListener::onInitialize().

Here is the call graph for this function:

Here is the caller graph for this function:

onInitialize()

void cl_gcalcli::CpCalendarPoller::onInitialize ( )

overridevirtual

Reimplemented from smacc2::ISmaccComponent.

Definition at line 26 of file cp_calendar_poller.cpp.

{
  if (!initialized_)
  {
    requiresComponent(connection_);
 
    if (connection_ == nullptr)
    {
      RCLCPP_ERROR(getLogger(), "[CpCalendarPoller] CpGcalcliConnection component not found!");
      return;
    }
 
    last_poll_attempt_ = std::chrono::steady_clock::now();
    initialized_ = true;
 
    RCLCPP_INFO(getLogger(), "[CpCalendarPoller] Initialized");
  }
}

References connection_, smacc2::ISmaccComponent::getLogger(), initialized_, last_poll_attempt_, and smacc2::ISmaccComponent::requiresComponent().

Here is the call graph for this function:

onStateOrthogonalAllocation()

template<typename TOrthogonal , typename TSourceObject >

void cl_gcalcli::CpCalendarPoller::onStateOrthogonalAllocation ( )

inline

Template method for type-safe event posting setup.

Definition at line 103 of file cp_calendar_poller.hpp.

  {
    postAgendaUpdatedEvent_ = [this](const std::vector<CalendarEvent> & events)
    {
      auto ev = new EvAgendaUpdated<CpCalendarPoller, TOrthogonal>();
      ev->events = events;
      this->postEvent(ev);
    };
  }

References postAgendaUpdatedEvent_, and smacc2::ISmaccComponent::postEvent().

Here is the call graph for this function:

parseDateTime()

std::optional< std::chrono::system_clock::time_point > cl_gcalcli::CpCalendarPoller::parseDateTime ( const std::string & date_str, const std::string & time_str )

private

Parse date and time strings into time_point.

Parameters

date_str	Date string (MM/DD/YYYY or similar)
time_str	Time string (HH:MM or similar)

Definition at line 296 of file cp_calendar_poller.cpp.

{
  std::tm tm = {};
 
  // Parse date - gcalcli TSV uses YYYY-MM-DD format
  std::istringstream date_stream(date_str);
  char sep1, sep2;
  int year, month, day;
 
  if (date_stream >> year >> sep1 >> month >> sep2 >> day && sep1 == '-' && sep2 == '-')
  {
    // YYYY-MM-DD format (gcalcli TSV)
    tm.tm_year = year - 1900;
    tm.tm_mon = month - 1;
    tm.tm_mday = day;
  }
  else
  {
    // Try MM/DD/YYYY format as fallback
    date_stream.clear();
    date_stream.str(date_str);
    if (date_stream >> month >> sep1 >> day >> sep2 >> year && sep1 == '/' && sep2 == '/')
    {
      tm.tm_mon = month - 1;
      tm.tm_mday = day;
      tm.tm_year = year - 1900;
    }
    else
    {
      RCLCPP_DEBUG(getLogger(), "[CpCalendarPoller] Failed to parse date: %s", date_str.c_str());
      return std::nullopt;
    }
  }
 
  // Parse time - gcalcli TSV uses 24-hour HH:MM format
  if (!time_str.empty())
  {
    std::istringstream time_stream(time_str);
    char colon;
    int hour, minute;
 
    if (time_stream >> hour >> colon >> minute && colon == ':')
    {
      tm.tm_hour = hour;
      tm.tm_min = minute;
 
      // Check for am/pm suffix (for non-TSV formats)
      std::string rest;
      std::getline(time_stream, rest);
      if (!rest.empty())
      {
        // Remove leading spaces
        size_t start = rest.find_first_not_of(" ");
        if (start != std::string::npos)
        {
          rest = rest.substr(start);
        }
        // Check for am/pm
        if (rest == "pm" || rest == "PM" || rest == "p" || rest == "P")
        {
          if (hour != 12) tm.tm_hour += 12;
        }
        else if (rest == "am" || rest == "AM" || rest == "a" || rest == "A")
        {
          if (hour == 12) tm.tm_hour = 0;
        }
      }
    }
    else
    {
      RCLCPP_DEBUG(getLogger(), "[CpCalendarPoller] Failed to parse time: %s", time_str.c_str());
      return std::nullopt;
    }
  }
 
  tm.tm_sec = 0;
  tm.tm_isdst = -1;  // Let mktime determine DST
 
  std::time_t time = std::mktime(&tm);
  if (time == -1)
  {
    return std::nullopt;
  }
 
  return std::chrono::system_clock::from_time_t(time);
}

References smacc2::ISmaccComponent::getLogger().

Referenced by parseTsvLine().

Here is the call graph for this function:

Here is the caller graph for this function:

parseTsvLine()

std::optional< CalendarEvent > cl_gcalcli::CpCalendarPoller::parseTsvLine ( const std::string & line )

private

Parse a single TSV line into a CalendarEvent.

Definition at line 235 of file cp_calendar_poller.cpp.

{
  // TSV columns: Start_Date | Start_Time | End_Date | End_Time | Title | Location | Description | Calendar
  std::vector<std::string> fields;
  std::istringstream stream(line);
  std::string field;
 
  while (std::getline(stream, field, '\t'))
  {
    fields.push_back(field);
  }
 
  // We need at least 5 fields (date/time + title)
  if (fields.size() < 5)
  {
    RCLCPP_DEBUG(
      getLogger(), "[CpCalendarPoller] Skipping line with insufficient fields: %s", line.c_str());
    return std::nullopt;
  }
 
  CalendarEvent event;
 
  // Parse start time
  auto start = parseDateTime(fields[0], fields[1]);
  if (!start.has_value())
  {
    RCLCPP_DEBUG(
      getLogger(), "[CpCalendarPoller] Failed to parse start time: %s %s", fields[0].c_str(),
      fields[1].c_str());
    return std::nullopt;
  }
  event.start_time = start.value();
 
  // Parse end time
  auto end = parseDateTime(fields[2], fields[3]);
  if (!end.has_value())
  {
    RCLCPP_DEBUG(
      getLogger(), "[CpCalendarPoller] Failed to parse end time: %s %s", fields[2].c_str(),
      fields[3].c_str());
    return std::nullopt;
  }
  event.end_time = end.value();
 
  // Title (required)
  event.title = fields[4];
 
  // Optional fields
  if (fields.size() > 5) event.location = fields[5];
  if (fields.size() > 6) event.description = fields[6];
  if (fields.size() > 7) event.calendar_name = fields[7];
 
  // Check for all-day event (typically has no time or 00:00)
  event.is_all_day = (fields[1].empty() || fields[1] == "00:00" || fields[1] == "12:00am");
 
  // Generate ID
  event.id = generateEventId(event);
 
  return event;
}

References generateEventId(), smacc2::ISmaccComponent::getLogger(), and parseDateTime().

Referenced by parseTsvOutput().

Here is the call graph for this function:

Here is the caller graph for this function:

parseTsvOutput()

std::vector< CalendarEvent > cl_gcalcli::CpCalendarPoller::parseTsvOutput ( const std::string & output )

private

Parse TSV output into CalendarEvent structures.

Definition at line 211 of file cp_calendar_poller.cpp.

{
  std::vector<CalendarEvent> events;
  std::istringstream stream(output);
  std::string line;
 
  while (std::getline(stream, line))
  {
    // Skip empty lines
    if (line.empty() || line.find_first_not_of(" \t\r\n") == std::string::npos)
    {
      continue;
    }
 
    auto event = parseTsvLine(line);
    if (event.has_value())
    {
      events.push_back(event.value());
    }
  }
 
  return events;
}

References parseTsvLine().

Referenced by refreshAgenda().

Here is the call graph for this function:

Here is the caller graph for this function:

refreshAgenda()

bool cl_gcalcli::CpCalendarPoller::refreshAgenda

(

)

Force an immediate agenda refresh.

Returns

true if refresh was successful

Definition at line 45 of file cp_calendar_poller.cpp.

{
  if (!connection_ || !connection_->isConnected())
  {
    RCLCPP_WARN(getLogger(), "[CpCalendarPoller] Cannot refresh - not connected");
    return false;
  }
 
  const auto & config = connection_->getConfig();
 
  // Build the agenda command with TSV output
  std::stringstream args;
  args << "agenda --tsv --nocolor";
  args << " --nodeclined";
 
  // Add date range
  auto now = std::chrono::system_clock::now();
  auto end = now + std::chrono::hours(24 * config.agenda_days);
 
  auto now_t = std::chrono::system_clock::to_time_t(now);
  auto end_t = std::chrono::system_clock::to_time_t(end);
 
  std::tm now_tm = *std::localtime(&now_t);
  std::tm end_tm = *std::localtime(&end_t);
 
  args << " \"" << std::put_time(&now_tm, "%m/%d/%Y") << "\"";
  args << " \"" << std::put_time(&end_tm, "%m/%d/%Y") << "\"";
 
  auto result = connection_->executeGcalcli(args.str(), 30000);
 
  if (result.exit_code != 0 || result.timed_out)
  {
    RCLCPP_WARN(
      getLogger(), "[CpCalendarPoller] Agenda fetch failed: %s", result.stdout_output.c_str());
    return false;
  }
 
  // Parse the TSV output
  auto events = parseTsvOutput(result.stdout_output);
 
  {
    std::lock_guard<std::mutex> lock(events_mutex_);
    cached_events_ = events;
    last_poll_time_ = std::chrono::system_clock::now();
  }
 
  RCLCPP_DEBUG(getLogger(), "[CpCalendarPoller] Refreshed agenda: %zu events", events.size());
 
  // Emit signal and post event
  onAgendaUpdated_(events);
  if (postAgendaUpdatedEvent_)
  {
    postAgendaUpdatedEvent_(events);
  }
 
  return true;
}

References cached_events_, connection_, events_mutex_, cl_gcalcli::CpGcalcliConnection::executeGcalcli(), cl_gcalcli::CpGcalcliConnection::getConfig(), smacc2::ISmaccComponent::getLogger(), cl_gcalcli::CpGcalcliConnection::isConnected(), last_poll_time_, onAgendaUpdated_, parseTsvOutput(), and postAgendaUpdatedEvent_.

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void cl_gcalcli::CpCalendarPoller::update ( )

overrideprotectedvirtual

Periodic update for polling (called by SignalDetector)

Implements smacc2::ISmaccUpdatable.

Definition at line 188 of file cp_calendar_poller.cpp.

{
  if (!initialized_ || !connection_)
  {
    return;
  }
 
  if (!connection_->isConnected())
  {
    return;
  }
 
  const auto & config = connection_->getConfig();
  auto now = std::chrono::steady_clock::now();
  auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - last_poll_attempt_);
 
  if (elapsed >= config.poll_interval)
  {
    refreshAgenda();
    last_poll_attempt_ = now;
  }
}

References connection_, cl_gcalcli::CpGcalcliConnection::getConfig(), initialized_, cl_gcalcli::CpGcalcliConnection::isConnected(), last_poll_attempt_, and refreshAgenda().

Here is the call graph for this function:

Member Data Documentation

cached_events_

std::vector<CalendarEvent> cl_gcalcli::CpCalendarPoller::cached_events_

private

Definition at line 144 of file cp_calendar_poller.hpp.

Referenced by findEvents(), getActiveEvents(), getEvents(), getEventsInWindow(), and refreshAgenda().

connection_

CpGcalcliConnection* cl_gcalcli::CpCalendarPoller::connection_

private

Definition at line 143 of file cp_calendar_poller.hpp.

Referenced by onInitialize(), refreshAgenda(), and update().

events_mutex_

std::mutex cl_gcalcli::CpCalendarPoller::events_mutex_

mutableprivate

Definition at line 149 of file cp_calendar_poller.hpp.

Referenced by findEvents(), getActiveEvents(), getEvents(), getEventsInWindow(), getLastPollTime(), and refreshAgenda().

initialized_

bool cl_gcalcli::CpCalendarPoller::initialized_

private

Definition at line 147 of file cp_calendar_poller.hpp.

Referenced by onInitialize(), and update().

last_poll_attempt_

std::chrono::steady_clock::time_point cl_gcalcli::CpCalendarPoller::last_poll_attempt_

private

Definition at line 146 of file cp_calendar_poller.hpp.

Referenced by onInitialize(), and update().

last_poll_time_

std::chrono::system_clock::time_point cl_gcalcli::CpCalendarPoller::last_poll_time_

private

Definition at line 145 of file cp_calendar_poller.hpp.

Referenced by getLastPollTime(), and refreshAgenda().

onAgendaUpdated_

smacc2::SmaccSignal<void(const std::vector<CalendarEvent> &)> cl_gcalcli::CpCalendarPoller::onAgendaUpdated_

Definition at line 86 of file cp_calendar_poller.hpp.

Referenced by refreshAgenda().

postAgendaUpdatedEvent_

std::function<void(const std::vector<CalendarEvent> &)> cl_gcalcli::CpCalendarPoller::postAgendaUpdatedEvent_

Definition at line 97 of file cp_calendar_poller.hpp.

Referenced by onStateOrthogonalAllocation(), and refreshAgenda().

---

The documentation for this class was generated from the following files:

• smacc2_client_library/cl_gcalcli/include/cl_gcalcli/components/cp_calendar_poller.hpp
• smacc2_client_library/cl_gcalcli/src/cl_gcalcli/components/cp_calendar_poller.cpp