cpp, meta,
C++
// btree.h3
private: void Btree :: check_page
// -----------------------------------------------------------------------------
(
Btree_page & p
) ;
private: char * Btree :: to_s260
// -----------------------------------------------------------------------------
(
char * ak
, uchar pos
) ;
private: void Btree :: show_krMin
/* -----------------------------------------------------------------------------
aufzurufen als: show key range minimum
-----------------------------------------------------------------------------
*/ (
Btree_page * p
, path & sanf
) ;
private: BOOL Btree :: str_ok( char * s
// -----------------------------------------------------------------------------
) ;
private: void Btree :: trac1_page
// -----------------------------------------------------------------------------
(
Btree_page & p
) ;
private: void Btree :: trac1_page
/* -----------------------------------------------------------------------------
trace page and check its content for consistency
-----------------------------------------------------------------------------
*/ (
Btree_page & p
, FILE * f // soll geschrieben werden nach ) ;
private: char * Btree :: spare_At ( Btree_page * p
// -----------------------------------------------------------------------------
// return pointer to common prefix
// -----------------------------------------------------------------------------
) ;
private: void Btree :: trace_pos_m
// -----------------------------------------------------------------------------
(
FILE * f
) ;
private: int Btree :: relate
/* -----------------------------------------------------------------------------
return -1 iff ( k1 < k2 )
0 iff ( k1 = k2 )
1 iff ( k1 > k2 )
-----------------------------------------------------------------------------
*/ (
char * k1
, uchar n1 // number of bytes in k1, char * k2 // key, uchar n2 // number of bytes in k2, uchar same
, uchar spa
) ;
private: BOOL Btree :: locate
/* -----------------------------------------------------------------------------
Make pos_m[] the path to the page containing (or to contain) k.
Beachte: pos_m[ deepest ].m zeigt auf die gesuchte Position g e r u n d e t
auf ein direkt benachbartes Element (ein existierendes bei m > 0, ansonsten
auf den Anfang der Datenseite, was 0 < r zur Folge hat).
pos_m[ deepest ].r sagt ob die gesuchte Position durch m exakt gegeben ist,
d.h. als Element schon existiert ( r == 0 ), oder ob sie sich - als erst noch
zu erzeugende Position - direkt davor ( r < 0 ) oder direkt danach ( 0 < r )
einordnet.
-----------------------------------------------------------------------------
*/ (
char * k
, uchar n1 // number of bytes in key ) ;
private: BOOL Btree :: locate_ipos
/* -----------------------------------------------------------------------------
for index pages only !!!!
-----------------------------------------------------------------------------
*/ (
char * k
, uchar n1 // number of bytes in key, int & m
, int & r
, Btree_page & p
) ;
private: BOOL Btree :: locate_pos
/* -----------------------------------------------------------------------------
for data pages only !!!!
-----------------------------------------------------------------------------
*/ (
char * k
, uchar n1 // number of bytes in key, int & m
, int & r
, Btree_page & p
) ;
private: BOOL Btree :: locate_First(
/* -----------------------------------------------------------------------------
Return Wahrheitswert "gesuchtes Element gefunden"
-----------------------------------------------------------------------------
*/ ) ;
private: BOOL Btree :: locate_Last (
/* -----------------------------------------------------------------------------
Return Wahrheitswert "gesuchtes Element gefunden"
-----------------------------------------------------------------------------
*/ ) ;
private: BOOL Btree :: locate_Next
// -----------------------------------------------------------------------------
(
char * k
, uchar kL // number of bytes in key ) ;
private: BOOL Btree :: locate_Prev
// -----------------------------------------------------------------------------
(
char * k
, uchar kL // number of bytes in key ) ;
private: void Btree :: data_to_file
/* -----------------------------------------------------------------------------
Der Aufrufer sagt:
Store data d in a file associated to the Btree and make ( d, d_L, t )
the local path to this file.
Die Funktion garantiert: fErr || ok
-----------------------------------------------------------------------------
*/ (
char * & d
, int & d_L // number of bytes in data, uchar & t // set t = t_file ) ;
private: BOOL Btree :: NoUpd
/* -----------------------------------------------------------------------------
Der Aufrufer sagt:
Return( true ) iff ( d, d_L ) is the value for the key at
pos_m[ deepest ].m .
Die Funktion garantiert: fErr || ok
-----------------------------------------------------------------------------
*/ (
char * d
, int d_L // number of bytes in data ) ;
private: BOOL Btree :: reduce_spare
/* -----------------------------------------------------------------------------
If we want to insert a key larger than all current keys, we may
find the node's current spare too large.
However:
Reduction of spare implies that we will need more space in the node's
heap - more space than may be available. So, quite often, we need to
split the node.
-----------------------------------------------------------------------------
*/ (
Btree_page * p
, char * k // key, char * V // Value, uchar kL // Len of key, uchar VL // Len of Value ) ;
private: void Btree :: check_path
// -----------------------------------------------------------------------------
(
char * k
, int k_L
, Surr k_father
) ;
private: void Btree :: into_father
/* -----------------------------------------------------------------------------
Der Aufrufer sagt:
Insert ( k, son ) into index page[ --deepest ] .
Die Funktion garantiert: fErr || ok && Return( re-localize )
-----------------------------------------------------------------------------
*/ (
char * k
, uchar spare // of son, pageNr son // Btree_index.son ) ;
private: Btree_page * Btree :: into_root
/* -----------------------------------------------------------------------------
Der Aufrufer sagt:
Insert ( k, son ) into root (= page[0] ).
Die Funktion garantiert: fErr || ok && Return( re-localize )
-----------------------------------------------------------------------------
*/ (
char * k
, pageNr son // Btree_index.son ////alt: int ) ;
private: void Btree :: split_data
/* -----------------------------------------------------------------------------
Node neu is empty. Move alt.e/2 nodes from alt to neu.
-----------------------------------------------------------------------------
*/ (
Btree_page * alt
, Btree_page * neu
) ;
private: void Btree :: split_index
/* -----------------------------------------------------------------------------
Der Aufrufer sagt:
Make the second half of this index page a new index page. Then
insert the pair ( k, son ) into the union of these two pages.
Die Funktion garantiert: fErr || ok && Return( re-localize )
-----------------------------------------------------------------------------
*/ (
char * k
, pageNr son // node.nr //alt: uint2, int & m //, Btree_page * & p // ) ;
private: void Btree :: split_root
/* -----------------------------------------------------------------------------
the Btree is growing at its root
-----------------------------------------------------------------------------
*/ (
char * k
, pageNr son // Btree_index.son ) ;
private: uchar Btree :: our_uspar
// -----------------------------------------------------------------------------
(
char * xu
, char * xo
) ;
private: void Btree :: reorganize
/* -----------------------------------------------------------------------------
Der Aufrufer sagt:
Set p->e = e_neu , then reorganize the page for pruning all garbage.
Die Funktion garantiert: fErr || ok && ( p->dirty )
-----------------------------------------------------------------------------
*/ (
Btree_page * p
, int e_neu // define p->e = e_neu, uchar usparP // neues spare = altes spare + uspar ) ;
private: Btree_page * Btree :: new_page(
/* -----------------------------------------------------------------------------
Create a new page in the tree and cache it.
-----------------------------------------------------------------------------
*/ ) ;
private: void Btree :: trace_in_cache( pageNr nr
/* -----------------------------------------------------------------------------
trace the cached version of page
-----------------------------------------------------------------------------
*/ ) ;
private: void Btree :: zeige
/* -----------------------------------------------------------------------------
trace page[ i ].nr == pnr
-----------------------------------------------------------------------------
*/ (
long pnr
, uint steNr
) ;
private: void Btree :: get_page
/* -----------------------------------------------------------------------------
establisch page[ i ].nr == nr with page[i] pointing into the cache
-----------------------------------------------------------------------------
*/ (
int i
, long nr
) ;
private: void Btree :: to_Disk( int s
// -----------------------------------------------------------------------------
) ;
private: void Btree :: to_extra( Btree_page * p
// -----------------------------------------------------------------------------
) ;
private: void Btree :: ensure_cache( Btree_page * p
// -----------------------------------------------------------------------------
) ;
private: void Btree :: new_cache( int notAt
// -----------------------------------------------------------------------------
) ;
private: uint Btree :: become_trans
/* -----------------------------------------------------------------------------
Create the transitive closure of a binary relation ~
-----------------------------------------------------------------------------
*/ (
char * x1
, char * x2
) ;
private: uint Btree :: become_deep_trans
/* -----------------------------------------------------------------------------
Create the transitive closure of a binary relation ~
-----------------------------------------------------------------------------
*/ (
char * x1
, char * x2
) ;
private: Surr Btree :: located_key_and_data
/* -----------------------------------------------------------------------------
Read into 'd the data assigned to the located key in the Btree
and assure d.c[ d.L ] == 0 .
Return the key's surrogate.
-----------------------------------------------------------------------------
*/ (
store_256 & d
, int line
) ;