OLCB_Alias_Cache.h

#ifndef __OLCB_ALIAS_CACHE_H__
#define __OLCB_ALIAS_CACHE_H__

/********
OLCB_Alias_Cache is a class that caches the aliases of all virtual nodes hosted in this
board, as well as the most recently accessed NodeIDs elsewhere on the network.
It watches for messages that add, delete, or modify the can aliases of any node.
This class is here so that CAN aliases can be handled transparently, without any knowledge
or dependencies by the end user of the library.
Used by OLCB_Link
********/


class OLCB_Alias_Cache;

#if defined(__AVR__)
#include <stdlib.h>
#if defined(OLCB_DEBUG)
#include "Arduino.h"
#endif
#endif

#include <string.h>
#include "OLCB_NodeID.h"

class OLCB_Alias_Cache
{
 public:
  OLCB_Alias_Cache() : _size(0)
  {
  }
  
  void initialize(uint8_t newSize) //must be AT LEAST the number of virtual nodes plus 1; the larger the more efficient sending addressed outbound messages will be
  {
    if(_size)
    {
      //if already inited, release existing memory? TODO
    }
    _size = newSize;
#if defined(__arm__)
    _nids = new OLCB_NodeID[_size];
    _hits = new uint8_t[_size];
#elif defined(__AVR__)
    _nids = (OLCB_NodeID*)malloc(sizeof(OLCB_NodeID)*_size);
    _hits = (uint8_t*)malloc(sizeof(uint8_t)*_size);
#endif
    for(uint8_t i = 0; i < _size; ++i)
    {
      _nids[i].set(0,0,0,0,0,0);
      _nids[i].alias = 0;
      _hits[i] = 0;
    }
  }
  
  void add(OLCB_NodeID *nid)
  {
    //Serial.println("In AliasCache->add()");
    //find the least used entry, while making sure the alias isn't already cached.
    if(!nid->alias) //No alias? Nothing to cache!
    {
      //Serial.println("No alias, no cache!");
      return;
    }
    //else
    //Serial.print("Cacheing alias "); //Serial.println(nid->alias,DEC);
    
    uint8_t leasthits = 255;
    uint8_t index = 0;
    for(uint8_t i=0; i < _size; ++i)
    {
      if(_nids[i] == *nid)
      {
        //already cached; return.
        //Serial.println("What do you know? Already in the cache!");
        return;
      }
      if(_hits[i] < leasthits)
      {
        leasthits = _hits[i];
        index = i;
      }
    }
    //Serial.print("Cacheing it in index "); //Serial.println(index, DEC);
    memcpy(&(_nids[index]), nid, sizeof(OLCB_NodeID));
    _hits[index] = 1;
    //Serial.println("Leaving add()");
  }
  
  bool getAliasByNID(OLCB_NodeID *nid)
  {
  	//Serial.println("Looking for alias for:");
  	//nid->print();
    for(uint8_t i = 0; i < _size; ++i)
    {
      if(_nids[i] == *nid)
      {
        if(_hits[i] < 255) ++_hits[i];
        nid->alias = _nids[i].alias;
        return true;
      }
    }
    //Serial.println("Not in alias cache");
    return false;
  }
  
  bool getNIDByAlias(OLCB_NodeID *nid)
  {
    for(uint8_t i = 0; i < _size; ++i)
    {
      if(_nids[i].alias == nid->alias)
      {
        if(_hits[i] < 255) ++_hits[i];
        memcpy(&(nid->val), &(_nids[i].val), 6);
        return true;
      }
    }
    return false;
  }
  
  bool removeByAlias(uint16_t alias)
  {
    //Serial.print("alias helper: ");
    for(uint8_t i=0; i < _size; ++i)
    {
      if(_nids[i].alias == alias)
      {
      	//Serial.print("removing alias at loc ");
      	//Serial.print(i, DEC);
        _nids[i].set(0,0,0,0,0,0);
        _hits[i] = 0;
        return true;
      }
    }
    //Serial.println();
    return false; //not in cache
  }
  
 private:
  uint8_t _size;
  OLCB_NodeID* _nids;
  uint8_t* _hits;
};

#endif