/** @file */
/***********************************************

 !!!! DO NOT EDIT THIS FILE !!!!

 All content has been auto-generated by 
 the boilerplater.pl utility.

 See boilerplater's documentation for details.

 ***********************************************/



#ifndef R_KINO_HASH
#define R_KINO_HASH 1

#include "KinoSearch/Util/Hash.h"

#define KINO_HASH_BOILERPLATE

typedef void
(*kino_Hash_destroy_t)(kino_Hash *self);

typedef void
(*kino_Hash_clear_t)(kino_Hash *self);

typedef void
(*kino_Hash_store_t)(kino_Hash *self, const char *str, size_t len, 
                    kino_Obj *value);

typedef void
(*kino_Hash_store_bb_t)(kino_Hash *self, const kino_ByteBuf *key, kino_Obj *value);

typedef void
(*kino_Hash_store_i64_t)(kino_Hash *self, const char *str, size_t key_len, 
                        chy_i64_t num);

typedef kino_Obj*
(*kino_Hash_fetch_bb_t)(kino_Hash *self, const kino_ByteBuf *key);

typedef kino_Obj*
(*kino_Hash_fetch_t)(kino_Hash *self, const char *key, size_t key_len);

typedef chy_i64_t
(*kino_Hash_fetch_i64_t)(kino_Hash *self, const char *key, size_t key_len);

typedef chy_bool_t
(*kino_Hash_delete_bb_t)(kino_Hash *self, const kino_ByteBuf *key);

typedef chy_bool_t
(*kino_Hash_delete_t)(kino_Hash *self, const char *key, size_t key_ley);

typedef void
(*kino_Hash_iter_init_t)(kino_Hash *self);

typedef chy_bool_t
(*kino_Hash_iter_next_t)(kino_Hash *self, kino_ByteBuf **key, kino_Obj **value);

typedef kino_ByteBuf*
(*kino_Hash_add_key_t)(kino_Hash *self, const kino_ByteBuf *key);

typedef kino_ByteBuf*
(*kino_Hash_find_key_t)(kino_Hash *self, const kino_ByteBuf *key);

typedef struct kino_VArray*
(*kino_Hash_keys_t)(kino_Hash *self);

#define Kino_Hash_Clone(self) \
    (self)->_->clone((kino_Obj*)self)

#define Kino_Hash_Destroy(self) \
    (self)->_->destroy((kino_Obj*)self)

#define Kino_Hash_Equals(self, other) \
    (self)->_->equals((kino_Obj*)self, other)

#define Kino_Hash_Hash_Code(self) \
    (self)->_->hash_code((kino_Obj*)self)

#define Kino_Hash_Is_A(self, target_vtable) \
    (self)->_->is_a((kino_Obj*)self, target_vtable)

#define Kino_Hash_To_String(self) \
    (self)->_->to_string((kino_Obj*)self)

#define Kino_Hash_Serialize(self, target) \
    (self)->_->serialize((kino_Obj*)self, target)

#define Kino_Hash_Clear(self) \
    (self)->_->clear((kino_Hash*)self)

#define Kino_Hash_Store(self, str, len, value) \
    (self)->_->store((kino_Hash*)self, str, len, value)

#define Kino_Hash_Store_BB(self, key, value) \
    (self)->_->store_bb((kino_Hash*)self, key, value)

#define Kino_Hash_Store_I64(self, str, key_len, num) \
    (self)->_->store_i64((kino_Hash*)self, str, key_len, num)

#define Kino_Hash_Fetch_BB(self, key) \
    (self)->_->fetch_bb((kino_Hash*)self, key)

#define Kino_Hash_Fetch(self, key, key_len) \
    (self)->_->fetch((kino_Hash*)self, key, key_len)

#define Kino_Hash_Fetch_I64(self, key, key_len) \
    (self)->_->fetch_i64((kino_Hash*)self, key, key_len)

#define Kino_Hash_Delete_BB(self, key) \
    (self)->_->delete_bb((kino_Hash*)self, key)

#define Kino_Hash_Delete(self, key, key_ley) \
    (self)->_->delete((kino_Hash*)self, key, key_ley)

#define Kino_Hash_Iter_Init(self) \
    (self)->_->iter_init((kino_Hash*)self)

#define Kino_Hash_Iter_Next(self, key, value) \
    (self)->_->iter_next((kino_Hash*)self, key, value)

#define Kino_Hash_Add_Key(self, key) \
    (self)->_->add_key((kino_Hash*)self, key)

#define Kino_Hash_Find_Key(self, key) \
    (self)->_->find_key((kino_Hash*)self, key)

#define Kino_Hash_Keys(self) \
    (self)->_->keys((kino_Hash*)self)

struct KINO_HASH_VTABLE {
    KINO_OBJ_VTABLE *_;
    chy_u32_t refcount;
    KINO_OBJ_VTABLE *parent;
    const char *class_name;
    kino_Obj_clone_t clone;
    kino_Obj_destroy_t destroy;
    kino_Obj_equals_t equals;
    kino_Obj_hash_code_t hash_code;
    kino_Obj_is_a_t is_a;
    kino_Obj_to_string_t to_string;
    kino_Obj_serialize_t serialize;
    kino_Hash_clear_t clear;
    kino_Hash_store_t store;
    kino_Hash_store_bb_t store_bb;
    kino_Hash_store_i64_t store_i64;
    kino_Hash_fetch_bb_t fetch_bb;
    kino_Hash_fetch_t fetch;
    kino_Hash_fetch_i64_t fetch_i64;
    kino_Hash_delete_bb_t delete_bb;
    kino_Hash_delete_t delete;
    kino_Hash_iter_init_t iter_init;
    kino_Hash_iter_next_t iter_next;
    kino_Hash_add_key_t add_key;
    kino_Hash_find_key_t find_key;
    kino_Hash_keys_t keys;
};

extern KINO_HASH_VTABLE KINO_HASH;

#ifdef KINO_USE_SHORT_NAMES
  #define Hash kino_Hash
  #define HASH KINO_HASH
  #define Hash_new kino_Hash_new
  #define Hash_destroy kino_Hash_destroy
  #define Hash_clear_t kino_Hash_clear_t
  #define Hash_clear kino_Hash_clear
  #define Hash_store_t kino_Hash_store_t
  #define Hash_store kino_Hash_store
  #define Hash_store_bb_t kino_Hash_store_bb_t
  #define Hash_store_bb kino_Hash_store_bb
  #define Hash_store_i64_t kino_Hash_store_i64_t
  #define Hash_store_i64 kino_Hash_store_i64
  #define Hash_fetch_bb_t kino_Hash_fetch_bb_t
  #define Hash_fetch_bb kino_Hash_fetch_bb
  #define Hash_fetch_t kino_Hash_fetch_t
  #define Hash_fetch kino_Hash_fetch
  #define Hash_fetch_i64_t kino_Hash_fetch_i64_t
  #define Hash_fetch_i64 kino_Hash_fetch_i64
  #define Hash_delete_bb_t kino_Hash_delete_bb_t
  #define Hash_delete_bb kino_Hash_delete_bb
  #define Hash_delete_t kino_Hash_delete_t
  #define Hash_delete kino_Hash_delete
  #define Hash_iter_init_t kino_Hash_iter_init_t
  #define Hash_iter_init kino_Hash_iter_init
  #define Hash_iter_next_t kino_Hash_iter_next_t
  #define Hash_iter_next kino_Hash_iter_next
  #define Hash_add_key_t kino_Hash_add_key_t
  #define Hash_add_key kino_Hash_add_key
  #define Hash_find_key_t kino_Hash_find_key_t
  #define Hash_find_key kino_Hash_find_key
  #define Hash_keys_t kino_Hash_keys_t
  #define Hash_keys kino_Hash_keys
  #define Hash_Clone Kino_Hash_Clone
  #define Hash_Destroy Kino_Hash_Destroy
  #define Hash_Equals Kino_Hash_Equals
  #define Hash_Hash_Code Kino_Hash_Hash_Code
  #define Hash_Is_A Kino_Hash_Is_A
  #define Hash_To_String Kino_Hash_To_String
  #define Hash_Serialize Kino_Hash_Serialize
  #define Hash_Clear Kino_Hash_Clear
  #define Hash_Store Kino_Hash_Store
  #define Hash_Store_BB Kino_Hash_Store_BB
  #define Hash_Store_I64 Kino_Hash_Store_I64
  #define Hash_Fetch_BB Kino_Hash_Fetch_BB
  #define Hash_Fetch Kino_Hash_Fetch
  #define Hash_Fetch_I64 Kino_Hash_Fetch_I64
  #define Hash_Delete_BB Kino_Hash_Delete_BB
  #define Hash_Delete Kino_Hash_Delete
  #define Hash_Iter_Init Kino_Hash_Iter_Init
  #define Hash_Iter_Next Kino_Hash_Iter_Next
  #define Hash_Add_Key Kino_Hash_Add_Key
  #define Hash_Find_Key Kino_Hash_Find_Key
  #define Hash_Keys Kino_Hash_Keys
#endif /* KINO_USE_SHORT_NAMES */

#define KINO_HASH_MEMBER_VARS \
    chy_u32_t  refcount; \
    struct kino_HashEntry ** buckets; \
    chy_u32_t  num_buckets; \
    chy_u32_t  size; \
    chy_u32_t  threshold; \
    struct kino_HashEntry * next_entry; \
    chy_u32_t  iter_bucket

#ifdef KINO_WANT_HASH_VTABLE
KINO_HASH_VTABLE KINO_HASH = {
    (KINO_OBJ_VTABLE*)&KINO_VIRTUALTABLE,
    1,
    (KINO_OBJ_VTABLE*)&KINO_OBJ,
    "KinoSearch::Util::Hash",
    (kino_Obj_clone_t)kino_Obj_clone,
    (kino_Obj_destroy_t)kino_Hash_destroy,
    (kino_Obj_equals_t)kino_Obj_equals,
    (kino_Obj_hash_code_t)kino_Obj_hash_code,
    (kino_Obj_is_a_t)kino_Obj_is_a,
    (kino_Obj_to_string_t)kino_Obj_to_string,
    (kino_Obj_serialize_t)kino_Obj_serialize,
    (kino_Hash_clear_t)kino_Hash_clear,
    (kino_Hash_store_t)kino_Hash_store,
    (kino_Hash_store_bb_t)kino_Hash_store_bb,
    (kino_Hash_store_i64_t)kino_Hash_store_i64,
    (kino_Hash_fetch_bb_t)kino_Hash_fetch_bb,
    (kino_Hash_fetch_t)kino_Hash_fetch,
    (kino_Hash_fetch_i64_t)kino_Hash_fetch_i64,
    (kino_Hash_delete_bb_t)kino_Hash_delete_bb,
    (kino_Hash_delete_t)kino_Hash_delete,
    (kino_Hash_iter_init_t)kino_Hash_iter_init,
    (kino_Hash_iter_next_t)kino_Hash_iter_next,
    (kino_Hash_add_key_t)kino_Hash_add_key,
    (kino_Hash_find_key_t)kino_Hash_find_key,
    (kino_Hash_keys_t)kino_Hash_keys
};
#endif /* KINO_WANT_HASH_VTABLE */

#undef KINO_HASH_BOILERPLATE


#endif /* R_KINO_HASH */


/* Copyright 2007 Marvin Humphrey
 *
 * This program is free software; you can redistribute it and/or modify
 * under the same terms as Perl itself.
 */