You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1342 lines
32 KiB
1342 lines
32 KiB
// format.cpp --
|
|
// $Id$
|
|
// This is part of Metakit, the homepage is http://www.equi4.com/metakit/
|
|
|
|
/** @file
|
|
* Format handlers deal with the representation of data
|
|
*/
|
|
|
|
#include "header.h"
|
|
#include "handler.h"
|
|
#include "column.h"
|
|
#include "format.h"
|
|
#include "persist.h"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
class c4_FormatHandler : public c4_Handler
|
|
{
|
|
c4_HandlerSeq& _owner;
|
|
|
|
public:
|
|
c4_FormatHandler (const c4_Property& prop_, c4_HandlerSeq& owner_);
|
|
virtual ~c4_FormatHandler ();
|
|
|
|
virtual bool IsPersistent() const;
|
|
|
|
protected:
|
|
c4_HandlerSeq& Owner() const;
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// c4_FormatHandler
|
|
|
|
c4_FormatHandler::c4_FormatHandler (const c4_Property& prop_, c4_HandlerSeq& owner_)
|
|
: c4_Handler (prop_), _owner (owner_)
|
|
{
|
|
}
|
|
|
|
c4_FormatHandler::~c4_FormatHandler ()
|
|
{
|
|
}
|
|
|
|
d4_inline c4_HandlerSeq& c4_FormatHandler::Owner() const
|
|
{
|
|
return _owner;
|
|
}
|
|
|
|
bool c4_FormatHandler::IsPersistent() const
|
|
{
|
|
return _owner.Persist() != 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
class c4_FormatX : public c4_FormatHandler
|
|
{
|
|
public:
|
|
c4_FormatX (const c4_Property& prop_, c4_HandlerSeq& seq_,
|
|
int width_ =sizeof (t4_i32));
|
|
|
|
virtual void Define(int, const t4_byte**);
|
|
virtual void OldDefine(char type_, c4_Persist&);
|
|
virtual void FlipBytes();
|
|
|
|
virtual int ItemSize(int index_);
|
|
virtual const void* Get(int index_, int& length_);
|
|
virtual void Set(int index_, const c4_Bytes& buf_);
|
|
|
|
virtual void Insert(int index_, const c4_Bytes& buf_, int count_);
|
|
virtual void Remove(int index_, int count_);
|
|
|
|
virtual void Commit(c4_SaveContext& ar_);
|
|
|
|
virtual void Unmapped();
|
|
|
|
static int DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_);
|
|
|
|
protected:
|
|
c4_ColOfInts _data;
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
c4_FormatX::c4_FormatX (const c4_Property& p_, c4_HandlerSeq& s_, int w_)
|
|
: c4_FormatHandler (p_, s_), _data (s_.Persist(), w_)
|
|
{
|
|
}
|
|
|
|
int c4_FormatX::DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_)
|
|
{
|
|
return c4_ColOfInts::DoCompare(b1_, b2_);
|
|
}
|
|
|
|
void c4_FormatX::Commit(c4_SaveContext& ar_)
|
|
{
|
|
_data.FixSize(true);
|
|
ar_.CommitColumn(_data);
|
|
//_data.FixSize(false);
|
|
}
|
|
|
|
void c4_FormatX::Define(int rows_, const t4_byte** ptr_)
|
|
{
|
|
if (ptr_ != 0)
|
|
_data.PullLocation(*ptr_);
|
|
|
|
_data.SetRowCount(rows_);
|
|
}
|
|
|
|
void c4_FormatX::OldDefine(char, c4_Persist& pers_)
|
|
{
|
|
pers_.FetchOldLocation(_data);
|
|
_data.SetRowCount(Owner().NumRows());
|
|
}
|
|
|
|
void c4_FormatX::FlipBytes()
|
|
{
|
|
_data.FlipBytes();
|
|
}
|
|
|
|
int c4_FormatX::ItemSize(int index_)
|
|
{
|
|
return _data.ItemSize(index_);
|
|
}
|
|
|
|
const void* c4_FormatX::Get(int index_, int& length_)
|
|
{
|
|
return _data.Get(index_, length_);
|
|
}
|
|
|
|
void c4_FormatX::Set(int index_, const c4_Bytes& buf_)
|
|
{
|
|
_data.Set(index_, buf_);
|
|
}
|
|
|
|
void c4_FormatX::Insert(int index_, const c4_Bytes& buf_, int count_)
|
|
{
|
|
_data.Insert(index_, buf_, count_);
|
|
}
|
|
|
|
void c4_FormatX::Remove(int index_, int count_)
|
|
{
|
|
_data.Remove(index_, count_);
|
|
}
|
|
|
|
void c4_FormatX::Unmapped()
|
|
{
|
|
_data.ReleaseAllSegments();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#if !q4_TINY
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
class c4_FormatL : public c4_FormatX
|
|
{
|
|
public:
|
|
c4_FormatL (const c4_Property& prop_, c4_HandlerSeq& seq_);
|
|
|
|
virtual void Define(int, const t4_byte**);
|
|
|
|
static int DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_);
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
c4_FormatL::c4_FormatL (const c4_Property& prop_, c4_HandlerSeq& seq_)
|
|
: c4_FormatX (prop_, seq_, sizeof (t4_i64))
|
|
{
|
|
// force maximum size, autosizing more than 32 bits won't work
|
|
_data.SetAccessWidth(8 * sizeof (t4_i64));
|
|
}
|
|
|
|
int c4_FormatL::DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_)
|
|
{
|
|
d4_assert(b1_.Size() == sizeof (t4_i64));
|
|
d4_assert(b2_.Size() == sizeof (t4_i64));
|
|
|
|
t4_i64 v1 = *(const t4_i64*) b1_.Contents();
|
|
t4_i64 v2 = *(const t4_i64*) b2_.Contents();
|
|
|
|
return v1 == v2 ? 0 : v1 < v2 ? -1 : +1;
|
|
}
|
|
|
|
void c4_FormatL::Define(int rows_, const t4_byte** ptr_)
|
|
{
|
|
if (ptr_ == 0 && rows_ > 0) {
|
|
d4_assert(_data.ColSize() == 0);
|
|
_data.InsertData(0, rows_ * sizeof (t4_i64), true);
|
|
}
|
|
|
|
c4_FormatX::Define(rows_, ptr_);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
class c4_FormatF : public c4_FormatX
|
|
{
|
|
public:
|
|
c4_FormatF (const c4_Property& prop_, c4_HandlerSeq& seq_);
|
|
|
|
static int DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_);
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
c4_FormatF::c4_FormatF (const c4_Property& prop_, c4_HandlerSeq& seq_)
|
|
: c4_FormatX (prop_, seq_, sizeof (float))
|
|
{
|
|
}
|
|
|
|
int c4_FormatF::DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_)
|
|
{
|
|
d4_assert(b1_.Size() == sizeof (float));
|
|
d4_assert(b2_.Size() == sizeof (float));
|
|
|
|
float v1 = *(const float*) b1_.Contents();
|
|
float v2 = *(const float*) b2_.Contents();
|
|
|
|
return v1 == v2 ? 0 : v1 < v2 ? -1 : +1;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
class c4_FormatD : public c4_FormatX
|
|
{
|
|
public:
|
|
c4_FormatD (const c4_Property& prop_, c4_HandlerSeq& seq_);
|
|
|
|
virtual void Define(int, const t4_byte**);
|
|
|
|
static int DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_);
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
c4_FormatD::c4_FormatD (const c4_Property& prop_, c4_HandlerSeq& seq_)
|
|
: c4_FormatX (prop_, seq_, sizeof (double))
|
|
{
|
|
// force maximum size, autosizing more than 32 bits won't work
|
|
_data.SetAccessWidth(8 * sizeof (double));
|
|
}
|
|
|
|
int c4_FormatD::DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_)
|
|
{
|
|
d4_assert(b1_.Size() == sizeof (double));
|
|
d4_assert(b2_.Size() == sizeof (double));
|
|
|
|
double v1 = *(const double*) b1_.Contents();
|
|
double v2 = *(const double*) b2_.Contents();
|
|
|
|
return v1 == v2 ? 0 : v1 < v2 ? -1 : +1;
|
|
}
|
|
|
|
void c4_FormatD::Define(int rows_, const t4_byte** ptr_)
|
|
{
|
|
if (ptr_ == 0 && rows_ > 0) {
|
|
d4_assert(_data.ColSize() == 0);
|
|
_data.InsertData(0, rows_ * sizeof (double), true);
|
|
}
|
|
|
|
c4_FormatX::Define(rows_, ptr_);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#endif // !q4_TINY
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Byte properties are used for raw bytes and for indirect (memo) data.
|
|
|
|
There are two columns: the actual data and the item sizes. If the data
|
|
is indirect, then the size is stored as a negative value.
|
|
|
|
In addition, there is an in-memory-only vector of columns (_memos).
|
|
Columns are created when asked for, and stay around until released with
|
|
a commit call. If the column object exists and is not dirty, then it
|
|
is either a real column (size < 0), or simply a duplicate of the data
|
|
stored inline as bytes.
|
|
*/
|
|
|
|
class c4_FormatB : public c4_FormatHandler
|
|
{
|
|
public:
|
|
c4_FormatB (const c4_Property& prop_, c4_HandlerSeq& seq_);
|
|
virtual ~c4_FormatB ();
|
|
|
|
virtual void Define(int, const t4_byte**);
|
|
virtual void OldDefine(char type_, c4_Persist&);
|
|
virtual void Commit(c4_SaveContext& ar_);
|
|
|
|
virtual int ItemSize(int index_);
|
|
virtual const void* Get(int index_, int& length_);
|
|
virtual void Set(int index_, const c4_Bytes& buf_);
|
|
|
|
virtual void Insert(int index_, const c4_Bytes& buf_, int count_);
|
|
virtual void Remove(int index_, int count_);
|
|
|
|
virtual c4_Column* GetNthMemoCol(int index_, bool alloc_);
|
|
|
|
virtual void Unmapped();
|
|
|
|
static int DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_);
|
|
|
|
protected:
|
|
const void* GetOne(int index_, int& length_);
|
|
void SetOne(int index_, const c4_Bytes& buf_, bool ignoreMemos_ =false);
|
|
|
|
private:
|
|
t4_i32 Offset(int index_) const;
|
|
bool ShouldBeMemo(int length_) const;
|
|
int ItemLenOffCol(int index_, t4_i32& off_, c4_Column*& col_);
|
|
bool CommitItem(c4_SaveContext& ar_, int index_);
|
|
void InitOffsets(c4_ColOfInts& sizes_);
|
|
|
|
c4_Column _data;
|
|
c4_ColOfInts _sizeCol; // 2001-11-27: keep, to track position on disk
|
|
c4_Column _memoCol; // 2001-11-27: keep, to track position on disk
|
|
c4_DWordArray _offsets;
|
|
c4_PtrArray _memos;
|
|
bool _recalc; // 2001-11-27: remember when to redo _{size,memo}Col
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
c4_FormatB::c4_FormatB (const c4_Property& prop_, c4_HandlerSeq& seq_)
|
|
: c4_FormatHandler (prop_, seq_), _data (seq_.Persist()),
|
|
_sizeCol (seq_.Persist()), _memoCol (seq_.Persist()), _recalc (false)
|
|
{
|
|
_offsets.SetSize(1, 100);
|
|
_offsets.SetAt(0, 0);
|
|
}
|
|
|
|
c4_FormatB::~c4_FormatB ()
|
|
{
|
|
// cleanup allocated columns
|
|
//better? for (int i = _memos.GetSize(); --i >= 0 ;)
|
|
for (int i = 0; i < _memos.GetSize(); ++i)
|
|
delete (c4_Column*) _memos.GetAt(i);
|
|
}
|
|
|
|
d4_inline t4_i32 c4_FormatB::Offset(int index_) const
|
|
{
|
|
d4_assert((t4_i32) _offsets.GetAt(_offsets.GetSize() - 1) == _data.ColSize());
|
|
d4_assert(_offsets.GetSize() == _memos.GetSize() + 1);
|
|
d4_assert(index_ < _offsets.GetSize());
|
|
|
|
// extend offset vectors for missing empty entries at end
|
|
int n = _offsets.GetSize();
|
|
d4_assert(n > 0);
|
|
|
|
if (index_ >= n)
|
|
index_ = n - 1;
|
|
|
|
return _offsets.GetAt(index_);
|
|
}
|
|
|
|
d4_inline bool c4_FormatB::ShouldBeMemo(int length_) const
|
|
{
|
|
// items over 10000 bytes are always memos
|
|
// items up to 100 bytes are never memos
|
|
//
|
|
// else, memo only if the column would be under 1 Mb
|
|
// (assuming all items had the same size as this one)
|
|
//
|
|
// the effect is that as the number of rows increases,
|
|
// smaller and smaller items get turned into memos
|
|
//
|
|
// note that items which are no memo right now stay
|
|
// as is, and so do memos which have not been modified
|
|
|
|
int rows = _memos.GetSize() + 1; // avoids divide by zero
|
|
return length_ > 10000 || length_ > 100 && length_ > 1000000 / rows;
|
|
}
|
|
|
|
int c4_FormatB::ItemLenOffCol(int index_, t4_i32& off_, c4_Column*& col_)
|
|
{
|
|
col_ = (c4_Column*) _memos.GetAt(index_);
|
|
if (col_ != 0) {
|
|
off_ = 0;
|
|
return col_->ColSize();
|
|
}
|
|
|
|
col_ = &_data;
|
|
off_ = Offset(index_);
|
|
return Offset(index_ + 1) - off_;
|
|
}
|
|
|
|
c4_Column* c4_FormatB::GetNthMemoCol(int index_, bool alloc_)
|
|
{
|
|
t4_i32 start;
|
|
c4_Column* col;
|
|
int n = ItemLenOffCol(index_, start, col);
|
|
|
|
if (col == &_data && alloc_) {
|
|
col = d4_new c4_Column (_data.Persist());
|
|
_memos.SetAt(index_, col);
|
|
|
|
if (n > 0)
|
|
if (_data.IsDirty()) {
|
|
c4_Bytes temp;
|
|
_data.FetchBytes(start, n, temp, true);
|
|
col->SetBuffer(n);
|
|
col->StoreBytes(0, temp);
|
|
}
|
|
else
|
|
col->SetLocation(_data.Position() + start, n);
|
|
}
|
|
|
|
return col;
|
|
}
|
|
|
|
void c4_FormatB::Unmapped()
|
|
{
|
|
_data.ReleaseAllSegments();
|
|
_sizeCol.ReleaseAllSegments();
|
|
_memoCol.ReleaseAllSegments();
|
|
|
|
for (int i = 0; i < _memos.GetSize(); ++i) {
|
|
c4_Column* cp = (c4_Column*) _memos.GetAt(i);
|
|
if (cp != 0)
|
|
cp->ReleaseAllSegments();
|
|
}
|
|
}
|
|
|
|
void c4_FormatB::Define(int, const t4_byte** ptr_)
|
|
{
|
|
d4_assert(_memos.GetSize() == 0);
|
|
|
|
if (ptr_ != 0) {
|
|
_data.PullLocation(*ptr_);
|
|
if (_data.ColSize() > 0)
|
|
_sizeCol.PullLocation(*ptr_);
|
|
_memoCol.PullLocation(*ptr_);
|
|
}
|
|
|
|
// everything below this point could be delayed until use
|
|
// in that case, watch out that column space use is properly tracked
|
|
|
|
InitOffsets(_sizeCol);
|
|
|
|
if (_memoCol.ColSize() > 0) {
|
|
c4_Bytes walk;
|
|
_memoCol.FetchBytes(0, _memoCol.ColSize(), walk, true);
|
|
|
|
const t4_byte* p = walk.Contents();
|
|
|
|
for (int row = 0; p < walk.Contents() + walk.Size(); ++row) {
|
|
row += c4_Column::PullValue(p);
|
|
d4_assert(row < _memos.GetSize());
|
|
|
|
c4_Column* mc = d4_new c4_Column (_data.Persist());
|
|
d4_assert(mc != 0);
|
|
_memos.SetAt(row, mc);
|
|
|
|
mc->PullLocation(p);
|
|
}
|
|
|
|
d4_assert(p == walk.Contents() + walk.Size());
|
|
}
|
|
}
|
|
|
|
void c4_FormatB::OldDefine(char type_, c4_Persist& pers_)
|
|
{
|
|
int rows = Owner().NumRows();
|
|
|
|
c4_ColOfInts sizes (_data.Persist());
|
|
|
|
if (type_ == 'M') {
|
|
InitOffsets(sizes);
|
|
|
|
c4_ColOfInts szVec (_data.Persist());
|
|
pers_.FetchOldLocation(szVec);
|
|
szVec.SetRowCount(rows);
|
|
|
|
c4_ColOfInts posVec (_data.Persist());
|
|
pers_.FetchOldLocation(posVec);
|
|
posVec.SetRowCount(rows);
|
|
|
|
for (int r = 0; r < rows; ++r) {
|
|
t4_i32 sz = szVec.GetInt(r);
|
|
if (sz > 0) {
|
|
c4_Column* mc = d4_new c4_Column (_data.Persist());
|
|
d4_assert(mc != 0);
|
|
_memos.SetAt(r, mc);
|
|
|
|
mc->SetLocation(posVec.GetInt(r), sz);
|
|
}
|
|
}
|
|
} else {
|
|
pers_.FetchOldLocation(_data);
|
|
|
|
if (type_ == 'B') {
|
|
pers_.FetchOldLocation(sizes);
|
|
|
|
#if !q4_OLD_IS_ALWAYS_V2
|
|
|
|
// WARNING - HUGE HACK AHEAD - THIS IS NOT 100% FULLPROOF!
|
|
//
|
|
// The above is correct for MK versions 2.0 and up, but *NOT*
|
|
// for MK 1.8.6 datafiles, which store sizes first (OUCH!!!).
|
|
// This means that there is not a 100% safe way to auto-convert
|
|
// both 1.8.6 and 2.0 files - since there is no way to detect
|
|
// unambiguously which version a datafile is. All we can do,
|
|
// is to carefully check both vectors, and *hope* that only one
|
|
// of them is valid as sizes vector. This problem applies to
|
|
// the 'B' (bytes) property type only, and only pre 2.0 files.
|
|
//
|
|
// To build a version which *always* converts assuming 1.8.6,
|
|
// add flag "-Dq4_OLD_IS_PRE_V2" to the compiler command line.
|
|
// Conversely, "-Dq4_OLD_IS_ALWAYS_V2" forces 2.0 conversion.
|
|
|
|
if (rows > 0) {
|
|
t4_i32 s1 = sizes.ColSize();
|
|
t4_i32 s2 = _data.ColSize();
|
|
|
|
#if !q4_OLD_IS_PRE_V2
|
|
// if the size vector is clearly impossible, swap vectors
|
|
bool fix = c4_ColOfInts::CalcAccessWidth(rows, s1) < 0;
|
|
|
|
// if the other vector might be valid as well, check further
|
|
if (!fix && c4_ColOfInts::CalcAccessWidth(rows, s2) >= 0) {
|
|
sizes.SetRowCount(rows);
|
|
t4_i32 total = 0;
|
|
for (int i = 0; i < rows; ++i) {
|
|
t4_i32 w = sizes.GetInt(i);
|
|
if (w < 0 || total > s2) {
|
|
total = -1;
|
|
break;
|
|
}
|
|
total += w;
|
|
}
|
|
|
|
// if the sizes don't add up, swap vectors
|
|
fix = total != s2;
|
|
}
|
|
|
|
if (fix)
|
|
#endif
|
|
{
|
|
t4_i32 p1 = sizes.Position();
|
|
t4_i32 p2 = _data.Position();
|
|
_data.SetLocation(p1, s1);
|
|
sizes.SetLocation(p2, s2);
|
|
}
|
|
}
|
|
#endif
|
|
InitOffsets(sizes);
|
|
} else {
|
|
d4_assert(type_ == 'S');
|
|
|
|
sizes.SetRowCount(rows);
|
|
|
|
t4_i32 pos = 0;
|
|
t4_i32 lastEnd = 0;
|
|
int k = 0;
|
|
|
|
c4_ColIter iter (_data, 0, _data.ColSize());
|
|
while (iter.Next()) {
|
|
const t4_byte* p = iter.BufLoad();
|
|
for (int j = 0; j < iter.BufLen(); ++j)
|
|
if (!p[j]) {
|
|
sizes.SetInt(k++, pos + j + 1 - lastEnd);
|
|
lastEnd = pos + j + 1;
|
|
}
|
|
|
|
pos += iter.BufLen();
|
|
}
|
|
|
|
d4_assert(pos == _data.ColSize());
|
|
|
|
if (lastEnd < pos) { // last entry had no zero byte
|
|
_data.InsertData(pos++, 1, true);
|
|
sizes.SetInt(k, pos - lastEnd);
|
|
}
|
|
|
|
InitOffsets(sizes);
|
|
|
|
// get rid of entries with just a null byte
|
|
for (int r = 0; r < rows; ++r)
|
|
if (c4_FormatB::ItemSize(r) == 1)
|
|
SetOne(r, c4_Bytes ());
|
|
}
|
|
}
|
|
}
|
|
|
|
void c4_FormatB::InitOffsets(c4_ColOfInts& sizes_)
|
|
{
|
|
int rows = Owner().NumRows();
|
|
|
|
if (sizes_.RowCount() != rows) {
|
|
sizes_.SetRowCount(rows);
|
|
}
|
|
|
|
_memos.SetSize(rows);
|
|
_offsets.SetSize(rows + 1);
|
|
|
|
if (_data.ColSize() > 0) {
|
|
t4_i32 total = 0;
|
|
|
|
for (int r = 0; r < rows; ++r) {
|
|
int n = sizes_.GetInt(r);
|
|
d4_assert(n >= 0);
|
|
total += n;
|
|
_offsets.SetAt(r + 1, total);
|
|
}
|
|
|
|
d4_assert(total == _data.ColSize());
|
|
}
|
|
|
|
}
|
|
|
|
int c4_FormatB::ItemSize(int index_)
|
|
{
|
|
t4_i32 start;
|
|
c4_Column* col;
|
|
return ItemLenOffCol(index_, start, col);
|
|
}
|
|
|
|
const void* c4_FormatB::GetOne(int index_, int& length_)
|
|
{
|
|
t4_i32 start;
|
|
c4_Column* cp;
|
|
length_ = ItemLenOffCol(index_, start, cp);
|
|
d4_assert(length_ >= 0);
|
|
|
|
if (length_ == 0)
|
|
return "";
|
|
|
|
return cp->FetchBytes(start, length_, Owner().Buffer(), false);
|
|
}
|
|
|
|
const void* c4_FormatB::Get(int index_, int& length_)
|
|
{
|
|
return GetOne(index_, length_);
|
|
}
|
|
|
|
void c4_FormatB::SetOne(int index_, const c4_Bytes& xbuf_, bool ignoreMemos_)
|
|
{
|
|
// this fixes bug in 2.4.0 when copying string from higher row
|
|
// TODO: this fix is very conservative, figure out when to copy
|
|
// (can probably look at pointer to see whether it's from us)
|
|
int sz = xbuf_.Size();
|
|
c4_Bytes buf_ (xbuf_.Contents(), sz, 0 < sz && sz <= c4_Column::kSegMax);
|
|
|
|
c4_Column* cp = &_data;
|
|
t4_i32 start = Offset(index_);
|
|
int len = Offset(index_ + 1) - start;
|
|
|
|
if (!ignoreMemos_ && _memos.GetAt(index_) != 0)
|
|
len = ItemLenOffCol(index_, start, cp);
|
|
|
|
int m = buf_.Size();
|
|
int n = m - len;
|
|
|
|
if (n > 0)
|
|
cp->Grow(start, n);
|
|
else if (n < 0)
|
|
cp->Shrink(start, - n);
|
|
else if (m == 0)
|
|
return; // no size change and no contents
|
|
|
|
_recalc = true;
|
|
|
|
cp->StoreBytes(start, buf_);
|
|
|
|
if (n && cp == &_data) { // if size has changed
|
|
int k = _offsets.GetSize() - 1;
|
|
|
|
// if filling in an empty entry at end: extend offsets first
|
|
if (m > 0 && index_ >= k) {
|
|
_offsets.InsertAt(k, _offsets.GetAt(k), index_ - k + 1);
|
|
|
|
k = index_ + 1;
|
|
d4_assert(k == _offsets.GetSize() - 1);
|
|
}
|
|
|
|
// adjust following entry offsets
|
|
while (++index_ <= k)
|
|
_offsets.ElementAt(index_) += n;
|
|
}
|
|
|
|
d4_assert((t4_i32) _offsets.GetAt(_offsets.GetSize() - 1) == _data.ColSize());
|
|
}
|
|
|
|
void c4_FormatB::Set(int index_, const c4_Bytes& buf_)
|
|
{
|
|
SetOne(index_, buf_);
|
|
}
|
|
|
|
int c4_FormatB::DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_)
|
|
{
|
|
int n = b1_.Size();
|
|
if (n > b2_.Size())
|
|
n = b2_.Size();
|
|
|
|
int f = memcmp(b1_.Contents(), b2_.Contents(), n);
|
|
return f ? f : b1_.Size() - b2_.Size();
|
|
}
|
|
|
|
void c4_FormatB::Insert(int index_, const c4_Bytes& buf_, int count_)
|
|
{
|
|
d4_assert(count_ > 0);
|
|
|
|
_recalc = true;
|
|
|
|
int m = buf_.Size();
|
|
t4_i32 off = Offset(index_);
|
|
|
|
_memos.InsertAt(index_, 0, count_);
|
|
|
|
// insert the appropriate number of bytes
|
|
t4_i32 n = count_ * (t4_i32) m;
|
|
if (n > 0) {
|
|
_data.Grow(off, n);
|
|
|
|
// store as many copies as needed, but may have to do it in chunks
|
|
int spos = 0;
|
|
|
|
c4_ColIter iter (_data, off, off + n);
|
|
while (iter.Next(m - spos)) {
|
|
memcpy(iter.BufSave(), buf_.Contents() + spos, iter.BufLen());
|
|
|
|
spos += iter.BufLen();
|
|
if (spos >= m)
|
|
spos = 0;
|
|
}
|
|
|
|
d4_assert(spos == 0); // must have copied an exact multiple of the data
|
|
}
|
|
|
|
// define offsets of the new entries
|
|
_offsets.InsertAt(index_, 0, count_);
|
|
d4_assert(_offsets.GetSize() <= _memos.GetSize() + 1);
|
|
|
|
while (--count_ >= 0) {
|
|
_offsets.SetAt(index_++, off);
|
|
off += m;
|
|
}
|
|
|
|
d4_assert(index_ < _offsets.GetSize());
|
|
|
|
// adjust all following entries
|
|
while (index_ < _offsets.GetSize())
|
|
_offsets.ElementAt(index_++) += n;
|
|
|
|
d4_assert((t4_i32) _offsets.GetAt(index_ - 1) == _data.ColSize());
|
|
d4_assert(index_ <= _memos.GetSize() + 1);
|
|
}
|
|
|
|
void c4_FormatB::Remove(int index_, int count_)
|
|
{
|
|
_recalc = true;
|
|
|
|
t4_i32 off = Offset(index_);
|
|
t4_i32 n = Offset(index_ + count_) - off;
|
|
d4_assert(n >= 0);
|
|
|
|
// remove the columns, if present
|
|
for (int i = 0; i < count_; ++i)
|
|
delete (c4_Column*) _memos.GetAt(index_ + i);
|
|
_memos.RemoveAt(index_, count_);
|
|
|
|
if (n > 0)
|
|
_data.Shrink(off, n);
|
|
|
|
_offsets.RemoveAt(index_, count_);
|
|
|
|
d4_assert(index_ < _offsets.GetSize());
|
|
|
|
// adjust all following entries
|
|
while (index_ < _offsets.GetSize())
|
|
_offsets.ElementAt(index_++) -= n;
|
|
|
|
d4_assert((t4_i32) _offsets.GetAt(index_ - 1) == _data.ColSize());
|
|
d4_assert(index_ <= _memos.GetSize() + 1);
|
|
}
|
|
|
|
void c4_FormatB::Commit(c4_SaveContext& ar_)
|
|
{
|
|
int rows = _memos.GetSize();
|
|
d4_assert(rows > 0);
|
|
|
|
bool full = _recalc || ar_.Serializing();
|
|
|
|
if (!full)
|
|
for (int i = 0; i < rows; ++i) {
|
|
c4_Column* col = (c4_Column*) _memos.GetAt(i);
|
|
if (col != 0) {
|
|
full = true;
|
|
break;
|
|
}
|
|
}
|
|
d4_assert(_recalc || _sizeCol.RowCount() == rows);
|
|
|
|
if (full) {
|
|
_memoCol.SetBuffer(0);
|
|
_sizeCol.SetBuffer(0);
|
|
_sizeCol.SetAccessWidth(0);
|
|
_sizeCol.SetRowCount(rows);
|
|
|
|
int skip = 0;
|
|
|
|
c4_Column* saved = ar_.SetWalkBuffer(&_memoCol);
|
|
|
|
for (int r = 0; r < rows; ++r) {
|
|
++skip;
|
|
|
|
t4_i32 start;
|
|
c4_Column* col;
|
|
int len = ItemLenOffCol(r, start, col);
|
|
|
|
bool oldMemo = col != &_data;
|
|
bool newMemo = ShouldBeMemo(len);
|
|
|
|
if (!oldMemo && newMemo) {
|
|
col = GetNthMemoCol(r, true);
|
|
d4_assert(col != &_data);
|
|
//? start = 0;
|
|
}
|
|
|
|
c4_Bytes temp;
|
|
|
|
if (newMemo) { // it now is a memo, inlined data will be empty
|
|
ar_.StoreValue(skip - 1);
|
|
skip = 0;
|
|
ar_.CommitColumn(*col);
|
|
} else if (!oldMemo) { // it was no memo, done if it hasn't become one
|
|
_sizeCol.SetInt(r, len);
|
|
continue;
|
|
} else { // it was a memo, but it no longer is
|
|
d4_assert(start == 0);
|
|
if (len > 0)
|
|
{
|
|
_sizeCol.SetInt(r, len);
|
|
col->FetchBytes(start, len, temp, true);
|
|
delete (c4_Column*) _memos.GetAt(r); // 28-11-2001: fix mem leak
|
|
_memos.SetAt(r, 0); // 02-11-2001: fix for use after commit
|
|
}
|
|
}
|
|
|
|
SetOne(r, temp, true); // bypass current memo pointer
|
|
}
|
|
|
|
ar_.SetWalkBuffer(saved);
|
|
}
|
|
|
|
ar_.CommitColumn(_data);
|
|
|
|
if (_data.ColSize() > 0) {
|
|
_sizeCol.FixSize(true);
|
|
ar_.CommitColumn(_sizeCol);
|
|
//_sizeCol.FixSize(false);
|
|
}
|
|
|
|
ar_.CommitColumn(_memoCol);
|
|
|
|
// need a way to find out when the data has been committed (on 2nd pass)
|
|
// both _sizeCol and _memoCol will be clean again when it has
|
|
// but be careful because dirty flag is only useful if size is nonzero
|
|
if (_recalc && !ar_.Serializing())
|
|
_recalc = _sizeCol.ColSize() > 0 && _sizeCol.IsDirty() ||
|
|
_memoCol.ColSize() > 0 && _memoCol.IsDirty();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
class c4_FormatS : public c4_FormatB
|
|
{
|
|
public:
|
|
c4_FormatS (const c4_Property& prop_, c4_HandlerSeq& seq_);
|
|
|
|
virtual int ItemSize(int index_);
|
|
virtual const void* Get(int index_, int& length_);
|
|
virtual void Set(int index_, const c4_Bytes& buf_);
|
|
|
|
virtual void Insert(int index_, const c4_Bytes& buf_, int count_);
|
|
|
|
static int DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_);
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
c4_FormatS::c4_FormatS (const c4_Property& prop_, c4_HandlerSeq& seq_)
|
|
: c4_FormatB (prop_, seq_)
|
|
{
|
|
}
|
|
|
|
int c4_FormatS::ItemSize(int index_)
|
|
{
|
|
int n = c4_FormatB::ItemSize(index_) - 1;
|
|
return n >= 0 ? n : 0;
|
|
}
|
|
|
|
const void* c4_FormatS::Get(int index_, int& length_)
|
|
{
|
|
const void* ptr = GetOne(index_, length_);
|
|
|
|
if (length_ == 0) {
|
|
length_ = 1;
|
|
ptr = "";
|
|
}
|
|
|
|
d4_assert(((const char*) ptr)[length_-1] == 0);
|
|
return ptr;
|
|
}
|
|
|
|
void c4_FormatS::Set(int index_, const c4_Bytes& buf_)
|
|
{
|
|
int m = buf_.Size();
|
|
if (--m >= 0) {
|
|
d4_assert(buf_.Contents()[m] == 0);
|
|
if (m == 0) {
|
|
SetOne(index_, c4_Bytes ()); // don't store data for empty strings
|
|
return;
|
|
}
|
|
}
|
|
|
|
SetOne(index_, buf_);
|
|
}
|
|
|
|
int c4_FormatS::DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_)
|
|
{
|
|
c4_String v1 ((const char*) b1_.Contents(), b1_.Size());
|
|
c4_String v2 ((const char*) b2_.Contents(), b2_.Size());
|
|
|
|
return v1.CompareNoCase(v2);
|
|
}
|
|
|
|
void c4_FormatS::Insert(int index_, const c4_Bytes& buf_, int count_)
|
|
{
|
|
d4_assert(count_ > 0);
|
|
|
|
int m = buf_.Size();
|
|
if (--m >= 0) {
|
|
d4_assert(buf_.Contents()[m] == 0);
|
|
if (m == 0) {
|
|
c4_FormatB::Insert(index_, c4_Bytes (), count_);
|
|
return;
|
|
}
|
|
}
|
|
|
|
c4_FormatB::Insert(index_, buf_, count_);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
class c4_FormatV : public c4_FormatHandler
|
|
{
|
|
public:
|
|
c4_FormatV (const c4_Property& prop_, c4_HandlerSeq& seq_);
|
|
virtual ~c4_FormatV ();
|
|
|
|
virtual void Define(int rows_, const t4_byte** ptr_);
|
|
virtual void OldDefine(char type_, c4_Persist&);
|
|
virtual void Commit(c4_SaveContext& ar_);
|
|
|
|
virtual void FlipBytes();
|
|
|
|
virtual int ItemSize(int index_);
|
|
virtual const void* Get(int index_, int& length_);
|
|
virtual void Set(int index_, const c4_Bytes& buf_);
|
|
|
|
virtual void Insert(int index_, const c4_Bytes& buf_, int count_);
|
|
virtual void Remove(int index_, int count_);
|
|
|
|
virtual void Unmapped();
|
|
virtual bool HasSubview(int index_);
|
|
|
|
static int DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_);
|
|
|
|
private:
|
|
c4_HandlerSeq& At(int index_);
|
|
void Replace(int index_, c4_HandlerSeq* seq_);
|
|
void SetupAllSubviews();
|
|
void ForgetSubview(int index_);
|
|
|
|
c4_Column _data;
|
|
c4_PtrArray _subSeqs;
|
|
bool _inited;
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
c4_FormatV::c4_FormatV (const c4_Property& prop_, c4_HandlerSeq& seq_)
|
|
: c4_FormatHandler (prop_, seq_), _data (seq_.Persist()), _inited (false)
|
|
{
|
|
}
|
|
|
|
c4_FormatV::~c4_FormatV ()
|
|
{
|
|
for (int i = 0; i < _subSeqs.GetSize(); ++i)
|
|
ForgetSubview(i);
|
|
}
|
|
|
|
c4_HandlerSeq& c4_FormatV::At(int index_)
|
|
{
|
|
d4_assert(_inited);
|
|
|
|
c4_HandlerSeq*& hs = (c4_HandlerSeq*&) _subSeqs.ElementAt(index_);
|
|
if (hs == 0) {
|
|
hs = d4_new c4_HandlerSeq (Owner(), this);
|
|
hs->IncRef();
|
|
}
|
|
|
|
return *hs;
|
|
}
|
|
|
|
void c4_FormatV::SetupAllSubviews()
|
|
{
|
|
d4_assert(!_inited);
|
|
_inited = true;
|
|
|
|
if (_data.ColSize() > 0) {
|
|
c4_Bytes temp;
|
|
_data.FetchBytes(0, _data.ColSize(), temp, true);
|
|
const t4_byte* ptr = temp.Contents();
|
|
|
|
for (int r = 0; r < _subSeqs.GetSize(); ++r) {
|
|
// don't materialize subview if it is empty
|
|
// duplicates code which is in c4_HandlerSeq::Prepare
|
|
const t4_byte* p2 = ptr;
|
|
d4_dbgdef(t4_i32 sias =)
|
|
c4_Column::PullValue(p2);
|
|
d4_assert(sias == 0); // not yet
|
|
|
|
if (c4_Column::PullValue(p2) > 0)
|
|
At(r).Prepare(&ptr, false);
|
|
else
|
|
ptr = p2;
|
|
}
|
|
|
|
d4_assert(ptr == temp.Contents() + temp.Size());
|
|
}
|
|
}
|
|
|
|
void c4_FormatV::Define(int rows_, const t4_byte** ptr_)
|
|
{
|
|
if (_inited) {
|
|
// big oops: a root handler already tqcontains data
|
|
|
|
for (int i = 0; i < _subSeqs.GetSize(); ++i)
|
|
ForgetSubview(i);
|
|
|
|
_inited = false;
|
|
}
|
|
|
|
_subSeqs.SetSize(rows_);
|
|
if (ptr_ != 0)
|
|
_data.PullLocation(*ptr_);
|
|
}
|
|
|
|
void c4_FormatV::OldDefine(char, c4_Persist& pers_)
|
|
{
|
|
int rows = Owner().NumRows();
|
|
_subSeqs.SetSize(rows);
|
|
|
|
for (int i = 0; i < rows; ++i) {
|
|
int n = pers_.FetchOldValue();
|
|
if (n) {
|
|
// 14-11-2000: do not create again (this causes a mem leak)
|
|
// 04-12-2000: but do create if absent (fixes occasional crash)
|
|
c4_HandlerSeq* hs = (c4_HandlerSeq*) _subSeqs.GetAt(i);
|
|
if (hs == 0) {
|
|
hs = d4_new c4_HandlerSeq (Owner(), this);
|
|
_subSeqs.SetAt(i, hs);
|
|
hs->IncRef();
|
|
}
|
|
hs->SetNumRows(n);
|
|
hs->OldPrepare();
|
|
}
|
|
}
|
|
}
|
|
|
|
void c4_FormatV::FlipBytes()
|
|
{
|
|
if (!_inited)
|
|
SetupAllSubviews();
|
|
|
|
for (int i = 0; i < _subSeqs.GetSize(); ++i)
|
|
At(i).FlipAllBytes();
|
|
}
|
|
|
|
int c4_FormatV::ItemSize(int index_)
|
|
{
|
|
if (!_inited)
|
|
SetupAllSubviews();
|
|
|
|
// 06-02-2002: avoid creating empty subview
|
|
c4_HandlerSeq* hs = (c4_HandlerSeq*&) _subSeqs.ElementAt(index_);
|
|
return hs == 0 ? 0 : hs->NumRows();
|
|
}
|
|
|
|
const void* c4_FormatV::Get(int index_, int& length_)
|
|
{
|
|
if (!_inited)
|
|
SetupAllSubviews();
|
|
|
|
At(index_); // forces existence of a real entry
|
|
c4_HandlerSeq*& e = (c4_HandlerSeq*&) _subSeqs.ElementAt(index_);
|
|
|
|
length_ = sizeof (c4_HandlerSeq**);
|
|
return &e;
|
|
}
|
|
|
|
void c4_FormatV::Set(int index_, const c4_Bytes& buf_)
|
|
{
|
|
d4_assert(buf_.Size() == sizeof (c4_Sequence*));
|
|
|
|
if (!_inited)
|
|
SetupAllSubviews();
|
|
|
|
c4_HandlerSeq* value = *(c4_HandlerSeq* const*) buf_.Contents();
|
|
|
|
if (value != & At(index_))
|
|
Replace(index_, value);
|
|
}
|
|
|
|
void c4_FormatV::Replace(int index_, c4_HandlerSeq* seq_)
|
|
{
|
|
if (!_inited)
|
|
SetupAllSubviews();
|
|
|
|
c4_HandlerSeq*& curr = (c4_HandlerSeq*&) _subSeqs.ElementAt(index_);
|
|
if (seq_ == curr)
|
|
return;
|
|
|
|
if (curr != 0) {
|
|
d4_assert(&curr->Parent() == &Owner());
|
|
curr->DetachFromParent();
|
|
curr->DetachFromStorage(true);
|
|
|
|
curr->DecRef();
|
|
curr = 0;
|
|
}
|
|
|
|
if (seq_) {
|
|
int n = seq_->NumRows();
|
|
|
|
c4_HandlerSeq& t = At(index_);
|
|
d4_assert(t.NumRows() == 0);
|
|
|
|
t.Resize(n);
|
|
|
|
c4_Bytes data;
|
|
|
|
// this dest seq has only the persistent handlers
|
|
// and maybe in a different order
|
|
// create any others we need as temporary properties
|
|
for (int i = 0; i < seq_->NumHandlers(); ++i) {
|
|
c4_Handler& h1 = seq_->NthHandler(i);
|
|
|
|
int j = t.PropIndex(h1.Property());
|
|
d4_assert(j >= 0);
|
|
|
|
c4_Handler& h2 = t.NthHandler(j);
|
|
|
|
for (int k = 0; k < n; ++k)
|
|
if (seq_->Get(k, h1.PropId(), data))
|
|
h2.Set(k, data);
|
|
}
|
|
}
|
|
}
|
|
|
|
int c4_FormatV::DoCompare(const c4_Bytes& b1_, const c4_Bytes& b2_)
|
|
{
|
|
d4_assert(b1_.Size() == sizeof (c4_Sequence*));
|
|
d4_assert(b2_.Size() == sizeof (c4_Sequence*));
|
|
|
|
c4_View v1 = *(c4_Sequence* const*) b1_.Contents();
|
|
c4_View v2 = *(c4_Sequence* const*) b2_.Contents();
|
|
|
|
return v1.Compare(v2);
|
|
}
|
|
|
|
void c4_FormatV::Insert(int index_, const c4_Bytes& buf_, int count_)
|
|
{
|
|
d4_assert(buf_.Size() == sizeof (c4_Sequence*));
|
|
d4_assert(count_ > 0);
|
|
|
|
// can only insert an empty entry!
|
|
d4_assert(*(c4_Sequence* const*) buf_.Contents() == 0);
|
|
|
|
if (!_inited)
|
|
SetupAllSubviews();
|
|
|
|
_subSeqs.InsertAt(index_, 0, count_);
|
|
_data.SetBuffer(0); // 2004-01-18 force dirty
|
|
}
|
|
|
|
void c4_FormatV::Remove(int index_, int count_)
|
|
{
|
|
d4_assert(count_ > 0);
|
|
|
|
if (!_inited)
|
|
SetupAllSubviews();
|
|
|
|
for (int i = 0; i < count_; ++i)
|
|
ForgetSubview(index_ + i);
|
|
|
|
_subSeqs.RemoveAt(index_, count_);
|
|
_data.SetBuffer(0); // 2004-01-18 force dirty
|
|
}
|
|
|
|
void c4_FormatV::Unmapped()
|
|
{
|
|
if (_inited)
|
|
for (int i = 0; i < _subSeqs.GetSize(); ++i)
|
|
if (HasSubview(i)) {
|
|
c4_HandlerSeq& hs = At(i);
|
|
hs.UnmappedAll();
|
|
if (hs.NumRefs() == 1 && hs.NumRows() == 0)
|
|
ForgetSubview(i);
|
|
}
|
|
|
|
_data.ReleaseAllSegments();
|
|
}
|
|
|
|
bool c4_FormatV::HasSubview(int index_)
|
|
{
|
|
if (!_inited)
|
|
SetupAllSubviews();
|
|
|
|
return _subSeqs.ElementAt(index_) != 0;
|
|
}
|
|
|
|
void c4_FormatV::ForgetSubview(int index_)
|
|
{
|
|
c4_HandlerSeq*& seq = (c4_HandlerSeq*&) _subSeqs.ElementAt(index_);
|
|
if (seq != 0) {
|
|
d4_assert(&seq->Parent() == &Owner());
|
|
seq->DetachFromParent();
|
|
seq->DetachFromStorage(true);
|
|
seq->UnmappedAll();
|
|
seq->DecRef();
|
|
seq = 0;
|
|
}
|
|
}
|
|
|
|
void c4_FormatV::Commit(c4_SaveContext& ar_)
|
|
{
|
|
if (!_inited)
|
|
SetupAllSubviews();
|
|
|
|
int rows = _subSeqs.GetSize();
|
|
d4_assert(rows > 0);
|
|
|
|
c4_Column temp (0);
|
|
c4_Column* saved = ar_.SetWalkBuffer(&temp);
|
|
|
|
for (int r = 0; r < rows; ++r)
|
|
if (HasSubview(r)) {
|
|
c4_HandlerSeq& hs = At(r);
|
|
ar_.CommitSequence(hs, false);
|
|
if (hs.NumRefs() == 1 && hs.NumRows() == 0)
|
|
ForgetSubview(r);
|
|
} else {
|
|
ar_.StoreValue(0); // sias
|
|
ar_.StoreValue(0); // row count
|
|
}
|
|
|
|
ar_.SetWalkBuffer(saved);
|
|
|
|
c4_Bytes buf;
|
|
temp.FetchBytes(0, temp.ColSize(), buf, true);
|
|
|
|
bool changed = temp.ColSize() != _data.ColSize();
|
|
|
|
if (!changed) {
|
|
c4_Bytes buf2;
|
|
_data.FetchBytes(0, _data.ColSize(), buf2, true);
|
|
changed = buf != buf2;
|
|
}
|
|
|
|
if (changed) {
|
|
_data.SetBuffer(buf.Size());
|
|
_data.StoreBytes(0, buf);
|
|
}
|
|
|
|
ar_.CommitColumn(_data);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
c4_Handler* f4_CreateFormat(const c4_Property& prop_, c4_HandlerSeq& seq_)
|
|
{
|
|
switch (prop_.Type()) {
|
|
case 'I': return d4_new c4_FormatX (prop_, seq_);
|
|
#if !q4_TINY
|
|
case 'L': return d4_new c4_FormatL (prop_, seq_);
|
|
case 'F': return d4_new c4_FormatF (prop_, seq_);
|
|
case 'D': return d4_new c4_FormatD (prop_, seq_);
|
|
#endif
|
|
case 'B': return d4_new c4_FormatB (prop_, seq_);
|
|
case 'S': return d4_new c4_FormatS (prop_, seq_);
|
|
case 'V': return d4_new c4_FormatV (prop_, seq_);
|
|
}
|
|
|
|
d4_assert(0);
|
|
// 2004-01-16 turn bad definition type into an int property to avoid crash
|
|
return d4_new c4_FormatX (c4_IntProp (prop_.Name()), seq_);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
int f4_ClearFormat(char type_)
|
|
{
|
|
switch (type_) {
|
|
case 'I': return sizeof (t4_i32);
|
|
#if !q4_TINY
|
|
case 'L': return sizeof (t4_i64);
|
|
case 'F': return sizeof (float);
|
|
case 'D': return sizeof (double);
|
|
#endif
|
|
case 'S': return 1;
|
|
case 'V': return sizeof (c4_Sequence*);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
int f4_CompareFormat(char type_, const c4_Bytes& b1_, const c4_Bytes& b2_)
|
|
{
|
|
switch (type_) {
|
|
case 'I': return c4_FormatX::DoCompare(b1_, b2_);
|
|
#if !q4_TINY
|
|
case 'L': return c4_FormatL::DoCompare(b1_, b2_);
|
|
case 'F': return c4_FormatF::DoCompare(b1_, b2_);
|
|
case 'D': return c4_FormatD::DoCompare(b1_, b2_);
|
|
#endif
|
|
case 'B': return c4_FormatB::DoCompare(b1_, b2_);
|
|
case 'S': return c4_FormatS::DoCompare(b1_, b2_);
|
|
case 'V': return c4_FormatV::DoCompare(b1_, b2_);
|
|
}
|
|
|
|
d4_assert(0);
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|