#include <OTStorage.hpp>

Inheritance diagram for opentxs::OTDB::Storage:

Public Member Functions
EXPORT OTPacker *	GetPacker (PackType ePackType=OTDB_DEFAULT_PACKER)

virtual bool	Exists (std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")=0

virtual int64_t	FormPathString (std::string &strOutput, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")=0

virtual	~Storage ()

EXPORT bool	StoreString (std::string strContents, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")

EXPORT std::string	QueryString (std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")

EXPORT bool	StorePlainString (std::string strContents, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")

EXPORT std::string	QueryPlainString (std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")

EXPORT bool	StoreObject (Storable &theContents, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")

EXPORT Storable *	QueryObject (StoredObjectType theObjectType, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")

EXPORT std::string	EncodeObject (Storable &theContents)

EXPORT Storable *	DecodeObject (StoredObjectType theObjectType, std::string strInput)

EXPORT bool	EraseValueByKey (std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")

EXPORT Storable *	CreateObject (StoredObjectType eType)

EXPORT StorageType	GetType () const

Static Public Member Functions
static EXPORT Storage *	Create (StorageType eStorageType, PackType ePackType)

Protected Member Functions
	Storage ()

	Storage (const Storage &)

void	SetPacker (OTPacker &thePacker)

virtual bool	onStorePackedBuffer (PackedBuffer &theBuffer, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")=0

virtual bool	onQueryPackedBuffer (PackedBuffer &theBuffer, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")=0

virtual bool	onStorePlainString (std::string &theBuffer, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")=0

virtual bool	onQueryPlainString (std::string &theBuffer, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")=0

virtual bool	onEraseValueByKey (std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")=0

Detailed Description

Definition at line 610 of file OTStorage.hpp.

Constructor & Destructor Documentation

opentxs::OTDB::Storage::Storage ( )

inlineprotected

Definition at line 616 of file OTStorage.hpp.

         : m_pPacker(nullptr)
     {
     }

opentxs::OTDB::Storage::Storage ( const Storage & )

inlineprotected

Definition at line 621 of file OTStorage.hpp.

         : m_pPacker(nullptr)
     {
     } // We don't want to copy the pointer. Let it create its own.

virtual opentxs::OTDB::Storage::~Storage ( )

inlinevirtual

Definition at line 714 of file OTStorage.hpp.

     {
         if (nullptr != m_pPacker) delete m_pPacker;
         m_pPacker = nullptr;
     }

Member Function Documentation

Storage * opentxs::OTDB::Storage::Create	(	StorageType	eStorageType,
		PackType	ePackType
	)

static

Definition at line 2145 of file OTStorage.cpp.

 {
     Storage* pStore = nullptr;
 
     switch (eStorageType) {
     case STORE_FILESYSTEM:
         pStore = StorageFS::Instantiate();
         OT_ASSERT(nullptr != pStore);
         break;
     //            case STORE_COUCH_DB:
     //                pStore = new StorageCouchDB; OT_ASSERT(nullptr != pStore);
     // break;
     default:
         otErr << "OTDB::Storage::Create: Failed: Unknown storage type.\n";
         break;
     }
 
     // IF we successfully created the storage context, now let's
     // try to create the packer that goes with it.
     // (They are created together and linked until death.)
 
     if (nullptr != pStore) {
         OTPacker* pPacker = OTPacker::Create(ePackType);
 
         if (nullptr == pPacker) {
             otErr << "OTDB::Storage::Create: Failed while creating packer.\n";
 
             // For whatever reason, we failed. Memory issues or whatever.
             delete pStore;
             pStore = nullptr;
             return nullptr;
         }
 
         // Now they're married.
         pStore->SetPacker(*pPacker);
     }
     else
         otErr << "OTDB::Storage::Create: Failed, since pStore is nullptr.\n";
 
     return pStore; // Possible to return nullptr.
 }

Storable * opentxs::OTDB::Storage::CreateObject ( StoredObjectType eType )

Definition at line 2128 of file OTStorage.cpp.

 {
     OTPacker* pPacker = GetPacker();
 
     if (nullptr == pPacker) {
         otErr << "OTDB::Storage::CreateObject: Failed, since GetPacker() "
                  "returned nullptr.\n";
         return nullptr;
     }
 
     Storable* pStorable = Storable::Create(eType, pPacker->GetType());
 
     return pStorable; // May return nullptr.
 }

Storable * opentxs::OTDB::Storage::DecodeObject	(	StoredObjectType	theObjectType,
		std::string	strInput
	)

Definition at line 2435 of file OTStorage.cpp.

 {
     if (strInput.size() < 1) return nullptr;
 
     OTPacker* pPacker = GetPacker();
 
     if (nullptr == pPacker) return nullptr;
 
     PackedBuffer* pBuffer = pPacker->CreateBuffer();
 
     if (nullptr == pBuffer) return nullptr;
 
     // Below this point, responsible for pBuffer.
 
     Storable* pStorable = CreateObject(theObjectType);
 
     if (nullptr == pStorable) {
         delete pBuffer;
         return nullptr;
     }
 
     // Below this point, responsible for pBuffer AND pStorable.
 
     OTASCIIArmor theArmor;
     theArmor.Set(strInput.c_str(), static_cast<uint32_t>(strInput.size()));
     const OTPayload thePayload(theArmor);
 
     // Put thePayload's contents into pBuffer here.
     //
     pBuffer->SetData(
         static_cast<const uint8_t*>(thePayload.GetPayloadPointer()),
         thePayload.GetSize());
 
     // Now let's unpack it and return the Storable object.
 
     const bool bUnpacked = pPacker->Unpack(*pBuffer, *pStorable);
 
     if (!bUnpacked) {
         delete pBuffer;
         delete pStorable;
 
         return nullptr;
     }
 
     // Success :-)
 
     // Don't want any leaks here, do we?
     delete pBuffer;
 
     return pStorable; // caller is responsible to delete.
 }

std::string opentxs::OTDB::Storage::EncodeObject ( Storable & theContents )

Definition at line 2389 of file OTStorage.cpp.

 {
     std::string strReturnValue("");
 
     OTPacker* pPacker = GetPacker();
 
     if (nullptr == pPacker) {
         otErr << "Storage::EncodeObject: No packer allocated.\n";
         return strReturnValue;
     }
 
     PackedBuffer* pBuffer = pPacker->Pack(theContents);
 
     if (nullptr == pBuffer) {
         otErr << "Storage::EncodeObject: Packing failed.\n";
         return strReturnValue;
     }
 
     // OTPackedBuffer:
     //        virtual const    uint8_t *    GetData()=0;
     //        virtual            size_t            GetSize()=0;
     //
     const uint32_t nNewSize = static_cast<const uint32_t>(pBuffer->GetSize());
     const void* pNewData = static_cast<const void*>(pBuffer->GetData());
 
     if ((nNewSize < 1) || (nullptr == pNewData)) {
         delete pBuffer;
         pBuffer = nullptr;
 
         otErr << "Storage::EncodeObject: Packing failed (2).\n";
         return strReturnValue;
     }
 
     const OTData theData(pNewData, nNewSize);
     const OTASCIIArmor theArmor(theData);
 
     strReturnValue.assign(theArmor.Get(), theArmor.GetLength());
 
     // Don't want any leaks here, do we?
     delete pBuffer;
 
     return strReturnValue;
 }

bool opentxs::OTDB::Storage::EraseValueByKey	(	std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

Definition at line 2488 of file OTStorage.cpp.

 {
     bool bSuccess = onEraseValueByKey(strFolder, oneStr, twoStr, threeStr);
 
     if (!bSuccess)
         otErr << "Storage::EraseValueByKey: Failed trying to erase a value "
                  "(while calling onEraseValueByKey) \n";
 
     return bSuccess;
 }

virtual bool opentxs::OTDB::Storage::Exists	(	std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

pure virtual

Implemented in opentxs::OTDB::StorageFS.

virtual int64_t opentxs::OTDB::Storage::FormPathString	(	std::string &	strOutput,
		std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

pure virtual

Implemented in opentxs::OTDB::StorageFS.

OTPacker * opentxs::OTDB::Storage::GetPacker ( PackType ePackType = OTDB_DEFAULT_PACKER )

Definition at line 2103 of file OTStorage.cpp.

 {
     // Normally if you use Create(), the packer is created at that time.
     // However, in the future, coders using the API may create subclasses of
     // Storage through SWIG, which Create could not anticipate. This mechanism
     // makes sure that in those cases, the packer still gets set (on the first
     // Get() call), and the coder using the API still has the ability to choose
     // what type of packer will be used.
     //
     if (nullptr == m_pPacker) {
         m_pPacker = OTPacker::Create(ePackType);
     }
 
     return m_pPacker; // May return nullptr. (If Create call above fails.)
 }

StorageType opentxs::OTDB::Storage::GetType ( ) const

Definition at line 2187 of file OTStorage.cpp.

 {
     // If I find the type, then I return it. Otherwise I ASSUME
     // that the coder using the API has subclassed Storage, and
     // that this is a custom Storage type invented by the API user.
 
     if (typeid(*this) == typeid(StorageFS)) return STORE_FILESYSTEM;
     //    else if (typeid(*this) == typeid(StorageCouchDB))
     //        return STORE_COUCH_DB;
     //  Etc.
     //
     else
         return STORE_TYPE_SUBCLASS; // The Java coder using API must have
                                     // subclassed Storage himself.
 }

virtual bool opentxs::OTDB::Storage::onEraseValueByKey	(	std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

protectedpure virtual

Implemented in opentxs::OTDB::StorageFS.

virtual bool opentxs::OTDB::Storage::onQueryPackedBuffer	(	PackedBuffer &	theBuffer,
		std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

protectedpure virtual

Implemented in opentxs::OTDB::StorageFS.

virtual bool opentxs::OTDB::Storage::onQueryPlainString	(	std::string &	theBuffer,
		std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

protectedpure virtual

Implemented in opentxs::OTDB::StorageFS.

virtual bool opentxs::OTDB::Storage::onStorePackedBuffer	(	PackedBuffer &	theBuffer,
		std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

protectedpure virtual

Implemented in opentxs::OTDB::StorageFS.

virtual bool opentxs::OTDB::Storage::onStorePlainString	(	std::string &	theBuffer,
		std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

protectedpure virtual

Implemented in opentxs::OTDB::StorageFS.

Storable * opentxs::OTDB::Storage::QueryObject	(	StoredObjectType	theObjectType,
		std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

Definition at line 2336 of file OTStorage.cpp.

 {
     OTPacker* pPacker = GetPacker();
 
     if (nullptr == pPacker) return nullptr;
 
     PackedBuffer* pBuffer = pPacker->CreateBuffer();
 
     if (nullptr == pBuffer) return nullptr;
 
     // Below this point, responsible for pBuffer.
 
     Storable* pStorable = CreateObject(theObjectType);
 
     if (nullptr == pStorable) {
         delete pBuffer;
         return nullptr;
     }
 
     // Below this point, responsible for pBuffer AND pStorable.
 
     bool bSuccess =
         onQueryPackedBuffer(*pBuffer, strFolder, oneStr, twoStr, threeStr);
 
     if (!bSuccess) {
         delete pBuffer;
         delete pStorable;
 
         return nullptr;
     }
 
     // We got the packed buffer back from the query!
     // Now let's unpack it and return the Storable object.
 
     bool bUnpacked = pPacker->Unpack(*pBuffer, *pStorable);
 
     if (!bUnpacked) {
         delete pBuffer;
         delete pStorable;
 
         return nullptr;
     }
 
     // Success :-)
 
     // Don't want any leaks here, do we?
     delete pBuffer;
 
     return pStorable; // caller is responsible to delete.
 }

std::string opentxs::OTDB::Storage::QueryPlainString	(	std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

Definition at line 2290 of file OTStorage.cpp.

 {
     std::string theString("");
 
     if (!onQueryPlainString(theString, strFolder, oneStr, twoStr, threeStr))
         theString = "";
 
     return theString;
 }

std::string opentxs::OTDB::Storage::QueryString	(	std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

Definition at line 2237 of file OTStorage.cpp.

 {
     std::string theString("");
 
     OTPacker* pPacker = GetPacker();
 
     if (nullptr == pPacker) return theString;
 
     PackedBuffer* pBuffer = pPacker->CreateBuffer();
 
     if (nullptr == pBuffer) return theString;
 
     // Below this point, responsible for pBuffer.
 
     bool bSuccess =
         onQueryPackedBuffer(*pBuffer, strFolder, oneStr, twoStr, threeStr);
 
     if (!bSuccess) {
         delete pBuffer;
         pBuffer = nullptr;
         return theString;
     }
 
     // We got the packed buffer back from the query!
     // Now let's unpack it and return the Storable object.
 
     bool bUnpacked = pPacker->Unpack(*pBuffer, theString);
 
     if (!bUnpacked) {
         delete pBuffer;
         theString = "";
         return theString;
     }
 
     // Success :-)
 
     // Don't want any leaks here, do we?
     delete pBuffer;
     pBuffer = nullptr;
 
     return theString;
 }

void opentxs::OTDB::Storage::SetPacker ( OTPacker & thePacker )

inlineprotected

Definition at line 627 of file OTStorage.hpp.

     {
         OT_ASSERT(nullptr == m_pPacker);
         m_pPacker = &thePacker;
     }

bool opentxs::OTDB::Storage::StoreObject	(	Storable &	theContents,
		std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

Definition at line 2301 of file OTStorage.cpp.

 {
     OTPacker* pPacker = GetPacker();
 
     if (nullptr == pPacker) {
         otErr << "No packer allocated in Storage::StoreObject\n";
         return false;
     }
 
     PackedBuffer* pBuffer = pPacker->Pack(theContents);
 
     if (nullptr == pBuffer) {
         otErr << "Packing failed in Storage::StoreObject\n";
         return false;
     }
 
     bool bSuccess =
         onStorePackedBuffer(*pBuffer, strFolder, oneStr, twoStr, threeStr);
 
     if (!bSuccess) {
         otErr << "Storing failed in Storage::StoreObject (calling "
                  "onStorePackedBuffer) \n";
         return false;
     }
 
     // Don't want any leaks here, do we?
     delete pBuffer;
 
     return bSuccess;
 }

bool opentxs::OTDB::Storage::StorePlainString	(	std::string	strContents,
		std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

Definition at line 2283 of file OTStorage.cpp.

 {
     return onStorePlainString(strContents, strFolder, oneStr, twoStr, threeStr);
 }

bool opentxs::OTDB::Storage::StoreString	(	std::string	strContents,
		std::string	strFolder,
		std::string	oneStr = `""`,
		std::string	twoStr = `""`,
		std::string	threeStr = `""`
	)

Definition at line 2203 of file OTStorage.cpp.

 {
     OTString ot_strFolder(strFolder), ot_oneStr(oneStr), ot_twoStr(twoStr),
         ot_threeStr(threeStr);
     OT_ASSERT_MSG(ot_strFolder.Exists(),
                   "Storage::StoreString: strFolder is null");
 
     if (!ot_oneStr.Exists()) {
         OT_ASSERT_MSG((!ot_twoStr.Exists() && !ot_threeStr.Exists()),
                       "Storage::StoreString: bad options");
         oneStr = strFolder;
         strFolder = ".";
     }
 
     OTPacker* pPacker = GetPacker();
 
     if (nullptr == pPacker) return false;
 
     PackedBuffer* pBuffer = pPacker->Pack(strContents);
 
     if (nullptr == pBuffer) return false;
 
     bool bSuccess =
         onStorePackedBuffer(*pBuffer, strFolder, oneStr, twoStr, threeStr);
 
     // Don't want any leaks here, do we?
     delete pBuffer;
     pBuffer = nullptr;
 
     return bSuccess;
 }

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation