along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/TBTree/TBTree.h

2172 lines
50 KiB
C
Raw Normal View History

firs commit
2026-01-23 17:03:45 +08:00
/*
Implementation of the trajectory bundle tree.
*/
#ifndef TBTREE_H
#define TBTREE_H
#include "Algebras/TupleIdentifier/TupleIdentifier.h"
#include "Algebras/Rectangle/RectangleAlgebra.h"
#include "SecondoSMI.h"
#include "Algebras/Temporal/TemporalAlgebra.h"
#include "NestedList.h"
#include "ListUtils.h"
#include <cassert>
#include <vector>
#include <iostream>
namespace tbtree{
bool CheckTBTree(ListExpr type, ListExpr& ErrorInfo);
/*
1 Class LeafInfo
This class contains the information of an leaf entry in the tree.
*/
class TBLeafInfo{
public:
/*
~Constructors~
*/
TBLeafInfo():tid(0){}
TBLeafInfo(const TupleId& id): tid(id) {}
TBLeafInfo(const TBLeafInfo& li): tid(li.tid) {}
/*
~ Assignment operator~
*/
TBLeafInfo& operator=(const TBLeafInfo& li){
this->tid = li.tid;
return *this;
}
bool operator==(const TBLeafInfo& li) const{
return (this->tid == li.tid);
}
/*
~ Destructor~
*/
~TBLeafInfo() {}
/*
~Getter~
*/
inline TupleId getTupleId() const{
return tid;
}
/*
Writing into a buffer.
*/
inline void writeTo(char* buffer,unsigned int& offset) const{
memcpy(buffer+offset, &tid, sizeof(TupleId));
offset += sizeof(TupleId);
}
/*
Reading from a buffer.
*/
inline void readFrom(const char* buffer, unsigned int& offset) {
memcpy(&tid, buffer+offset, sizeof(TupleId));
offset += sizeof(TupleId);
}
/*
Size required for a buffer.
*/
static int bufferSize() {
return sizeof(TupleId);
}
/*
prints out this object
*/
std::ostream& print(std::ostream& os){
return os << tid ;
}
private:
TupleId tid;
};
/*
2 class InnerInfo
This class contains the information of an entry of an inner node in the tree.
*/
class InnerInfo{
public:
/*
Constructors
*/
InnerInfo(): pointer(0){}
InnerInfo(const SmiRecordId& p): pointer(p) {}
InnerInfo(const InnerInfo& ii): pointer(ii.pointer) {}
/*
Assignment operator
*/
InnerInfo& operator=(const InnerInfo& ii){
pointer = ii.pointer;
return *this;
}
inline bool operator==(const InnerInfo& ii) const{
return this->pointer == ii.pointer;
}
/*
Destructor
*/
~InnerInfo(){}
/*
Getter
*/
inline SmiRecordId getPointer() const{
return pointer;
}
/*
Writing into a buffer.
*/
inline void writeTo(char* buffer, unsigned int& offset) const{
memcpy(buffer + offset, &pointer, sizeof(SmiRecordId));
offset += sizeof(SmiRecordId);
}
/*
Reading from a buffer.
*/
inline void readFrom(const char* buffer,unsigned int& offset) {
memcpy(&pointer, buffer + offset, sizeof(SmiRecordId));
offset += sizeof(SmiRecordId);
}
/*
Required buffersize to store it.
*/
static int bufferSize() {
return sizeof(SmiRecordId);
}
/*
prints out the pointer
*/
std::ostream& print(std::ostream& os){
return os << pointer;
}
private:
SmiRecordId pointer;
};
/*
Function copying a defined rectangle into a buffer
*/
template<int Dim>
inline void writeRectangle(const Rectangle<Dim>& r,
char* buffer,
unsigned int& offset){
assert(r.IsDefined());
for(int i = 0; i< Dim; i++){
double d = r.MinD(i);
memcpy(buffer+offset, &d, sizeof(double));
offset += sizeof(double);
d = r.MaxD(i);
memcpy(buffer+offset, &d, sizeof(double));
offset += sizeof(double);
}
}
/*
Function reading a rectangle from a buffer
*/
template<int Dim>
inline void readRectangle(Rectangle<Dim>& r,
const char* buffer,
unsigned int& offset){
double mi[Dim];
double ma[Dim];
double d;
for(int i = 0; i< Dim; i++){
memcpy(&d, buffer+offset, sizeof(double));
offset += sizeof(double);
mi[i] = d;
memcpy(&d, buffer+offset, sizeof(double));
offset += sizeof(double);
ma[i] = d;
}
r.Set(true, mi, ma);
}
/*
Size required to store a rectangle.
*/
template<int Dim>
inline int rectBufferSize(){
return 2 * Dim * sizeof(double);
}
/*
3 Class Entry
This class realized an entry within the tree. It should be
intantiated with InnerInfo or LeafInfo.
*/
template<int Dim, class Info>
class Entry{
public:
/*
Constructors
*/
Entry() {}
Entry(const Rectangle<Dim>& b,const Info& i): box(b), info(i) {}
Entry(const Entry<Dim, Info>& src): box(src.box), info(src.info) {}
/*
Assignment operator
*/
Entry<Dim, Info>& operator=(const Entry<Dim, Info>& e){
this->box = e.box;
this->info = e.info;
return *this;
}
inline bool operator==(const Entry<Dim, Info>& e) const{
return (this->box == e.box) && (this->info==e.info);
}
/*
Destructor
*/
~Entry() {}
/*
Getter
*/
inline const Rectangle<Dim> getBox() const{
return box;
}
inline const Info& getInfo() const{
return info;
}
/*
Writing into a buffer
*/
inline void writeTo(char* buffer, unsigned int& offset) const{
writeRectangle<Dim>(box, buffer, offset);
info.writeTo(buffer, offset);
}
/*
Reading from a buffer
*/
inline void readFrom(const char* buffer,unsigned int& offset) {
readRectangle<Dim>(box, buffer, offset);
info.readFrom(buffer, offset);
}
/*
Required BufferSize
*/
inline static int bufferSize(){
return rectBufferSize<Dim>() + Info::bufferSize();
}
/*
Let the box be the union of the original box and b;
*/
inline void addBox(const Rectangle<Dim>& b){
box = box.Union(b);
}
/*
Prints entry to stream;
*/
std::ostream& print(std::ostream& os){
os << "(";
box.Print(os);
os << ", ";
info.print(os);
os << ")";
return os;
}
private:
Rectangle<Dim> box;
Info info;
};
/*
class BasicNode
This is the super class for all types of nodes.
*/
template<unsigned Dim>
class BasicNode{
public:
/*
1 Constructors
*/
BasicNode(uint16_t min1, uint16_t max1):
min(min1), max(max1), current(0) {}
BasicNode(const BasicNode<Dim>& src):
min(src.min), max(src.max), current(src.current) {}
/*
2 Assignment operator
*/
BasicNode<Dim>& operator=(const BasicNode<Dim>& src){
this->min = src.min;
this->max = src.max;
this->current = src.current;
return *this;
}
/*
3 Comparison
*/
inline bool operator==(const BasicNode<Dim>& bn) const{
return this->min == bn.min &&
this->max == bn.max &&
this->current == bn.current;
}
/*
4 some pure virtual functions.
*/
virtual ~BasicNode() {}
virtual void writeTo(char* buffer, unsigned int& offset) const = 0;
virtual void readFrom(const char* buffer,unsigned int& offset) = 0;
virtual Rectangle<Dim> getBox() const = 0;
virtual const bool isLeaf()const = 0;
virtual int bufferSize() const =0;
virtual std::ostream& print(std::ostream& os ) const=0;
virtual BasicNode<Dim>* clone() const=0;
/*
5 some Getter
*/
uint16_t entryCount() const{
return current;
}
inline uint16_t getMin() const{
return min;
}
inline virtual uint16_t getMax() const{
return max;
}
protected:
uint16_t min; // minimum entrycount
uint16_t max; // maximum entrycount
uint16_t current; // current entrycount
};
/*
4 Class Node
This is the super class of inner nodes and leaf nodes.
*/
template<unsigned Dim, class Info>
class Node : public BasicNode<Dim>{
public:
/*
4.1 Constructors
*/
Node(int min1, int max1): BasicNode<Dim>(min1,max1){
entries = new Entry<Dim, Info>*[BasicNode<Dim>::max +1];
for(int i=0;i<BasicNode<Dim>::max+1; i++){
entries[i] = 0;
}
}
Node(const Node<Dim, Info>& src) : BasicNode<Dim>(src){
entries = new Entry<Dim,Info>*[BasicNode<Dim>::max +1];
for(int i=0;i< src.entryCount(); i++){
this->entries[i] = new Entry<Dim, Info>(*(src.entries[i]));
}
for(int i=src.entryCount(); i<BasicNode<Dim>::max; i++){
this->entries[i] = 0;
}
}
/*
4.2 Assignment operator
*/
Node& operator=(const Node<Dim, Info>& src) {
// first, delete all included entries
for(int i=0; i< BasicNode<Dim>::current; i++){
delete entries[i];
entries[i] = 0;
}
// if the size is different, adopt it
if(BasicNode<Dim>::max!=src.max){
delete[] entries;
entries = new Entry<Dim, Info>*[src.max+1];
}
BasicNode<Dim>::operator=(src);
for(int i=0;i< BasicNode<Dim>::current; i++){
entries[i] = new Entry<Dim, Info>(*(src.entries[i]));
}
}
/*
4.3 Comparision
*/
bool operator==(const Node<Dim, Info>& n) const{
if(! (BasicNode<Dim>::operator==(n))){
return false;
}
for(int i=0;i<BasicNode<Dim>::current; i++){
if(!( *(this->entries[i]) == *(n.entries[i]))){
return false;
}
}
return true;
}
/*
4.4 Destructor
*/
virtual ~Node(){
for(int i=0;i<BasicNode<Dim>::current;i++){
delete entries[i];
}
BasicNode<Dim>::current = 0;
delete[] entries;
entries = 0;
}
/*
4.5 ~deleteEntries~
Removes all entries from this node.
*/
inline void deleteEntries() {
for(int i=0;i<BasicNode<Dim>::current;i++){
delete entries[i];
}
BasicNode<Dim>::current = 0;
}
/*
4.6 ~getEntry~
Returns the entry at the given position.
*/
inline const Entry<Dim, Info>* getEntry(int index) const{
assert(index<BasicNode<Dim>::current);
return entries[index];
}
/*
4.7 ~getBox~
Returns the union of all boxes of all entries.
*/
inline virtual Rectangle<Dim> getBox() const{
if(BasicNode<Dim>::current==0){
Rectangle<Dim> r(false);
return r;
} else {
Rectangle<Dim> res(entries[0]->getBox());
for(int i=1; i< BasicNode<Dim>::current; i++){
res = res.Union(entries[i]->getBox());
}
return res;
}
}
/*
4.8 ~writeTo~
Writes this node to an existing buffer.
*/
inline virtual void writeTo(char* buffer, unsigned int& offset) const{
uint16_t c = BasicNode<Dim>::current;
memcpy(buffer+offset, &c, sizeof(uint16_t));
offset += sizeof(uint16_t);
for(int i=0; i< BasicNode<Dim>::current; i++){
entries[i]->writeTo(buffer, offset);
}
}
/*
4.9 ~readFrom~
Reconstructs the node from a buffer.
*/
inline virtual void readFrom(const char* buffer,unsigned int& offset){
// delete old entries
for(int i=0;i<BasicNode<Dim>::current; i++){
delete entries[i];
entries[i] = 0;
}
uint16_t c;
memcpy(&c, buffer+offset, sizeof(uint16_t));
BasicNode<Dim>::current = c;
offset += sizeof(uint16_t);
for(int i=0; i< BasicNode<Dim>::current; i++){
entries[i] = new Entry<Dim, Info>();
entries[i]->readFrom(buffer, offset);
}
}
/*
4.10 ~bufferSize~
Returns the number of bytes required to store this node.
*/
inline virtual int bufferSize() const{
return sizeof(uint16_t) +
BasicNode<Dim>::current*Entry<Dim, Info>::bufferSize();
}
/*
4.11 ~getMax~
Return the maximum count of nodes which can be placed in a buffer with
given size.
*/
static uint32_t getMax(const uint32_t buffersize){
uint32_t ls = buffersize - sizeof(uint16_t); // current
return ls / Entry<Dim, Info>::bufferSize();
}
/*
4.12 ~isFull~
Returns true if no more elements can be inserted into this node.
*/
inline bool isFull() const{
return BasicNode<Dim>::current == BasicNode<Dim>::max -1;
}
/*
4.12 ~insert~
Appends a new entry. If there is an overflow, the result will be true.
*/
inline bool insert(const Entry<Dim, Info>& e){
assert(BasicNode<Dim>::current <= BasicNode<Dim>::max);
entries[BasicNode<Dim>::current] = new Entry<Dim, Info>(e);
BasicNode<Dim>::current++;
return BasicNode<Dim>::current==BasicNode<Dim>::max+1;
}
/*
4.14 ~addBoxAt~
Builds the uion of the given box and the box of element at position pos
and stores the result at posiotion pos.
*/
inline void addBoxAt(const int pos, const Rectangle<Dim>& r){
entries[pos]->addBox(r);
}
/*
4.15 ~remove~
Removes the entrie at position pos from this node.
*/
inline void remove(const int index){
assert(index < BasicNode<Dim>::current);
delete entries[index];
BasicNode<Dim>::current--;
for(int i=index; i<BasicNode<Dim>::current; i++){
entries[i] = entries[i+1];
}
entries[BasicNode<Dim>::current] = 0;
}
/*
4.16 getEmptyNode()
pure virtual.
*/
virtual Node* getEmptyNode()const = 0;
/*
~updateEntry~
Replaces the entry at the given position by the new one.
*/
inline void updateEntry(int pos, Entry<Dim, Info> e){
assert(pos < BasicNode<Dim>::current);
*(entries[pos]) = e;
}
/*
~isLeaf~
pure virtual.
*/
virtual const bool isLeaf() const = 0;
/*
~print~
*/
std::ostream& print(std::ostream& os) const{
os << "(node - ";
os << (isLeaf() ? "leaf" : "inner");
os << "[" << BasicNode<Dim>::min <<", "
<< BasicNode<Dim>::max << ", "
<< BasicNode<Dim>::current << "] ::{" ;
for(int i=0;i<BasicNode<Dim>::current;i++){
entries[i]->print(os);
}
os << "}])";
return os;
}
protected:
Entry<Dim, Info>** entries;
};
/*
Class ~QNodeSplitter~
This class provides some functions to split a node into 2 new ones
using quadratic split algorithm.
*/
template<int Dim, class Info>
class QNodeSplitter{
public:
std::pair<Node<Dim, Info>*, Node<Dim, Info>* >
splitNode(Node<Dim, Info>& node){
std::pair<int, int> seeds = pickSeeds(node);
int index1 = seeds.first;
int index2 = seeds.second;
Node<Dim, Info>* node1 = node.getEmptyNode();
Node<Dim, Info>* node2 = node.getEmptyNode();
node1->insert(*(node.getEntry(index1)));
node2->insert(*(node.getEntry(index2)));
node.remove(std::max(index1,index2));
node.remove(std::min(index1,index2));
int min = node.getMin();
while(node.entryCount() > 0){
if(node.entryCount() + node1->entryCount() == min){
for(int i=0;i<node.entryCount();i++){
node1->insert(*node.getEntry(i));
}
node.deleteEntries();
}else if(node.entryCount() + node2->entryCount() == min){
for(int i=0;i<node.entryCount();i++){
node2->insert(*(node.getEntry(i)));
}
node.deleteEntries();
} else {
std::pair<unsigned int, unsigned int> next =
pickNext(&node,node1,node2);
if(next.second == 1){
node1->insert(*(node.getEntry(next.first)));
} else {
node2->insert(*node.getEntry(next.first));
}
node.remove(next.first);
}
}
return std::make_pair(node1,node2);
} // end of splitNode
private:
typedef Node<Dim,Info> node_type;
std::pair<unsigned int,unsigned int> pickSeeds(const node_type& n) const{
std::pair<int, int> res;
double d = 0;
for(int i=0;i<n.entryCount();i++){
for(int j=i+1;j<n.entryCount();j++){
Rectangle<Dim> r1(n.getEntry(i)->getBox());
Rectangle<Dim> r2(n.getEntry(j)->getBox());
double d2 = 2 * r1.Union(r2).Area() - (r1.Area() + r2.Area());
if(d2>d){
res.first = i;
res.second = j;
d = d2;
}
}
}
if(d==0){ // all boxes are the same
res.first = 0;
res.second = n.entryCount()-1;
}
return res;
}
std::pair<unsigned int,unsigned int>
pickNext(const node_type* source,
const node_type* grpone,
const node_type* grptwo) const{
double d1 = source->getEntry(0)->getBox().Union(grpone->getBox()).Area();
double d2 = source->getEntry(0)->getBox().Union(grptwo->getBox()).Area();
unsigned int index = 0;
unsigned int bestgrp = -1;
double d = std::fabs(d1-d2);
Rectangle<Dim> b1 = grpone->getBox();
Rectangle<Dim> b2 = grptwo->getBox();
double a1 = b1.Area();
double a2 = b2.Area();
for(int i=1;i<source->entryCount();i++){
d1 = source->getEntry(i)->getBox().Union(b1).Area();
d2 = source->getEntry(i)->getBox().Union(b2).Area();
double d3 = std::fabs(d1-d2);
if(d3>d){
d = d3;
index = i;
d1 = d1 - a1;
d2 = d2 - a2;
if(d1!=d2){
bestgrp = d1<d2?1:2;
} else if(a1!=a2){
bestgrp = a1<a2?1:2;
} else if(grpone->entryCount()!=grptwo->entryCount()){
bestgrp = grpone->entryCount()<grptwo->entryCount()? 1:2;
} else { // all criterions failed
bestgrp = 1;
}
}
}
std::pair<unsigned int , unsigned int> res;
res.first = index;
res.second = bestgrp;
return res;
}
};
/*
5 class TBLeafNode
*/
template<int Dim, class Info>
class TBLeafNode : public Node<Dim, Info>{
public:
/*
5.1 Constructors
*/
TBLeafNode() {}
TBLeafNode(int min, int max, int trjid1):
Node<Dim, Info>(min,max), next(0), trjid(trjid1){}
TBLeafNode(const TBLeafNode& src): Node<Dim, Info>(src),
next(src.next),
trjid(src.trjid){ }
/*
5.2 Assignment Operator
*/
inline TBLeafNode& operator=(const TBLeafNode<Dim,Info>& src){
Node<Dim, Info>::operator=(src);
this->next = src.next;
this->trjid = src.trjid;
return *this;
}
/*
5.3 Comparison
*/
inline bool operator==(const TBLeafNode<Dim, Info>& ln)const{
return Node<Dim, Info>::operator==(ln) &&
this->next == ln.next &&
this->trjid == ln.trjid;
}
/*
5.4 Destructor
*/
virtual ~TBLeafNode(){
Node<Dim, Info>::deleteEntries();
}
/*
5.5 isLeaf
Returns allways true.
*/
inline virtual const bool isLeaf() const{
return true;
}
/*
5.6 Import/Export to a buffer
*/
inline virtual void writeTo(char* buffer, unsigned int& offset) const{
Node<Dim, Info>::writeTo(buffer, offset);
memcpy(buffer + offset, &next, sizeof(SmiRecordId));
offset += sizeof(SmiRecordId);
memcpy(buffer + offset, &trjid, sizeof(int));
offset += sizeof(int);
}
inline virtual void readFrom(const char* buffer,unsigned int& offset){
Node<Dim, Info>::readFrom(buffer, offset);
memcpy(&next, buffer + offset, sizeof(SmiRecordId));
offset += sizeof(SmiRecordId);
memcpy(&trjid, buffer + offset, sizeof(int));
offset += sizeof(int);
}
inline int bufferSize() const{
return Node<Dim, Info>::bufferSize() + sizeof(SmiRecordId)+sizeof(int);
}
inline uint16_t getMax(){
return BasicNode<3>::getMax();
}
/*
~getMax~
Returns the maximum number of nodes whiach can be placed into a buffer with
given size.
*/
static uint32_t getMax(const uint32_t buffersize){
uint32_t ls = buffersize - (sizeof(SmiRecordId) + sizeof(int));
return Node<Dim,Info>::getMax(ls);
}
/*
Getter / Setter
*/
inline SmiRecordId getNext() const{
return next;
}
inline void setNext(const SmiRecordId id){
next = id;
}
inline int getTrjId() const{
return trjid;
}
inline void setTrjId(const int trjid){
this->trjid = trjid;
}
/*
Returns a node wiout any entries.
*/
inline Node<Dim, Info>* getEmptyNode() const{
return new TBLeafNode<Dim, Info>(BasicNode<Dim>::min,
BasicNode<Dim>::max, 0);
}
/*
Prints out this node.
*/
virtual std::ostream& print(std::ostream& os)const{
return Node<Dim, Info>::print(os) << next << endl;
}
/*
Returns a clone of this node.
*/
inline virtual BasicNode<Dim>* clone() const{
return new TBLeafNode<Dim, Info>(*this);
}
private:
SmiRecordId next;
int trjid;
};
/*
5 class InnerNode
*/
template<int Dim, class Info>
class InnerNode : public Node<Dim, Info>{
public:
/*
5.1 Constructors
*/
InnerNode(const int min1, const int max1): Node<Dim, Info>(min1, max1) {}
InnerNode(const InnerNode<Dim, Info>& src): Node<Dim, Info>(src) {}
/*
5.2 Assignment operator
*/
inline InnerNode& operator=(const InnerNode<Dim, Info>& src) {
return Node<Dim, Info>::operator=(src);
}
/*
5.3 Comparison
*/
inline bool operator==(const InnerNode<Dim, Info>& in) const{
return Node<Dim, Info>::operator==(in);
}
/*
5.4 Destructor
*/
virtual ~InnerNode(){
Node<Dim, Info>::deleteEntries();
}
/*
~isLeaf~
returns allways false.
*/
inline virtual const bool isLeaf() const{
return false;
}
/*
~selectBestNode~
for details see Gutmans paper about the r-tree.
*/
int selectBestNode(const Rectangle<Dim>& r) const{
assert( (Node<Dim, Info>::current)>0);
int res = 0;
Rectangle<Dim> r1(Node<Dim, Info>::entries[0]->getBox());
double diff = r1.Union(r).Area() - r1.Area();
for(int i=1; i< (Node<Dim, Info>::current); i++){
r1 = Node<Dim, Info>::entries[i]->getBox();
double diff2 = r1.Union(r).Area() - r1.Area();
if(diff2<diff){
res = i;
diff = diff2;
}
}
return res;
}
/*
~getEmptyNode~
Returns a node without any entries.
*/
inline Node<Dim, Info>* getEmptyNode() const{
return new InnerNode<Dim, Info>(BasicNode<Dim>::min,
BasicNode<Dim>::max);
}
/*
~clone~
Returns a clone of this node.
*/
inline virtual BasicNode<Dim>* clone() const{
return new InnerNode<Dim, Info>(*this);
}
/*
~getMax~
Returns the maximum number of inner nodes which can be stored
into a buffer of given size.
*/
inline static uint32_t getMax(uint32_t buffersize){
return Node<Dim,Info>::getMax(buffersize);
}
};
/*
5 Class PathEntry
This class supports the searchNode function of a tbtree.
*/
template<int Dim>
struct pathEntry{
public:
pathEntry(const SmiRecordId id1, BasicNode<Dim>* node1, const int pos1):
id(id1), node(node1), pos(pos1){}
pathEntry(const pathEntry& pe):id(pe.id), node(pe.node), pos(pe.pos){}
inline pathEntry& operator=(const pathEntry& s){
this->id = s.id;
this->node = s.node;
this->pos = s.pos;
return *this;
}
inline bool operator==(const pathEntry& s)const{
return this->id == s.id &&
this->node == s.node &&
this->pos == s.pos;
}
~pathEntry(){}
SmiRecordId id; // the record id
BasicNode<Dim>* node; // the node corresponding to that id
int pos; // position of the next entry
};
/*
7 class TBTree
This is the implementation of a tbtree. In contrast to the
original paper, we don't store the direction in each leaf entry.
Instead we store an trip id in each leaf node.
*/
class TBTree{
public:
/*
Creates an empty TBTree
*/
TBTree(const int pageSize): file(true, pageSize-64),rootId(0){
file.Create();
int size = file.GetRecordLength();
recordLength = size;
leafMax = TBLeafNode<3, TBLeafInfo>::getMax(size);
leafMin = leafMax / 4;
innerMax = InnerNode<3, InnerInfo>::getMax(size);
innerMin = innerMax / 4;
noEntries = 0;
noNodes = 0;
noLeafNodes = 0;
level = 0;
Rectangle<3> b(false);
box = b;
SmiRecord dummy;
headerId =0;
saveHeader();
}
/*
Opens an existing TBTRee from file
*/
TBTree(const SmiFileId id, SmiRecordId hid): file(true), headerId(hid){
file.Open(id);
readHeader();
}
/*
~ Destructor ~
*/
~TBTree(){
if(file.IsOpen()){
saveHeader();
file.Close();
}
}
/*
Returns the fileId of the underlying file.
*/
inline SmiFileId getFileId() {
return file.GetFileId();
}
/*
Returns the record id of the record storing the header of the tree.
*/
inline SmiRecordId getHeaderId() const{
return headerId;
}
/*
Returns the record id storing the root of the tree. If the tree is emty, the
result will be 0.
*/
inline SmiRecordId getRootId() const{
return rootId;
}
/*
Returns the node stored at the given id.
*/
inline BasicNode<3>* getNode(const SmiRecordId id){
return readNode(id);
}
/*
Stores a new entry.
*/
void insert(const temporalalgebra::UPoint& up,
const int trjid, const TupleId tid){
if(!up.IsDefined()){
return;
}
noEntries++;
TBLeafInfo li(tid);
Entry<3, TBLeafInfo> e(up.BoundingBox(), li);
if(!rootId){ // the tree is empty
TBLeafNode<3, TBLeafInfo> node(leafMin, leafMax, trjid);
node.insert(e);
rootId = saveNode(node);
level++;
box = e.getBox();
return;
} else {
box = box.Union(e.getBox());
std::vector<pathEntry<3> > path;
TBLeafNode<3, TBLeafInfo>* newLeaf(0);
SmiRecordId id(0);
if(searchNode(rootId, path, e, trjid)) {
TBLeafNode<3, TBLeafInfo>* leaf =
dynamic_cast<TBLeafNode<3, TBLeafInfo>* >
(path[path.size()-1].node);
if(!leaf->isFull()) {
leaf->insert(e);
updateNode(path[path.size()-1].id, *leaf);
Rectangle<3> b = leaf->getBox();
updatePath(path, b);
} else {
assert(! leaf->getNext());
newLeaf = new TBLeafNode<3, TBLeafInfo>(leafMin, leafMax, trjid);
newLeaf->insert(e);
id = saveNode(*newLeaf);
leaf->setNext(id);
updateNode(path[path.size()-1].id, *leaf); // update next
}
} else { // no predecessor was found -> create a new leaf
newLeaf = new TBLeafNode<3, TBLeafInfo>(leafMin, leafMax,trjid);
newLeaf->insert(e);
id = saveNode(*newLeaf);
}
// path processed or needless, delete the entries
for(unsigned int i=0;i<path.size(); i++){
assert(path[i].node); // dont allow an empty entry
delete path[i].node;
path[i].node = 0;
}
while(!path.empty()){
path.pop_back();
}
if(newLeaf){ // there is new leaf which has to
// inserted into the tree structure
SmiRecordId newRootId = insertLeaf(id, e.getBox());
if(newRootId!=rootId){
level++;
}
rootId = newRootId;
delete newLeaf;
}
}
}
/*
~insertLeaf~
Stores a new Leaf in the tree. To be used in bulk loading.
Returns the id of the used record
*/
SmiRecordId insertLeaf(const TBLeafNode<3, TBLeafInfo>& leaf,
const SmiRecordId predecessor = 0){
assert(leaf.entryCount() >0);
noEntries += leaf.entryCount();
SmiRecordId id = saveNode(leaf); // save the leaf
if(!rootId){ // tree was empty
level++;
box = leaf.getBox();
rootId = id;
return id;
}
// there is a predecessor
if(predecessor){
TBLeafNode<3, TBLeafInfo>* pred =
dynamic_cast<TBLeafNode<3, TBLeafInfo>*>(readNode(predecessor));
pred->setNext(id);
updateNode(predecessor, * pred);
delete pred;
}
// update bounding box
box = box.Union(leaf.getBox());
// insert the new leaf into the structure
SmiRecordId newRootId = insertLeaf(id, leaf.getBox());
if(newRootId!=rootId){
level++;
rootId = newRootId;
}
return id;
}
/*
Returns a new empty leaf node
*/
TBLeafNode<3, TBLeafInfo>* getEmptyLeaf(const TupleId trjid){
return new TBLeafNode<3, TBLeafInfo>(leafMin, leafMax, trjid);
}
/*
Deletes the underlying file. After that operator, the TBTree is not longer
usable.
*/
void deleteFile(){
file.Close();
file.Drop();
}
std::string toString(){
std::ostringstream os;
os << "[ -- tbtree -- " << endl
<< " fileId : " << file.GetFileId() << endl
<< " rootId : " << rootId << endl
<< " headerId : " << headerId << endl
<< " leafMin : " << leafMin << endl
<< " leafMax : " << leafMax << endl
<< " innerMin : " << innerMin << endl
<< " innerMax : " << innerMax << endl
<< " entries : " << noEntries << endl
<< " nodes : " << noNodes << endl
<< " leafNodes : " << noLeafNodes << endl
<< " level : " << level << endl
<< " recordLength : " << recordLength << endl
<< " box : ";
if(!box.IsDefined()){
os << "undef";
} else {
os << box;
}
os << endl << "]";
return os.str();
}
/*
Some Getter
*/
int entryCount() const{
return noEntries;
}
int nodeCount() const{
return noNodes;
}
int leafnodeCount() const{
return noLeafNodes;
}
int getHeight() const{
return level;
}
Rectangle<3> getBox()const{
return box;
}
bool getFileStats( SmiStatResultType &result ) {
result = file.GetFileStatistics(SMI_STATS_EAGER);
std::stringstream fileid;
fileid << file.GetFileId();
result.push_back(std::pair<std::string,std::string>("FilePurpose",
"SecondaryTBTreetreeIndexFile"));
result.push_back(std::pair<std::string,std::string>(
"FileId",fileid.str()));
return true;
}
static const std::string BasicType(){
return "tbtree";
}
static const bool checkType(ListExpr type){
ListExpr errorInfo = listutils::emptyErrorInfo();
return CheckTBTree(type, errorInfo);
}
/*
calculate number of different trajectories in this node
*/
int getcoverage(BasicNode<3>* n){
if(n->isLeaf())
return 1;
InnerNode<3,InnerInfo>* innernode =
dynamic_cast<InnerNode<3, InnerInfo>* >(n);
std::vector<int> trajid;
std::vector<Entry<3,InnerInfo> > list1;
std::vector<Entry<3,InnerInfo> > list2;
for(unsigned int i = 0;i < innernode->entryCount();i++){
list1.push_back(*(innernode->getEntry(i)));
}
SmiRecordId adr;
while(!list1.empty()){
for(unsigned int i = 0;i < list1.size();i++){
adr = list1[i].getInfo().getPointer();
BasicNode<3>* node = getNode(adr);
if(node->isLeaf()){ //get trajid
TBLeafNode<3,TBLeafInfo>* leafnode =
dynamic_cast<TBLeafNode<3, TBLeafInfo>* >(node);
trajid.push_back(leafnode->getTrjId());
}
else{
innernode = dynamic_cast<InnerNode<3, InnerInfo>* >(node);
for(unsigned int j = 0;j < innernode->entryCount();j++)
list2.push_back(*(innernode->getEntry(j)));
}
delete node;
}
list1.clear();
list1.swap(list2);
list2.clear();
}
stable_sort(trajid.begin(),trajid.end());
std::vector<int>::iterator end;
end = unique(trajid.begin(),trajid.end());
std::vector<int>::iterator begin = trajid.begin();
int count = 0;
while(begin != end){
begin++;
count++;
}
return count;
}
// for CloneTBtree
void Clone(TBTree*);
SmiRecordId DFVisit_TBtree(TBTree*,tbtree::BasicNode<3>*);
private:
SmiRecordFile file;
SmiRecordId rootId;
SmiRecordId headerId;
uint16_t leafMin;
uint16_t leafMax;
uint16_t innerMin;
uint16_t innerMax;
uint32_t noEntries; // numer of stored entries
uint32_t noNodes; // number of nodes in the tree
uint32_t level; // height of the tree
uint32_t noLeafNodes; // number of leaf nodes
Rectangle<3> box; // bounding boc of the whole tree
uint32_t recordLength;
void saveHeader() {
//unsigned int size = 4*sizeof(uint16_t) + sizeof(SmiRecordId) +
// 4*sizeof(uint32_t) + sizeof(char) +
// rectBufferSize<3>();
unsigned int size = recordLength;
char buffer[size];
memset(buffer,0,size);
unsigned int offset = 0;
// rootid
memcpy(buffer+offset, &rootId, sizeof(SmiRecordId));
offset += sizeof(SmiRecordId);
// min, max stuff
memcpy(buffer+offset, &leafMin, sizeof(uint16_t));
offset += sizeof(uint16_t);
memcpy(buffer+offset, &leafMax, sizeof(uint16_t));
offset += sizeof(uint16_t);
memcpy(buffer+offset, &innerMin, sizeof(uint16_t));
offset += sizeof(uint16_t);
memcpy(buffer+offset, &innerMax, sizeof(uint16_t));
offset += sizeof(uint16_t);
// counters
memcpy(buffer+offset, &noEntries, sizeof(uint32_t));
offset += sizeof(uint32_t);
memcpy(buffer+offset, &noNodes, sizeof(uint32_t));
offset += sizeof(uint32_t);
memcpy(buffer+offset, &noLeafNodes, sizeof(uint32_t));
offset += sizeof(uint32_t);
memcpy(buffer+offset, &level, sizeof(uint32_t));
offset += sizeof(uint32_t);
// bounding box
if(box.IsDefined()){
char c = 1;
memcpy(buffer+offset,&c,sizeof(char));
offset += sizeof(char);
writeRectangle<3>(box, buffer, offset);
} else {
char c = 0;
memcpy(buffer+offset,&c,sizeof(char));
offset += sizeof(char);
double d = -1;
for(int i=0;i<2*3; i++){
memcpy(buffer+offset,&d, sizeof(double));
offset += sizeof(double);
}
}
if(offset>size){
cout << "offset = " << offset << " , size = " << size << endl;
}
assert(offset<=size);
// store the buffer
SmiRecord record;
if(headerId != 0){
file.SelectRecord(headerId, record, SmiFile::Update);
SmiSize hss = record.Write(buffer,size,0);
assert(hss == size);
} else {
file.AppendRecord(headerId, record);
assert(headerId !=0);
SmiSize hss = record.Write(buffer,size,0);
assert(hss == size);
}
record.Finish();
}
void readHeader(){
// read buffer
unsigned int size = 4*sizeof(uint16_t) + sizeof(SmiRecordId) +
4*sizeof(uint32_t) + sizeof(char) +
rectBufferSize<3>() ;
char buffer[size];
SmiRecord record;
file.SelectRecord(headerId, record);
recordLength = record.Size();
SmiSize hs = record.Read(buffer,size,0);
unsigned int offset = 0;
assert(hs == size);
memcpy(&rootId, buffer+offset, sizeof(SmiRecordId));
offset += sizeof(SmiRecordId);
memcpy(&leafMin, buffer+offset, sizeof(uint16_t));
offset += sizeof(uint16_t);
memcpy(&leafMax, buffer+offset, sizeof(uint16_t));
offset += sizeof(uint16_t);
memcpy(& innerMin, buffer+offset, sizeof(uint16_t));
offset += sizeof(uint16_t);
memcpy(&innerMax, buffer+offset, sizeof(uint16_t));
offset += sizeof(uint16_t);
// counters
memcpy(&noEntries, buffer+offset, sizeof(uint32_t));
offset += sizeof(uint32_t);
memcpy(&noNodes, buffer+offset, sizeof(uint32_t));
offset += sizeof(uint32_t);
memcpy(&noLeafNodes, buffer+offset, sizeof(uint32_t));
offset += sizeof(uint32_t);
memcpy(&level, buffer+offset, sizeof(uint32_t));
offset += sizeof(uint32_t);
// bounding box
char c;
memcpy(&c, buffer+offset, sizeof(char));
offset += sizeof(char);
if(c==0){
box.SetDefined(false);
} else {
readRectangle<3>(box, buffer, offset);
}
}
static bool EqualNodes(const BasicNode<3>* n1, const BasicNode<3>* n2) {
if(n1->isLeaf()!=n2->isLeaf()){
return false;
}
if(n1->isLeaf()){
const TBLeafNode<3, TBLeafInfo>* ln1 =
dynamic_cast<const TBLeafNode<3, TBLeafInfo>*>(n1);
const TBLeafNode<3, TBLeafInfo>* ln2 =
dynamic_cast<const TBLeafNode<3, TBLeafInfo>*>(n2);
return *ln1 == *ln2;
} else {
const InnerNode<3, InnerInfo>* in1 =
dynamic_cast<const InnerNode<3, InnerInfo>*>(n1);
const InnerNode<3, InnerInfo>* in2 =
dynamic_cast<const InnerNode<3, InnerInfo>*>(n2);
return *in1 == *in2;
}
}
SmiRecordId saveNode(const BasicNode<3>& n){
noNodes++;
if(n.isLeaf()){
noLeafNodes++;
}
assert(n.entryCount()>0); // never save an empty node
unsigned int size = recordLength;
char buffer[size];
memset(buffer,0,size);
char leaf = n.isLeaf()?1:0;
unsigned int offset = 0;
memcpy(buffer , &leaf, sizeof(char));
offset += sizeof(char);
n.writeTo(buffer, offset);
SmiRecordId id = 0;
SmiRecord record;
file.AppendRecord(id, record);
SmiSize os = 0; // offset
SmiSize rss = record.Write(buffer, size, os);
assert(rss == size);
record.Finish();
return id;
}
void updateNode(const SmiRecordId id, const BasicNode<3>& n){
assert(n.entryCount() > 0);
SmiRecord record;
file.SelectRecord(id, record, SmiFile::Update);
// unsigned int size = n.bufferSize()+sizeof(char);
unsigned int size = recordLength;
char buffer[size];
memset(buffer,0,size);
unsigned int offset = 0;
char isLeaf = n.isLeaf()?1:0;
memcpy(buffer,&isLeaf,sizeof(char));
offset += sizeof(char);
n.writeTo(buffer, offset);
SmiSize os = 0; // offset
SmiSize rss = record.Write(buffer, size, os);
assert(rss == size);
if(record.Size()>size){
record.Truncate(size);
}
record.Finish();
}
BasicNode<3>* readNode(const SmiRecordId id) {
SmiRecord record;
file.SelectRecord(id, record);
SmiSize size = record.Size();
assert(size>1);
char buffer[size];
SmiSize bs = record.Read(buffer, size, 0); // read record completely
assert(bs == size);
unsigned int offset = 0;
char leaf;
memcpy(&leaf, buffer, sizeof(char));
offset += sizeof(char);
BasicNode<3>* res(0);
if(leaf==1){
res = createLeafNodeFrom(buffer, offset);
} else {
res = createInnerNodeFrom(buffer, offset);
}
assert(offset<=size);
return res;
}
TBLeafNode<3, TBLeafInfo>* createLeafNodeFrom(const char* buffer,
unsigned int& offset){
TBLeafNode<3, TBLeafInfo>* res =
new TBLeafNode<3, TBLeafInfo>(leafMin, leafMax, 0);
res->readFrom(buffer, offset);
return res;
}
InnerNode<3, InnerInfo>* createInnerNodeFrom(const char* buffer,
unsigned int& offset){
InnerNode<3, InnerInfo>* res =
new InnerNode<3, InnerInfo>(innerMin, innerMax);
res->readFrom(buffer, offset);
return res;
}
bool searchNode(const SmiRecordId id, std::vector<pathEntry<3> >& path,
const Entry<3, TBLeafInfo>& li, const int trjid ) {
BasicNode<3>* bn = readNode(id);
assert(bn->entryCount()>0);
if(bn->isLeaf()){
TBLeafNode<3, TBLeafInfo>* leaf =
dynamic_cast<TBLeafNode<3, TBLeafInfo>*> (bn);
if(leaf->getTrjId()==trjid && leaf->getNext()==0){
path.push_back(pathEntry<3>(id,leaf, -1));
return true;
} else {
delete leaf;
return false;
}
} else { // an inner node
InnerNode<3, InnerInfo>* node =
dynamic_cast<InnerNode<3, InnerInfo>* >(bn);
const Entry<3, InnerInfo>* entry;
uint16_t c = node->entryCount();
for(uint16_t i=0; i < c; i++){
entry = node->getEntry(i);
if(entry->getBox().Intersects(li.getBox())){
path.push_back(pathEntry<3>(id, node,i));
if(searchNode(entry->getInfo().getPointer(), path, li, trjid)){
return true;
} else {
path.pop_back();
}
}
}
delete node;
return false;
}
}
void updatePath(const std::vector<pathEntry<3> >& path,
const Rectangle<3>& b ) {
// a new entry was inserted at the end of the path.
// we have to update the bounding boxes of all nodes in a path
for(int i=path.size()-2; i>=0;i--){
InnerNode<3, InnerInfo>* node =
dynamic_cast<InnerNode<3, InnerInfo>* >(path[i].node);
int pos = path[i].pos;
Rectangle<3> r = node->getEntry(pos)->getBox();
if(r.Contains(b)){
return;
} else {
node->addBoxAt(pos, b);
updateNode(path[i].id, *node);
}
}
}
/*
~InsertLeaf~
This function embedds the leaf with given id and box into the tree structure.
*/
SmiRecordId insertLeaf(const SmiRecordId& id, const Rectangle<3>& rect){
std::pair<SmiRecordId, SmiRecordId> res =
insertLeafRec(rootId, id, rect, 0);
if(res.second==0){
return res.first;
} else {
BasicNode<3>* s1 = readNode(res.first);
BasicNode<3>* s2 = readNode(res.second);
Entry<3, InnerInfo> e1(s1->getBox(), res.first);
Entry<3, InnerInfo> e2(s2->getBox(), res.second);
InnerNode<3, InnerInfo> n(innerMin, innerMax);
n.insert(e1);
n.insert(e2);
delete s1;
delete s2;
return saveNode(n);
}
}
std::pair<SmiRecordId, SmiRecordId>
insertLeafRec(const SmiRecordId rootId,
const SmiRecordId& id,
const Rectangle<3>& rect,
const int level){
BasicNode<3>* root = readNode(rootId);
if(root->isLeaf()){
std::pair<SmiRecordId, SmiRecordId> res(rootId, id);
delete root;
return res;
} else {
InnerNode<3, InnerInfo>* iroot =
dynamic_cast<InnerNode<3, InnerInfo>*>(root);
int sonIndex = iroot->selectBestNode(rect);
SmiRecordId sonId = iroot->getEntry(sonIndex)->getInfo().getPointer();
std::pair<SmiRecordId, SmiRecordId> sonRes =
insertLeafRec(sonId, id, rect, level+1);
if(sonRes.second == 0 ){ // no split required
Rectangle<3> b(root->getBox());
if(!b.Contains(rect)){ // bounding box update required
b = b.Union(rect);
Entry<3, InnerInfo> newSon(b, sonId);
iroot->updateEntry(sonIndex, newSon);
updateNode(rootId, *iroot);
}
delete iroot;
sonRes.first = rootId;
return sonRes;
} else { // son was split into two nodes
// update first son
BasicNode<3>* firstSon = readNode(sonRes.first);
Entry<3, InnerInfo> newSon1(firstSon->getBox(), sonRes.first);
BasicNode<3>* secondSon = readNode(sonRes.second);
Entry<3, InnerInfo> newSon2(secondSon->getBox(), sonRes.second);
delete firstSon;
delete secondSon;
iroot->updateEntry(sonIndex, newSon1);
if(!iroot->insert(newSon2)){ // root has space enough
updateNode(rootId, *iroot);
sonRes.first = rootId;
sonRes.second = 0;
delete iroot;
return sonRes;
} else {
QNodeSplitter<3, InnerInfo> ns;
std::pair<Node<3, InnerInfo>*, Node<3, InnerInfo>* > nodes =
ns.splitNode(*iroot);
delete iroot;
updateNode(rootId, *(nodes.first));
sonRes.first = rootId;
sonRes.second = saveNode(*(nodes.second));
delete nodes.first;
delete nodes.second;
return sonRes;
}
}
}
}
};
/*
9 classes for a tree traversal
9.1 Iterator element
Using an iterator implementation, instances of obkjects of this class
will be returned as return values.
*/
template<int Dim>
class IteratorElement{
public:
/*
~Constructors~
*/
IteratorElement(): ownId(0),parentId(0), node(0), level(0){}
IteratorElement(SmiRecordId ownId1,
SmiRecordId parentId1,
BasicNode<Dim>* node1,
int level1): ownId(ownId1), parentId(parentId1),
node(node1), level(level1) {}
IteratorElement( const IteratorElement<Dim>& s):
ownId(s.ownId), parentId(s.parentId),
node(s.node), level(s.level) {}
/*
Assignment operator
*/
IteratorElement<Dim>& operator=(const IteratorElement<Dim>& s){
ownId = s.ownId;
parentId = s.parentId;
node = s.node;
level = s.level;
return *this;
}
/*
~Destructor~
*/
~IteratorElement(){}
void deleteNode(){
if(node){
delete node;
node = 0;
}
}
/*
~Getter~
*/
SmiRecordId getOwnId() const{ return ownId; }
SmiRecordId getParentId() const {return parentId;}
BasicNode<Dim>* getNode() const { return node; }
int getLevel() const { return level; }
/*
~print~
*/
std::ostream& print(std::ostream& os){
return os << "ownId = " << ownId << ", parentId = "
<< parentId << ", level = " << level;
}
private:
SmiRecordId ownId; // id of the node
SmiRecordId parentId; // parent id, 0 if root
BasicNode<Dim>* node; // the node
int level; // level (0 = root)
};
/*
Class PathElement
For internal use within the DepthSearch class.
*/
template<int Dim>
class PathElement: public IteratorElement<Dim>{
public:
PathElement(SmiRecordId ownId,
SmiRecordId parentId,
BasicNode<Dim>* node,
int level): IteratorElement<Dim>(ownId, parentId, node, level),
pos(0), used(false) {}
PathElement(const PathElement<Dim>& p): IteratorElement<Dim>(p),
pos(p.pos), used(p.used){}
PathElement<Dim>& operator=(const PathElement<Dim>& s){
IteratorElement<Dim>::operator=(s);
pos = s.pos;
used = s.used;
return *this;
}
std::ostream& print(std::ostream& os){
return IteratorElement<Dim>::print(os) << " , pos = "
<< pos << ", used = " << used;
}
int pos;
bool used;
};
/*
Class NoPruner
Prunes no entry.
*/
template<class InnerNode>
class NoPruner{
public:
inline bool prune(const InnerNode& node, const int pos) const{
return false;
}
};
/*
Class IntersectsPruner
Prunes all entries whose bounding box does not intersect the
rectangle given in construction of this class.
*/
template<unsigned Dim, class InnerNode>
class IntersectsPruner{
public:
IntersectsPruner(const Rectangle<Dim> rect1): rect(rect1){}
inline bool prune(const InnerNode& node, const int pos) const{
return !rect.Intersects(node.getEntry(pos)->getBox());
}
Rectangle<Dim> getBox() const{
return rect;
}
private:
Rectangle<Dim> rect;
};
/*
Class DepthSearc
This is an iterator class which performs a depth search on a tree.
By setting Select and Prune classes this class can be used in a
flexible way.
*/
template<class Tree, class InnerNode, int Dim, class Select, class Pruner>
class DepthSearch{
public:
/*
~Constructor~
*/
DepthSearch(Tree* tree1, const Select& select1, const Pruner pruner1):
tree(tree1), select(select1), pruner(pruner1){
SmiRecordId rid = tree->getRootId();
if(rid){
init(rid);
}
}
/*
~Next~
Returns the next node.
*/
bool next(IteratorElement<Dim>& result){
if(path.empty()){
return false;
}
return next1(result);
}
/*
~finish~
Destroys local variables.
*/
void finish(){
while(!path.empty()){
PathElement<Dim> p = path.top();
delete p.getNode();
path.pop();
}
}
std::stack<PathElement<Dim> > getPath()
{
return path;
}
private:
Tree* tree;
std::stack<PathElement<Dim> > path;
Select select;
Pruner pruner;
/* puts the root of the tree to the path */
void init(SmiRecordId rid){
BasicNode<Dim>* root = tree->getNode(rid);
PathElement<Dim> p(rid, 0, root , 0);
path.push(p);
}
/* gets the next objects */
bool next1(IteratorElement<Dim>& result){
while(!path.empty()){
PathElement<Dim> top = path.top();
if(!(top.used) ){
path.pop();
top.used = true;
path.push(top);
if(select(top.getNode())){
IteratorElement<Dim> r(top.getOwnId(), top.getParentId(),
top.getNode()->clone(),top.getLevel());
result = r;
return true;
}
}
if(top.getNode()->isLeaf()){ // used leaf found
path.pop();
delete top.getNode();
if(path.empty()){
return false;
} else {
top = path.top();
top.pos++;
path.pop();
path.push(top);
}
}
// p contains an inner node
while(top.pos == top.getNode()->entryCount()){ // no more sons available
path.pop();
delete top.getNode();
if(path.empty()){
return false;
} else {
top = path.top();
top.pos++;
path.pop();
path.push(top);
}
}
InnerNode* in = dynamic_cast<InnerNode*>(top.getNode());
if(!pruner.prune(*in, top.pos)){
SmiRecordId sonId = in->getEntry(top.pos)->getInfo().getPointer();
BasicNode<Dim>* son = tree->getNode(sonId);
PathElement<Dim> p(sonId, top.getOwnId(), son , top.getLevel()+1);
path.push(p);
} else {
path.pop();
top.pos++;
path.push(top);
}
}
return false;
}
};
} // end of namespace tbtree
#endif
Reference in New Issue Copy Permalink