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());
}
}
void c4_FormatX::Define(int rows_, const t4_byte** ptr_)
{
if (ptr_ != 0)
_data.PullLocation(*ptr_);
_data.SetRowCount(rows_);
}
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::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_FormatX::FlipBytes() {
_data.FlipBytes();
}
void c4_FormatX::OldDefine(char, c4_Persist &pers_) {
pers_.FetchOldLocation(_data);
_data.SetRowCount(Owner().NumRows());
}
void c4_FormatX::Commit(c4_SaveContext &ar_) {
_data.FixSize(true);
ar_.CommitColumn(_data);
//_data.FixSize(false);
}
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();
}
void c4_FormatX::Unmapped() {
_data.ReleaseAllSegments();
}
void c4_FormatX::Remove(int index_, int count_) {
_data.Remove(index_, count_);
}
void c4_FormatX::Insert(int index_, const c4_Bytes &buf_, int count_) {
_data.Insert(index_, buf_, count_);
}
void c4_FormatX::Set(int index_, const c4_Bytes &buf_) {
_data.Set(index_, buf_);
}
const void *c4_FormatX::Get(int index_, int &length_) {
return _data.Get(index_, length_);
}
int c4_FormatX::ItemSize(int index_) {
return _data.ItemSize(index_);
}
