NuSMV/code/nusmv/core/utils/LRUCache.h

Go to the documentation of this file.

/* ---------------------------------------------------------------------------


  This file is part of the ``utils'' package of NuSMV version 2.
  Copyright (C) 2011 by FBK-irst.

  NuSMV version 2 is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  NuSMV version 2 is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA.

  For more information on NuSMV see <http://nusmv.fbk.eu>
  or email to <nusmv-users@fbk.eu>.
  Please report bugs to <nusmv-users@fbk.eu>.

  To contact the NuSMV development board, email to <nusmv@fbk.eu>.

-----------------------------------------------------------------------------*/

#ifndef __NUSMV_CORE_UTILS_LRUCACHE_H__
#define __NUSMV_CORE_UTILS_LRUCACHE_H__


#include "nusmv/core/utils/utils.h"
#include "nusmv/core/utils/OAHash.h"

typedef struct LRUCache_TAG*  LRUCache_ptr;

typedef OAHashIter LRUCacheIter;

/* Function pointers for LRU */

typedef OA_HASH_EQ_FUN LRU_CACHE_EQ_FUN;

typedef OA_HASH_HASH_FUN LRU_CACHE_HASH_FUN;

typedef OA_HASH_FREE_FUN LRU_CACHE_FREE_FUN;

#define LRU_CACHE(self) \
         ((LRUCache_ptr) self)

#define LRU_CACHE_CHECK_INSTANCE(self) \
         (nusmv_assert(LRU_CACHE(self) != LRU_CACHE(NULL)))

#define LRU_CACHE_FOREACH(self, iter)             \
  for (iter = LRUCache_get_first_iter(self);      \
       !LRUCache_iter_is_end(self, iter);         \
       iter = LRUCache_iter_next(self, iter))

#define LRU_CACHE_FOREACH_ENTRY(self, iter, key, value)                 \
  for (iter = LRUCache_get_first_iter(self);                            \
       !LRUCache_iter_is_end(self, iter) &&                             \
         (LRUCache_iter_values(self, iter, (void**)key, (void**)value), true); \
       iter = LRUCache_iter_next(self, iter))


/* Export some functionalities from the OAHash, that don't need any
   overriding */

/* boolean LRUCache_has_key (LRUCache_ptr self, const void* key) */

#define LRUCache_has_key(self, key)             \
  OAHash_has_key(OA_HASH(self), key)

/* LRUCacheIter LRUCache_get_first_iter (LRUCache_ptr self) */

#define LRUCache_get_first_iter(self)           \
  OAHash_get_first_iter(OA_HASH(self))

/* LRUCacheIter LRUCache_iter_next (LRUCache_ptr self,
                                          LRUCacheIter iter) */

#define LRUCache_iter_next(self, iter)                  \
  OAHash_iter_next(OA_HASH(self), (OAHashIter)iter)

/* boolean LRUCache_iter_is_end (const LRUCache_ptr self,
   const LRUCacheIter iter) */

#define LRUCache_iter_is_end(self, iter)                \
  OAHash_iter_is_end(OA_HASH(self), (OAHashIter)iter)

/* size_t LRUCache_get_size (const LRUCache_ptr self) */

#define LRUCache_get_size(self)                 \
  OAHash_get_size(OA_HASH(self))

/*---------------------------------------------------------------------------*/
/* Function prototypes                                                       */
/*---------------------------------------------------------------------------*/

LRUCache_ptr LRUCache_create(size_t threshold,
                             LRU_CACHE_EQ_FUN key_eq_fun,
                             LRU_CACHE_HASH_FUN key_hash_fun,
                             LRU_CACHE_FREE_FUN free_entry_fun,
                             void* custom_arg);

void LRUCache_destroy(LRUCache_ptr self);

void* LRUCache_lookup(LRUCache_ptr self, const void* key);

boolean LRUCache_insert(LRUCache_ptr self,
                        const void* key, const void* value);

boolean LRUCache_remove(LRUCache_ptr self, const void* key);

void LRUCache_clear(LRUCache_ptr self);

void LRUCache_iter_values(const LRUCache_ptr self,
                          const LRUCacheIter iter,
                          void** k, void** v);

#endif /* __NUSMV_CORE_UTILS_LRUCACHE_H__ */

---