PersistenceTracker.hpp

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX INC 2026. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX INC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX INC.
******************************************************************************/
#ifndef UTILS_PERSISTENCE_TRACKER_HPP
#define UTILS_PERSISTENCE_TRACKER_HPP
 
#include "types.h"
#include "architecture/CircularBuffer.hpp"
 
namespace clockwerk {

template <typename T, uint8 N>
class PersistenceTracker {
public:    
    PersistenceTracker(uint8 required=N) {_required = required;}
    ~PersistenceTracker() {}

    void pushValue(T value) {_values.write(value);}

    bool greaterThan(T value);

    bool lessThan(T value);

    bool inRange(T min, T max);

    bool outsideRange(T min, T max);
protected:
    // Buffer to hold last N values for persistence check
    CircularBuffer<T, N> _values;
    uint8 _required = 0;
};
 
template <typename T, uint8 N>
bool PersistenceTracker<T, N>::greaterThan(T value) {
    uint8 count = 0;
    T tmp;
    for (uint8 i = 0; i < _values.valsHeld(); i++) {
        // Read from the queue into tmp, and return error if we encounter one
        // (which should not be possible here, because the only error is a range one)
        if(_values.peekIndex(i, tmp)) {return false;}
        if (tmp > value) count++;
    }
    return count >= _required;
}
 
template <typename T, uint8 N>
bool PersistenceTracker<T, N>::lessThan(T value) {
    uint8 count = 0;
    T tmp;
    for (uint8 i = 0; i < _values.valsHeld(); i++) {
        // Read from the queue into tmp, and return error if we encounter one
        // (which should not be possible here, because the only error is a range one)
        if(_values.peekIndex(i, tmp)) {return false;}
        if (tmp < value) count++;
    }
    return count >= _required;
}
 
template <typename T, uint8 N>
bool PersistenceTracker<T, N>::inRange(T min, T max) {
    if(min >= max) {return false;}
 
    uint8 count = 0;
    T tmp;
    for (uint8 i = 0; i < _values.valsHeld(); i++) {
        // Read from the queue into tmp, and return error if we encounter one
        // (which should not be possible here, because the only error is a range one)
        if(_values.peekIndex(i, tmp)) {return false;}
        if (tmp > min && tmp < max) count++;
    }
    return count >= _required;
}
 
template <typename T, uint8 N>
bool PersistenceTracker<T, N>::outsideRange(T min, T max) {
    if(min >= max) {return false;}
 
    uint8 count = 0;
    T tmp;
    for (uint8 i = 0; i < _values.valsHeld(); i++) {
        // Read from the queue into tmp, and return error if we encounter one
        // (which should not be possible here, because the only error is a range one)
        if(_values.peekIndex(i, tmp)) {return false;}
        if (tmp < min || tmp > max) count++;
    }
    return count >= _required;
}
 
}
 
#endif