Tree-M/GiST/GiSTentry.h

// -*- Mode: C++ -*-

//          GiSTentry.h
//
// Copyright (c) 1996, Regents of the University of California


#ifndef GISTENTRY_H
#define GISTENTRY_H

#include <string.h>     // for memcpy
#include "GiSTdefs.h"
#include "GiSTpredicate.h"

class GiSTnode;

// GiSTcompressedEntry is the compressed format of a key-pointer pair.
class GiSTcompressedEntry {
public:
        char *key;
        int keyLen;
        GiSTpage ptr;

        GiSTcompressedEntry(): key(NULL), keyLen(0), ptr(0) {}
        const GiSTcompressedEntry operator = (const GiSTcompressedEntry c) {
                key=c.key;
                keyLen=c.keyLen;
                ptr=c.ptr;
                return(*this);
        }
};

// GiSTpenalty is the token returned by the Penalty method.  We don't
// just use doubles here because it can be useful to use more
// complex Penalty comparisons (e.g. to support multivalued Penalties that
// break ties in a single value).
class GiSTpenalty {
public:
        GiSTpenalty(): amount(0) {}
        GiSTpenalty(const double d): amount(d) {}
        virtual double operator = (const double d) { 
                amount=d; 
                return amount;
        }
        virtual int operator < (const GiSTpenalty &p) const {
                if(amount<p.amount) return(1);
                else return(0);
        }

        virtual ~GiSTpenalty() {}

protected:
        double amount;
};

// GiSTentry: a key/pointer pair inside a node.
// The key is a pointer to a GiSTobject, which can be used to
// point to just about anything you like.
class GiSTentry : public GiSTobject {
public:
        GiSTentry(): node(NULL), level(0) {}
        GiSTentry(GiSTpage ptr): node(NULL), ptr(ptr) {}
        GiSTentry(const GiSTentry& e): node(e.node), ptr(e.ptr), 
        position(e.position), level(e.level) {}

        virtual ~GiSTentry() { if(key) delete key; }

        // The following methods must be overridden by descendant classes
        virtual GiSTpenalty *Penalty(const GiSTentry &key) const=0;
        virtual int CompressedLength() const=0; // length of compressed key
#ifdef PRINTING_OBJECTS
        virtual void Print(ostream& os) const=0;
#endif
        virtual GiSTobject *Copy() const=0;
        // Default compression is just to copy the key (i.e. no compression).
        // Since the copy method is virtual, the appropriate Copy method is called.
        // Besides compressing the key, Compress also sets the pointer.
        virtual GiSTcompressedEntry Compress() const {
                GiSTcompressedEntry compressedEntry;

                compressedEntry.key=(char *)key->Copy();
                compressedEntry.keyLen=CompressedLength();
                compressedEntry.ptr=ptr;
                return compressedEntry;
        }
        // Besides decompressing the key, Decompress also sets the pointer.
        virtual void Decompress(const GiSTcompressedEntry entry) {
                key=(GiSTobject *)new char[entry.keyLen];
                memcpy(key, entry.key, entry.keyLen);
                ptr=entry.ptr;
        }

        // If you have ordered keys, this can be overridden a la qsort's compare
        virtual int Compare(const GiSTentry& entry) const { return 0; }

        // access to the protected info
        GiSTpage Ptr() const { return ptr; }
        void SetPtr(GiSTpage p) { ptr=p; }
        GiSTobject *Key() const { return key; }

        GiSTobjid IsA() const { return GISTENTRY_CLASS; }
        int IsLeaf() const { return level==0; }
        int Level() const { return level; }
        void SetLevel(int l) { level=l; }

        void SetPosition(int pos) { position=pos; }
        int Position() const { return position; }

        GiSTnode *Node() const { return node; }
        void SetNode(GiSTnode *n) { node=n; }

protected:
        GiSTnode *node;
        GiSTpage ptr;
        int position;
        int level;
        GiSTobject *key;
};

#endif
Revision:	1.1
Committed:	Sun May 6 00:45:51 2001 UTC (25 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	* empty log message *
#	User	Rev	Content
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