BoundsQuery.h   BoundsQuery.h 
skipping to change at line 31 skipping to change at line 31
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
class BoundsQuery : public SpatialIndex::IQueryStrategy #include "sidx_export.h"
class SIDX_DLL BoundsQuery : public SpatialIndex::IQueryStrategy
{ {
private: private:
SpatialIndex::Region* m_bounds; SpatialIndex::Region* m_bounds;
public: public:
BoundsQuery(); BoundsQuery();
~BoundsQuery() { if (m_bounds != 0) delete m_bounds; } ~BoundsQuery() { if (m_bounds != 0) delete m_bounds; }
void getNextEntry( const SpatialIndex::IEntry& entry, void getNextEntry( const SpatialIndex::IEntry& entry,
SpatialIndex::id_type& nextEntry, SpatialIndex::id_type& nextEntry,
 End of changes. 1 change blocks. 
1 lines changed or deleted 3 lines changed or added


 CountVisitor.h   CountVisitor.h 
skipping to change at line 31 skipping to change at line 31
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
class CountVisitor : public SpatialIndex::IVisitor #include "sidx_export.h"
class SIDX_DLL CountVisitor : public SpatialIndex::IVisitor
{ {
private: private:
uint64_t nResults; uint64_t nResults;
public: public:
CountVisitor(); CountVisitor();
~CountVisitor(); ~CountVisitor();
uint64_t GetResultCount() const { return nResults; } uint64_t GetResultCount() const { return nResults; }
 End of changes. 1 change blocks. 
1 lines changed or deleted 3 lines changed or added


 CustomStorage.h   CustomStorage.h 
skipping to change at line 31 skipping to change at line 31
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
#include "sidx_export.h"
namespace SpatialIndex namespace SpatialIndex
{ {
namespace StorageManager namespace StorageManager
{ {
struct CustomStorageManagerCallbacks struct SIDX_DLL CustomStorageManagerCallbacks
{ {
CustomStorageManagerCallbacks() CustomStorageManagerCallbacks()
: context(0) : context(0)
, createCallback(0) , createCallback(0)
, destroyCallback(0) , destroyCallback(0)
, loadByteArrayCallback(0) , loadByteArrayCallback(0)
, storeByteArrayCallback(0) , storeByteArrayCallback(0)
, deleteByteArrayCallback(0) , deleteByteArrayCallback(0)
{} {}
void* context; void* context;
void (*createCallback)( const void* context, int* errorCode ); void (*createCallback)( const void* context, int* errorCode );
void (*destroyCallback)( const void* context, int* errorCode ); void (*destroyCallback)( const void* context, int* errorCode );
void (*flushCallback)( const void* context, int* err orCode ); void (*flushCallback)( const void* context, int* err orCode );
void (*loadByteArrayCallback)( const void* context, const id_ty pe page, uint32_t* len, byte** data, int* errorCode ); void (*loadByteArrayCallback)( const void* context, const id_ty pe page, uint32_t* len, byte** data, int* errorCode );
void (*storeByteArrayCallback)( const void* context, id_type* p age, const uint32_t len, const byte* const data, int* errorCode ); void (*storeByteArrayCallback)( const void* context, id_type* p age, const uint32_t len, const byte* const data, int* errorCode );
void (*deleteByteArrayCallback)( const void* context, const id_ type page, int* errorCode ); void (*deleteByteArrayCallback)( const void* context, const id_ type page, int* errorCode );
}; };
class CustomStorageManager : public SpatialIndex::IStorageManager class SIDX_DLL CustomStorageManager : public SpatialIndex::IStorage Manager
{ {
public: public:
// I'd like this to be an enum, but casting between enums and i nts is not nice // I'd like this to be an enum, but casting between enums and i nts is not nice
static const int NoError = 0; static const int NoError = 0;
static const int InvalidPageError = 1; static const int InvalidPageError = 1;
static const int IllegalStateError = 2; static const int IllegalStateError = 2;
CustomStorageManager(Tools::PropertySet&); CustomStorageManager(Tools::PropertySet&);
virtual ~CustomStorageManager(); virtual ~CustomStorageManager();
 End of changes. 3 change blocks. 
2 lines changed or deleted 4 lines changed or added


 DataStream.h   DataStream.h 
skipping to change at line 31 skipping to change at line 31
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
class DataStream : public SpatialIndex::IDataStream #include "sidx_export.h"
class SIDX_DLL DataStream : public SpatialIndex::IDataStream
{ {
public: public:
DataStream(int (*readNext)(SpatialIndex::id_type* id, double **pMin, do uble **pMax, uint32_t *nDimension, const uint8_t **pData, uint32_t *nDataLe ngth)); DataStream(int (*readNext)(SpatialIndex::id_type* id, double **pMin, do uble **pMax, uint32_t *nDimension, const uint8_t **pData, uint32_t *nDataLe ngth));
~DataStream(); ~DataStream();
SpatialIndex::IData* getNext(); SpatialIndex::IData* getNext();
bool hasNext() throw (Tools::NotSupportedException); bool hasNext();
uint32_t size() throw (Tools::NotSupportedException); uint32_t size();
void rewind() throw (Tools::NotSupportedException); void rewind();
protected: protected:
SpatialIndex::RTree::Data* m_pNext; SpatialIndex::RTree::Data* m_pNext;
SpatialIndex::id_type m_id; SpatialIndex::id_type m_id;
private: private:
int (*iterfunct)(SpatialIndex::id_type *id, double **pMin, double **pMa x, uint32_t *nDimension, const uint8_t **pData, uint32_t *nDataLength); int (*iterfunct)(SpatialIndex::id_type *id, double **pMin, double **pMa x, uint32_t *nDimension, const uint8_t **pData, uint32_t *nDataLength);
bool readData(); bool readData();
bool m_bDoneReading; bool m_bDoneReading;
 End of changes. 3 change blocks. 
4 lines changed or deleted 6 lines changed or added


 Error.h   Error.h 
skipping to change at line 31 skipping to change at line 31
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
class Error #include "sidx_export.h"
class SIDX_DLL Error
{ {
public: public:
Error(int code, std::string const& message, std::string const& method); Error(int code, std::string const& message, std::string const& method);
/// Copy constructor. /// Copy constructor.
Error(Error const& other); Error(Error const& other);
/// Assignment operator. /// Assignment operator.
Error& operator=(Error const& rhs); Error& operator=(Error const& rhs);
 End of changes. 1 change blocks. 
1 lines changed or deleted 3 lines changed or added


 IdVisitor.h   IdVisitor.h 
skipping to change at line 31 skipping to change at line 31
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
class IdVisitor : public SpatialIndex::IVisitor #include "sidx_export.h"
class SIDX_DLL IdVisitor : public SpatialIndex::IVisitor
{ {
private: private:
std::vector<uint64_t> m_vector; std::vector<uint64_t> m_vector;
uint64_t nResults; uint64_t nResults;
public: public:
IdVisitor(); IdVisitor();
~IdVisitor(); ~IdVisitor();
 End of changes. 1 change blocks. 
1 lines changed or deleted 3 lines changed or added


 Index.h   Index.h 
skipping to change at line 31 skipping to change at line 31
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
class Index #include "sidx_export.h"
class SIDX_DLL Index
{ {
public: public:
Index(const Tools::PropertySet& poProperties); Index(Tools::PropertySet& poProperties);
Index(const Tools::PropertySet& poProperties, int (*readNext)(SpatialIn Index(Tools::PropertySet& poProperties, int (*readNext)(SpatialIndex::i
dex::id_type *id, double **pMin, double **pMax, uint32_t *nDimension, const d_type *id, double **pMin, double **pMax, uint32_t *nDimension, const uint8
uint8_t **pData, uint32_t *nDataLength)); _t **pData, uint32_t *nDataLength));
~Index(); ~Index();
const Tools::PropertySet& GetProperties() { return m_properties; } const Tools::PropertySet& GetProperties() { return m_properties; }
bool insertFeature(uint64_t id, double *min, double *max); bool insertFeature(uint64_t id, double *min, double *max);
RTIndexType GetIndexType(); RTIndexType GetIndexType();
void SetIndexType(RTIndexType v); void SetIndexType(RTIndexType v);
RTStorageType GetIndexStorage(); RTStorageType GetIndexStorage();
void SetIndexStorage(RTStorageType v); void SetIndexStorage(RTStorageType v);
RTIndexVariant GetIndexVariant(); RTIndexVariant GetIndexVariant();
void SetIndexVariant(RTStorageType v); void SetIndexVariant(RTStorageType v);
int64_t GetResultSetOffset();
void SetResultSetOffset(int64_t v);
int64_t GetResultSetLimit();
void SetResultSetLimit(int64_t v);
void flush();
SpatialIndex::ISpatialIndex& index() {return *m_rtree;} SpatialIndex::ISpatialIndex& index() {return *m_rtree;}
SpatialIndex::StorageManager::IBuffer& buffer() {return *m_buffer;} SpatialIndex::StorageManager::IBuffer& buffer() {return *m_buffer;}
private: private:
Index& operator=(const Index&);
Index();
void Initialize(); void Initialize();
SpatialIndex::IStorageManager* m_storage; SpatialIndex::IStorageManager* m_storage;
SpatialIndex::StorageManager::IBuffer* m_buffer; SpatialIndex::StorageManager::IBuffer* m_buffer;
SpatialIndex::ISpatialIndex* m_rtree; SpatialIndex::ISpatialIndex* m_rtree;
Tools::PropertySet m_properties; Tools::PropertySet& m_properties;
void Setup(); void Setup();
SpatialIndex::IStorageManager* CreateStorage(); SpatialIndex::IStorageManager* CreateStorage();
SpatialIndex::StorageManager::IBuffer* CreateIndexBuffer(SpatialIndex:: IStorageManager& storage); SpatialIndex::StorageManager::IBuffer* CreateIndexBuffer(SpatialIndex:: IStorageManager& storage);
SpatialIndex::ISpatialIndex* CreateIndex(); SpatialIndex::ISpatialIndex* CreateIndex();
}; };
 End of changes. 5 change blocks. 
6 lines changed or deleted 19 lines changed or added


 LeafQuery.h   LeafQuery.h 
skipping to change at line 31 skipping to change at line 31
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
#include "sidx_export.h"
class LeafQueryResult; class LeafQueryResult;
class LeafQuery : public SpatialIndex::IQueryStrategy class SIDX_DLL LeafQuery : public SpatialIndex::IQueryStrategy
{ {
private: private:
std::queue<SpatialIndex::id_type> m_ids; std::queue<SpatialIndex::id_type> m_ids;
std::vector<LeafQueryResult> m_results; std::vector<LeafQueryResult> m_results;
public: public:
LeafQuery(); LeafQuery();
~LeafQuery() { } ~LeafQuery() { }
void getNextEntry( const SpatialIndex::IEntry& entry, void getNextEntry( const SpatialIndex::IEntry& entry,
SpatialIndex::id_type& nextE ntry, SpatialIndex::id_type& nextE ntry,
bool& hasNext); bool& hasNext);
std::vector<LeafQueryResult> const& GetResults() const {return m_res ults;} std::vector<LeafQueryResult> const& GetResults() const {return m_res ults;}
}; };
class LeafQueryResult class SIDX_DLL LeafQueryResult
{ {
private: private:
std::vector<SpatialIndex::id_type> ids; std::vector<SpatialIndex::id_type> ids;
SpatialIndex::Region* bounds; SpatialIndex::Region* bounds;
uint32_t m_id; SpatialIndex::id_type m_id;
LeafQueryResult(); LeafQueryResult();
public: public:
LeafQueryResult(uint32_t id) : bounds(0), m_id(id){} LeafQueryResult(SpatialIndex::id_type id) : bounds(0), m_id(id){}
~LeafQueryResult() {if (bounds!=0) delete bounds;} ~LeafQueryResult() {if (bounds!=0) delete bounds;}
/// Copy constructor. /// Copy constructor.
LeafQueryResult(LeafQueryResult const& other); LeafQueryResult(LeafQueryResult const& other);
/// Assignment operator. /// Assignment operator.
LeafQueryResult& operator=(LeafQueryResult const& rhs); LeafQueryResult& operator=(LeafQueryResult const& rhs);
std::vector<SpatialIndex::id_type> const& GetIDs() const; std::vector<SpatialIndex::id_type> const& GetIDs() const;
void SetIDs(std::vector<SpatialIndex::id_type>& v); void SetIDs(std::vector<SpatialIndex::id_type>& v);
const SpatialIndex::Region* GetBounds() const; const SpatialIndex::Region* GetBounds() const;
void SetBounds(const SpatialIndex::Region* b); void SetBounds(const SpatialIndex::Region* b);
uint32_t getIdentifier() const {return m_id;} SpatialIndex::id_type getIdentifier() const {return m_id;}
void setIdentifier(uint32_t v) {m_id = v;} void setIdentifier(uint32_t v) {m_id = v;}
}; };
 End of changes. 6 change blocks. 
5 lines changed or deleted 7 lines changed or added


 ObjVisitor.h   ObjVisitor.h 
skipping to change at line 31 skipping to change at line 31
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
class ObjVisitor : public SpatialIndex::IVisitor #include "sidx_export.h"
class SIDX_DLL ObjVisitor : public SpatialIndex::IVisitor
{ {
private: private:
std::vector<SpatialIndex::IData*> m_vector; std::vector<SpatialIndex::IData*> m_vector;
uint64_t nResults; uint64_t nResults;
public: public:
ObjVisitor(); ObjVisitor();
~ObjVisitor(); ~ObjVisitor();
uint32_t GetResultCount() const { return nResults; } uint64_t GetResultCount() const { return nResults; }
std::vector<SpatialIndex::IData*>& GetResults() { return m_vector; } std::vector<SpatialIndex::IData*>& GetResults() { return m_vector; }
void visitNode(const SpatialIndex::INode& n); void visitNode(const SpatialIndex::INode& n);
void visitData(const SpatialIndex::IData& d); void visitData(const SpatialIndex::IData& d);
void visitData(std::vector<const SpatialIndex::IData*>& v); void visitData(std::vector<const SpatialIndex::IData*>& v);
}; };
 End of changes. 2 change blocks. 
2 lines changed or deleted 4 lines changed or added


 SpatialIndex.h   SpatialIndex.h 
skipping to change at line 160 skipping to change at line 160
virtual double getMinimumDistance(const IShape& query, const IData& data) = 0; virtual double getMinimumDistance(const IShape& query, const IData& data) = 0;
virtual ~INearestNeighborComparator() {} virtual ~INearestNeighborComparator() {}
}; // INearestNeighborComparator }; // INearestNeighborComparator
class SIDX_DLL IStorageManager class SIDX_DLL IStorageManager
{ {
public: public:
virtual void loadByteArray(const id_type id, uint32_t& len, byte** data) = 0; virtual void loadByteArray(const id_type id, uint32_t& len, byte** data) = 0;
virtual void storeByteArray(id_type& id, const uint32_t len, const byte* const data) = 0; virtual void storeByteArray(id_type& id, const uint32_t len, const byte* const data) = 0;
virtual void deleteByteArray(const id_type id) = 0; virtual void deleteByteArray(const id_type id) = 0;
virtual void flush() = 0;
virtual ~IStorageManager() {} virtual ~IStorageManager() {}
}; // IStorageManager }; // IStorageManager
class SIDX_DLL IVisitor class SIDX_DLL IVisitor
{ {
public: public:
virtual void visitNode(const INode& in) = 0; virtual void visitNode(const INode& in) = 0;
virtual void visitData(const IData& in) = 0; virtual void visitData(const IData& in) = 0;
virtual void visitData(std::vector<const IData*>& v) = 0; virtual void visitData(std::vector<const IData*>& v) = 0;
virtual ~IVisitor() {} virtual ~IVisitor() {}
 End of changes. 1 change blocks. 
0 lines changed or deleted 1 lines changed or added


 TPRTree.h   TPRTree.h 
skipping to change at line 36 skipping to change at line 36
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
namespace SpatialIndex namespace SpatialIndex
{ {
namespace TPRTree namespace TPRTree
{ {
SIDX_DLL enum TPRTreeVariant SIDX_DLL enum TPRTreeVariant
{ {
TPRV_RSTAR = 0x0 TPRV_RSTAR = 0x2
}; };
SIDX_DLL enum PersistenObjectIdentifier SIDX_DLL enum PersistenObjectIdentifier
{ {
PersistentIndex = 0x1, PersistentIndex = 0x1,
PersistentLeaf = 0x2 PersistentLeaf = 0x2
}; };
SIDX_DLL enum RangeQueryType SIDX_DLL enum RangeQueryType
{ {
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 Tools.h   Tools.h 
skipping to change at line 71 skipping to change at line 71
#include <string> #include <string>
#include <sstream> #include <sstream>
#include <fstream> #include <fstream>
#include <queue> #include <queue>
#include <vector> #include <vector>
#include <map> #include <map>
#include <set> #include <set>
#include <stack> #include <stack>
#include <list> #include <list>
#include <algorithm> #include <algorithm>
// #include <cmath> #include <cwchar>
// #include <limits>
// #include <climits>
#if HAVE_PTHREAD_H #if HAVE_PTHREAD_H
#include <pthread.h> #include <pthread.h>
#endif #endif
#include "SmartPointer.h" #include "SmartPointer.h"
#include "PointerPool.h" #include "PointerPool.h"
#include "PoolPointer.h" #include "PoolPointer.h"
typedef uint8_t byte; typedef uint8_t byte;
skipping to change at line 112 skipping to change at line 110
VT_CHAR, VT_CHAR,
VT_USHORT, VT_USHORT,
VT_ULONG, VT_ULONG,
VT_INT, VT_INT,
VT_UINT, VT_UINT,
VT_BOOL, VT_BOOL,
VT_PCHAR, VT_PCHAR,
VT_PVOID, VT_PVOID,
VT_EMPTY, VT_EMPTY,
VT_LONGLONG, VT_LONGLONG,
VT_ULONGLONG VT_ULONGLONG,
}; VT_PWCHAR
};
SIDX_DLL enum FileMode SIDX_DLL enum FileMode
{ {
APPEND = 0x0, APPEND = 0x0,
CREATE CREATE
}; };
// //
// Exceptions // Exceptions
// //
skipping to change at line 300 skipping to change at line 299
byte bVal; // VT_BYTE byte bVal; // VT_BYTE
float fltVal; // VT_FLOAT float fltVal; // VT_FLOAT
double dblVal; // VT_DOUBLE double dblVal; // VT_DOUBLE
char cVal; // VT_CHAR char cVal; // VT_CHAR
uint16_t uiVal; // VT_USHORT uint16_t uiVal; // VT_USHORT
uint32_t ulVal; // VT_ULONG uint32_t ulVal; // VT_ULONG
uint64_t ullVal; // VT_ULONGLONG uint64_t ullVal; // VT_ULONGLONG
bool blVal; // VT_BOOL bool blVal; // VT_BOOL
char* pcVal; // VT_PCHAR char* pcVal; // VT_PCHAR
void* pvVal; // VT_PVOID void* pvVal; // VT_PVOID
wchar_t* pwcVal;
} m_val; } m_val;
}; // Variant }; // Variant
class SIDX_DLL PropertySet; class SIDX_DLL PropertySet;
SIDX_DLL std::ostream& operator<<(std::ostream& os, const Tools::Pro pertySet& p); SIDX_DLL std::ostream& operator<<(std::ostream& os, const Tools::Pro pertySet& p);
class SIDX_DLL PropertySet : public ISerializable class SIDX_DLL PropertySet : public ISerializable
{ {
public: public:
PropertySet(); PropertySet();
PropertySet(const byte* data); PropertySet(const byte* data);
virtual ~PropertySet(); virtual ~PropertySet();
Variant getProperty(std::string property); Variant getProperty(std::string property) const;
void setProperty(std::string property, Variant& v); void setProperty(std::string property, Variant const& v);
void removeProperty(std::string property); void removeProperty(std::string property);
virtual uint32_t getByteArraySize(); virtual uint32_t getByteArraySize();
virtual void loadFromByteArray(const byte* data); virtual void loadFromByteArray(const byte* data);
virtual void storeToByteArray(byte** data, uint32_t& length) ; virtual void storeToByteArray(byte** data, uint32_t& length) ;
private: private:
std::map<std::string, Variant> m_propertySet; std::map<std::string, Variant> m_propertySet;
#ifdef HAVE_PTHREAD_H // #ifdef HAVE_PTHREAD_H
pthread_rwlock_t m_rwLock; // pthread_rwlock_t m_rwLock;
#else // #else
bool m_rwLock; // bool m_rwLock;
#endif // #endif
friend SIDX_DLL std::ostream& Tools::operator<<(std::ostream & os, const Tools::PropertySet& p); friend SIDX_DLL std::ostream& Tools::operator<<(std::ostream & os, const Tools::PropertySet& p);
}; // PropertySet }; // PropertySet
// does not support degenerate intervals. // does not support degenerate intervals.
class SIDX_DLL Interval : public IInterval class SIDX_DLL Interval : public IInterval
{ {
public: public:
Interval(); Interval();
Interval(IntervalType, double, double); Interval(IntervalType, double, double);
Interval(double, double); Interval(double, double);
 End of changes. 5 change blocks. 
12 lines changed or deleted 12 lines changed or added


 Utility.h   Utility.h 
skipping to change at line 29 skipping to change at line 29
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY, * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILI TY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTH ER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#include "ObjVisitor.h"
#include "IdVisitor.h"
#include "sidx_export.h"
#pragma once #pragma once
Tools::PropertySet* GetDefaults(); SIDX_DLL Tools::PropertySet* GetDefaults();
SIDX_DLL void Page_ResultSet_Ids(IdVisitor& visitor, int64_t** ids, int64_t
nStart, int64_t nResultLimit, uint64_t* nResults);
SIDX_DLL void Page_ResultSet_Obj(ObjVisitor& visitor, IndexItemH** items, i
nt64_t nStart, int64_t nResultLimit, uint64_t* nResults);
 End of changes. 2 change blocks. 
0 lines changed or deleted 4 lines changed or added


 Version.h   Version.h 
skipping to change at line 33 skipping to change at line 33
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * 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 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE. * DEALINGS IN THE SOFTWARE.
*************************************************************************** ***/ *************************************************************************** ***/
#pragma once #pragma once
#ifndef SIDX_VERSION_MAJOR #ifndef SIDX_VERSION_MAJOR
#define SIDX_VERSION_MAJOR 1 #define SIDX_VERSION_MAJOR 1
#define SIDX_VERSION_MINOR 8 #define SIDX_VERSION_MINOR 8
#define SIDX_VERSION_REV 1 #define SIDX_VERSION_REV 2
#define SIDX_VERSION_BUILD 0 #define SIDX_VERSION_BUILD 0
#endif #endif
#ifndef SIDX_VERSION_NUM #ifndef SIDX_VERSION_NUM
#define SIDX_VERSION_NUM (SIDX_VERSION_MAJOR*1000+SIDX_VERSION_MINOR*1 00+SIDX_VERSION_REV*10+SIDX_VERSION_BUILD) #define SIDX_VERSION_NUM (SIDX_VERSION_MAJOR*1000+SIDX_VERSION_MINOR*1 00+SIDX_VERSION_REV*10+SIDX_VERSION_BUILD)
#endif #endif
#ifndef SIDX_RELEASE_DATE #ifndef SIDX_RELEASE_DATE
#define SIDX_RELEASE_DATE 20130626 #define SIDX_RELEASE_DATE 20140728
#endif #endif
#ifndef SIDX_RELEASE_NAME #ifndef SIDX_RELEASE_NAME
#define SIDX_RELEASE_NAME "1.8.1" #define SIDX_RELEASE_NAME "1.8.2"
#endif #endif
 End of changes. 3 change blocks. 
3 lines changed or deleted 3 lines changed or added


 sidx_api.h   sidx_api.h 
skipping to change at line 53 skipping to change at line 53
SIDX_DLL void Index_Destroy(IndexH index); SIDX_DLL void Index_Destroy(IndexH index);
SIDX_DLL IndexPropertyH Index_GetProperties(IndexH index); SIDX_DLL IndexPropertyH Index_GetProperties(IndexH index);
SIDX_DLL RTError Index_DeleteData( IndexH index, SIDX_DLL RTError Index_DeleteData( IndexH index,
int6 4_t id, int6 4_t id,
doub le* pdMin, doub le* pdMin,
doub le* pdMax, doub le* pdMax,
uint 32_t nDimension); uint 32_t nDimension);
SIDX_C_DLL RTError Index_DeleteTPData( IndexH index,
int64_t id,
double* pdMin,
double* pdMax,
double* pdVMin,
double* pdVMax,
double tStart,
double tEnd,
uint32_t nDimension
);
SIDX_C_DLL RTError Index_DeleteMVRData( IndexH index,
int6
4_t id,
doub
le* pdMin,
doub
le* pdMax,
doub
le tStart,
doub
le tEnd,
uint
32_t nDimension
);
SIDX_DLL RTError Index_InsertData( IndexH index, SIDX_DLL RTError Index_InsertData( IndexH index,
int6 4_t id, int6 4_t id,
doub le* pdMin, doub le* pdMin,
doub le* pdMax, doub le* pdMax,
uint 32_t nDimension, uint 32_t nDimension,
cons t uint8_t* pData, cons t uint8_t* pData,
size _t nDataLength); size _t nDataLength);
SIDX_C_DLL RTError Index_InsertTPData( IndexH index,
int64_t id,
double* pdMin,
double* pdMax,
double* pdVMin,
double* pdVMax,
double tStart,
double tEnd,
uint32_t nDimension,
const uint8_t* pData,
size_t nDataLength);
SIDX_C_DLL RTError Index_InsertMVRData( IndexH index,
int64_t id,
double* pdMin,
double* pdMax,
double tStart,
double tEnd,
uint32_t nDimension,
const uint8_t* pData,
size_t nDataLength);
SIDX_DLL uint32_t Index_IsValid(IndexH index); SIDX_DLL uint32_t Index_IsValid(IndexH index);
SIDX_C_DLL RTError Index_TPIntersects_obj( IndexH index,
double* pdMin,
double* pdMax,
double* pdVMin,
double* pdVMax,
double tStart,
double tEnd,
uint32_t nDimension,
IndexItemH** items,
uint64_t* nResults);
SIDX_C_DLL RTError Index_MVRIntersects_obj( IndexH index,
double* pdMin,
double* pdMax,
double tStart,
double tEnd,
uint32_t nDimension,
IndexItemH** items,
uint64_t* nResults);
SIDX_DLL RTError Index_Intersects_obj( IndexH index, SIDX_DLL RTError Index_Intersects_obj( IndexH index,
double* pdMin, double* pdMin,
double* pdMax, double* pdMax,
uint32_t nDimension, uint32_t nDimension,
IndexItemH** items, IndexItemH** items,
uint64_t* nResults); uint64_t* nResults);
SIDX_C_DLL RTError Index_TPIntersects_id( IndexH index,
double* pdMin,
double* pdMax,
double* pdVMin,
double* pdVMax,
double tStart,
double tEnd,
uint32_t nDimension,
int64_t** ids,
uint64_t* nResults);
SIDX_C_DLL RTError Index_MVRIntersects_id( IndexH index,
double* pdMin,
double* pdMax,
double tStart,
double tEnd,
uint32_t nDimension,
int64_t** ids,
uint64_t* nResults);
SIDX_DLL RTError Index_Intersects_id( IndexH index, SIDX_DLL RTError Index_Intersects_id( IndexH index,
double* pdMin, double* pdMin,
double* pdMax, double* pdMax,
uint32_t nDimension, uint32_t nDimension,
int64_t** items, int64_t** items,
uint64_t* nResults); uint64_t* nResults);
SIDX_C_DLL RTError Index_TPIntersects_count( IndexH index,
double* pdMin,
double* pdMax,
double* pdVMin,
double* pdVMax,
double tStart,
double tEnd,
uint32_t nDimension,
uint64_t* nResults);
SIDX_C_DLL RTError Index_MVRIntersects_count( IndexH index,
double* pdMin,
double* pdMax,
double tStart,
double tEnd,
uint32_t nDimension,
uint64_t* nResults);
SIDX_DLL RTError Index_Intersects_count( IndexH index, SIDX_DLL RTError Index_Intersects_count( IndexH index,
double* pdMin, double* pdMin,
double* pdMax, double* pdMax,
uint32_t nDimension, uint32_t nDimension,
uint64_t* nResults); uint64_t* nResults);
SIDX_C_DLL RTError Index_TPNearestNeighbors_obj(IndexH index,
double* pdMin,
double* pdMax,
double* pdVMin,
double* pdVMax,
double tStart,
double tEnd,
uint32_t nDimension,
IndexItemH** items,
uint64_t* nResults);
SIDX_C_DLL RTError Index_MVRNearestNeighbors_obj(IndexH index,
double* pdMin,
double* pdMax,
double tStart,
double tEnd,
uint32_t nDimension,
IndexItemH** items,
uint64_t* nResults);
SIDX_DLL RTError Index_NearestNeighbors_obj(IndexH index, SIDX_DLL RTError Index_NearestNeighbors_obj(IndexH index,
double* pdMin, double* pdMin,
double* pdMax, double* pdMax,
uint32_t nDimension, uint32_t nDimension,
IndexItemH** items, IndexItemH** items,
uint64_t* nResults); uint64_t* nResults);
SIDX_C_DLL RTError Index_TPNearestNeighbors_id(IndexH index,
double* pdMin,
double* pdMax,
double* pdVMin,
double* pdVMax,
double tStart,
double tEnd,
uint32_t nDimension,
int64_t** ids,
uint64_t* nResults);
SIDX_C_DLL RTError Index_MVRNearestNeighbors_id(IndexH index,
double* pdMin,
double* pdMax,
double tStart,
double tEnd,
uint32_t nDimension,
int64_t** ids,
uint64_t* nResults);
SIDX_DLL RTError Index_NearestNeighbors_id( IndexH index, SIDX_DLL RTError Index_NearestNeighbors_id( IndexH index,
double* pdMin, double* pdMin,
double* pdMax, double* pdMax,
uint32_t nDimension, uint32_t nDimension,
int64_t** items, int64_t** items,
uint64_t* nResults); uint64_t* nResults);
SIDX_DLL RTError Index_GetBounds( IndexH index, SIDX_DLL RTError Index_GetBounds( IndexH index,
doub le** ppdMin, doub le** ppdMin,
doub le** ppdMax, doub le** ppdMax,
skipping to change at line 110 skipping to change at line 251
SIDX_C_DLL RTError Index_GetLeaves( IndexH index, SIDX_C_DLL RTError Index_GetLeaves( IndexH index,
uint 32_t* nLeafNodes, uint 32_t* nLeafNodes,
uint 32_t** nLeafSizes, uint 32_t** nLeafSizes,
int6 4_t** nLeafIDs, int6 4_t** nLeafIDs,
int6 4_t*** nLeafChildIDs, int6 4_t*** nLeafChildIDs,
doub le*** pppdMin, doub le*** pppdMin,
doub le*** pppdMax, doub le*** pppdMax,
uint 32_t* nDimension); uint 32_t* nDimension);
SIDX_DLL RTError Index_SetResultSetOffset(IndexH index, int64_t value);
SIDX_DLL int64_t Index_GetResultSetOffset(IndexH index);
SIDX_DLL RTError Index_SetResultSetLimit(IndexH index, int64_t value);
SIDX_DLL int64_t Index_GetResultSetLimit(IndexH index);
SIDX_DLL void Index_DestroyObjResults(IndexItemH* results, uint32_t nResult s); SIDX_DLL void Index_DestroyObjResults(IndexItemH* results, uint32_t nResult s);
SIDX_DLL void Index_ClearBuffer(IndexH index); SIDX_DLL void Index_ClearBuffer(IndexH index);
SIDX_DLL void Index_Free(void* object); SIDX_DLL void Index_Free(void* object);
SIDX_DLL void Index_Flush(IndexH index);
SIDX_DLL void IndexItem_Destroy(IndexItemH item); SIDX_DLL void IndexItem_Destroy(IndexItemH item);
SIDX_DLL int64_t IndexItem_GetID(IndexItemH item); SIDX_DLL int64_t IndexItem_GetID(IndexItemH item);
SIDX_DLL RTError IndexItem_GetData(IndexItemH item, uint8_t** data, uint64_ t* length); SIDX_DLL RTError IndexItem_GetData(IndexItemH item, uint8_t** data, uint64_ t* length);
SIDX_DLL RTError IndexItem_GetBounds( IndexItemH item, SIDX_DLL RTError IndexItem_GetBounds( IndexItemH item,
double** ppdMin, double** ppdMin,
double** ppdMax, double** ppdMax,
uint32_t* nDimension); uint32_t* nDimension);
skipping to change at line 208 skipping to change at line 356
SIDX_DLL RTError IndexProperty_SetCustomStorageCallbacks(IndexPropertyH ipr op, const void* value); SIDX_DLL RTError IndexProperty_SetCustomStorageCallbacks(IndexPropertyH ipr op, const void* value);
SIDX_DLL void* IndexProperty_GetCustomStorageCallbacks(IndexPropertyH iprop ); SIDX_DLL void* IndexProperty_GetCustomStorageCallbacks(IndexPropertyH iprop );
SIDX_DLL RTError IndexProperty_SetIndexID(IndexPropertyH iprop, int64_t val ue); SIDX_DLL RTError IndexProperty_SetIndexID(IndexPropertyH iprop, int64_t val ue);
SIDX_DLL int64_t IndexProperty_GetIndexID(IndexPropertyH iprop); SIDX_DLL int64_t IndexProperty_GetIndexID(IndexPropertyH iprop);
SIDX_C_DLL void* SIDX_NewBuffer(size_t bytes); SIDX_C_DLL void* SIDX_NewBuffer(size_t bytes);
SIDX_C_DLL void SIDX_DeleteBuffer(void* buffer); SIDX_C_DLL void SIDX_DeleteBuffer(void* buffer);
SIDX_DLL RTError IndexProperty_SetResultSetLimit(IndexPropertyH iprop, uint
64_t value);
SIDX_DLL uint64_t IndexProperty_GetResultSetLimit(IndexPropertyH iprop);
SIDX_C_DLL char* SIDX_Version(); SIDX_C_DLL char* SIDX_Version();
SIDX_C_DLL char* Error_GetLastErrorMsg(void);
IDX_C_END IDX_C_END
#endif #endif
 End of changes. 11 change blocks. 
0 lines changed or deleted 194 lines changed or added


 sidx_config.h   sidx_config.h 
skipping to change at line 60 skipping to change at line 60
#else #else
#include <stdint.h> #include <stdint.h>
#define SIDX_THREAD __thread #define SIDX_THREAD __thread
#include <spatialindex/SpatialIndex.h> #include <spatialindex/SpatialIndex.h>
#define STRDUP strdup #define STRDUP strdup
#endif #endif
#include <sys/stat.h> #include <sys/stat.h>
#include "sidx_export.h"
class Item; class Item;
class Index; class Index;
typedef enum typedef enum
{ {
RT_None = 0, RT_None = 0,
RT_Debug = 1, RT_Debug = 1,
RT_Warning = 2, RT_Warning = 2,
RT_Failure = 3, RT_Failure = 3,
RT_Fatal = 4 RT_Fatal = 4
skipping to change at line 108 skipping to change at line 110
# define IDX_C_END } # define IDX_C_END }
#else #else
# define IDX_C_START # define IDX_C_START
# define IDX_C_END # define IDX_C_END
#endif #endif
typedef Index *IndexH; typedef Index *IndexH;
typedef SpatialIndex::IData *IndexItemH; typedef SpatialIndex::IData *IndexItemH;
typedef Tools::PropertySet *IndexPropertyH; typedef Tools::PropertySet *IndexPropertyH;
#ifndef SIDX_C_DLL
#if defined(_MSC_VER)
# define SIDX_C_DLL __declspec(dllexport)
#else
# if defined(USE_GCC_VISIBILITY_FLAG)
# define SIDX_C_DLL __attribute__ ((visibility("default")))
# else
# define SIDX_C_DLL
# endif
#endif
#endif
#endif #endif
 End of changes. 2 change blocks. 
12 lines changed or deleted 2 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/