598 lines
14 KiB
C++
598 lines
14 KiB
C++
/*
|
|
----
|
|
This file is part of SECONDO.
|
|
|
|
Copyright (C) 2004-2009, University in Hagen, Faculty of Mathematics
|
|
and Computer Science, Database Systems for New Applications.
|
|
|
|
SECONDO is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
SECONDO is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with SECONDO; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
----
|
|
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "AlgebraTypes.h"
|
|
#include "AttrArray.h"
|
|
#include "Attribute.h"
|
|
#include <cstdint>
|
|
#include "Algebras/Geoid/Geoid.h"
|
|
#include "NestedList.h"
|
|
#include "ReadWrite.h"
|
|
#include "SecondoSMI.h"
|
|
#include "Shared.h"
|
|
#include "SpatialAttrArray.h"
|
|
#include <string>
|
|
|
|
namespace CRelAlgebra
|
|
{
|
|
class GAttrArrayInfo;
|
|
class GAttrArrayIterator;
|
|
|
|
/*
|
|
Smartpointer to a ~GAttrArrayInfo~
|
|
|
|
*/
|
|
typedef Shared<const GAttrArrayInfo> PGAttrArrayInfo;
|
|
|
|
/*
|
|
Holds a ~GAttrArray~'s ~count~ and ~flobFileId~ values.
|
|
Moving those values into this class allows writing and reading them with one
|
|
operation and seperate storage (See ~AttrArray.Save~ and
|
|
~AttrArrayTypeConstructor.Load~).
|
|
|
|
*/
|
|
class GAttrArrayHeader
|
|
{
|
|
public:
|
|
uint64_t count;
|
|
|
|
SmiFileId flobFileId;
|
|
|
|
/*
|
|
Creates a ~GAttrArrayHeader~ with uninitialized values.
|
|
|
|
*/
|
|
GAttrArrayHeader();
|
|
|
|
/*
|
|
Creates a ~GAttrArrayHeader~ with the provided ~count~ and ~flobFileId~.
|
|
|
|
*/
|
|
GAttrArrayHeader(uint64_t count, SmiFileId flobFileId);
|
|
|
|
/*
|
|
Creates a ~GAttrArrayHeader~ with the ~count~ and ~flobFileId~ from a
|
|
~AttrArrayHeader~.
|
|
|
|
*/
|
|
GAttrArrayHeader(const AttrArrayHeader &header);
|
|
};
|
|
|
|
/*
|
|
A generic ~AttrArray~ implementation.
|
|
The attribute type is specified by a ~GAttrArrayInfo~.
|
|
|
|
The ~Attribute~s are stored in a byte-array of their root blocks.
|
|
~Flob~s are either copied to a designated file (persistent ~GAttrArray~s) or
|
|
left untouched (transient ~GAttrArray~s).
|
|
|
|
*/
|
|
class GAttrArray : public AttrArray
|
|
{
|
|
public:
|
|
/*
|
|
Creates a empty ~GAttrArray~ for the attribute type specified by ~info~.
|
|
If persistence is desired a valid ~SmiFileId~ for ~Flob~ storage must be
|
|
provided.
|
|
|
|
*/
|
|
GAttrArray(const PGAttrArrayInfo &info, SmiFileId flobFileId = 0);
|
|
|
|
/*
|
|
Restores a ~GAttrArray~ with attributes of the type specified by ~info~
|
|
from ~source~.
|
|
|
|
Preconditions:
|
|
*~source~ must hold data created by ~GAttrArray.Save~ with
|
|
~includeHeader~ == true.
|
|
*~source~ must hold data created by a ~GAttrArray~ of equal attribute
|
|
type
|
|
*/
|
|
GAttrArray(const PGAttrArrayInfo &info, Reader &source);
|
|
|
|
/*
|
|
Restores a ~GAttrArray~ with attributes of the type specified by ~info~ from
|
|
~source~ and ~header~.
|
|
|
|
Preconditions:
|
|
*~source~ must hold data created by ~GAttrArray.Save~ with
|
|
~includeHeader~ == false.
|
|
*~source~ must hold data created by a ~GAttrArray~ of equal attribute
|
|
type.
|
|
*~header.count~ must equal the saved ~GAttrArray~'s row count.
|
|
*~header.flobFile~ must equal the saved ~GAttrArray~'s flobFile count.
|
|
*/
|
|
GAttrArray(const PGAttrArrayInfo &info, Reader &source,
|
|
const GAttrArrayHeader &header);
|
|
|
|
GAttrArray(const GAttrArray &array,
|
|
const SharedArray<const uint64_t> &filter);
|
|
|
|
virtual ~GAttrArray();
|
|
|
|
virtual AttrArray *Filter(const SharedArray<const uint64_t> filter) const;
|
|
|
|
/*
|
|
Returns a shared pointer to the ~GAttrArrayInfo~ specifying this arrays
|
|
attribute type.
|
|
|
|
*/
|
|
const PGAttrArrayInfo &GetInfo() const;
|
|
|
|
//~AttrArray.GetCount~
|
|
virtual uint64_t GetCount() const;
|
|
|
|
/*
|
|
Returns the ammount of memory occupied ~Attribute~ root blocks.
|
|
This does not include allocated but unused memory.
|
|
|
|
*/
|
|
//~AttrArray.GetSize~
|
|
virtual uint64_t GetSize() const;
|
|
|
|
//~AttrArray.Save~
|
|
virtual void Save(Writer &target, bool includeHeader = true) const;
|
|
|
|
//~AttrArray.DeleteRecords~
|
|
virtual void DeleteRecords();
|
|
|
|
//~AttrArray.Append~
|
|
virtual void Append(const AttrArray &array, uint64_t row);
|
|
|
|
//~AttrArray.Append~
|
|
virtual void Append(Attribute &value);
|
|
|
|
//~AttrArray.Remove~
|
|
virtual void Remove();
|
|
|
|
//~AttrArray.Clear~
|
|
virtual void Clear();
|
|
|
|
/*
|
|
Returns the ~Attribute~ stored in the specified ~row~.
|
|
|
|
Precondition: ~row~ < ~GetCount()~
|
|
|
|
*/
|
|
Attribute &GetAt(uint64_t row) const;
|
|
Attribute &operator[](uint64_t row) const;
|
|
|
|
//AttrArray.IsDefined
|
|
virtual bool IsDefined(uint64_t row) const;
|
|
|
|
//AttrArray.Compare
|
|
virtual int Compare(uint64_t rowA, const AttrArray &arrayB,
|
|
uint64_t rowB) const;
|
|
|
|
//AttrArray.Compare
|
|
virtual int Compare(uint64_t row, Attribute &value) const;
|
|
|
|
//AttrArray.CompareAlmost
|
|
virtual int CompareAlmost(uint64_t rowA, const AttrArray &arrayB,
|
|
uint64_t rowB) const;
|
|
|
|
//AttrArray.CompareAlmost
|
|
virtual int CompareAlmost(uint64_t row, Attribute &value) const;
|
|
|
|
//AttrArray.Equals
|
|
virtual bool Equals(uint64_t rowA, const AttrArray &arrayB,
|
|
uint64_t rowB) const;
|
|
|
|
//AttrArray.Equals
|
|
virtual bool Equals(uint64_t row, Attribute &value) const;
|
|
|
|
//AttrArray.GetHash
|
|
virtual uint64_t GetHash(uint64_t row) const;
|
|
|
|
//AttrArray.GetAttribute
|
|
virtual Attribute *GetAttribute(uint64_t row, bool clone) const;
|
|
|
|
/*
|
|
Returns a ~GAttrArrayIterator~ over the stored attributes.
|
|
|
|
*/
|
|
GAttrArrayIterator GetIterator() const;
|
|
|
|
/*
|
|
Returns ~GAttrArrayIterator~s used (only!) for range-loop support.
|
|
|
|
*/
|
|
GAttrArrayIterator begin() const;
|
|
GAttrArrayIterator end() const;
|
|
|
|
private:
|
|
friend class GAttrArrayIterator;
|
|
|
|
GAttrArrayHeader m_header;
|
|
|
|
const PGAttrArrayInfo m_info;
|
|
|
|
uint64_t m_capacity,
|
|
m_size;
|
|
|
|
SharedArray<char> m_data;
|
|
|
|
char *m_attributesEnd;
|
|
|
|
/*
|
|
Deleted copy-constructor to prevent copying pointers.
|
|
|
|
*/
|
|
GAttrArray(const GAttrArray &array) = delete;
|
|
};
|
|
|
|
/*
|
|
Specifies and holds some info related to a ~GAttrArray~'s attribute type
|
|
which can be shared among ~GattrArray~s.
|
|
|
|
*/
|
|
class GAttrArrayInfo
|
|
{
|
|
public:
|
|
uint64_t attributeSize,
|
|
attributeFLOBCount;
|
|
|
|
ObjectCast attributeCastFunction;
|
|
|
|
/*
|
|
Creates a uninitialized ~GAttrArrayInfo~
|
|
|
|
*/
|
|
GAttrArrayInfo();
|
|
|
|
/*
|
|
Creates a ~GAttrArrayInfo~ specifying the provided attribute type.
|
|
|
|
*/
|
|
GAttrArrayInfo(ListExpr attributeTypeExpr);
|
|
};
|
|
|
|
/*
|
|
A iterator over the attributes of a ~GAttrArray~.
|
|
|
|
Changes of the ~GAttrArray~ invalidate the iterator which is not reflected by
|
|
~GAttrArrayIterator.IsValid~. Further usage is considered undefined behaviour.
|
|
|
|
The functions are defined in this header file to enable inlining.
|
|
|
|
*/
|
|
class GAttrArrayIterator
|
|
{
|
|
public:
|
|
/*
|
|
Creates a invalid iterator.
|
|
|
|
*/
|
|
GAttrArrayIterator() :
|
|
m_instance(nullptr),
|
|
m_attributeSize(0),
|
|
m_current(nullptr),
|
|
m_end(nullptr)
|
|
{
|
|
}
|
|
|
|
/*
|
|
Creates a iterator pointing at the first entry in the passed ~array~.
|
|
If the ~array~ is empty the iterator is invalid.
|
|
|
|
*/
|
|
GAttrArrayIterator(const GAttrArray &array) :
|
|
m_instance(&array),
|
|
m_attributeSize(array.m_info->attributeSize),
|
|
m_current(array.m_data.GetPointer()),
|
|
m_end(array.m_attributesEnd)
|
|
{
|
|
}
|
|
|
|
/*
|
|
Determines if the iterator's current position is valid.
|
|
|
|
*/
|
|
bool IsValid() const
|
|
{
|
|
return m_current < m_end;
|
|
}
|
|
|
|
/*
|
|
Returns a ~Attribute~ at the iterator's current position.
|
|
|
|
Precondition: ~IsValid()~
|
|
|
|
*/
|
|
Attribute &Get()
|
|
{
|
|
return *(Attribute*)m_current;
|
|
}
|
|
|
|
Attribute &operator * ()
|
|
{
|
|
return Get();
|
|
}
|
|
|
|
/*
|
|
Moves the iterator to the next position.
|
|
Returns true if that position is still valid.
|
|
|
|
Precondition: ~IsValid()~
|
|
|
|
*/
|
|
bool MoveToNext()
|
|
{
|
|
if (IsValid())
|
|
{
|
|
m_current += m_attributeSize;
|
|
|
|
return IsValid();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
Moves the iterator to the next position.
|
|
|
|
Precondition: ~IsValid()~
|
|
|
|
*/
|
|
GAttrArrayIterator &operator ++ ()
|
|
{
|
|
MoveToNext();
|
|
|
|
return *this;
|
|
}
|
|
|
|
/*
|
|
Compares this iterator and the ~other~ iterator for equality.
|
|
|
|
*/
|
|
bool operator == (const GAttrArrayIterator &other) const
|
|
{
|
|
return !(*this != other);
|
|
}
|
|
|
|
/*
|
|
Compares this iterator and the ~other~ iterator for inequality.
|
|
|
|
*/
|
|
bool operator != (const GAttrArrayIterator &other) const
|
|
{
|
|
if (m_current < m_end)
|
|
{
|
|
if (other.m_current < other.m_end)
|
|
{
|
|
return m_current != other.m_current || m_instance != other.m_instance;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return other.m_current < other.m_end;
|
|
}
|
|
|
|
private:
|
|
const GAttrArray *m_instance;
|
|
|
|
uint64_t m_attributeSize;
|
|
|
|
char *m_current,
|
|
*m_end;
|
|
};
|
|
|
|
template<int dim>
|
|
class GSpatialAttrArrayIterator;
|
|
|
|
/*
|
|
A generic ~SpatialAttrArray<dim>~ implementation.
|
|
The attribute type is specified by a ~GAttrArrayInfo~.
|
|
|
|
This class wraps a ~GAttrArray~ with a attribute type of kind
|
|
SPATIAL1D, SPATIAL2D, SPATIAL3D, SPATIAL4D or SPATIAL8D.
|
|
|
|
The fact that ~GAttrArray~ stores ~Attribute~s root blocks, allows to simply
|
|
cast those into ~StandardSpatialAttribute<dim>~s.
|
|
|
|
*/
|
|
template<int dim>
|
|
class GSpatialAttrArray : public SpatialAttrArray<dim>
|
|
{
|
|
public:
|
|
/*
|
|
The constructors only call ~GAttrArray~'s constructor.
|
|
|
|
The attribute type specified by ~info~ must be of kind
|
|
SPATIAL1D, SPATIAL2D, SPATIAL3D, SPATIAL4D or SPATIAL8D.
|
|
|
|
*/
|
|
GSpatialAttrArray(const PGAttrArrayInfo &info);
|
|
|
|
GSpatialAttrArray(const PGAttrArrayInfo &info, SmiFileId flobFileId);
|
|
|
|
GSpatialAttrArray(const PGAttrArrayInfo &info, Reader &source);
|
|
|
|
GSpatialAttrArray(const PGAttrArrayInfo &info, Reader &source,
|
|
const GAttrArrayHeader &header);
|
|
|
|
GSpatialAttrArray(const GSpatialAttrArray &array,
|
|
const SharedArray<const uint64_t> &filter);
|
|
|
|
virtual AttrArray *Filter(const SharedArray<const uint64_t> filter) const;
|
|
|
|
//~AttrArray.GetCount~
|
|
virtual uint64_t GetCount() const;
|
|
|
|
//~AttrArray.GetSize~
|
|
virtual uint64_t GetSize() const;
|
|
|
|
//~AttrArray.Save~
|
|
virtual void Save(Writer &target, bool includeHeader = true) const;
|
|
|
|
//~AttrArray.DeleteRecords~
|
|
virtual void DeleteRecords();
|
|
|
|
//~AttrArray.Append~
|
|
virtual void Append(const AttrArray &array, uint64_t row);
|
|
|
|
//~AttrArray.Append~
|
|
virtual void Append(Attribute &value);
|
|
|
|
//~AttrArray.Remove~
|
|
virtual void Remove();
|
|
|
|
//~AttrArray.Clear~
|
|
virtual void Clear();
|
|
|
|
/*
|
|
Returns the ~StandardSpatialAttribute<dim>~ stored in the specified ~row~.
|
|
|
|
Precondition: ~row~ < ~GetCount()~
|
|
|
|
*/
|
|
StandardSpatialAttribute<dim> &GetAt(uint64_t index) const;
|
|
|
|
StandardSpatialAttribute<dim> &operator[](uint64_t index) const;
|
|
|
|
//~AttrArray.IsDefined~
|
|
virtual bool IsDefined(uint64_t row) const;
|
|
|
|
//~AttrArray.Compare~
|
|
virtual int Compare(uint64_t rowA, const AttrArray &arrayB,
|
|
uint64_t rowB) const;
|
|
|
|
//~AttrArray.Compare~
|
|
virtual int Compare(uint64_t row, Attribute &value) const;
|
|
|
|
//~AttrArray.CompareAlmost~
|
|
virtual int CompareAlmost(uint64_t rowA, const AttrArray &arrayB,
|
|
uint64_t rowB) const;
|
|
|
|
//~AttrArray.CompareAlmost~
|
|
virtual int CompareAlmost(uint64_t row, Attribute &value) const;
|
|
|
|
//~AttrArray.Equals~
|
|
virtual bool Equals(uint64_t rowA, const AttrArray &arrayB,
|
|
uint64_t rowB) const;
|
|
|
|
//~AttrArray.Equals~
|
|
virtual bool Equals(uint64_t row, Attribute &value) const;
|
|
|
|
//~AttrArray.EqualsAlmost~
|
|
virtual bool EqualsAlmost(uint64_t rowA, const AttrArray &arrayB,
|
|
uint64_t rowB) const;
|
|
|
|
//~AttrArray.EqualsAlmost~
|
|
virtual bool EqualsAlmost(uint64_t row, Attribute &value) const;
|
|
|
|
//~AttrArray.GetHash~
|
|
virtual uint64_t GetHash(uint64_t row) const;
|
|
|
|
//~AttrArray.GetAttribute~
|
|
virtual Attribute *GetAttribute(uint64_t row, bool clone) const;
|
|
|
|
//~SpatialAttrArray<dim>.GetBoundingBox~
|
|
virtual Rectangle<dim> GetBoundingBox(uint64_t row,
|
|
const Geoid* geoid = nullptr) const;
|
|
|
|
//~SpatialAttrArray<dim>.GetDistance~
|
|
virtual double GetDistance(uint64_t row, const Rectangle<dim>& rect,
|
|
const Geoid* geoid = nullptr) const;
|
|
|
|
//~SpatialAttrArray<dim>.Intersects~
|
|
virtual bool Intersects(uint64_t row, const Rectangle<dim>& rect,
|
|
const Geoid* geoid = nullptr) const;
|
|
|
|
//~SpatialAttrArray<dim>.IsEmpty~
|
|
virtual bool IsEmpty(uint64_t row) const;
|
|
|
|
/*
|
|
Returns a ~GSpatialAttrArrayIterator<dim>~ over the stored attributes.
|
|
|
|
*/
|
|
GSpatialAttrArrayIterator<dim> GetIterator() const;
|
|
|
|
/*
|
|
Returns ~GSpatialAttrArrayIterator<dim>~s used (only!) for range-loop
|
|
support.
|
|
|
|
*/
|
|
GSpatialAttrArrayIterator<dim> begin() const;
|
|
GSpatialAttrArrayIterator<dim> end() const;
|
|
|
|
private:
|
|
friend class GSpatialAttrArrayIterator<dim>;
|
|
|
|
GAttrArray m_array;
|
|
};
|
|
|
|
/*
|
|
A iterator over the attributes of a ~GSpatialAttrArray<dim>~.
|
|
|
|
Changes of the ~GSpatialAttrArray<dim>~ invalidate the iterator which is not
|
|
reflected by ~IsValid~. Further usage is considered undefined behaviour.
|
|
|
|
The functions are defined in this header file to enable inlining.
|
|
|
|
*/
|
|
template<int dim>
|
|
class GSpatialAttrArrayIterator : public GAttrArrayIterator
|
|
{
|
|
public:
|
|
/*
|
|
Creates a invalid iterator.
|
|
|
|
*/
|
|
GSpatialAttrArrayIterator()
|
|
{
|
|
}
|
|
|
|
/*
|
|
Creates a iterator pointing at the first entry in the passed ~array~.
|
|
If the ~array~ is empty the iterator is invalid.
|
|
|
|
*/
|
|
GSpatialAttrArrayIterator(const GSpatialAttrArray<dim> &array) :
|
|
GAttrArrayIterator(array.m_array)
|
|
{
|
|
}
|
|
|
|
/*
|
|
Returns a ~StandardSpatialAttribute<dim>~ at the iterator's current
|
|
position.
|
|
|
|
Precondition: ~IsValid()~
|
|
|
|
*/
|
|
StandardSpatialAttribute<dim> &Get()
|
|
{
|
|
return (StandardSpatialAttribute<dim>&)GAttrArrayIterator::Get();
|
|
}
|
|
|
|
StandardSpatialAttribute<dim> &operator * ()
|
|
{
|
|
return Get();
|
|
}
|
|
};
|
|
}
|