abstract_state_machine.h

Go to the documentation of this file.

/*
 * Software License Agreement (Apache License)
 *
 * Copyright (c) 2018 Plus One Robotics
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
#include "packml_sm/state_changed_event_args.h"
#include "packml_sm/packml_stats_snapshot.h"
#include "packml_sm/packml_stats_itemized.h"
#include "common.h"

#include <map>
#include <mutex>
#include <chrono>
#include <functional>

namespace packml_sm
{
class AbstractStateMachine
{
public:
  EventHandler<AbstractStateMachine, StateChangedEventArgs> stateChangedEvent; 
  AbstractStateMachine();

  virtual ~AbstractStateMachine()
  {
  }

  virtual bool activate() = 0;

  virtual bool deactivate() = 0;

  virtual bool setStarting(std::function<int()> state_method) = 0;

  virtual bool setExecute(std::function<int()> state_method) = 0;

  virtual bool setCompleting(std::function<int()> state_method) = 0;

  virtual bool setAborting(std::function<int()> state_method) = 0;

  virtual bool setClearing(std::function<int()> state_method) = 0;

  virtual bool setStopping(std::function<int()> state_method) = 0;

  virtual bool setResetting(std::function<int()> state_method) = 0;

  virtual bool setSuspending(std::function<int()> state_method) = 0;

  virtual bool setUnsuspending(std::function<int()> state_method) = 0;

  virtual bool setHolding(std::function<int()> state_method) = 0;

  virtual bool setUnholding(std::function<int()> state_method) = 0;

  virtual bool isActive() = 0;

  StatesEnum getCurrentState() const
  {
    return current_state_;
  }

  double getIdleTime();

  double getStartingTime();

  double getResettingTime();

  double getExecuteTime();

  double getHeldTime();

  double getHoldingTime();

  double getUnholdingTime();

  double getSuspendedTime();

  double getSuspendingTime();

  double getUnsuspendingTime();

  double getCompleteTime();

  double getStoppedTime();

  double getClearingTime();

  double getStoppingTime();

  double getAbortedTime();

  double getAbortingTime();

  void resetStats();

  void incrementErrorStatItem(int16_t id, int32_t count, double duration);

  void incrementQualityStatItem(int16_t id, int32_t count, double duration);

  void incrementSuccessCount();

  void incrementFailureCount();

  void setIdealCycleTime(float ideal_cycle_time);

  virtual bool start();

  virtual bool clear();

  virtual bool reset();

  virtual bool hold();

  virtual bool unhold();

  virtual bool suspend();

  virtual bool unsuspend();

  virtual bool stop();

  virtual bool abort();

  void getCurrentStatSnapshot(PackmlStatsSnapshot& snapshot_out);

protected:
  void invokeStateChangedEvent(const std::string& name, StatesEnum value);

  virtual void _start() = 0;

  virtual void _clear() = 0;

  virtual void _reset() = 0;

  virtual void _hold() = 0;

  virtual void _unhold() = 0;

  virtual void _suspend() = 0;

  virtual void _unsuspend() = 0;

  virtual void _stop() = 0;

  virtual void _abort() = 0;

private:
  std::map<int16_t, PackmlStatsItemized> itemized_error_map_;
  std::map<int16_t, PackmlStatsItemized> itemized_quality_map_;
  int success_count_ = 0;        
  int failure_count_ = 0;        
  float ideal_cycle_time_ = 0.0; 
  std::recursive_mutex stat_mutex_;                  
  StatesEnum current_state_ = StatesEnum::UNDEFINED; 
  std::map<StatesEnum, double> duration_map_; 
  std::chrono::steady_clock::time_point start_time_; 
  void incrementMapStatItem(std::map<int16_t, PackmlStatsItemized>& itemized_map, int16_t id, int32_t count,
                            double duration);

  void updateClock(StatesEnum new_state);

  double getStateDuration(StatesEnum state);

  double calculateTotalTime();
};
}