TupleAccessor Class Reference

TupleAccessor defines how to efficiently marshal and unmarshal values in a stored tuple. More...

#include <TupleAccessor.h>

List of all members.

Public Types
typedef uint16_t	StoredValueOffset
Public Member Functions
	TupleAccessor ()
virtual	~TupleAccessor ()
void	compute (TupleDescriptor const &tuple, TupleFormat format=TUPLE_FORMAT_STANDARD)
	Precomputes access for a particular tuple format.
uint	getMaxByteCount () const
	Returns: the maximum possible tuple storage size in bytes
uint	getMinByteCount () const
	Returns: the minimum possible tuple storage size in bytes
bool	isFixedWidth () const
	Returns: whether all tuples have the same fixed size
uint	getBitFieldOffset () const
	Returns: the offset of the first byte of bit fields, or MAXU if no bit fields
PConstBuffer	getCurrentTupleBuf () const
	Accesses the buffer storing the current tuple image.
void	setCurrentTupleBuf (PConstBuffer pTupleBuf, bool valid=true)
	Sets the buffer storing the current tuple image.
void	resetCurrentTupleBuf ()
	Forgets the current tuple buffer.
uint	getCurrentByteCount () const
	Determines the number of bytes stored in the current tuple buffer.
uint	getBufferByteCount (PConstBuffer pBuf) const
	Determines the number of bytes stored in a tuple buffer without actually preparing to unmarshal it.
uint	getByteCount (TupleData const &tuple) const
	Determines the number of bytes required to store a tuple without actually marshalling it.
bool	isBufferSufficient (TupleData const &tuple, uint cbBuffer) const
	Determines whether a buffer is big enough to fit marshalled tuple data.
void	unmarshal (TupleData &tuple, uint iFirstDatum=0) const
	Unmarshals the current tuple buffer, setting a tuple's values to reference the contents.
AttributeAccessor const &	getAttributeAccessor (uint iAttribute) const
	Gets an accessor for an individual attribute.
void	marshal (TupleData const &tuple, PBuffer pTupleBuf)
	Marshals a tuple's values into a buffer.
uint	size () const
	Returns: number of attributes accessed
boost::dynamic_bitset< FixedBuffer > const &	getBitFields () const
	Returns: the array of bit fields for the current tuple image
StoredValueOffset const *	referenceIndirectOffset (uint iIndirectOffset) const
	Resolves an indirect offset into a pointer to the data offset.
Static Public Member Functions
static StoredValueOffset *	referenceIndirectOffset (PBuffer pTupleBuf, uint iIndirectOffset)
	Resolves an indirect offset into a pointer to the data offset.
Static Public Attributes
static const bool	BOOL_TRUE
	Constant value for true.
static const bool	BOOL_FALSE
	Constant value for false.
Private Member Functions
void	initFixedAccessors (TupleDescriptor const &, VectorOfUint &)
void	clear ()
Private Attributes
std::vector< AttributeAccessor * >	ppAttributeAccessors
	Precomputed accessors for attributes, in logical tuple order.
VectorOfUint	pVarWidthAttrIndices
	Array of 0-based indices of variable-width attributes.
VectorOfUint	marshalOrder
	Permutation in which attributes should be marshalled; empty when !bAlignedVar, in which case attributes should be marshalled in logical order.
uint	cbMaxStorage
	See also: getMaxByteCount()
uint	cbMinStorage
	See also: getMinByteCount()
uint	nBitFields
	Precomputed size of bit field array (in bits).
uint	iBitFieldOffset
	Precomputed byte offset for bit array.
uint	iFirstVarEndIndirectOffset
	Precomputed offset for indirect offset of end of first variable-width attribute, or MAXU if there are no variable-width attributes.
uint	iLastVarEndIndirectOffset
	Precomputed offset for indirect offset of end of last variable-width attribute, or MAXU if there are no variable-length attributes.
uint	iFirstVarOffset
	Precomputed offset for fixed start of first variable-width attribute, or MAXU if there are no variable-width attributes.
bool	bAlignedVar
	Whether any variable-width attributes with alignment requirements (currently restricted to 2-byte alignment for UNICODE strings) are present.
PConstBuffer	pTupleBuf
	See also: getCurrentTupleBuf()
boost::dynamic_bitset< FixedBuffer >	bitFields
	See also: getBitFields()
TupleFormat	format

---

Detailed Description

TupleAccessor defines how to efficiently marshal and unmarshal values in a stored tuple.

The same logical tuple definition can have multiple storage formats. See the design docs for more details.

Definition at line 48 of file TupleAccessor.h.

---

Member Typedef Documentation

typedef uint16_t TupleAccessor::StoredValueOffset

Definition at line 130 of file TupleAccessor.h.

---

Constructor & Destructor Documentation

TupleAccessor::TupleAccessor

(

)

[explicit]

Definition at line 55 of file TupleAccessor.cpp.

References pTupleBuf.

{
    pTupleBuf = NULL;
}

TupleAccessor::~TupleAccessor

(

)

[virtual]

Definition at line 60 of file TupleAccessor.cpp.

References clear().

{
    clear();
}

---

Member Function Documentation

void TupleAccessor::initFixedAccessors	(	TupleDescriptor const &	,
		VectorOfUint &
	)			[private]

Definition at line 403 of file TupleAccessor.cpp.

References cbMaxStorage, TupleAttributeDescriptor::cbStorage, AttributeAccessor::iFixedOffset, and ppAttributeAccessors.

Referenced by compute().

{
    for (uint i = 0; i < v.size(); i++) {
        uint iAttr = v[i];
        TupleAttributeDescriptor const &attr = tuple[iAttr];
        AttributeAccessor &accessor = *(ppAttributeAccessors[iAttr]);
        accessor.iFixedOffset = cbMaxStorage;
        cbMaxStorage += attr.cbStorage;
    }
}

void TupleAccessor::clear

(

)

[private]

Definition at line 65 of file TupleAccessor.cpp.

References bAlignedVar, marshalOrder, ppAttributeAccessors, pTupleBuf, and pVarWidthAttrIndices.

Referenced by compute(), and ~TupleAccessor().

{
    using namespace boost::lambda;
    std::for_each(
        ppAttributeAccessors.begin(),
        ppAttributeAccessors.end(),
        bind(delete_ptr(),_1));
    ppAttributeAccessors.clear();
    pVarWidthAttrIndices.clear();
    marshalOrder.clear();
    pTupleBuf = NULL;
    bAlignedVar = false;
}

void TupleAccessor::compute	(	TupleDescriptor const &	tuple,
		TupleFormat	format = TUPLE_FORMAT_STANDARD
	)

Precomputes access for a particular tuple format.

Must be called before any other method.

Parameters:

	tuple	the tuple to be accessed
	format	how to store tuple

Definition at line 85 of file TupleAccessor.cpp.

References alignRoundUp(), bAlignedVar, bitFields, bytesForBits(), cbMaxStorage, cbMinStorage, AttributeAccessor::cbStorage, TupleAttributeDescriptor::cbStorage, clear(), format, StoredTypeDescriptor::getAlignmentByteCount(), getAttributeAccessor(), StoredTypeDescriptor::getBitCount(), StoredTypeDescriptor::getFixedByteCount(), StoredTypeDescriptor::getMinByteCount(), StoredTypeDescriptor::getOrdinal(), iBitFieldOffset, iFirstVarEndIndirectOffset, iFirstVarOffset, AttributeAccessor::iFixedOffset, iLastVarEndIndirectOffset, initFixedAccessors(), AttributeAccessor::iNullBit, StandardTypeDescriptor::isArray(), isMAXU(), TupleAttributeDescriptor::isNullable, marshalOrder, MAXU, nBitFields, ppAttributeAccessors, TupleAttributeDescriptor::pTypeDescriptor, pVarWidthAttrIndices, TUPLE_FORMAT_ALL_FIXED, and TUPLE_FORMAT_NETWORK.

Referenced by BTreeAccessBase::BTreeAccessBase(), BTreeReadersTest::BTreeReadersTest(), BTreeTest::BTreeTest(), TupleDataWithBuffer::computeAndAllocate(), ReshapeExecStream::copyCompareTuple(), FtrsTableWriter::createIndexWriter(), CalcAssembler::createTupleData(), ExternalSortMerger::ExternalSortMerger(), ExternalSortOutput::ExternalSortOutput(), ExternalSortRunAccessor::ExternalSortRunAccessor(), ExternalSortRunLoader::ExternalSortRunLoader(), FtrsTableWriter::FtrsTableWriter(), LcsRowScanExecStreamTest::generateBitmaps(), LbmSplicerExecStreamTest::generateRidInput(), LbmSplicerExecStreamTest::generateTupleInput(), LhxHashKeyAccessor::init(), LhxHashDataAccessor::init(), LbmSearchTest::initEqualSearch(), LbmExecStreamTestBase::initKeyBitmap(), ExternalSortRunAccessor::initRead(), Java_net_sf_farrago_fennel_FennelStorage_getAccessorXmiForTupleDescriptor(), BTreeNodeAccessor::onInit(), LhxPartitionReader::open(), LhxPartitionWriter::open(), ErrorSource::postError(), LbmSearchExecStream::prepare(), LbmNormalizerExecStream::prepare(), BTreePrefetchSearchExecStream::prepare(), ExecStreamBufAccessor::setTupleShape(), TestCalculator::setUp(), LbmExecStreamTestBase::testCaseSetUp(), CollectExecStreamTestSuite::testCollectInts(), LcsRowScanExecStreamTest::testFilterCols(), LbmSplicerExecStreamTest::testLER5968(), LbmSplicerExecStreamTest::testLER6473(), ExecStreamTestSuite::testMergeImplicitPullInputs(), BTreeTest::testMultiKeySearches(), LbmSearchTest::testMultipleRanges(), ExecStreamTestSuite::testReshapeExecStream(), TupleTest::testStandardTypes(), TupleTest::testZeroByteTuple(), tupleFiddle(), unitTestBool(), unitTestFloat(), unitTestLong(), unitTestNullableLocal(), unitTestPointer(), unitTestPointerCache(), unitTestStatusRegister(), unitTestWarnings(), and ExecStreamUnitTestBase::verifyBufferedOutput().

{
    clear();
    format = formatInit;

    // these vectors keep track of the logical 0-based indices of the
    // attributes belonging to the various attribute storage classes
    VectorOfUint aligned8;
    VectorOfUint aligned4;
    VectorOfUint aligned2;
    VectorOfUint unalignedFixed;
    VectorOfUint unalignedVar;
    VectorOfUint alignedVar2;

    // special-case reference to the accessor for the first variable-width
    // attribute
    AttributeAccessor *pFirstVariableAccessor = NULL;

    // number of bit fields seen so far
    nBitFields = 0;

    // sum of max storage size for variable-width attributes seen so far
    uint cbVarDataMax = 0;

    // sum of total storage size seen so far; this is used as an accumulator
    // for assigning actual offsets
    cbMaxStorage = 0;

#if DEBUG_TUPLE_ACCESS
    cbMaxStorage += sizeof(MagicNumber);
#endif

    // first pass over all attributes in logical order:  collate them into
    // storage classes and precompute everything we can
    for (uint iAttr = 0; iAttr < tuple.size(); iAttr++) {
        AttributeAccessor *pNewAccessor;
        TupleAttributeDescriptor const &attr = tuple[iAttr];
        uint cbFixed = attr.pTypeDescriptor->getFixedByteCount();
        uint cbMin = attr.pTypeDescriptor->getMinByteCount(attr.cbStorage);
        if (cbFixed) {
            assert(cbFixed == attr.cbStorage);
            assert(cbFixed == cbMin);
        }
        bool bFixedWidth = (cbMin == attr.cbStorage);
        if (bFixedWidth && !attr.cbStorage) {
            if (!attr.pTypeDescriptor->getMinByteCount(1)) {
                // this is a "0-length variable-width" field masquerading
                // as a fixed-width field
                bFixedWidth = false;
            }
        }
        bool bNullable = attr.isNullable;
        uint nBits = (attr.pTypeDescriptor->getBitCount());
        assert(nBits <= 1);
        if (format == TUPLE_FORMAT_ALL_FIXED) {
            bFixedWidth = true;
            nBits = 0;
        }
        uint iAlign = attr.pTypeDescriptor->getAlignmentByteCount(
            attr.cbStorage);
        if (!bFixedWidth) {
            cbVarDataMax += attr.cbStorage;
            if (iAlign == 2) {
                alignedVar2.push_back(iAttr);
                bAlignedVar = true;
            } else {
                assert(iAlign == 1);
                unalignedVar.push_back(iAttr);
            }
            // We need to defer actual creation of the accessor until
            // after we've sorted out aligned from unaligned, so just
            // fill a placeholder into the array for now and
            // we'll overwrite it later.
            pNewAccessor = new VarOffsetAccessor<false>();
        } else if (nBits) {
            if (bNullable) {
                pNewAccessor = new NullableAccessor<BitAccessor>;
            } else {
                pNewAccessor = new BitAccessor;
            }
            pNewAccessor->iValueBit = nBitFields;
            nBitFields++;
        } else {
            assert((cbMin % iAlign) == 0);
            bool bArray =
                StandardTypeDescriptor::isArray(
                    StandardTypeDescriptorOrdinal(
                        attr.pTypeDescriptor->getOrdinal()));
            switch (iAlign) {
            case 2:
                if (bNullable) {
                    if ((format == TUPLE_FORMAT_NETWORK) && !bArray) {
                        pNewAccessor =
                            new NullableAccessor<FixedWidthNetworkAccessor16>;
                    } else {
                        pNewAccessor =
                            new NullableAccessor<FixedWidthAccessor>;
                    }
                } else {
                    if ((format == TUPLE_FORMAT_NETWORK) && !bArray) {
                        pNewAccessor = new FixedWidthNetworkAccessor16;
                    } else {
                        pNewAccessor = new FixedWidthAccessor;
                    }
                }
                break;
            case 4:
                if (bNullable) {
                    if (format == TUPLE_FORMAT_NETWORK) {
                        pNewAccessor =
                            new NullableAccessor<FixedWidthNetworkAccessor32>;
                    } else {
                        pNewAccessor =
                            new NullableAccessor<FixedWidthAccessor>;
                    }
                } else {
                    if (format == TUPLE_FORMAT_NETWORK) {
                        pNewAccessor = new FixedWidthNetworkAccessor32;
                    } else {
                        pNewAccessor = new FixedWidthAccessor;
                    }
                }
                break;
            case 8:
                if (bNullable) {
                    if (format == TUPLE_FORMAT_NETWORK) {
                        pNewAccessor =
                            new NullableAccessor<FixedWidthNetworkAccessor64>;
                    } else {
                        pNewAccessor =
                            new NullableAccessor<FixedWidthAccessor>;
                    }
                } else {
                    if (format == TUPLE_FORMAT_NETWORK) {
                        pNewAccessor = new FixedWidthNetworkAccessor64;
                    } else {
                        pNewAccessor = new FixedWidthAccessor;
                    }
                }
                break;
            default:
                if (bNullable) {
                    pNewAccessor = new NullableAccessor<FixedWidthAccessor>;
                } else {
                    pNewAccessor = new FixedWidthAccessor;
                }
                break;
            }
            switch (iAlign) {
            case 1:
                unalignedFixed.push_back(iAttr);
                break;
            case 2:
                aligned2.push_back(iAttr);
                break;
            case 4:
                aligned4.push_back(iAttr);
                break;
            case 8:
                aligned8.push_back(iAttr);
                break;
            default:
                permAssert(false);
            }
        }
        if (bNullable) {
            pNewAccessor->iNullBit = nBitFields;
            nBitFields++;
        }
        pNewAccessor->cbStorage = attr.cbStorage;
        ppAttributeAccessors.push_back(pNewAccessor);
    }
    bitFields.resize(nBitFields);

    // fill in variable-width attributes, since we had to defer them
    // above so that we could collect aligned ones before unaligned ones
    pVarWidthAttrIndices.resize(alignedVar2.size() + unalignedVar.size());
    std::copy(
        alignedVar2.begin(), alignedVar2.end(),
        pVarWidthAttrIndices.begin());
    std::copy(
        unalignedVar.begin(), unalignedVar.end(),
        pVarWidthAttrIndices.begin() + alignedVar2.size());
    for (uint i = 0; i < pVarWidthAttrIndices.size(); ++i) {
        uint iAttr = pVarWidthAttrIndices[i];
        TupleAttributeDescriptor const &attr = tuple[iAttr];
        bool bNullable = attr.isNullable;
        AttributeAccessor *pNewAccessor;
        if (pFirstVariableAccessor) {
            if (bNullable) {
                if (format == TUPLE_FORMAT_NETWORK) {
                    pNewAccessor =
                        new NullableAccessor< VarOffsetAccessor<true> >;
                } else {
                    pNewAccessor =
                        new NullableAccessor< VarOffsetAccessor<false> >;
                }
            } else {
                if (format == TUPLE_FORMAT_NETWORK) {
                    pNewAccessor = new VarOffsetAccessor<true>;
                } else {
                    pNewAccessor = new VarOffsetAccessor<false>;
                }
            }
        } else {
            if (bNullable) {
                if (format == TUPLE_FORMAT_NETWORK) {
                    pFirstVariableAccessor =
                        new NullableAccessor<
                        FixedOffsetVarWidthAccessor<true> >;
                } else {
                    pFirstVariableAccessor =
                        new NullableAccessor<
                        FixedOffsetVarWidthAccessor<false> >;
                }
            } else {
                if (format == TUPLE_FORMAT_NETWORK) {
                    pFirstVariableAccessor =
                        new FixedOffsetVarWidthAccessor<true>;
                } else {
                    pFirstVariableAccessor =
                        new FixedOffsetVarWidthAccessor<false>;
                }
            }
            pNewAccessor = pFirstVariableAccessor;
        }
        AttributeAccessor *pPlaceholder = ppAttributeAccessors[iAttr];
        pNewAccessor->cbStorage = attr.cbStorage;
        pNewAccessor->iNullBit = pPlaceholder->iNullBit;
        // overwrite placeholder
        ppAttributeAccessors[iAttr] = pNewAccessor;
        delete pPlaceholder;
    }

    // now, make a pass over each storage class, calculating actual offsets;
    // note that initFixedAccessors advances cbMaxStorage as a side-effect
    initFixedAccessors(tuple,aligned8);
    initFixedAccessors(tuple,aligned4);
    initFixedAccessors(tuple,aligned2);

    if (pFirstVariableAccessor) {
        iFirstVarEndIndirectOffset = cbMaxStorage;
    } else {
        iFirstVarEndIndirectOffset = MAXU;
    }

    for (uint i = 0; i < pVarWidthAttrIndices.size(); i++) {
        ppAttributeAccessors[pVarWidthAttrIndices[i]]->iEndIndirectOffset =
            cbMaxStorage;
        cbMaxStorage += sizeof(StoredValueOffset);
    }

    if (pFirstVariableAccessor) {
        iLastVarEndIndirectOffset = cbMaxStorage - sizeof(StoredValueOffset);
    } else {
        iLastVarEndIndirectOffset = MAXU;
    }

    initFixedAccessors(tuple,unalignedFixed);

    if (nBitFields) {
        iBitFieldOffset = cbMaxStorage;
    } else {
        iBitFieldOffset = MAXU;
    }
    cbMaxStorage += bytesForBits(nBitFields);
    if (pFirstVariableAccessor) {
        if (bAlignedVar) {
            // First variable-width value needs to be 2-byte aligned,
            // so add one byte of padding if necessary.
            if (cbMaxStorage & 1) {
                ++cbMaxStorage;
            }
        }
        pFirstVariableAccessor->iFixedOffset = cbMaxStorage;
        iFirstVarOffset = cbMaxStorage;
    } else {
        iFirstVarOffset = MAXU;
    }
    cbMinStorage = cbMaxStorage;
    cbMaxStorage += cbVarDataMax;

    // Avoid 0-byte tuples, because it's very hard to count something
    // that isn't there.  This bumps them up to 1-byte, which will get
    // further bumped up to the minimum alignment unit below.
    if (!cbMaxStorage) {
        cbMinStorage = 1;
        cbMaxStorage = 1;
    }

    // now round the entire row width up to the next alignment boundary;
    // this only affects the end of the row, which is why it is done
    // AFTER computing cbMaxStorage based on the unaligned cbMinStorage
    cbMinStorage = alignRoundUp(cbMinStorage);
    cbMaxStorage = alignRoundUp(cbMaxStorage);

    // if aligned variable-width fields are present, permute the marshalling
    // order so that they come before unaligned variable-width fields
    if (bAlignedVar) {
        // add all of the fixed-width attributes
        for (uint i = 0; i < tuple.size(); ++i) {
            AttributeAccessor const &accessor = getAttributeAccessor(i);
            if (isMAXU(accessor.iEndIndirectOffset)) {
                marshalOrder.push_back(i);
            }
        }
        uint nFixed = marshalOrder.size();
        assert(nFixed + pVarWidthAttrIndices.size() == tuple.size());
        marshalOrder.resize(tuple.size());
        // then all of the variable-width attributes, in the correct order
        std::copy(
            pVarWidthAttrIndices.begin(),
            pVarWidthAttrIndices.end(),
            marshalOrder.begin() + nFixed);
    }
}

uint TupleAccessor::getMaxByteCount

(

)

const [inline]

Returns:

the maximum possible tuple storage size in bytes

Definition at line 165 of file TupleAccessor.h.

Referenced by BTreeReadersTest::BTreeReadersTest(), BTreeTest::BTreeTest(), TupleDataWithBuffer::computeAndAllocate(), CalcAssembler::createTupleData(), FtrsTableWriter::FtrsTableWriter(), LhxHashKeyAccessor::getAvgStorageSize(), LhxHashDataAccessor::getAvgStorageSize(), BTreePrefetchSearchExecStream::getResourceRequirements(), LbmSearchTest::initEqualSearch(), LbmExecStreamTestBase::initKeyBitmap(), isBufferSufficient(), ExternalSortRunLoader::loadRun(), BTreeCompactNodeAccessor::onInit(), LcsClusterAppendExecStream::open(), MockResourceExecStream::open(), ErrorSource::postError(), FtrsTableWriterExecStream::prepare(), MockProducerExecStream::prepare(), BarrierExecStream::prepare(), TestCalculator::setUp(), CollectExecStreamTestSuite::testCollectInts(), TupleTest::testDebugAccess(), LcsRowScanExecStreamTest::testFilterCols(), TupleTest::testMarshal(), ExecStreamTestSuite::testMergeImplicitPullInputs(), BTreeTest::testMultiKeySearches(), LbmSearchTest::testMultipleRanges(), ExecStreamTestSuite::testReshapeExecStream(), TupleTest::testStandardTypes(), TupleTest::testZeroByteTuple(), tupleFiddle(), unitTestBool(), unitTestFloat(), unitTestLong(), unitTestNullableLocal(), unitTestPointer(), unitTestPointerCache(), unitTestStatusRegister(), and unitTestWarnings().

    {
        return cbMaxStorage;
    }

uint TupleAccessor::getMinByteCount

(

)

const [inline]

Returns:

the minimum possible tuple storage size in bytes

Definition at line 173 of file TupleAccessor.h.

Referenced by LhxHashKeyAccessor::getAvgStorageSize(), LhxHashDataAccessor::getAvgStorageSize(), Java_net_sf_farrago_fennel_FennelStorage_getAccessorXmiForTupleDescriptor(), FtrsTableWriter::redoLogicalAction(), TupleTest::testStandardTypes(), and TupleTest::testZeroByteTuple().

    {
        return cbMinStorage;
    }

bool TupleAccessor::isFixedWidth

(

)

const [inline]

Returns:

whether all tuples have the same fixed size

Definition at line 181 of file TupleAccessor.h.

References isMAXU().

Referenced by BTreeAccessBase::BTreeAccessBase(), getBufferByteCount(), getByteCount(), BTreeHeapNodeAccessor::hasFixedWidthEntries(), and MockProducerExecStream::prepare().

    {
        return isMAXU(iFirstVarOffset);
    }

uint TupleAccessor::getBitFieldOffset

(

)

const [inline]

Returns:

the offset of the first byte of bit fields, or MAXU if no bit fields

Definition at line 190 of file TupleAccessor.h.

Referenced by Java_net_sf_farrago_fennel_FennelStorage_getAccessorXmiForTupleDescriptor().

    {
        return iBitFieldOffset;
    }

PConstBuffer TupleAccessor::getCurrentTupleBuf

(

)

const [inline]

Accesses the buffer storing the current tuple image.

Returns:

address of tuple image, or NULL if no current tuple

Definition at line 200 of file TupleAccessor.h.

Referenced by ExecStreamBufAccessor::accessConsumptionTuple(), BTreeNodeAccessor::compactNode(), ExecStreamBufAccessor::consumeTuple(), BTreeWriter::deleteCurrent(), FtrsTableWriter::execute(), BTreeSortExecStream::execute(), LcsRowScanExecStream::initializeFiltersIfNeeded(), LhxPartitionReader::isTupleConsumptionPending(), ExecStreamBufAccessor::isTupleConsumptionPending(), BTreeNodeAccessor::splitNode(), unmarshal(), VarOffsetAccessor< network >::unmarshalValue(), FixedOffsetVarWidthAccessor< network >::unmarshalValue(), and FixedWidthAccessor::unmarshalValue().

    {
        return pTupleBuf;
    }

void TupleAccessor::setCurrentTupleBuf	(	PConstBuffer	pTupleBuf,
		bool	valid = true
	)

Sets the buffer storing the current tuple image.

Must be called before getCurrentByteCount and unmarshal.

Parameters:

	pTupleBuf	address of tuple image
	valid	(default: true) the buffer contains a marshalled tuple. False means the buffer is free space; unmarshal binds a TupleData to the buffer. This is useful only for TUPLE_FORMAT_ALL_FIXED.

REVIEW: An alternative is to require the caller to zero out the buffer; but that seems riskier.

Definition at line 463 of file TupleAccessor.cpp.

References bitFields, iBitFieldOffset, isMAXU(), pTupleBuf, and TUPLE_MAGIC_NUMBER.

Referenced by ExecStreamBufAccessor::accessConsumptionTuple(), BTreeWriter::checkMonotonicity(), TupleDataWithBuffer::computeAndAllocate(), ReshapeExecStream::copyCompareTuple(), CalcAssembler::createTupleData(), BTreeHeapNodeAccessor::deallocateEntry(), LhxPartitionReader::demandData(), BTreeNodeAccessor::dumpNode(), UncollectExecStream::execute(), ExecStreamBufAccessor::getConsumptionTuplesAvailable(), ExternalSortMerger::heapify(), LcsRowScanExecStream::initializeFiltersIfNeeded(), BTreeWriter::insertTupleFromBuffer(), BTreeBuildLevel::processInput(), BarrierExecStream::processInputTuple(), ExternalSortRunLoader::quickSortFindPivot(), ExternalSortRunLoader::quickSortPartition(), FtrsTableWriter::redoLogicalAction(), LhxHashKeyAccessor::setCurrent(), LhxHashDataAccessor::setCurrent(), LbmSearchExecStream::setLowerBoundKey(), BTreePrefetchSearchExecStream::setLowerBoundKey(), TestCalculator::setUp(), BTreePrefetchSearchExecStream::setUpSearchKey(), ExecStreamBufAccessor::spanWholeTuples(), BTreeWriter::splitCurrentNode(), TupleTest::testDebugAccess(), LbmSearchTest::testScanIdx(), LbmUnionExecStreamTest::testUnion(), ExecStreamScheduler::traceStreamBufferContents(), tupleFiddle(), unitTestBool(), unitTestFloat(), unitTestLong(), unitTestNullableLocal(), unitTestPointer(), unitTestPointerCache(), unitTestStatusRegister(), unitTestWarnings(), BTreeReadersTest::unmarshalLeafRecord(), BTreeTest::unmarshalRecord(), and ExecStreamUnitTestBase::verifyBufferedOutput().

{
    assert(pTupleBufInit);
    pTupleBuf = pTupleBufInit;          // bind to buffer
    if (!isMAXU(iBitFieldOffset)) {
        // if buffer holds a valid marshalled tuple, load its bitFields
        if (valid) {
#if DEBUG_TUPLE_ACCESS
            assert(
                *reinterpret_cast<MagicNumber const *>(pTupleBuf)
                == TUPLE_MAGIC_NUMBER);
#endif
            // TODO:  trick dynamic_bitset to avoid copy
            boost::from_block_range(
                pTupleBuf + iBitFieldOffset,
                pTupleBuf + iBitFieldOffset + bitFields.num_blocks(),
                bitFields);
        }
    }
}

void TupleAccessor::resetCurrentTupleBuf

(

)

Forgets the current tuple buffer.

Definition at line 484 of file TupleAccessor.cpp.

References pTupleBuf.

Referenced by ExecStreamBufAccessor::clear(), LhxPartitionReader::consumeTuple(), ExecStreamBufAccessor::consumeTuple(), and LhxPartitionReader::open().

{
    pTupleBuf = NULL;
}

uint TupleAccessor::getCurrentByteCount

(

)

const [inline]

Determines the number of bytes stored in the current tuple buffer.

This will always be greater than or equal to getMinByteCount() and less than getMaxByteCount().

Returns:

byte count

Definition at line 348 of file TupleAccessor.h.

References getBufferByteCount(), and pTupleBuf.

Referenced by BTreeNodeAccessor::compactNode(), LcsClusterAppendExecStream::compress(), ExecStreamBufAccessor::consumeTuple(), ReshapeExecStream::copyCompareTuple(), BTreeHeapNodeAccessor::deallocateEntry(), BTreeWriter::deleteCurrent(), FtrsTableWriterExecStream::execute(), FtrsTableWriter::execute(), BTreeSortExecStream::execute(), UncollectExecStream::execute(), MockResourceExecStream::execute(), BarrierExecStream::execute(), LbmSplicerExecStreamTest::generateRidInput(), LbmSplicerExecStreamTest::generateTupleInput(), ExecStreamBufAccessor::getConsumptionTuplesAvailable(), LcsRowScanExecStream::initializeFiltersIfNeeded(), BTreeWriter::insertTupleFromBuffer(), BTreeBuildLevel::processInput(), LcsRowScanExecStreamTest::produceEntry(), LbmExecStreamTestBase::produceEntry(), ExecStreamBufAccessor::produceTuple(), FtrsTableWriter::redoLogicalAction(), LcsRowScanExecStreamTest::setSearchKey(), LbmSearchTest::setSearchKey(), ExecStreamBufAccessor::spanWholeTuples(), BTreeWriter::splitCurrentNode(), BTreeNodeAccessor::splitNode(), BTreeTest::testBulkLoad(), LbmSplicerExecStreamTest::testLER5968(), LbmSplicerExecStreamTest::testLER6473(), TupleTest::testMarshal(), BTreeReadersTest::testReaders(), LbmSearchTest::testScanFullKey(), LbmSearchTest::testScanPartialKey(), ExecStreamScheduler::traceStreamBufferContents(), BTreeReadersTest::unmarshalLeafRecord(), BTreeTest::unmarshalRecord(), BTreeWriter::updateCurrent(), BTreeAccessBase::validateTupleSize(), and ExecStreamUnitTestBase::verifyBufferedOutput().

{
    assert(pTupleBuf);
    return getBufferByteCount(pTupleBuf);
}

uint TupleAccessor::getBufferByteCount

(

PConstBuffer

pBuf

)

const

Determines the number of bytes stored in a tuple buffer without actually preparing to unmarshal it.

Parameters:

pBuf

tuple buffer

Returns:

byte count

Definition at line 415 of file TupleAccessor.cpp.

References alignRoundUp(), cbMaxStorage, format, iLastVarEndIndirectOffset, isFixedWidth(), referenceIndirectOffset(), and TUPLE_FORMAT_NETWORK.

Referenced by LhxPartitionReader::demandData(), ExternalSortRunAccessor::fetch(), ExternalSortOutput::fetch(), ExecStreamBufAccessor::getConsumptionAvailableBounded(), getCurrentByteCount(), ExternalSortRunLoader::loadRun(), and ExternalSortRunAccessor::storeRun().

{
    if (isFixedWidth()) {
        return cbMaxStorage;
    } else {
        // variable-width tuple:  use the end of the last variable-width
        // attribute
        StoredValueOffset cb =
            *referenceIndirectOffset(
                const_cast<PBuffer>(pBuf),
                iLastVarEndIndirectOffset);
        if (format == TUPLE_FORMAT_NETWORK) {
            cb = ntohs(cb);
        }
        // round up for alignment padding
        return alignRoundUp(cb);
    }
}

uint TupleAccessor::getByteCount

(

TupleData const &

tuple

)

const

Determines the number of bytes required to store a tuple without actually marshalling it.

Parameters:

tuple

the tuple data

Returns:

byte count

Definition at line 434 of file TupleAccessor.cpp.

References alignRoundUp(), cbMaxStorage, iFirstVarOffset, isFixedWidth(), and pVarWidthAttrIndices.

Referenced by LhxPartitionWriter::aggAndMarshalTuple(), LhxPartitionWriter::close(), LhxHashKeyAccessor::getDiskStorageSize(), LhxHashDataAccessor::getDiskStorageSize(), LhxHashKeyAccessor::getStorageSize(), LhxHashDataAccessor::getStorageSize(), BTreeWriter::grow(), BTreeBuildLevel::indexLastChild(), VariableBuildLevel::indexLastKey(), isBufferSufficient(), LhxPartitionWriter::marshalTuple(), ErrorSource::postError(), BTreePrefetchSearchExecStream::setSearchKeyData(), TupleTest::testMarshal(), BTreeWriter::updateCurrent(), and ExecStreamBufAccessor::validateTupleSize().

{
    if (isFixedWidth()) {
        return cbMaxStorage;
    } else {
        // variable-width tuple:  add up all var-width fields
        uint cb = iFirstVarOffset;
        for (uint i = 0; i < pVarWidthAttrIndices.size(); ++i) {
            TupleDatum const &datum = tuple[pVarWidthAttrIndices[i]];
            if (datum.pData) {
                cb += datum.cbData;
            }
        }
        // round up for alignment padding
        return alignRoundUp(cb);
    }
}

bool TupleAccessor::isBufferSufficient	(	TupleData const &	tuple,
		uint	cbBuffer
	)			const

Determines whether a buffer is big enough to fit marshalled tuple data.

Parameters:

	tuple	the tuple to be marshalled
	cbBuffer	the size of the candidate buffer

Returns:

true if cbBuffer is big enough

Definition at line 452 of file TupleAccessor.cpp.

References getByteCount(), and getMaxByteCount().

Referenced by ExecStreamBufAccessor::produceTuple(), and ExecStreamBufAccessor::validateTupleSize().

{
    // fast optimistic check
    if (getMaxByteCount() <= cbBuffer) {
        return true;
    }
    // slower conservative check
    return getByteCount(tuple) <= cbBuffer;
}

void TupleAccessor::unmarshal	(	TupleData &	tuple,
		uint	iFirstDatum = 0
	)			const

Unmarshals the current tuple buffer, setting a tuple's values to reference the contents.

Parameters:

	tuple	the tuple which will be modified to reference the unmarshalled values
	iFirstDatum	0-based index of TupleDatum at which to start writing to tuple (defaults to first TupleDatum); note that unmarshalling always starts with the first attribute

Definition at line 489 of file TupleAccessor.cpp.

References bAlignedVar, bitFields, AttributeAccessor::cbStorage, format, getAttributeAccessor(), getCurrentTupleBuf(), AttributeAccessor::iEndIndirectOffset, iFirstVarEndIndirectOffset, iFirstVarOffset, AttributeAccessor::iFixedOffset, AttributeAccessor::iNullBit, isMAXU(), AttributeAccessor::iValueBit, min(), ppAttributeAccessors, referenceIndirectOffset(), and TUPLE_FORMAT_NETWORK.

Referenced by TupleDataWithBuffer::computeAndAllocate(), ReshapeExecStream::copyCompareTuple(), CalcAssembler::createTupleData(), LbmEntryDump::dump(), BTreeNodeAccessor::dumpNode(), UncollectExecStream::execute(), LcsRowScanExecStream::initializeFiltersIfNeeded(), LhxHashKeyAccessor::matches(), BarrierExecStream::processInputTuple(), BTreeSearchExecStream::readSearchKey(), FtrsTableWriter::redoLogicalAction(), TupleDataWithBuffer::resetBuffer(), LbmSearchExecStream::setLowerBoundKey(), BTreePrefetchSearchExecStream::setLowerBoundKey(), TestCalculator::setUp(), BTreePrefetchSearchExecStream::setUpSearchKey(), BTreeTest::testInserts(), LbmSplicerExecStreamTest::testLER5968(), LbmSplicerExecStreamTest::testLER6473(), TupleTest::testMarshal(), BTreeTest::testScan(), BTreeReadersTest::testScan(), BTreeTest::testSearch(), BTreeReadersTest::testSearch(), LbmSplicerExecStreamTest::testSpliceRids(), LbmSplicerExecStreamTest::testSpliceWithKeys(), ExecStreamScheduler::traceStreamBufferContents(), tupleFiddle(), unitTestBool(), unitTestFloat(), unitTestLong(), unitTestNullableLocal(), unitTestPointer(), unitTestPointerCache(), unitTestStatusRegister(), unitTestWarnings(), BTreeReadersTest::unmarshalLeafRecord(), BTreeTest::unmarshalRecord(), LhxPartitionReader::unmarshalTuple(), ExecStreamBufAccessor::unmarshalTuple(), LhxHashKeyAccessor::unpack(), LhxHashDataAccessor::unpack(), BTreeAccessBase::validateTupleSize(), and ExecStreamUnitTestBase::verifyBufferedOutput().

{
    uint n = std::min(tuple.size() - iFirstDatum,ppAttributeAccessors.size());

    if ((format == TUPLE_FORMAT_NETWORK) || bAlignedVar) {
        // for TUPLE_FORMAT_NETWORK, unmarshal attributes individually
        for (uint i = 0; i < n; ++i) {
            getAttributeAccessor(i).unmarshalValue(
                *this,tuple[iFirstDatum + i]);
        }
        return;
    }

    // for other formats, we can go a little faster by avoiding per-attribute
    // call overhead

    uint iNextVarOffset = iFirstVarOffset;
    StoredValueOffset const *pNextVarEndOffset =
        referenceIndirectOffset(iFirstVarEndIndirectOffset);

    for (uint i = 0; i < n; i++) {
        TupleDatum &value = tuple[i + iFirstDatum];
        AttributeAccessor const &accessor = getAttributeAccessor(i);
        if (!isMAXU(accessor.iNullBit)) {
            if (bitFields[accessor.iNullBit]) {
                value.pData = NULL;
                if (!isMAXU(accessor.iEndIndirectOffset)) {
                    pNextVarEndOffset++;
                }
                continue;
            }
        }
        if (!isMAXU(accessor.iFixedOffset)) {
            value.pData = getCurrentTupleBuf() + accessor.iFixedOffset;
        } else if (isMAXU(accessor.iValueBit)) {
            value.pData = getCurrentTupleBuf() + iNextVarOffset;
        } else {
            static_cast<BitAccessor const &>(accessor).unmarshalValue(
                *this,value);
        }
        if (!isMAXU(accessor.iEndIndirectOffset)) {
            assert(pNextVarEndOffset ==
                   referenceIndirectOffset(accessor.iEndIndirectOffset));
            uint iEndOffset = *pNextVarEndOffset;
            pNextVarEndOffset++;
            value.cbData = iEndOffset - iNextVarOffset;
            iNextVarOffset = iEndOffset;
        }
        assert(value.cbData <= accessor.cbStorage);
    }
}

AttributeAccessor const& TupleAccessor::getAttributeAccessor

(

uint

iAttribute

)

const [inline]

Gets an accessor for an individual attribute.

This can be used to unmarshal values individually.

Parameters:

iAttribute

0-based index of the attribute within the tuple

Definition at line 284 of file TupleAccessor.h.

Referenced by TupleProjectionAccessor::bind(), compute(), Java_net_sf_farrago_fennel_FennelStorage_getAccessorXmiForTupleDescriptor(), marshal(), TupleTest::testMarshal(), and unmarshal().

    {
        return *(ppAttributeAccessors[iAttribute]);
    }

void TupleAccessor::marshal	(	TupleData const &	tuple,
		PBuffer	pTupleBuf
	)

Marshals a tuple's values into a buffer.

Parameters:

	tuple	the tuple to be marshalled
	pTupleBuf	the buffer into which to marshal, which also becomes the current tuple buffer

Definition at line 541 of file TupleAccessor.cpp.

References bAlignedVar, bitFields, TupleDatum::cbData, AttributeAccessor::cbStorage, format, getAttributeAccessor(), iBitFieldOffset, AttributeAccessor::iEndIndirectOffset, iFirstVarEndIndirectOffset, iFirstVarOffset, AttributeAccessor::iFixedOffset, AttributeAccessor::iNullBit, isMAXU(), AttributeAccessor::iValueBit, marshalOrder, AttributeAccessor::marshalValueData(), TupleDatum::pData, pTupleBuf, referenceIndirectOffset(), TUPLE_FORMAT_NETWORK, and TUPLE_MAGIC_NUMBER.

Referenced by LhxPartitionWriter::aggAndMarshalTuple(), LhxPartitionWriter::close(), LcsClusterAppendExecStream::compress(), FtrsTableWriterExecStream::execute(), SegBufferWriterExecStream::execute(), MockResourceExecStream::execute(), BarrierExecStream::execute(), LbmSplicerExecStreamTest::generateRidInput(), LbmSplicerExecStreamTest::generateTupleInput(), BTreeWriter::grow(), BTreeBuildLevel::indexLastChild(), VariableBuildLevel::indexLastKey(), BTreeReadersTest::marshalLeafRecord(), BTreeTest::marshalMultiKeyRecord(), BTreeTest::marshalRecord(), LhxPartitionWriter::marshalTuple(), LhxHashDataAccessor::pack(), LhxHashKeyAccessor::pack(), ErrorSource::postError(), LcsRowScanExecStreamTest::produceEntry(), LbmExecStreamTestBase::produceEntry(), ExecStreamBufAccessor::produceTuple(), LcsRowScanExecStreamTest::setSearchKey(), LbmSearchTest::setSearchKey(), BTreePrefetchSearchExecStream::setSearchKeyData(), BTreeWriter::splitCurrentNode(), CollectExecStreamTestSuite::testCollectInts(), LbmSplicerExecStreamTest::testLER5968(), LbmSplicerExecStreamTest::testLER6473(), TupleTest::testMarshal(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testReshapeExecStream(), LbmSearchTest::testScanFullKey(), LbmSearchTest::testScanPartialKey(), and BTreeWriter::updateCurrent().

{
#if DEBUG_TUPLE_ACCESS
    *reinterpret_cast<MagicNumber *>(pTupleBufDest) = TUPLE_MAGIC_NUMBER;
#endif

    pTupleBuf = pTupleBufDest;

    uint iNextVarOffset = iFirstVarOffset;
    StoredValueOffset *pNextVarEndOffset =
        referenceIndirectOffset(pTupleBufDest,iFirstVarEndIndirectOffset);

    for (uint i = 0; i < tuple.size(); i++) {
        uint iAttr;
        if (bAlignedVar) {
            iAttr = marshalOrder[i];
        } else {
            iAttr = i;
        }
        TupleDatum const &value = tuple[iAttr];
        AttributeAccessor const &accessor = getAttributeAccessor(iAttr);
        if (!isMAXU(accessor.iNullBit)) {
            bitFields[accessor.iNullBit] = value.pData ? false : true;
        }
        if (value.pData) {
            if (isMAXU(accessor.iValueBit)) {
                uint iOffset;
                if (!isMAXU(accessor.iFixedOffset)) {
                    iOffset = accessor.iFixedOffset;
                } else {
                    iOffset = iNextVarOffset;
                }
                assert(value.cbData <= accessor.cbStorage);
                accessor.marshalValueData(
                    pTupleBufDest + iOffset,
                    value);
            } else {
                bitFields[accessor.iValueBit] =
                    *reinterpret_cast<bool const *>(value.pData);
            }
        } else {
            // if you hit this assert, most likely the result produced a null
            // but type derivation in SqlValidator derived a non-nullable
            // result type
            assert(!isMAXU(accessor.iNullBit));
        }
        if (!isMAXU(accessor.iEndIndirectOffset)) {
            assert(pNextVarEndOffset ==
                referenceIndirectOffset(accessor.iEndIndirectOffset));
            if (value.pData) {
                iNextVarOffset += value.cbData;
            }
            // regardless of whether the value is null, we need to record the
            // end offset since it also marks the start of the next
            // non-null value
            if (format == TUPLE_FORMAT_NETWORK) {
                *pNextVarEndOffset =
                    htons(static_cast<StoredValueOffset>(iNextVarOffset));
            } else {
                *pNextVarEndOffset = iNextVarOffset;
            }
            pNextVarEndOffset++;
        }
    }
    if (!isMAXU(iBitFieldOffset)) {
        // TODO:  trick dynamic_bitset to avoid copy
        boost::to_block_range(
            bitFields,
            pTupleBufDest + iBitFieldOffset);
    }
}

uint TupleAccessor::size

(

)

const [inline]

Returns:

number of attributes accessed

Definition at line 302 of file TupleAccessor.h.

Referenced by LhxHashDataAccessor::pack(), and LhxHashKeyAccessor::pack().

    {
        return ppAttributeAccessors.size();
    }

boost::dynamic_bitset<FixedBuffer> const& TupleAccessor::getBitFields

(

)

const [inline]

Returns:

the array of bit fields for the current tuple image

Definition at line 312 of file TupleAccessor.h.

Referenced by AttributeAccessorImpl::unmarshalNullableValue(), and BitAccessor::unmarshalValue().

    {
        return bitFields;
    }

StoredValueOffset const* TupleAccessor::referenceIndirectOffset

(

uint

iIndirectOffset

)

const [inline]

Resolves an indirect offset into a pointer to the data offset.

Parameters:

iIndirectOffset

indirect offset within tuple image

Returns:

pointer to data offset

Definition at line 324 of file TupleAccessor.h.

Referenced by getBufferByteCount(), marshal(), unmarshal(), VarOffsetAccessor< network >::unmarshalValue(), and FixedOffsetVarWidthAccessor< network >::unmarshalValue().

    {
        return referenceIndirectOffset(
            const_cast<PBuffer>(pTupleBuf),
            iIndirectOffset);
    }

static StoredValueOffset* TupleAccessor::referenceIndirectOffset	(	PBuffer	pTupleBuf,
		uint	iIndirectOffset
	)			[inline, static]

Resolves an indirect offset into a pointer to the data offset.

Parameters:

	pTupleBuf	target buffer
	iIndirectOffset	indirect offset within tuple image

Returns:

pointer to data offset

Definition at line 340 of file TupleAccessor.h.

    {
        return reinterpret_cast<StoredValueOffset *>(
            pTupleBuf + iIndirectOffset);
    }

---

Member Data Documentation

std::vector<AttributeAccessor *> TupleAccessor::ppAttributeAccessors [private]

Precomputed accessors for attributes, in logical tuple order.

Definition at line 54 of file TupleAccessor.h.

Referenced by clear(), compute(), initFixedAccessors(), and unmarshal().

VectorOfUint TupleAccessor::pVarWidthAttrIndices [private]

Array of 0-based indices of variable-width attributes.

Definition at line 59 of file TupleAccessor.h.

Referenced by clear(), compute(), and getByteCount().

VectorOfUint TupleAccessor::marshalOrder [private]

Permutation in which attributes should be marshalled; empty when !bAlignedVar, in which case attributes should be marshalled in logical order.

Definition at line 66 of file TupleAccessor.h.

Referenced by clear(), compute(), and marshal().

uint TupleAccessor::cbMaxStorage [private]

See also:

getMaxByteCount()

Definition at line 71 of file TupleAccessor.h.

Referenced by compute(), getBufferByteCount(), getByteCount(), and initFixedAccessors().

uint TupleAccessor::cbMinStorage [private]

See also:

getMinByteCount()

Definition at line 76 of file TupleAccessor.h.

Referenced by compute().

uint TupleAccessor::nBitFields [private]

Precomputed size of bit field array (in bits).

Definition at line 81 of file TupleAccessor.h.

Referenced by compute().

uint TupleAccessor::iBitFieldOffset [private]

Precomputed byte offset for bit array.

Definition at line 86 of file TupleAccessor.h.

Referenced by compute(), marshal(), and setCurrentTupleBuf().

uint TupleAccessor::iFirstVarEndIndirectOffset [private]

Precomputed offset for indirect offset of end of first variable-width attribute, or MAXU if there are no variable-width attributes.

Definition at line 92 of file TupleAccessor.h.

Referenced by compute(), marshal(), and unmarshal().

uint TupleAccessor::iLastVarEndIndirectOffset [private]

Precomputed offset for indirect offset of end of last variable-width attribute, or MAXU if there are no variable-length attributes.

Definition at line 98 of file TupleAccessor.h.

Referenced by compute(), and getBufferByteCount().

uint TupleAccessor::iFirstVarOffset [private]

Precomputed offset for fixed start of first variable-width attribute, or MAXU if there are no variable-width attributes.

Definition at line 104 of file TupleAccessor.h.

Referenced by compute(), getByteCount(), marshal(), and unmarshal().

bool TupleAccessor::bAlignedVar [private]

Whether any variable-width attributes with alignment requirements (currently restricted to 2-byte alignment for UNICODE strings) are present.

Definition at line 111 of file TupleAccessor.h.

Referenced by clear(), compute(), marshal(), and unmarshal().

PConstBuffer TupleAccessor::pTupleBuf [private]

See also:

getCurrentTupleBuf()

Definition at line 116 of file TupleAccessor.h.

Referenced by clear(), getCurrentByteCount(), marshal(), resetCurrentTupleBuf(), setCurrentTupleBuf(), and TupleAccessor().

boost::dynamic_bitset<FixedBuffer> TupleAccessor::bitFields [private]

See also:

getBitFields()

Definition at line 121 of file TupleAccessor.h.

Referenced by compute(), marshal(), setCurrentTupleBuf(), and unmarshal().

TupleFormat TupleAccessor::format [private]

Definition at line 123 of file TupleAccessor.h.

Referenced by compute(), getBufferByteCount(), marshal(), and unmarshal().

const bool TupleAccessor::BOOL_TRUE [static]

Constant value for true.

This is used as a singleton unmarshalling address for true boolean values (since we can't reference individual bits).

Definition at line 137 of file TupleAccessor.h.

Referenced by BitAccessor::unmarshalValue().

const bool TupleAccessor::BOOL_FALSE [static]

Constant value for false.

This is used as a singleton unmarshalling address for false boolean values (since we can't reference individual bits).

Definition at line 144 of file TupleAccessor.h.

Referenced by BitAccessor::unmarshalValue().

---

The documentation for this class was generated from the following files:

• /home/pub/open/dev/fennel/tuple/TupleAccessor.h
• /home/pub/open/dev/fennel/tuple/TupleAccessor.cpp

---