1 |
root |
1.1 |
// -*- Mode: C++ -*- |
2 |
|
|
|
3 |
|
|
// GiSTentry.h |
4 |
|
|
// |
5 |
|
|
// Copyright (c) 1996, Regents of the University of California |
6 |
|
|
|
7 |
|
|
|
8 |
|
|
#ifndef GISTENTRY_H |
9 |
|
|
#define GISTENTRY_H |
10 |
|
|
|
11 |
|
|
#include <string.h> // for memcpy |
12 |
|
|
#include "GiSTdefs.h" |
13 |
|
|
#include "GiSTpredicate.h" |
14 |
|
|
|
15 |
|
|
class GiSTnode; |
16 |
|
|
|
17 |
|
|
// GiSTcompressedEntry is the compressed format of a key-pointer pair. |
18 |
|
|
class GiSTcompressedEntry { |
19 |
|
|
public: |
20 |
|
|
char *key; |
21 |
|
|
int keyLen; |
22 |
|
|
GiSTpage ptr; |
23 |
|
|
|
24 |
|
|
GiSTcompressedEntry(): key(NULL), keyLen(0), ptr(0) {} |
25 |
|
|
const GiSTcompressedEntry operator = (const GiSTcompressedEntry c) { |
26 |
|
|
key=c.key; |
27 |
|
|
keyLen=c.keyLen; |
28 |
|
|
ptr=c.ptr; |
29 |
|
|
return(*this); |
30 |
|
|
} |
31 |
|
|
}; |
32 |
|
|
|
33 |
|
|
// GiSTpenalty is the token returned by the Penalty method. We don't |
34 |
|
|
// just use doubles here because it can be useful to use more |
35 |
|
|
// complex Penalty comparisons (e.g. to support multivalued Penalties that |
36 |
|
|
// break ties in a single value). |
37 |
|
|
class GiSTpenalty { |
38 |
|
|
public: |
39 |
|
|
GiSTpenalty(): amount(0) {} |
40 |
|
|
GiSTpenalty(const double d): amount(d) {} |
41 |
|
|
virtual double operator = (const double d) { |
42 |
|
|
amount=d; |
43 |
|
|
return amount; |
44 |
|
|
} |
45 |
|
|
virtual int operator < (const GiSTpenalty &p) const { |
46 |
|
|
if(amount<p.amount) return(1); |
47 |
|
|
else return(0); |
48 |
|
|
}
|
49 |
|
|
|
50 |
|
|
virtual ~GiSTpenalty() {} |
51 |
|
|
|
52 |
|
|
protected: |
53 |
|
|
double amount; |
54 |
|
|
}; |
55 |
|
|
|
56 |
|
|
// GiSTentry: a key/pointer pair inside a node. |
57 |
|
|
// The key is a pointer to a GiSTobject, which can be used to |
58 |
|
|
// point to just about anything you like. |
59 |
|
|
class GiSTentry : public GiSTobject { |
60 |
|
|
public: |
61 |
|
|
GiSTentry(): node(NULL), level(0) {} |
62 |
|
|
GiSTentry(GiSTpage ptr): node(NULL), ptr(ptr) {} |
63 |
|
|
GiSTentry(const GiSTentry& e): node(e.node), ptr(e.ptr), |
64 |
|
|
position(e.position), level(e.level) {} |
65 |
|
|
|
66 |
|
|
virtual ~GiSTentry() { if(key) delete key; } |
67 |
|
|
|
68 |
|
|
// The following methods must be overridden by descendant classes |
69 |
|
|
virtual GiSTpenalty *Penalty(const GiSTentry &key) const=0; |
70 |
|
|
virtual int CompressedLength() const=0; // length of compressed key |
71 |
|
|
#ifdef PRINTING_OBJECTS |
72 |
|
|
virtual void Print(ostream& os) const=0; |
73 |
|
|
#endif |
74 |
|
|
virtual GiSTobject *Copy() const=0; |
75 |
|
|
// Default compression is just to copy the key (i.e. no compression). |
76 |
|
|
// Since the copy method is virtual, the appropriate Copy method is called. |
77 |
|
|
// Besides compressing the key, Compress also sets the pointer. |
78 |
|
|
virtual GiSTcompressedEntry Compress() const { |
79 |
|
|
GiSTcompressedEntry compressedEntry; |
80 |
|
|
|
81 |
|
|
compressedEntry.key=(char *)key->Copy(); |
82 |
|
|
compressedEntry.keyLen=CompressedLength(); |
83 |
|
|
compressedEntry.ptr=ptr; |
84 |
|
|
return compressedEntry; |
85 |
|
|
} |
86 |
|
|
// Besides decompressing the key, Decompress also sets the pointer. |
87 |
|
|
virtual void Decompress(const GiSTcompressedEntry entry) { |
88 |
|
|
key=(GiSTobject *)new char[entry.keyLen]; |
89 |
|
|
memcpy(key, entry.key, entry.keyLen); |
90 |
|
|
ptr=entry.ptr; |
91 |
|
|
} |
92 |
|
|
|
93 |
|
|
// If you have ordered keys, this can be overridden a la qsort's compare |
94 |
|
|
virtual int Compare(const GiSTentry& entry) const { return 0; } |
95 |
|
|
|
96 |
|
|
// access to the protected info |
97 |
|
|
GiSTpage Ptr() const { return ptr; } |
98 |
|
|
void SetPtr(GiSTpage p) { ptr=p; } |
99 |
|
|
GiSTobject *Key() const { return key; } |
100 |
|
|
|
101 |
|
|
GiSTobjid IsA() const { return GISTENTRY_CLASS; } |
102 |
|
|
int IsLeaf() const { return level==0; } |
103 |
|
|
int Level() const { return level; } |
104 |
|
|
void SetLevel(int l) { level=l; } |
105 |
|
|
|
106 |
|
|
void SetPosition(int pos) { position=pos; } |
107 |
|
|
int Position() const { return position; } |
108 |
|
|
|
109 |
|
|
GiSTnode *Node() const { return node; } |
110 |
|
|
void SetNode(GiSTnode *n) { node=n; } |
111 |
|
|
|
112 |
|
|
protected: |
113 |
|
|
GiSTnode *node; |
114 |
|
|
GiSTpage ptr; |
115 |
|
|
int position; |
116 |
|
|
int level; |
117 |
|
|
GiSTobject *key; |
118 |
|
|
}; |
119 |
|
|
|
120 |
|
|
#endif |