1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * db_index_entry_c.x 24 * 25 * Copyright (c) 1988-1992 Sun Microsystems Inc 26 * All Rights Reserved. 27 */ 28 29 %#pragma ident "%Z%%M% %I% %E% SMI" 30 31 #if RPC_HDR 32 33 %#ifndef _DB_INDEX_ENTRY_H 34 %#define _DB_INDEX_ENTRY_H 35 36 % 37 % /* db_index_entry is an entry in the hashtable. db_index_entries can be 38 % linked in one of two ways: 39 % * via the 'next' pointer and form the hash bucket 40 % * via the 'nextresult' pointer and form a chain of results. 41 % Each entry contains the key, the hash value of key, and location 42 % information 'entryp' 43 % entryp is location information. 44 % It might be pointer to an in core entry, or an indirect pointer 45 % identifying the location of an entry somewhere in memory (e.g. 46 % if there was a table where all complete entries are stored) --- this 47 % is desirable, for example, for XDR operations on a multi-indexed table; 48 % or, if used in conjunction with NetISAM, it may be the record number. */ 49 %/* *** notes */ 50 %/* remember to set next_result to null first if using XDR. */ 51 52 #ifdef USINGC 53 %#include "db_item_c.h" 54 %#include "db_table_c.h" /* contains definition of entryp */ 55 %typedef void *nullptr; 56 #else 57 %#include "db_item.h" 58 %#include "db_table.h" /* contains definition of entryp */ 59 #endif USIGNC 60 #endif RPC_HDR 61 62 63 #if RPC_HDR || RPC_XDR 64 #ifdef USINGC 65 struct db_index_entry { 66 unsigned long hashval; 67 item *key; 68 entryp location; 69 db_index_entry* next; 70 #ifdef USINGC 71 nullptr next_result; 72 #else 73 db_index_entry* next_result; 74 #endif 75 }; 76 typedef struct db_index_entry * db_index_entry_p; 77 #endif USINGC 78 #endif RPC_HDR 79 80 #ifndef USINGC 81 #ifdef RPC_HDR 82 %class db_index_entry { 83 % unsigned long hashval; 84 % item *key; 85 % entryp location; 86 % db_index_entry* next; 87 % db_index_entry* next_result; 88 % public: 89 % 90 %/* Constructor: create an entry using given string and location info. */ 91 % db_index_entry( char* name, int nlen, entryp location ); 92 % 93 %/* Constructor: create an entry using the given info. 94 % A copy of the key is made. New entry is added to head of list of 'n'. */ 95 % db_index_entry( unsigned long hval, item *, entryp, db_index_entry *n); 96 % 97 %/* Destructor: deletes key and itself. Assumes that deletion of 98 % object at location is done elsewhere (beforehand) */ 99 % ~db_index_entry() {delete key; } 100 % 101 %/* Relocate bucket starting with this entry to new hashtable 'new_tab'. */ 102 % void relocate( db_index_entry**, unsigned long ); 103 % 104 %/* Join two lists (entry as identified by its 'location' occurs on both list, 105 % then it is included in the list returned). 106 % Returns pointer to resulting list; size of list 107 % returned in 'newsize'. List is chained using the 'nextresult' pointer. */ 108 % db_index_entry* join( long size1, long size2, db_index_entry *list2, 109 % long * newsize ); 110 % 111 %/* Returns pointer to a list of index entries with the same hash value and 112 % key as those given. Returns in 'how_many' the number of entries in the 113 % list returned. The list is linked by the 'next_result' field of the 114 % index entries. These may be changed after the next call to 'lookup' 115 % or 'join'. */ 116 % db_index_entry* lookup( bool_t, unsigned long, item*, long *); 117 % 118 %/* Return pointer to index entry with same hash value, same key, 119 % and same record number as those supplied. Returns NULL if not found. */ 120 % db_index_entry* lookup( bool_t, unsigned long, item*, entryp ); //name entry 121 % 122 %/* Return the next entry in the bucket starting with this entry 123 % with the same hashvalue, key and location as this entry. */ 124 % db_index_entry* getnext( bool_t, unsigned long, item*, entryp ); 125 % 126 %/* Return the next entry in the bucket. */ 127 % db_index_entry* getnextentry() {return next;} 128 % 129 %/* Return the next entry in the 'next_result' chain. */ 130 % db_index_entry* getnextresult() {return next_result;} 131 % 132 %/* Return the location field of this entry. */ 133 % entryp getlocation() {return location;} 134 % 135 %/* Assign the given pointer as the next result after this entry. */ 136 % void addresult( db_index_entry * nr ) { next_result = nr; } 137 % 138 %/* Return the pointer to the key of this entry. */ 139 % item * get_key() {return key;} 140 % 141 %/* Remove entry with the specified hashvalue, key, and record number. 142 % Returns 'TRUE' if successful, FALSE otherwise. 143 % If the entry being removed is at the head of the list, then 144 % the head is updated to reflect the removal. The storage for the index 145 % entry is freed. The record pointed to by 'recnum' must be removed 146 % through another means. All that is updated in this operation is the 147 % index. */ 148 % bool_t remove( db_index_entry **, bool_t, unsigned long, item *, entryp ); 149 % 150 %/* Replace the 'location' field of the index entry with the given one. */ 151 % void replace( entryp ep ) {location = ep;} 152 % 153 %/* Create and add an entry with the given hashvalue, key value, and record 154 % location, to the bucket pointed to by 'hashvalue'. 155 % If an entry with the same identical information is found, no addition 156 % is done. If an entry with the same hashvalue and key value is found, 157 % the entry is added after the first entry with this property. Otherwise, 158 % the entry is added to the head of the bucket. This way, entries 159 % with the same hashvalue and key are not scattered throughout the bucket 160 % but they occur together. Copy is made of given key. */ 161 % bool_t add( db_index_entry **oldhead, bool_t, unsigned long hval, item *, 162 % entryp ); 163 % 164 %/* Print this entry to stdout. */ 165 % void print(); 166 % 167 %/* Print bucket starting with this entry. */ 168 % void print_all(); 169 % 170 %/* Print result list starting with this entry. */ 171 % void print_results(); 172 %}; 173 %typedef class db_index_entry * db_index_entry_p; 174 #endif RPC_HDR 175 #endif USINGC 176 177 #if RPC_HDR 178 %#endif _DB_INDEX_ENTRY_H 179 #endif RPC_HDR 180