opentxs::OTDB::OTPacker Class Reference

#include <OTStorage.hpp>

Inheritance diagram for opentxs::OTDB::OTPacker:

Public Member Functions
virtual	~OTPacker ()
PackType	GetType () const
PackedBuffer *	Pack (Storable &inObj)
EXPORT bool	Unpack (PackedBuffer &inBuf, Storable &outObj)
PackedBuffer *	Pack (std::string &inObj)
bool	Unpack (PackedBuffer &inBuf, std::string &outObj)
virtual PackedBuffer *	CreateBuffer ()=0

Static Public Member Functions
static OTPacker *	Create (PackType ePackType)

Protected Member Functions
	OTPacker ()

Detailed Description

Definition at line 542 of file OTStorage.hpp.

Constructor & Destructor Documentation

opentxs::OTDB::OTPacker::OTPacker ( )

inlineprotected

Definition at line 545 of file OTStorage.hpp.

    {
    } // To instantiate: OTPacker * pPacker =

virtual opentxs::OTDB::OTPacker::~OTPacker ( )

inlinevirtual

Definition at line 551 of file OTStorage.hpp.

    {
    }

Member Function Documentation

OTPacker * opentxs::OTDB::OTPacker::Create ( PackType  ePackType )

static

Definition at line 889 of file OTStorage.cpp.

{
    OTPacker* pPacker = nullptr;

    switch (ePackType) {
#if defined(OTDB_MESSAGE_PACK)
    case PACK_MESSAGE_PACK:
        pPacker = new PackerMsgpack;
        OT_ASSERT(nullptr != pPacker);
        break;
#endif
#if defined(OTDB_PROTOCOL_BUFFERS)
    case PACK_PROTOCOL_BUFFERS:
        pPacker = new PackerPB;
        OT_ASSERT(nullptr != pPacker);
        break;
#endif
    case PACK_TYPE_ERROR:
    default:
        break;
    }

    return pPacker; // May return nullptr...
}

virtual PackedBuffer* opentxs::OTDB::OTPacker::CreateBuffer ( )

pure virtual

Implemented in opentxs::OTDB::PackerSubclass< theBufferType >.

PackType opentxs::OTDB::OTPacker::GetType

(

)

const

Definition at line 914 of file OTStorage.cpp.

{
#if defined(OTDB_MESSAGE_PACK)
    if (typeid(*this) == typeid(PackerMsgpack)) return PACK_MESSAGE_PACK;
#endif
#if defined(OTDB_PROTOCOL_BUFFERS)
    if (typeid(*this) == typeid(PackerPB)) return PACK_PROTOCOL_BUFFERS;
#endif
    return PACK_TYPE_ERROR;
}

PackedBuffer * opentxs::OTDB::OTPacker::Pack

(

Storable &

inObj

)

Definition at line 930 of file OTStorage.cpp.

{
    IStorable* pStorable = dynamic_cast<IStorable*>(&inObj);

    if (nullptr ==
        pStorable) // ALL Storables should implement SOME subinterface
                   // of IStorable
    {
        otErr << "OTPacker::Pack: Error: IStorable dynamic_cast failed.\n";
        return nullptr;
    }

    // This is polymorphic, so we get the right kind of buffer for the packer.
    //
    PackedBuffer* pBuffer = CreateBuffer();
    OT_ASSERT(nullptr != pBuffer);

    // Must delete pBuffer, or return it, below this point.

    pStorable->hookBeforePack(); // Give the subclass a chance to prepare its
                                 // data for packing...

    // This line (commented out) shows how the line below it would have looked
    // if I had ended
    // up using polymorphic templates:
    //    if (!makeTStorablepStorable->pack(*pBuffer))

    if (!pStorable->onPack(*pBuffer, inObj)) {
        delete pBuffer;
        return nullptr;
    }

    return pBuffer;
}

PackedBuffer * opentxs::OTDB::OTPacker::Pack

(

std::string &

inObj

)

Definition at line 992 of file OTStorage.cpp.

{
    // This is polymorphic, so we get the right kind of buffer for the packer.
    //
    PackedBuffer* pBuffer = CreateBuffer();
    OT_ASSERT(nullptr != pBuffer);

    // Must delete pBuffer, or return it, below this point.

    if (!pBuffer->PackString(inObj)) {
        delete pBuffer;
        return nullptr;
    }

    return pBuffer;
}

bool opentxs::OTDB::OTPacker::Unpack	(	PackedBuffer &	inBuf,
		Storable &	outObj
	)

Definition at line 972 of file OTStorage.cpp.

{
    IStorable* pStorable = dynamic_cast<IStorable*>(&outObj);

    if (nullptr == pStorable) return false;

    // outObj is the OUTPUT OBJECT.
    // If we're unable to unpack the contents of inBuf
    // into outObj, return false.
    //
    if (!pStorable->onUnpack(inBuf, outObj)) {
        return false;
    }

    pStorable->hookAfterUnpack(); // Give the subclass a chance to settle its
                                  // data after unpacking...

    return true;
}

bool opentxs::OTDB::OTPacker::Unpack	(	PackedBuffer &	inBuf,
		std::string &	outObj
	)

Definition at line 1009 of file OTStorage.cpp.

{

    // outObj is the OUTPUT OBJECT.
    // If we're unable to unpack the contents of inBuf
    // into outObj, return false.
    //
    if (!inBuf.UnpackString(outObj)) return false;

    return true;
}

---

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

• /usr/local/src/opentxs/include/opentxs/core/OTStorage.hpp
• /usr/local/src/opentxs/src/core/OTStorage.cpp