callback_overlay.h

Go to the documentation of this file.

/*
  © 2023 Intel Corporation
 
  This software and the related documents are Intel copyrighted materials, and
  your use of them is governed by the express license under which they were
  provided to you ("License"). Unless the License provides otherwise, you may
  not use, modify, copy, publish, distribute, disclose or transmit this software
  or the related documents without Intel's prior written permission.
 
  This software and the related documents are provided as is, with no express or
  implied warranties, other than those that are expressly stated in the License.
*/
 
//-*- C++ -*-
 
#ifndef CPP_API_EXTENSIONS_SRC_SME_OVERLAYS_CALLBACK_OVERLAY_H
#define CPP_API_EXTENSIONS_SRC_SME_OVERLAYS_CALLBACK_OVERLAY_H
 
#include <stdarg.h>
#include <iostream>
 
#include "sme/aqpp/abstraction/compiler/_inline.h"
 
#include "sme/pattern_rules/I_pattern_rule.h"
#include "sme/pattern_rules/pattern_rule_container.h"
 
#include "sme/pattern_rules/notify.h"
#include "sme/pattern_rules/masked.h"
#include "sme/pattern_rules/pattern.h"
#include "sme/pattern_rules/rising_bit.h"
#include "sme/pattern_rules/falling_bit.h"
#include "sme/pattern_rules/any_rise.h"
#include "sme/pattern_rules/all_fall.h"
 
namespace sme
{
 
struct stage {
    enum E {
        PRE_READ = 0,
        POST_READ,
        PRE_WRITE,
        POST_WRITE
    };
};
 
struct type {
    enum E {
        NOTIFY = 0,
        MASKED,
        PATTERN,
        RISING_BIT,
        FALLING_BIT,
        ANY_RISE,
        ALL_FALL,
        NOT_IMPLEMENTED
    };
};
 
class callback_overlay {
public:
    callback_overlay()
        : m_pre_read( nullptr)
        , m_post_read( nullptr)
        , m_pre_write( nullptr)
        , m_post_write( nullptr)
    {;}
 
    ~callback_overlay() {
        if( m_pre_read != nullptr) delete m_pre_read;
        if( m_post_read != nullptr) delete m_post_read;
        if( m_pre_write != nullptr) delete m_pre_write;
        if( m_post_write != nullptr) delete m_post_write;
    }
    
    pattern_rule_container * get_rule_container( stage::E _stage) {
        switch( _stage) {
            case stage::PRE_READ:
                if( m_pre_read == nullptr) m_pre_read = new pattern_rule_container();
                return( m_pre_read);
                break;
            case stage::POST_READ:
                if( m_post_read == nullptr) m_post_read = new pattern_rule_container();
                return( m_post_read);
                break;
            case stage::PRE_WRITE:
                if( m_pre_write == nullptr) m_pre_write = new pattern_rule_container();
                return( m_pre_write);
                break;
            case stage::POST_WRITE:
                if( m_post_write == nullptr) m_post_write = new pattern_rule_container();
                return( m_post_write);
                break;
            default:
                std::cerr << "[ERROR][get_rule_container]: Invalid stage for rule container! (" << _stage << ")" << std::endl;
                break;
        }
        return( NULL);
    }
 
    void deactivate_rule( stage::E _stage, std::string _name) {
        get_rule_container( _stage)->deactivate_rule( _name);
    }
    
    void activate_rule( stage::E _stage, std::string _name) {
        get_rule_container( _stage)->activate_rule( _name);
    }
 
    void process_pre_read_rules( uint64_t _old_value, uint64_t _new_value) {
        if( this->m_pre_read != nullptr) {
            this->m_pre_read->process_active_rules( _old_value, _new_value);
        }
    }
    
    void process_post_read_rules( uint64_t _old_value, uint64_t _new_value) {
        if( this->m_post_read != nullptr) {
            this->m_post_read->process_active_rules( _old_value, _new_value);
        }
    }
    
    void process_pre_write_rules( uint64_t _old_value, uint64_t _new_value) {
        if( this->m_pre_write != nullptr) {
            this->m_pre_write->process_active_rules( _old_value, _new_value);
        }
    }
    
    void process_post_write_rules( uint64_t _old_value, uint64_t _new_value) {
        if( this->m_post_write != nullptr) {
            this->m_post_write->process_active_rules( _old_value, _new_value);
        }
    }
 
    I_pattern_rule * add_rule( std::function< void()> _func, stage::E _stage, type::E _type, std::string _name, ...) {
        va_list args;
        va_start( args, _name);
        I_pattern_rule * retval = this->__add_rule( _func, _stage, _type, _name, args);
        va_end( args);
        return( retval);
    }
 
protected:
    _keep_hot I_pattern_rule * __add_rule( std::function< void()> _func, stage::E _stage, type::E _type, std::string _name, va_list & args) {
 
        I_pattern_rule * rule = 0;
        pattern_rule_container * rules = get_rule_container( _stage);
 
        if( rules != 0)
        {
            switch( _type)
            {
                case type::NOTIFY:
                    rule = new sme::rules::notify();
                    break;
                case type::MASKED:
                    rule = new sme::rules::masked( va_arg( args, uint64_t));
                    break;
                case type::PATTERN:
                    rule = new sme::rules::pattern( va_arg( args, uint64_t),  va_arg( args, uint64_t),  va_arg( args, uint64_t));
                    break;
                case type::RISING_BIT:
                    rule = new sme::rules::rising_bit( uint8_t( va_arg( args, uint32_t)));
                    break;
                case type::FALLING_BIT:
                    rule = new sme::rules::falling_bit( uint8_t( va_arg( args, uint32_t)));
                    break;
                default:
                    std::cerr << "[ERROR][__add_rule]: Invalid stage for rule container! (" << _stage << ")" << std::endl;
                    break;
            }
 
            if( rule != 0) {
                rules->add_rule( _name, rule);
                rule->action( _func);
            }
        }
 
        return( rule);
    }
 
 
    pattern_rule_container * m_pre_read;
 
    pattern_rule_container * m_post_read;
 
    pattern_rule_container * m_pre_write;
 
    pattern_rule_container * m_post_write;
 
};
 
}
 
#endif