I have two classes that I'm using to represent some hardware: A Button and an InputPin class which represent a button that will change the value of an IC's input pin when it's pressed down. A
simple example of them is:
template <int pinNumber> class InputPin
{
static bool IsHigh()
{
return ( (*portAddress) & (1<<pinNumber) );
}
};
template <typename InputPin> class Button
{
static bool IsPressed()
{
return !InputPin::IsHigh();
}
};
This works beautifully and by using class templates, the condition below will compile
as tightly
as if I'd handwritten it in assembly (a single instruction).
Button < InputPin<1> > powerButton;
if (powerButton.IsPressed())
........;
However, I am extending it to deal with interrupts and have got a problem with circular references.
Compared to the original InputPin, a new InputPinIRQ class has an extra static member function that will
be called automatically by the hardware when the pin value changes. I'd like it to
be able to notify the Button class of this, so that the Button class can then notify the main application that it has been pressed/released. I am currently doing this with function pointers to callbacks. In order for the callback code to
be inlined by the compiler, I need to pass the function pointers
as template parameters. So now, both of the new classes have an extra template parameter that is a pointer to a callback function. Unfortunately this gives me a circular reference because to instantiate a ButtonIRQ class I now have to do something like this:
ButtonIRQ< InputPinIRQ< A1, ButtonIRQ<....>::OnPinChange, OnButtonChange > pB;
where the <...... represents the circular reference.
Does anyone know how I can avoid this circular reference? I am new to templates, so might
be missing something really
simple.
It's important that the compiler knows exactly what code will
be run when the interrupt occurs
as it then does some very useful optimisation - it is able to inline the callback function and literally inserts the callback function's code at the exact address that is called on a h/w interrupt.
