mirror of
https://github.com/MCLx86/xtreemtest.git
synced 2025-06-10 17:48:49 +02:00
508 lines
13 KiB
C++
508 lines
13 KiB
C++
/******************************************************************************
|
|
* Project: libspatialindex - A C++ library for spatial indexing
|
|
* Author: Marios Hadjieleftheriou, mhadji@gmail.com
|
|
******************************************************************************
|
|
* Copyright (c) 2004, Marios Hadjieleftheriou
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
******************************************************************************/
|
|
|
|
#pragma once
|
|
|
|
|
|
#if (defined _WIN32 || defined _WIN64 || defined WIN32 || defined WIN64) && !defined __GNUC__
|
|
typedef __int8 int8_t;
|
|
typedef __int16 int16_t;
|
|
typedef __int32 int32_t;
|
|
typedef __int64 int64_t;
|
|
typedef unsigned __int8 uint8_t;
|
|
typedef unsigned __int16 uint16_t;
|
|
typedef unsigned __int32 uint32_t;
|
|
typedef unsigned __int64 uint64_t;
|
|
|
|
// Nuke this annoying warning. See http://www.unknownroad.com/rtfm/VisualStudio/warningC4251.html
|
|
#pragma warning( disable: 4251 )
|
|
|
|
#else
|
|
#include <stdint.h>
|
|
#endif
|
|
|
|
#if (defined _WIN32 || defined _WIN64 || defined WIN32 || defined WIN64) && !defined __GNUC__
|
|
#ifdef SPATIALINDEX_CREATE_DLL
|
|
#define SIDX_DLL __declspec(dllexport)
|
|
#else
|
|
#define SIDX_DLL __declspec(dllimport)
|
|
#endif
|
|
#else
|
|
#define SIDX_DLL
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <iterator>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <queue>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <set>
|
|
#include <stack>
|
|
#include <list>
|
|
#include <algorithm>
|
|
#include <cwchar>
|
|
|
|
#if HAVE_PTHREAD_H
|
|
#include <pthread.h>
|
|
#endif
|
|
|
|
#include "SmartPointer.h"
|
|
#include "PointerPool.h"
|
|
#include "PoolPointer.h"
|
|
|
|
typedef uint8_t byte;
|
|
|
|
namespace Tools
|
|
{
|
|
SIDX_DLL enum IntervalType
|
|
{
|
|
IT_RIGHTOPEN = 0x0,
|
|
IT_LEFTOPEN,
|
|
IT_OPEN,
|
|
IT_CLOSED
|
|
};
|
|
|
|
SIDX_DLL enum VariantType
|
|
{
|
|
VT_LONG = 0x0,
|
|
VT_BYTE,
|
|
VT_SHORT,
|
|
VT_FLOAT,
|
|
VT_DOUBLE,
|
|
VT_CHAR,
|
|
VT_USHORT,
|
|
VT_ULONG,
|
|
VT_INT,
|
|
VT_UINT,
|
|
VT_BOOL,
|
|
VT_PCHAR,
|
|
VT_PVOID,
|
|
VT_EMPTY,
|
|
VT_LONGLONG,
|
|
VT_ULONGLONG,
|
|
VT_PWCHAR
|
|
};
|
|
|
|
SIDX_DLL enum FileMode
|
|
{
|
|
APPEND = 0x0,
|
|
CREATE
|
|
};
|
|
|
|
//
|
|
// Exceptions
|
|
//
|
|
class SIDX_DLL Exception
|
|
{
|
|
public:
|
|
virtual std::string what() = 0;
|
|
virtual ~Exception() {}
|
|
};
|
|
|
|
class SIDX_DLL IndexOutOfBoundsException : public Exception
|
|
{
|
|
public:
|
|
IndexOutOfBoundsException(size_t i);
|
|
virtual ~IndexOutOfBoundsException() {}
|
|
virtual std::string what();
|
|
|
|
private:
|
|
std::string m_error;
|
|
}; // IndexOutOfBoundsException
|
|
|
|
class SIDX_DLL IllegalArgumentException : public Exception
|
|
{
|
|
public:
|
|
IllegalArgumentException(std::string s);
|
|
virtual ~IllegalArgumentException() {}
|
|
virtual std::string what();
|
|
|
|
private:
|
|
std::string m_error;
|
|
}; // IllegalArgumentException
|
|
|
|
class SIDX_DLL IllegalStateException : public Exception
|
|
{
|
|
public:
|
|
IllegalStateException(std::string s);
|
|
virtual ~IllegalStateException() {}
|
|
virtual std::string what();
|
|
|
|
private:
|
|
std::string m_error;
|
|
}; // IllegalStateException
|
|
|
|
class SIDX_DLL EndOfStreamException : public Exception
|
|
{
|
|
public:
|
|
EndOfStreamException(std::string s);
|
|
virtual ~EndOfStreamException() {}
|
|
virtual std::string what();
|
|
|
|
private:
|
|
std::string m_error;
|
|
}; // EndOfStreamException
|
|
|
|
class SIDX_DLL ResourceLockedException : public Exception
|
|
{
|
|
public:
|
|
ResourceLockedException(std::string s);
|
|
virtual ~ResourceLockedException() {}
|
|
virtual std::string what();
|
|
|
|
private:
|
|
std::string m_error;
|
|
}; // ResourceLockedException
|
|
|
|
class SIDX_DLL NotSupportedException : public Exception
|
|
{
|
|
public:
|
|
NotSupportedException(std::string s);
|
|
virtual ~NotSupportedException() {}
|
|
virtual std::string what();
|
|
|
|
private:
|
|
std::string m_error;
|
|
}; // NotSupportedException
|
|
|
|
//
|
|
// Interfaces
|
|
//
|
|
class SIDX_DLL IInterval
|
|
{
|
|
public:
|
|
virtual ~IInterval() {}
|
|
|
|
virtual double getLowerBound() const = 0;
|
|
virtual double getUpperBound() const = 0;
|
|
virtual void setBounds(double, double) = 0;
|
|
virtual bool intersectsInterval(const IInterval&) const = 0;
|
|
virtual bool intersectsInterval(IntervalType type, const double start, const double end) const = 0;
|
|
virtual bool containsInterval(const IInterval&) const = 0;
|
|
virtual IntervalType getIntervalType() const = 0;
|
|
}; // IInterval
|
|
|
|
class SIDX_DLL IObject
|
|
{
|
|
public:
|
|
virtual ~IObject() {}
|
|
|
|
virtual IObject* clone() = 0;
|
|
// return a new object that is an exact copy of this one.
|
|
// IMPORTANT: do not return the this pointer!
|
|
}; // IObject
|
|
|
|
class SIDX_DLL ISerializable
|
|
{
|
|
public:
|
|
virtual ~ISerializable() {}
|
|
|
|
virtual uint32_t getByteArraySize() = 0;
|
|
// returns the size of the required byte array.
|
|
virtual void loadFromByteArray(const byte* data) = 0;
|
|
// load this object using the byte array.
|
|
virtual void storeToByteArray(byte** data, uint32_t& length) = 0;
|
|
// store this object in the byte array.
|
|
};
|
|
|
|
class SIDX_DLL IComparable
|
|
{
|
|
public:
|
|
virtual ~IComparable() {}
|
|
|
|
virtual bool operator<(const IComparable& o) const = 0;
|
|
virtual bool operator>(const IComparable& o) const = 0;
|
|
virtual bool operator==(const IComparable& o) const = 0;
|
|
}; //IComparable
|
|
|
|
class SIDX_DLL IObjectComparator
|
|
{
|
|
public:
|
|
virtual ~IObjectComparator() {}
|
|
|
|
virtual int compare(IObject* o1, IObject* o2) = 0;
|
|
}; // IObjectComparator
|
|
|
|
class SIDX_DLL IObjectStream
|
|
{
|
|
public:
|
|
virtual ~IObjectStream() {}
|
|
|
|
virtual IObject* getNext() = 0;
|
|
// returns a pointer to the next entry in the
|
|
// stream or 0 at the end of the stream.
|
|
|
|
virtual bool hasNext() = 0;
|
|
// returns true if there are more items in the stream.
|
|
|
|
virtual uint32_t size() = 0;
|
|
// returns the total number of entries available in the stream.
|
|
|
|
virtual void rewind() = 0;
|
|
// sets the stream pointer to the first entry, if possible.
|
|
}; // IObjectStream
|
|
|
|
//
|
|
// Classes & Functions
|
|
//
|
|
|
|
class SIDX_DLL Variant
|
|
{
|
|
public:
|
|
Variant();
|
|
|
|
VariantType m_varType;
|
|
|
|
union
|
|
{
|
|
int16_t iVal; // VT_SHORT
|
|
int32_t lVal; // VT_LONG
|
|
int64_t llVal; // VT_LONGLONG
|
|
byte bVal; // VT_BYTE
|
|
float fltVal; // VT_FLOAT
|
|
double dblVal; // VT_DOUBLE
|
|
char cVal; // VT_CHAR
|
|
uint16_t uiVal; // VT_USHORT
|
|
uint32_t ulVal; // VT_ULONG
|
|
uint64_t ullVal; // VT_ULONGLONG
|
|
bool blVal; // VT_BOOL
|
|
char* pcVal; // VT_PCHAR
|
|
void* pvVal; // VT_PVOID
|
|
wchar_t* pwcVal;
|
|
} m_val;
|
|
}; // Variant
|
|
|
|
class SIDX_DLL PropertySet;
|
|
SIDX_DLL std::ostream& operator<<(std::ostream& os, const Tools::PropertySet& p);
|
|
|
|
class SIDX_DLL PropertySet : public ISerializable
|
|
{
|
|
public:
|
|
PropertySet();
|
|
PropertySet(const byte* data);
|
|
virtual ~PropertySet();
|
|
|
|
Variant getProperty(std::string property) const;
|
|
void setProperty(std::string property, Variant const& v);
|
|
void removeProperty(std::string property);
|
|
|
|
virtual uint32_t getByteArraySize();
|
|
virtual void loadFromByteArray(const byte* data);
|
|
virtual void storeToByteArray(byte** data, uint32_t& length);
|
|
|
|
private:
|
|
std::map<std::string, Variant> m_propertySet;
|
|
// #ifdef HAVE_PTHREAD_H
|
|
// pthread_rwlock_t m_rwLock;
|
|
// #else
|
|
// bool m_rwLock;
|
|
// #endif
|
|
friend SIDX_DLL std::ostream& Tools::operator<<(std::ostream& os, const Tools::PropertySet& p);
|
|
}; // PropertySet
|
|
|
|
// does not support degenerate intervals.
|
|
class SIDX_DLL Interval : public IInterval
|
|
{
|
|
public:
|
|
Interval();
|
|
Interval(IntervalType, double, double);
|
|
Interval(double, double);
|
|
Interval(const Interval&);
|
|
virtual ~Interval() {}
|
|
virtual IInterval& operator=(const IInterval&);
|
|
|
|
virtual bool operator==(const Interval&) const;
|
|
virtual bool operator!=(const Interval&) const;
|
|
virtual double getLowerBound() const;
|
|
virtual double getUpperBound() const;
|
|
virtual void setBounds(double, double);
|
|
virtual bool intersectsInterval(const IInterval&) const;
|
|
virtual bool intersectsInterval(IntervalType type, const double start, const double end) const;
|
|
virtual bool containsInterval(const IInterval&) const;
|
|
virtual IntervalType getIntervalType() const;
|
|
|
|
IntervalType m_type;
|
|
double m_low;
|
|
double m_high;
|
|
}; // Interval
|
|
|
|
SIDX_DLL std::ostream& operator<<(std::ostream& os, const Tools::Interval& iv);
|
|
|
|
class SIDX_DLL Random
|
|
{
|
|
public:
|
|
Random();
|
|
Random(uint32_t seed, uint16_t xsubi0);
|
|
virtual ~Random();
|
|
|
|
int32_t nextUniformLong();
|
|
// returns a uniformly distributed long.
|
|
uint32_t nextUniformUnsignedLong();
|
|
// returns a uniformly distributed unsigned long.
|
|
int32_t nextUniformLong(int32_t low, int32_t high);
|
|
// returns a uniformly distributed long in the range [low, high).
|
|
uint32_t nextUniformUnsignedLong(uint32_t low, uint32_t high);
|
|
// returns a uniformly distributed unsigned long in the range [low, high).
|
|
int64_t nextUniformLongLong();
|
|
// returns a uniformly distributed long long.
|
|
uint64_t nextUniformUnsignedLongLong();
|
|
// returns a uniformly distributed unsigned long long.
|
|
int64_t nextUniformLongLong(int64_t low, int64_t high);
|
|
// returns a uniformly distributed unsigned long long in the range [low, high).
|
|
uint64_t nextUniformUnsignedLongLong(uint64_t low, uint64_t high);
|
|
// returns a uniformly distributed unsigned long long in the range [low, high).
|
|
int16_t nextUniformShort();
|
|
// returns a uniformly distributed short.
|
|
uint16_t nextUniformUnsignedShort();
|
|
// returns a uniformly distributed unsigned short.
|
|
double nextUniformDouble();
|
|
// returns a uniformly distributed double in the range [0, 1).
|
|
double nextUniformDouble(double low, double high);
|
|
// returns a uniformly distributed double in the range [low, high).
|
|
|
|
bool flipCoin();
|
|
|
|
private:
|
|
void initDrand(uint32_t seed, uint16_t xsubi0);
|
|
|
|
uint16_t* m_pBuffer;
|
|
}; // Random
|
|
|
|
#if HAVE_PTHREAD_H
|
|
class SIDX_DLL LockGuard
|
|
{
|
|
public:
|
|
LockGuard(pthread_mutex_t* pLock);
|
|
~LockGuard();
|
|
|
|
private:
|
|
pthread_mutex_t* m_pLock;
|
|
}; // LockGuard
|
|
#endif
|
|
|
|
class SIDX_DLL BufferedFile
|
|
{
|
|
public:
|
|
BufferedFile(uint32_t u32BufferSize = 16384);
|
|
virtual ~BufferedFile();
|
|
|
|
virtual void close();
|
|
virtual bool eof();
|
|
virtual void rewind() = 0;
|
|
virtual void seek(std::fstream::off_type offset) = 0;
|
|
|
|
protected:
|
|
std::fstream m_file;
|
|
char* m_buffer;
|
|
uint32_t m_u32BufferSize;
|
|
bool m_bEOF;
|
|
};
|
|
|
|
class SIDX_DLL BufferedFileReader : public BufferedFile
|
|
{
|
|
public:
|
|
BufferedFileReader();
|
|
BufferedFileReader(const std::string& sFileName, uint32_t u32BufferSize = 32768);
|
|
virtual ~BufferedFileReader();
|
|
|
|
virtual void open(const std::string& sFileName);
|
|
virtual void rewind();
|
|
virtual void seek(std::fstream::off_type offset);
|
|
|
|
virtual uint8_t readUInt8();
|
|
virtual uint16_t readUInt16();
|
|
virtual uint32_t readUInt32();
|
|
virtual uint64_t readUInt64();
|
|
virtual float readFloat();
|
|
virtual double readDouble();
|
|
virtual bool readBoolean();
|
|
virtual std::string readString();
|
|
virtual void readBytes(uint32_t u32Len, byte** pData);
|
|
};
|
|
|
|
class SIDX_DLL BufferedFileWriter : public BufferedFile
|
|
{
|
|
public:
|
|
BufferedFileWriter();
|
|
BufferedFileWriter(const std::string& sFileName, FileMode mode = CREATE, uint32_t u32BufferSize = 32768);
|
|
virtual ~BufferedFileWriter();
|
|
|
|
virtual void open(const std::string& sFileName, FileMode mode = CREATE);
|
|
virtual void rewind();
|
|
virtual void seek(std::fstream::off_type offset);
|
|
|
|
virtual void write(uint8_t i);
|
|
virtual void write(uint16_t i);
|
|
virtual void write(uint32_t i);
|
|
virtual void write(uint64_t i);
|
|
virtual void write(float i);
|
|
virtual void write(double i);
|
|
virtual void write(bool b);
|
|
virtual void write(const std::string& s);
|
|
virtual void write(uint32_t u32Len, byte* pData);
|
|
};
|
|
|
|
class SIDX_DLL TemporaryFile
|
|
{
|
|
public:
|
|
TemporaryFile();
|
|
virtual ~TemporaryFile();
|
|
|
|
void rewindForReading();
|
|
void rewindForWriting();
|
|
bool eof();
|
|
std::string getFileName() const;
|
|
|
|
uint8_t readUInt8();
|
|
uint16_t readUInt16();
|
|
uint32_t readUInt32();
|
|
uint64_t readUInt64();
|
|
float readFloat();
|
|
double readDouble();
|
|
std::string readString();
|
|
void readBytes(uint32_t u32Len, byte** pData);
|
|
|
|
void write(uint8_t i);
|
|
void write(uint16_t i);
|
|
void write(uint32_t i);
|
|
void write(uint64_t i);
|
|
void write(float i);
|
|
void write(double i);
|
|
void write(const std::string& s);
|
|
void write(uint32_t u32Len, byte* pData);
|
|
|
|
private:
|
|
std::string m_sFile;
|
|
BufferedFile* m_pFile;
|
|
};
|
|
}
|