AttributeAccessorImpl.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/tuple/AttributeAccessorImpl.h#12 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2005-2009 SQLstream, Inc.
// Copyright (C) 2005-2009 LucidEra, Inc.
// Portions Copyright (C) 1999-2009 John V. Sichi
//
// This program 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 approved by The Eigenbase Project.
//
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_AttributeAccessorImpl_Included
#define Fennel_AttributeAccessorImpl_Included

#include "fennel/tuple/AttributeAccessor.h"
#include "fennel/tuple/TupleAccessor.h"
#include "fennel/tuple/TupleData.h"

#ifdef __MSVC__
#include <winsock2.h>
#else
#include <netinet/in.h>
#endif

FENNEL_BEGIN_NAMESPACE

class FENNEL_TUPLE_EXPORT AttributeAccessorImpl
    : public AttributeAccessor
{
public:
    explicit AttributeAccessorImpl();

    bool unmarshalNullableValue(
        TupleAccessor const &tupleAccessor,TupleDatum &value) const
    {
        if (tupleAccessor.getBitFields()[iNullBit]) {
            value.pData = NULL;
            return true;
        } else {
            return false;
        }
    }

    void marshalValueData(
        PBuffer pDestData,
        TupleDatum const &value) const
    {
        memcpy(pDestData,value.pData,value.cbData);
    }
};

class FENNEL_TUPLE_EXPORT FixedWidthAccessor
    : public AttributeAccessorImpl
{
public:
    void unmarshalValue(
        TupleAccessor const &tupleAccessor,TupleDatum &value) const
    {
        value.pData = tupleAccessor.getCurrentTupleBuf() + iFixedOffset;
    }
};

class FENNEL_TUPLE_EXPORT FixedWidthNetworkAccessor16
    : public FixedWidthAccessor
{
public:
    void unmarshalValue(
        TupleAccessor const &tupleAccessor,TupleDatum &value) const
    {
        assert(value.cbData == sizeof(uint16_t));
        FixedWidthAccessor::unmarshalValue(tupleAccessor,value);
        value.data16 = ntohs(*reinterpret_cast<uint16_t const *>(value.pData));
        value.pData = reinterpret_cast<PConstBuffer>(&(value.data16));
    }

    void marshalValueData(
        PBuffer pDestData,
        TupleDatum const &value) const
    {
        assert(value.cbData == sizeof(uint16_t));
        *reinterpret_cast<uint16_t *>(pDestData) =
            htons(*reinterpret_cast<uint16_t const *>(value.pData));
    }
};

class FENNEL_TUPLE_EXPORT FixedWidthNetworkAccessor32
    : public FixedWidthAccessor
{
public:
    void unmarshalValue(
        TupleAccessor const &tupleAccessor,TupleDatum &value) const
    {
        assert(value.cbData == sizeof(uint32_t));
        FixedWidthAccessor::unmarshalValue(tupleAccessor,value);
        value.data32 = ntohl(*reinterpret_cast<uint32_t const *>(value.pData));
        value.pData = reinterpret_cast<PConstBuffer>(&(value.data32));
    }

    void marshalValueData(
        PBuffer pDestData,
        TupleDatum const &value) const
    {
        assert(value.cbData == sizeof(uint32_t));
        *reinterpret_cast<uint32_t *>(pDestData) =
            htonl(*reinterpret_cast<uint32_t const *>(value.pData));
    }
};

class FENNEL_TUPLE_EXPORT FixedWidthNetworkAccessor64
    : public FixedWidthAccessor
{
public:
    void unmarshalValue(
        TupleAccessor const &tupleAccessor,TupleDatum &value) const
    {
        assert(value.cbData == sizeof(uint64_t));
        FixedWidthAccessor::unmarshalValue(tupleAccessor,value);
        value.data64 = ntohll(*reinterpret_cast<uint64_t const *>(value.pData));
        value.pData = reinterpret_cast<PConstBuffer>(&(value.data64));
    }

    void marshalValueData(
        PBuffer pDestData,
        TupleDatum const &value) const
    {
        assert(value.cbData == sizeof(uint64_t));
        *reinterpret_cast<uint64_t *>(pDestData) =
            htonll(*reinterpret_cast<uint64_t const *>(value.pData));
    }
};

template<bool network>
class FixedOffsetVarWidthAccessor
    : public AttributeAccessorImpl
{
public:
    void unmarshalValue(
        TupleAccessor const &tupleAccessor,TupleDatum &value) const
    {
        value.pData = tupleAccessor.getCurrentTupleBuf() + iFixedOffset;
        TupleAccessor::StoredValueOffset const *pEndOffset =
            tupleAccessor.referenceIndirectOffset(iEndIndirectOffset);
        uint16_t iEndOffset = *pEndOffset;
        if (network) {
            iEndOffset = ntohs(iEndOffset);
        }
        value.cbData = iEndOffset - iFixedOffset;
        assert(value.cbData <= cbStorage);
    }
};

template<bool network>
class VarOffsetAccessor
    : public AttributeAccessorImpl
{
public:
    void unmarshalValue(
        TupleAccessor const &tupleAccessor,TupleDatum &value) const
    {
        TupleAccessor::StoredValueOffset const *pEndOffset =
            tupleAccessor.referenceIndirectOffset(iEndIndirectOffset);
        uint iOffset = pEndOffset[-1];
        uint iEndOffset = pEndOffset[0];
        if (network) {
            iOffset = ntohs(iOffset);
            iEndOffset = ntohs(iEndOffset);
        }
        value.pData = tupleAccessor.getCurrentTupleBuf() + iOffset;
        value.cbData = iEndOffset - iOffset;
        assert(value.cbData <= cbStorage);
    }
};

class FENNEL_TUPLE_EXPORT BitAccessor
    : public AttributeAccessorImpl
{
public:
    void unmarshalValue(
        TupleAccessor const &tupleAccessor,TupleDatum &value) const
    {
        if (tupleAccessor.getBitFields()[iValueBit]) {
            value.pData = reinterpret_cast<PConstBuffer>(
                &(TupleAccessor::BOOL_TRUE));
        } else {
            value.pData = reinterpret_cast<PConstBuffer>(
                &(TupleAccessor::BOOL_FALSE));
        }
    }
};

template <class Accessor>
class NullableAccessor : public Accessor
{
public:
    void unmarshalValue(
        TupleAccessor const &tupleAccessor,TupleDatum &value) const
    {
        if (Accessor::unmarshalNullableValue(tupleAccessor,value)) {
            return;
        }
        return Accessor::unmarshalValue(tupleAccessor,value);
    }
};

FENNEL_END_NAMESPACE

#endif

// End AttributeAccessorImpl.h

---