Compiler Explorer

Source code

#include "TwoSetsOfTriggersT.h"
#include "TwoSetsOfTriggersNewT.h"

#include <assert.h>

int main()
{
  {
    TwoSetsOfTriggersT tsot;

assert(tsot.StartAction(TRIGGER1));
    assert(!tsot.StartAction(TRIGGER1)); // already started
    assert(!tsot.StartAction(TRIGGER1, false)); // already started by other source

assert(tsot.StartAction(TRIGGER2, false));
    assert(!tsot.StartAction(TRIGGER2));
    assert(!tsot.StartAction(TRIGGER2));

assert(!tsot.StopAction(TRIGGER3)); // was not started, cannot be stopped

assert(!tsot.StopAction(TRIGGER1)); // still started by other source
    assert(tsot.StopAction(TRIGGER1, false)); // now yes

assert(!tsot.StopAction(TRIGGER2, false)); // still started by other source
    assert(tsot.StopAction(TRIGGER2)); // now yes
  }

{
    TwoSetsOfTriggersNewT tsot;

assert(tsot.AddTriggerAndCheckStart(TRIGGER1));
    assert(!tsot.AddTriggerAndCheckStart(TRIGGER1)); // already started
    assert(!tsot.AddTriggerAndCheckStart(TRIGGER1, TwoSetsOfTriggersNewT::MODULE_1)); // already started by other source

assert(tsot.AddTriggerAndCheckStart(TRIGGER2, TwoSetsOfTriggersNewT::MODULE_1));
    assert(!tsot.AddTriggerAndCheckStart(TRIGGER2));
    assert(!tsot.AddTriggerAndCheckStart(TRIGGER2));

assert(!tsot.RemoveTriggerAndCheckStop(TRIGGER3)); // was not started, cannot be stopped

assert(!tsot.RemoveTriggerAndCheckStop(TRIGGER1)); // still started by other source
    assert(tsot.RemoveTriggerAndCheckStop(TRIGGER1, TwoSetsOfTriggersNewT::MODULE_1)); // now yes

assert(!tsot.RemoveTriggerAndCheckStop(TRIGGER2, TwoSetsOfTriggersNewT::MODULE_1)); // still started by other source
    assert(tsot.RemoveTriggerAndCheckStop(TRIGGER2)); // now yes
  }
}

Source code

#include "TwoSetsOfTriggersT.h"

/*****************************************************************************/

TwoSetsOfTriggersT::TwoSetsOfTriggersT() :
  mModuleTriggers(NO_TRIGGER),
  mModule2Triggers(NO_TRIGGER),
  mCombinedTriggers(NO_TRIGGER)
{
}

/*****************************************************************************/

bool TwoSetsOfTriggersT::StopAction(const uint32_t trigger, const bool isFromModule2)
{
  // Was it a change
  bool isChanged = false;
  if (isFromModule2)
  {
    if (trigger == (mModule2Triggers & trigger))
    {
      mModule2Triggers &= ~trigger;
      isChanged = true;
    }
  }
  else
  {
    if (trigger == (mModuleTriggers & trigger))
    {
      mModuleTriggers &= ~trigger;
      isChanged = true;
    }
  }

// Return value
  bool isToBe = false;

if (isChanged)
  {
    if (trigger == (mCombinedTriggers & trigger))
    {
      if ((0 == (mModuleTriggers & trigger)) &&
        (0 == (mModule2Triggers & trigger)))
      {
        mCombinedTriggers &= ~trigger;
        isToBe = true;
      }
    }
  }

return isToBe;
}

/*****************************************************************************/

bool TwoSetsOfTriggersT::StartAction(const ActionTriggerT trigger, const bool isFromModule2)
{
  // Was it a change
  bool isChanged = false;
  if (isFromModule2)
  {
    if (0 == (mModule2Triggers & trigger))
    {
      mModule2Triggers |= trigger;
      isChanged = true;
    }
  }
  else
  {
    if (0 == (mModuleTriggers & trigger))
    {
      mModuleTriggers |= trigger;
      isChanged = true;
    }
  }

// Return value
  bool isToBe = false;

if (isChanged)
  {
    if (0 == (mCombinedTriggers & trigger))
    {
      mCombinedTriggers |= trigger;
      isToBe = true;
    }
  }

return isToBe;
}

Source code

#ifndef TWOSETSOFTRIGGERSNEW_H
#define TWOSETSOFTRIGGERSNEW_H

#include "ActionTriggers.h"

/**
 * This class coordinates triggers  which can be set by two modules to start and stop actions.
 * Both modules can set and remove the same set of triggers.
 * An action is started/stopped when a trigger is actually set/removed from one module
 * while it was not present from the other.
 */
class TwoSetsOfTriggersNewT
{
public:

/**
   * @brief The enum values are used as type-safe parameters in the public API,
   * and as an index into the trigger bit field array.
   */
  enum Module_E { MODULE_1, MODULE_2 };

/**
   * @brief Start with no trigger active.
   */
  TwoSetsOfTriggersNewT() // cannot initialize array in C++98 or C++03
  {
    mTriggersByModule[MODULE_1] = mTriggersByModule[MODULE_2] = NO_TRIGGER;
  }

/**
   * @brief Checks if the action should be stopped 
   * after a module has removed the given trigger.
   *
   * @param trigger the action trigger that is removed by the module.
   * @param module MODULE_1 or MODULE_2, indicating the module removing the trigger.
   *
   * @return @c true if the trigger from the given module was
   * active before and is now removed, and if that trigger is not active for the
   * other module.
   */
  bool RemoveTriggerAndCheckStop(ActionTriggerT trigger, Module_E module = MODULE_2)
  {
    return TryDelete(trigger, module) &&
      !TriggerIsActive(trigger, OtherModule(module));
  }

/**
   * @brief Checks if the action has to be started after a module has
   * activated the given trigger.
   *
   * @param trigger the trigger that was activated by the module.
   * @param module MODULE_1 or MODULE_2, indicating the calling module.
   *
   * @return @c true if the trigger was not yet set from either module
   *         and the action should be started
   */
  bool AddTriggerAndCheckStart(ActionTriggerT trigger, Module_E module = MODULE_2)
  {
    return TryAdd(trigger, module) &&
      !TriggerIsActive(trigger, OtherModule(module));
  }

private:
  /**
   * @brief Return the "other" module.
   * @param module the module for which we want to obtain the other module.
   * @return MODULE_1 if the argument was MODULE_2 and vice versa.
   */
  static Module_E OtherModule(Module_E module)
  {
    // This is much faster than a ternary conditional which may need a jump.
    return static_cast<Module_E>(!module);
  }

/**
   * @brief Delete, if necessary, the given trigger for the given module
   * and return whether it was set before
   * @param trigger One of the triggers (a bit in a 32 bit field)
   * @param module MODULE_1 or MODULE_2, indicating the calling module. 
   * @return Whether the given trigger was set before for the given module
   */
  bool TryDelete(ActionTriggerT trigger, Module_E module)
  {
    ActionTriggerT oldReason = mTriggersByModule[module];
    return (mTriggersByModule[module] &= ~trigger) != oldReason;
  }

/**
   * @brief Set the given trigger for the given module and return whether it
   * was unset before
   * @param trigger One of the triggers (a bit in a 32 bit field)
   * @param module MODULE_1 or MODULE_2, indicating the calling module
   * @return Whether the given trigger was unset before for the given module
   */
  bool TryAdd(ActionTriggerT trigger, Module_E module)
  {
    ActionTriggerT oldReason = mTriggersByModule[module];
    return (mTriggersByModule[module] |= trigger) != oldReason;
  }

/**
   * @brief Check whether the given trigger is active for the given module
   * but do not change it.
   * @param trigger One of the triggers (a bit in a 32 bit field)
   * @param module MODULE_1 or MODULE_2, indicating the calling module
   * @return whether the given trigger is active for the given module
   */
  bool TriggerIsActive(ActionTriggerT trigger,
    Module_E module) const
  {
    return mTriggersByModule[module] & trigger;
  }

/// Current triggers for module 1 and module 2 as a bit field.
  /// Reasons from module 1 are are in mTriggersByModule[MODULE_1], for module 2 in mTriggersByModule[MODULE_2]
  ActionTriggerT mTriggersByModule[2];
};

#endif // ndef TWOSETSOFTRIGGERSNEW_H

Source code

#ifndef TWOSETSOFTRIGGERS_H
#define TWOSETSOFTRIGGERS_H

#include "ActionTriggers.h"

/**
 * @brief This class coordinates action triggers from two modules.
 * StartAction() starts an action related to the trigger
 * if the trigger was not active from either module before, and StopAction()
 * stops it when the trigger was removed from one module and was not active from the other.
 *
 */
class TwoSetsOfTriggersT
{
public:
  /**
   * @brief Constructor.
   */
  TwoSetsOfTriggersT();

/**
   * @brief Checks if the action has to be stopped after a module has
   * stopped the specific trigger.
   *
   * @param trigger the action trigger that was stopped by the module.
   * @param isFromModule2 @c true if module 2 did release the trigger,
   *                 @c false otherwise
   *
   * @return @c true if the trigger is set for the action by us, but should
   *         now be stopped, @c false if either the trigger was not set
   *         by us or it should not yet be stopped.
   */
  bool StopAction(ActionTriggerT trigger, bool isFromModule2 = true);

/**
   * @brief Checks if the action has to be started after a module has
   * started the trigger.
   *
   * @param trigger the trigger that was started by the module.
   * @param isFromModule2 @c true if a module 2 did apply the trigger,
   *                 @c false otherwise
   *
   * @return @c true if the trigger is not yet set for the action by us, but
   *         should now be started, @c false if either the trigger is
   *         already started by us or it should not be started.
   */
  bool StartAction(ActionTriggerT trigger, bool isFromModule2 = true);

private:

/// Current triggers for module 1
  ActionTriggerT mModuleTriggers;

/// Current triggers for module 2
  ActionTriggerT mModule2Triggers;

/// Current triggers for all modules combined
  ActionTriggerT mCombinedTriggers;
};

#endif // TWOSETSOFTRIGGERS_H