#include <OTTransactionType.hpp>

Inheritance diagram for opentxs::OTTransactionType:

Collaboration diagram for opentxs::OTTransactionType:

Public Member Functions
EXPORT void	GetNumList (OTNumList &theOutput)

bool	Contains (const OTString &strContains)

EXPORT bool	Contains (const char *szContains)

bool	IsSameAccount (const OTTransactionType &rhs) const

void	SetLoadInsecure ()

const OTIdentifier &	GetUserID () const

void	SetUserID (const OTIdentifier &theID)

const OTIdentifier &	GetRealAccountID () const

void	SetRealAccountID (const OTIdentifier &theID)

const OTIdentifier &	GetPurportedAccountID () const

void	SetPurportedAccountID (const OTIdentifier &theID)

const OTIdentifier &	GetRealServerID () const

void	SetRealServerID (const OTIdentifier &theID)

const OTIdentifier &	GetPurportedServerID () const

void	SetPurportedServerID (const OTIdentifier &theID)

virtual EXPORT bool	VerifyContractID () const

virtual bool	VerifyAccount (const OTPseudonym &theNym)

	OTTransactionType (const OTIdentifier &theUserID, const OTIdentifier &theAccountID, const OTIdentifier &theServerID)

	OTTransactionType (const OTIdentifier &theUserID, const OTIdentifier &theAccountID, const OTIdentifier &theServerID, int64_t lTransactionNum)

void	InitTransactionType ()

virtual	~OTTransactionType ()

virtual void	Release ()

void	Release_TransactionType ()

EXPORT int64_t	GetTransactionNum () const

void	SetTransactionNum (int64_t lTransactionNum)

virtual EXPORT void	CalculateNumberOfOrigin ()

virtual EXPORT int64_t	GetNumberOfOrigin ()

EXPORT int64_t	GetRawNumberOfOrigin () const

EXPORT void	SetNumberOfOrigin (int64_t lTransactionNum)

EXPORT void	SetNumberOfOrigin (OTTransactionType &setFrom)

EXPORT bool	VerifyNumberOfOrigin (OTTransactionType &compareTo)

EXPORT int64_t	GetReferenceToNum () const

EXPORT void	SetReferenceToNum (int64_t lTransactionNum)

EXPORT void	GetReferenceString (OTString &theStr) const

EXPORT void	SetReferenceString (const OTString &theStr)

virtual bool	SaveContractWallet (std::ofstream &ofs) const

Public Member Functions inherited from opentxs::OTContract
const char *	GetHashType () const

void	SetIdentifier (const OTIdentifier &theID)

EXPORT	OTContract ()

EXPORT	OTContract (const OTString &name, const OTString &foldername, const OTString &filename, const OTString &strID)

EXPORT	OTContract (const OTString &strID)

EXPORT	OTContract (const OTIdentifier &theID)

void	Initialize ()

virtual EXPORT	~OTContract ()

EXPORT void	Release_Contract ()

EXPORT void	ReleaseSignatures ()

virtual EXPORT bool	CreateContract (const OTString &strContract, const OTPseudonym &theSigner)

EXPORT bool	InsertNym (const OTString &strKeyName, const OTString &strKeyValue)

EXPORT void	GetName (OTString &strName) const

EXPORT void	SetName (const OTString &strName)

virtual EXPORT bool	VerifyContract ()

virtual EXPORT void	GetIdentifier (OTIdentifier &theIdentifier) const

virtual EXPORT void	GetIdentifier (OTString &theIdentifier) const

EXPORT void	GetFilename (OTString &strFilename) const

EXPORT void	GetFoldername (OTString &strFoldername) const

virtual EXPORT bool	LoadContract ()

EXPORT bool	LoadContract (const char szFoldername, const char szFilename)

EXPORT bool	LoadContractFromString (const OTString &theStr)

bool	LoadContractRawFile ()

EXPORT bool	ParseRawFile ()

EXPORT bool	SaveToContractFolder ()

EXPORT bool	SaveContractRaw (OTString &strOutput) const

EXPORT bool	RewriteContract (OTString &strOutput) const

EXPORT bool	SaveContract ()

EXPORT bool	SaveContract (const char szFoldername, const char szFilename)

virtual EXPORT void	UpdateContents ()

virtual EXPORT void	CreateContents ()

EXPORT void	CreateInnerContents ()

virtual EXPORT bool	SaveContents (std::ofstream &ofs) const

virtual EXPORT bool	SaveContractWallet (OTString &strContents) const

virtual EXPORT bool	DisplayStatistics (OTString &strContents) const

virtual EXPORT bool	SaveContents (OTString &strContents) const

virtual EXPORT bool	SignContract (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTAsymmetricKey &theKey, OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const char szFoldername, const char szFilename, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

virtual EXPORT void	CalculateContractID (OTIdentifier &newID) const

virtual EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

virtual EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifyWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTAsymmetricKey &theKey, const OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const char szFoldername, const char szFilename, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT const OTAsymmetricKey *	GetContractPublicKey () const

EXPORT const OTPseudonym *	GetContractPublicNym () const

Static Public Member Functions
static EXPORT OTTransactionType *	TransactionFactory (OTString strInput)

Static Public Member Functions inherited from opentxs::OTContract
static EXPORT bool	DearmorAndTrim (const OTString &strInput, OTString &strOutput, OTString &strFirstLine)

static bool	AddBookendsAroundContent (OTString &strOutput, const OTString &strContents, const OTString &strContractType, const OTString &strHashType, const listOfSignatures &listSignatures)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTASCIIArmor &ascOutput)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTString &strOutput)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTASCIIArmor &ascOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTString &strOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	SkipToElement (irr::io::IrrXMLReader *&xml)

static bool	SkipToTextField (irr::io::IrrXMLReader *&xml)

static bool	SkipAfterLoadingField (irr::io::IrrXMLReader *&xml)

static EXPORT bool	SignFlatText (OTString &strFlatText, const OTString &strContractType, const OTPseudonym &theSigner, OTString &strOutput)

Protected Member Functions
	OTTransactionType ()

Protected Member Functions inherited from opentxs::OTContract
bool	LoadContractXML ()

virtual EXPORT int32_t	ProcessXMLNode (irr::io::IrrXMLReader *&xml)

Protected Attributes
OTIdentifier	m_AcctID

OTIdentifier	m_ServerID

OTIdentifier	m_AcctServerID

OTIdentifier	m_AcctUserID

int64_t	m_lTransactionNum

int64_t	m_lInReferenceToTransaction

int64_t	m_lNumberOfOrigin

OTASCIIArmor	m_ascInReferenceTo

bool	m_bLoadSecurely

OTNumList	m_Numlist

Protected Attributes inherited from opentxs::OTContract
OTString	m_strName

OTString	m_strFoldername

OTString	m_strFilename

OTIdentifier	m_ID

OTStringXML	m_xmlUnsigned

OTString	m_strRawFile

OTString	m_strSigHashType

OTString	m_strContractType

mapOfNyms	m_mapNyms

listOfSignatures	m_listSignatures

OTString	m_strVersion

OTString	m_strEntityShortName

OTString	m_strEntityLongName

OTString	m_strEntityEmail

OTString::Map	m_mapConditions

Detailed Description

Definition at line 147 of file OTTransactionType.hpp.

Constructor & Destructor Documentation

opentxs::OTTransactionType::OTTransactionType ( )

protected

Definition at line 254 of file OTTransactionType.cpp.

     : OTContract()
     , m_lTransactionNum(0)
     , m_lInReferenceToTransaction(0)
     , m_lNumberOfOrigin(0)
     , m_bLoadSecurely(true)
 {
     // this function is private to prevent people from using it.
     // Should never actually get called.
 
     //    InitTransactionType(); // Just in case.
 }

opentxs::OTTransactionType::OTTransactionType	(	const OTIdentifier &	theUserID,
		const OTIdentifier &	theAccountID,
		const OTIdentifier &	theServerID
	)

Definition at line 267 of file OTTransactionType.cpp.

     : OTContract(theAccountID)
     , m_ServerID(theServerID)
     , m_AcctUserID(theUserID)
     , m_lTransactionNum(0)
     , m_lInReferenceToTransaction(0)
     , m_lNumberOfOrigin(0)
     , m_bLoadSecurely(true)
 {
     //    InitTransactionType();
 
     //  m_ID            = theAccountID  -- This happens in OTContract, no need
     // to do it twice.
 
     // do NOT set m_AcctID and m_AcctServerID here.  Let the child classes LOAD
     // them or GENERATE them.
 }

opentxs::OTTransactionType::OTTransactionType	(	const OTIdentifier &	theUserID,
		const OTIdentifier &	theAccountID,
		const OTIdentifier &	theServerID,
		int64_t	lTransactionNum
	)

Definition at line 287 of file OTTransactionType.cpp.

     : OTContract(theAccountID)
     , m_ServerID(theServerID)
     , m_AcctUserID(theUserID)
     , m_lTransactionNum(lTransactionNum)
     , m_lInReferenceToTransaction(0)
     , m_lNumberOfOrigin(0)
     , m_bLoadSecurely(true)
 {
     // This initializes m_lTransactionNum, so it must come FIRST.
     // In fact, that's the general rule with this function.
     //    InitTransactionType();
 
     //  m_ID                = theAccountID  -- This happens in OTContract, no
     // need to do it twice.
 
     // do NOT set m_AcctID and m_AcctServerID here.  Let the child classes LOAD
     // them or GENERATE them.
 }

opentxs::OTTransactionType::~OTTransactionType ( )

virtual

Definition at line 318 of file OTTransactionType.cpp.

 {
     Release_TransactionType();
 }

Member Function Documentation

void opentxs::OTTransactionType::CalculateNumberOfOrigin ( )

virtual

Reimplemented in opentxs::OTTransaction, and opentxs::OTItem.

Definition at line 474 of file OTTransactionType.cpp.

 {
     m_lNumberOfOrigin = m_lTransactionNum;
 }

bool opentxs::OTTransactionType::Contains ( const OTString & strContains )

Definition at line 240 of file OTTransactionType.cpp.

 {
     return m_strRawFile.Contains(strContains);
 }

bool opentxs::OTTransactionType::Contains ( const char * szContains )

Definition at line 246 of file OTTransactionType.cpp.

 {
     return m_strRawFile.Contains(szContains);
 }

int64_t opentxs::OTTransactionType::GetNumberOfOrigin ( )

virtual

Reimplemented in opentxs::OTTransaction, and opentxs::OTItem.

Definition at line 481 of file OTTransactionType.cpp.

 {
     if (0 == m_lNumberOfOrigin) CalculateNumberOfOrigin();
 
     return m_lNumberOfOrigin;
 }

void opentxs::OTTransactionType::GetNumList ( OTNumList & theOutput )

Definition at line 233 of file OTTransactionType.cpp.

 {
     theOutput.Release();
     theOutput.Add(m_Numlist);
 }

const OTIdentifier& opentxs::OTTransactionType::GetPurportedAccountID ( ) const

inline

Definition at line 854 of file OTTransactionType.hpp.

     {
         return m_AcctID;
     }

const OTIdentifier& opentxs::OTTransactionType::GetPurportedServerID ( ) const

inline

Definition at line 874 of file OTTransactionType.hpp.

     {
         return m_AcctServerID;
     }

int64_t opentxs::OTTransactionType::GetRawNumberOfOrigin ( ) const

Definition at line 489 of file OTTransactionType.cpp.

 {
     return m_lNumberOfOrigin;
 }

const OTIdentifier& opentxs::OTTransactionType::GetRealAccountID ( ) const

inline

Definition at line 843 of file OTTransactionType.hpp.

     {
         return m_ID;
     }

const OTIdentifier& opentxs::OTTransactionType::GetRealServerID ( ) const

inline

Definition at line 864 of file OTTransactionType.hpp.

     {
         return m_ServerID;
     }

void opentxs::OTTransactionType::GetReferenceString ( OTString & theStr ) const

Definition at line 381 of file OTTransactionType.cpp.

 {
     m_ascInReferenceTo.GetString(theStr);
 }

int64_t opentxs::OTTransactionType::GetReferenceToNum ( ) const

Definition at line 529 of file OTTransactionType.cpp.

 {
     return m_lInReferenceToTransaction;
 }

int64_t opentxs::OTTransactionType::GetTransactionNum ( ) const

Definition at line 463 of file OTTransactionType.cpp.

 {
     return m_lTransactionNum;
 }

const OTIdentifier& opentxs::OTTransactionType::GetUserID ( ) const

inline

Definition at line 833 of file OTTransactionType.hpp.

     {
         return m_AcctUserID;
     }

void opentxs::OTTransactionType::InitTransactionType ( )

Definition at line 311 of file OTTransactionType.cpp.

 {
     m_lTransactionNum = 0;
     m_lInReferenceToTransaction = 0;
     m_lNumberOfOrigin = 0;
 }

bool opentxs::OTTransactionType::IsSameAccount ( const OTTransactionType & rhs ) const

Definition at line 372 of file OTTransactionType.cpp.

 {
     if ((GetUserID() != rhs.GetUserID()) ||
         (GetRealAccountID() != rhs.GetRealAccountID()) ||
         (GetRealServerID() != rhs.GetRealServerID()))
         return false;
     return true;
 }

void opentxs::OTTransactionType::Release ( void )

virtual

Reimplemented from opentxs::OTContract.

Reimplemented in opentxs::OTTransaction, opentxs::OTItem, opentxs::OTLedger, and opentxs::OTAccount.

Definition at line 359 of file OTTransactionType.cpp.

 {
     Release_TransactionType();
 
     ot_super::Release(); // since I've overridden the base class, I call it
                          // now...
 }

void opentxs::OTTransactionType::Release_TransactionType ( )

Definition at line 325 of file OTTransactionType.cpp.

 {
     // If there were any dynamically allocated objects, clean them up here.
 
     //  m_ID.Release();
     m_AcctID.Release(); // Compare m_AcctID to m_ID after loading it from string
                         // or file. They should match, and signature should
                         // verify.
 
     //    m_ServerID.Release();       // Server ID as used to instantiate the
     // transaction, based on expected ServerID.
     m_AcctServerID.Release(); // Actual ServerID within the signed portion.
                               // (Compare to m_ServerID upon loading.)
 
     //    m_AcctUserID.Release();
 
     m_lTransactionNum = 0;
     m_lInReferenceToTransaction = 0;
     m_lNumberOfOrigin = 0;
 
     m_ascInReferenceTo.Release(); // This item may be in reference to a
                                   // different item
 
     // This was causing OTLedger to fail loading. Can't set this to true until
     // the END
     // of loading. Todo: Starting reading the END TAGS during load. For example,
     // the OTLedger
     // END TAG could set this back to true...
     //
     //  m_bLoadSecurely = true; // defaults to true.
 
     m_Numlist.Release();
 }

bool opentxs::OTTransactionType::SaveContractWallet ( std::ofstream & ofs ) const

virtual

Implements opentxs::OTContract.

Reimplemented in opentxs::OTTransaction, opentxs::OTItem, opentxs::OTLedger, and opentxs::OTAccount.

Definition at line 391 of file OTTransactionType.cpp.

 {
     return true;
 }

void opentxs::OTTransactionType::SetLoadInsecure ( )

inline

Definition at line 825 of file OTTransactionType.hpp.

     {
         m_bLoadSecurely = false;
     }

void opentxs::OTTransactionType::SetNumberOfOrigin ( int64_t lTransactionNum )

Definition at line 494 of file OTTransactionType.cpp.

 {
     m_lNumberOfOrigin = lTransactionNum;
 }

void opentxs::OTTransactionType::SetNumberOfOrigin ( OTTransactionType & setFrom )

Definition at line 499 of file OTTransactionType.cpp.

 {
     m_lNumberOfOrigin = setFrom.GetNumberOfOrigin();
 }

void opentxs::OTTransactionType::SetPurportedAccountID ( const OTIdentifier & theID )

inline

Definition at line 858 of file OTTransactionType.hpp.

     {
         m_AcctID = theID;
     }

void opentxs::OTTransactionType::SetPurportedServerID ( const OTIdentifier & theID )

inline

Definition at line 878 of file OTTransactionType.hpp.

     {
         m_AcctServerID = theID;
     }

void opentxs::OTTransactionType::SetRealAccountID ( const OTIdentifier & theID )

inline

Definition at line 847 of file OTTransactionType.hpp.

     {
         m_ID = theID;
     }

void opentxs::OTTransactionType::SetRealServerID ( const OTIdentifier & theID )

inline

Definition at line 868 of file OTTransactionType.hpp.

     {
         m_ServerID = theID;
     }

void opentxs::OTTransactionType::SetReferenceString ( const OTString & theStr )

Definition at line 386 of file OTTransactionType.cpp.

 {
     m_ascInReferenceTo.SetString(theStr);
 }

void opentxs::OTTransactionType::SetReferenceToNum ( int64_t lTransactionNum )

Definition at line 534 of file OTTransactionType.cpp.

 {
     m_lInReferenceToTransaction = lTransactionNum;
 }

void opentxs::OTTransactionType::SetTransactionNum ( int64_t lTransactionNum )

Definition at line 468 of file OTTransactionType.cpp.

 {
     m_lTransactionNum = lTransactionNum;
 }

void opentxs::OTTransactionType::SetUserID ( const OTIdentifier & theID )

inline

Definition at line 837 of file OTTransactionType.hpp.

     {
         m_AcctUserID = theID;
     }

OTTransactionType * opentxs::OTTransactionType::TransactionFactory ( OTString strInput )

static

Definition at line 147 of file OTTransactionType.cpp.

 {
     OTString strContract, strFirstLine; // output for the below function.
     const bool bProcessed =
         OTContract::DearmorAndTrim(strInput, strContract, strFirstLine);
 
     if (bProcessed) {
         OTTransactionType* pContract = nullptr;
 
         if (strFirstLine.Contains(
                 "-----BEGIN SIGNED TRANSACTION-----")) // this string is 34
                                                        // chars long.
         {
             pContract = new OTTransaction();
             OT_ASSERT(nullptr != pContract);
         }
         else if (strFirstLine.Contains(
                        "-----BEGIN SIGNED TRANSACTION ITEM-----")) // this
                                                                    // string is
                                                                    // 39 chars
                                                                    // long.
         {
             pContract = new OTItem();
             OT_ASSERT(nullptr != pContract);
         }
         else if (strFirstLine.Contains(
                        "-----BEGIN SIGNED LEDGER-----")) // this string is 29
                                                          // chars long.
         {
             pContract = new OTLedger();
             OT_ASSERT(nullptr != pContract);
         }
         else if (strFirstLine.Contains(
                        "-----BEGIN SIGNED ACCOUNT-----")) // this string is 30
                                                           // chars long.
         {
             pContract = new OTAccount();
             OT_ASSERT(nullptr != pContract);
         }
 
         // The string didn't match any of the options in the factory.
         //
 
         const char* szFunc = "OTTransactionType::TransactionFactory";
         // The string didn't match any of the options in the factory.
         if (nullptr == pContract) {
             otOut << szFunc
                   << ": Object type not yet supported by class factory: "
                   << strFirstLine << "\n";
             return nullptr;
         }
 
         // This causes pItem to load ASSUMING that the PurportedAcctID and
         // PurportedServerID are correct.
         // The object is still expected to be internally consistent with its
         // sub-items, regarding those IDs,
         // but the big difference is that it will SET the Real Acct and Real
         // Server IDs based on the purported
         // values. This way you can load a transaction without knowing the
         // account in advance.
         //
         pContract->m_bLoadSecurely = false;
 
         // Does the contract successfully load from the string passed in?
         if (pContract->LoadContractFromString(strContract)) {
             // NOTE: this already happens in OTTransaction::ProcessXMLNode and
             // OTLedger::ProcessXMLNode.
             // Specifically, it happens when m_bLoadSecurely is set to false.
             //
             //          pContract->SetRealServerID(pItem->GetPurportedServerID());
             //          pContract->SetRealAccountID(pItem->GetPurportedAccountID());
             //
             return pContract;
         }
         else {
             otOut << szFunc
                   << ": Failed loading contract from string (first line): "
                   << strFirstLine << "\n";
             delete pContract;
             pContract = nullptr;
         }
     }
 
     return nullptr;
 }

bool opentxs::OTTransactionType::VerifyAccount ( const OTPseudonym & theNym )

virtual

Reimplemented in opentxs::OTTransaction, and opentxs::OTLedger.

Definition at line 402 of file OTTransactionType.cpp.

 {
     // Make sure that the supposed AcctID matches the one read from the file.
     //
     if (!VerifyContractID()) {
         otErr << "Error verifying account ID in "
                  "OTTransactionType::VerifyAccount\n";
         return false;
     }
     else if (!VerifySignature(theNym)) {
         otErr << "Error verifying signature in "
                  "OTTransactionType::VerifyAccount.\n";
         return false;
     }
 
     otLog4 << "\nWe now know that...\n"
               "1) The expected Account ID matches the ID that was found on the "
               "object.\n"
               "2) The SIGNATURE VERIFIED on the object.\n\n";
     return true;
 }

bool opentxs::OTTransactionType::VerifyContractID ( ) const

virtual

Reimplemented from opentxs::OTContract.

Definition at line 424 of file OTTransactionType.cpp.

 {
     // m_AcctID contains the number we read from the xml file
     // we can compare it to the existing and actual identifier.
 
     // m_AcctID  contains the "IDENTIFIER" of the object, according to the xml
     // file.
     //
     // Meanwhile m_ID contains the same identifier, except it was generated.
     //
     // Now let's compare the two and make sure they match...
 
     // Also, for this class, we compare ServerID as well.  They go hand in hand.
 
     if ((m_ID != m_AcctID) || (m_ServerID != m_AcctServerID)) {
         OTString str1(m_ID), str2(m_AcctID), str3(m_ServerID),
             str4(m_AcctServerID);
         otErr << "Identifiers do NOT match in "
                  "OTTransactionType::VerifyContractID.\n"
                  "m_ID: " << str1 << "\n m_AcctID: " << str2
               << "\n m_ServerID: " << str3 << "\n m_AcctServerID: " << str4
               << "\n";
 
         //        OT_FAIL;  // I was debugging.
 
         return false;
     }
     else {
         //        OTString str1(m_AcctID), str2(m_AcctServerID);
         //        otErr << "Expected Account ID and Server ID both *SUCCESSFUL*
         // match to "
         //                "IDs in the xml:\n Account ID:\n%s\n ServerID:\n%s\n"
         //                "-----------------------------------------------------------------------------\n",
         //                str1.Get(), str2.Get());
         return true;
     }
 }

bool opentxs::OTTransactionType::VerifyNumberOfOrigin ( OTTransactionType & compareTo )

Definition at line 520 of file OTTransactionType.cpp.

 {
     // Have to use the function here, NOT the internal variable.
     // (Because subclasses may override the function.)
     //
     return (GetNumberOfOrigin() == compareTo.GetNumberOfOrigin());
 }

Member Data Documentation

OTIdentifier opentxs::OTTransactionType::m_AcctID

protected

Definition at line 726 of file OTTransactionType.hpp.

OTIdentifier opentxs::OTTransactionType::m_AcctServerID

protected

Definition at line 732 of file OTTransactionType.hpp.

OTIdentifier opentxs::OTTransactionType::m_AcctUserID

protected

Definition at line 740 of file OTTransactionType.hpp.

OTASCIIArmor opentxs::OTTransactionType::m_ascInReferenceTo

protected

Definition at line 767 of file OTTransactionType.hpp.

bool opentxs::OTTransactionType::m_bLoadSecurely

protected

Definition at line 769 of file OTTransactionType.hpp.

int64_t opentxs::OTTransactionType::m_lInReferenceToTransaction

protected

Definition at line 747 of file OTTransactionType.hpp.

int64_t opentxs::OTTransactionType::m_lNumberOfOrigin

protected

Definition at line 765 of file OTTransactionType.hpp.

int64_t opentxs::OTTransactionType::m_lTransactionNum

protected

Definition at line 745 of file OTTransactionType.hpp.

OTNumList opentxs::OTTransactionType::m_Numlist

protected

Definition at line 794 of file OTTransactionType.hpp.

OTIdentifier opentxs::OTTransactionType::m_ServerID

protected

Definition at line 730 of file OTTransactionType.hpp.

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

/usr/local/src/opentxs/include/opentxs/core/OTTransactionType.hpp
/usr/local/src/opentxs/src/core/OTTransactionType.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation