#include <OTOffer.hpp>

Inheritance diagram for opentxs::OTOffer:

Collaboration diagram for opentxs::OTOffer:

Public Member Functions
EXPORT bool	MakeOffer (bool bBuyingOrSelling, const int64_t &lPriceLimit, const int64_t &lTotalAssetsOffer, const int64_t &lMinimumIncrement, const int64_t &lTransactionNum, const time64_t &VALID_FROM=OT_TIME_ZERO, const time64_t &VALID_TO=OT_TIME_ZERO)

void	IncrementFinishedSoFar (const int64_t &lFinishedSoFar)

int64_t	GetAmountAvailable () const

const int64_t &	GetTransactionNum () const

const int64_t &	GetPriceLimit () const

const int64_t &	GetTotalAssetsOnOffer () const

const int64_t &	GetFinishedSoFar () const

const int64_t &	GetMinimumIncrement ()

const int64_t &	GetScale () const

const OTIdentifier &	GetCurrencyID () const

void	SetCurrencyID (const OTIdentifier &CURRENCY_ID)

bool	IsBid ()

bool	IsAsk ()

bool	IsMarketOrder () const

bool	IsLimitOrder () const

OTTrade *	GetTrade ()

void	SetTrade (const OTTrade &theTrade)

EXPORT time64_t	GetDateAddedToMarket () const

EXPORT void	SetDateAddedToMarket (time64_t tDate)

EXPORT	OTOffer ()

EXPORT	OTOffer (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID, const OTIdentifier &CURRENCY_ID, const int64_t &MARKET_SCALE)

virtual EXPORT	~OTOffer ()

virtual void	GetIdentifier (OTIdentifier &theIdentifier) const

void	InitOffer ()

virtual void	Release ()

void	Release_Offer ()

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

virtual void	UpdateContents ()

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

Public Member Functions inherited from opentxs::OTInstrument
EXPORT	OTInstrument ()

EXPORT	OTInstrument (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

virtual EXPORT	~OTInstrument ()

void	Release_Instrument ()

EXPORT bool	VerifyCurrentDate ()

EXPORT bool	IsExpired ()

time64_t	GetValidFrom () const

time64_t	GetValidTo () const

const OTIdentifier &	GetAssetID () const

const OTIdentifier &	GetServerID () const

void	InitInstrument ()

Public Member Functions inherited from opentxs::OTScriptable
virtual EXPORT void	SetDisplayLabel (const std::string *pstrLabel=nullptr)

int32_t	GetPartyCount () const

int32_t	GetBylawCount () const

virtual EXPORT bool	AddParty (OTParty &theParty)

virtual EXPORT bool	AddBylaw (OTBylaw &theBylaw)

virtual EXPORT bool	ConfirmParty (OTParty &theParty)

EXPORT OTParty *	GetParty (std::string str_party_name) const

EXPORT OTBylaw *	GetBylaw (std::string str_bylaw_name) const

EXPORT OTClause *	GetClause (std::string str_clause_name) const

EXPORT OTParty *	GetPartyByIndex (int32_t nIndex) const

EXPORT OTBylaw *	GetBylawByIndex (int32_t nIndex) const

EXPORT OTParty *	FindPartyBasedOnNymAsAgent (OTPseudonym &theNym, OTAgent **ppAgent=nullptr) const

EXPORT OTParty *	FindPartyBasedOnNymAsAuthAgent (OTPseudonym &theNym, OTAgent **ppAgent=nullptr) const

OTParty *	FindPartyBasedOnAccount (OTAccount &theAccount, OTPartyAccount **ppPartyAccount=nullptr) const

OTParty *	FindPartyBasedOnNymIDAsAgent (const OTIdentifier &theNymID, OTAgent **ppAgent=nullptr) const

OTParty *	FindPartyBasedOnNymIDAsAuthAgent (const OTIdentifier &theNymID, OTAgent **ppAgent=nullptr) const

OTParty *	FindPartyBasedOnAccountID (const OTIdentifier &theAcctID, OTPartyAccount **ppPartyAccount=nullptr) const

OTAgent *	GetAgent (std::string str_agent_name) const

OTPartyAccount *	GetPartyAccount (std::string str_acct_name) const

OTPartyAccount *	GetPartyAccountByID (const OTIdentifier &theAcctID) const

EXPORT int32_t	GetCountTransNumsNeededForAgent (std::string str_agent_name) const

virtual EXPORT bool	VerifyNymAsAgent (OTPseudonym &theNym, OTPseudonym &theSignerNym, mapOfNyms *pmap_ALREADY_LOADED=nullptr) const

virtual EXPORT bool	VerifyNymAsAgentForAccount (OTPseudonym &theNym, OTAccount &theAccount) const

bool	VerifyPartyAuthorization (OTParty &theParty, OTPseudonym &theSignerNym, const OTString &strServerID, mapOfNyms pmap_ALREADY_LOADED=nullptr, mapOfNyms pmap_NEWLY_LOADED=nullptr, bool bBurnTransNo=false)

bool	VerifyPartyAcctAuthorization (OTPartyAccount &thePartyAcct, OTPseudonym &theSignerNym, const OTString &strServerID, bool bBurnTransNo=false)

EXPORT bool	VerifyThisAgainstAllPartiesSignedCopies ()

EXPORT bool	AllPartiesHaveSupposedlyConfirmed ()

void	RetrieveNymPointers (mapOfNyms &map_Nyms_Already_Loaded)

void	ClearTemporaryPointers ()

bool	GetHooks (std::string str_HookName, mapOfClauses &theResults)

OTClause *	GetCallback (std::string str_CallbackName)

OTVariable *	GetVariable (std::string str_VarName)

bool	IsDirty () const

bool	IsDirtyImportant () const

void	SetAsClean ()

EXPORT bool	SendNoticeToAllParties (bool bSuccessMsg, OTPseudonym &theServerNym, const OTIdentifier &theServerID, const int64_t &lNewTransactionNumber, const OTString &strReference, OTString pstrNote=nullptr, OTString pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr) const

EXPORT bool	CanExecuteClause (std::string str_party_name, std::string str_clause_name)

bool	ExecuteCallback (OTClause &theCallbackClause, mapOfVariables &theParameters, OTVariable &varReturnVal)

virtual EXPORT void	RegisterOTNativeCallsWithScript (OTScript &theScript)

virtual EXPORT bool	Compare (OTScriptable &rhs) const

	OTScriptable ()

virtual	~OTScriptable ()

void	UpdateContentsToString (OTString &strAppend, bool bCalculatingID) const

virtual EXPORT void	CalculateContractID (OTIdentifier &newID) const

void	Release_Scriptable ()

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 (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	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 bool	VerifyContractID () 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

Protected Member Functions
void	SetTransactionNum (const int64_t &lTransactionNum)

void	SetPriceLimit (const int64_t &lPriceLimit)

void	SetTotalAssetsOnOffer (const int64_t &lTotalAssets)

void	SetFinishedSoFar (const int64_t &lFinishedSoFar)

void	SetMinimumIncrement (const int64_t &lMinIncrement)

void	SetScale (const int64_t &lScale)

Protected Member Functions inherited from opentxs::OTInstrument
void	SetValidFrom (time64_t TIME_FROM)

void	SetValidTo (time64_t TIME_TO)

void	SetAssetID (const OTIdentifier &ASSET_ID)

void	SetServerID (const OTIdentifier &SERVER_ID)

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

Protected Attributes
OTTrade *	m_pTrade

OTIdentifier	m_CURRENCY_TYPE_ID

bool	m_bSelling

int64_t	m_lPriceLimit

int64_t	m_lTransactionNum

int64_t	m_lTotalAssetsOffer

int64_t	m_lFinishedSoFar

int64_t	m_lScale

int64_t	m_lMinimumIncrement

Protected Attributes inherited from opentxs::OTInstrument
OTIdentifier	m_AssetTypeID

OTIdentifier	m_ServerID

time64_t	m_VALID_FROM

time64_t	m_VALID_TO

Protected Attributes inherited from opentxs::OTScriptable
mapOfParties	m_mapParties

mapOfBylaws	m_mapBylaws

bool	m_bCalculatingID

bool	m_bSpecifyAssetID

bool	m_bSpecifyParties

OTString	m_strLabel

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

Additional Inherited Members
Static Public Member Functions inherited from opentxs::OTScriptable
static EXPORT OTScriptable *	InstantiateScriptable (const OTString &strInput)

static bool	ValidateName (std::string str_name)

static std::string	GetTime ()

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)

Detailed Description

Definition at line 167 of file OTOffer.hpp.

Constructor & Destructor Documentation

opentxs::OTOffer::OTOffer ( )

Definition at line 510 of file OTOffer.cpp.

     : ot_super()
     , m_tDateAddedToMarket(OT_TIME_ZERO)
     , m_pTrade(nullptr)
     , // No need to free m_pTrade, not responsible. Only here for convenience.
     m_bSelling(false)
     , m_lPriceLimit(0)
     , m_lTransactionNum(0)
     , m_lTotalAssetsOffer(0)
     , m_lFinishedSoFar(0)
     , m_lScale(1)
     , // This must be 1 or greater. CANNOT be zero. Enforced.
     m_lMinimumIncrement(
         1) // This must be 1 or greater. CANNOT be zero. Enforced.
 {
     InitOffer();
 }

opentxs::OTOffer::OTOffer	(	const OTIdentifier &	SERVER_ID,
		const OTIdentifier &	ASSET_ID,
		const OTIdentifier &	CURRENCY_ID,
		const int64_t &	MARKET_SCALE
	)

Definition at line 528 of file OTOffer.cpp.

     : ot_super(SERVER_ID, ASSET_ID)
     , m_tDateAddedToMarket(OT_TIME_ZERO)
     , m_pTrade(nullptr)
     , // No need to free m_pTrade, not responsible. Only here for convenience.
     m_bSelling(false)
     , m_lPriceLimit(0)
     , m_lTransactionNum(0)
     , m_lTotalAssetsOffer(0)
     , m_lFinishedSoFar(0)
     , m_lScale(1)
     , // This must be 1 or greater. CANNOT be zero. Enforced.
     m_lMinimumIncrement(
         1) // This must be 1 or greater. CANNOT be zero. Enforced.
 {
     InitOffer();
 
     SetScale(lScale);
 
     m_CURRENCY_TYPE_ID = CURRENCY_ID;
 }

opentxs::OTOffer::~OTOffer ( )

virtual

Definition at line 551 of file OTOffer.cpp.

 {
     Release_Offer();
 }

Member Function Documentation

int64_t opentxs::OTOffer::GetAmountAvailable ( ) const

inline

Definition at line 273 of file OTOffer.hpp.

     {
         return GetTotalAssetsOnOffer() - GetFinishedSoFar();
     }

const OTIdentifier& opentxs::OTOffer::GetCurrencyID ( ) const

inline

Definition at line 304 of file OTOffer.hpp.

     {
         return m_CURRENCY_TYPE_ID;
     }

time64_t opentxs::OTOffer::GetDateAddedToMarket ( ) const

Definition at line 498 of file OTOffer.cpp.

 {
     return m_tDateAddedToMarket;
 }

const int64_t& opentxs::OTOffer::GetFinishedSoFar ( ) const

inline

Definition at line 290 of file OTOffer.hpp.

     {
         return m_lFinishedSoFar;
     }

void opentxs::OTOffer::GetIdentifier ( OTIdentifier & theIdentifier ) const

virtual

Reimplemented from opentxs::OTContract.

Definition at line 206 of file OTOffer.cpp.

 {
     OTString strTemp, strAsset(GetAssetID()), strCurrency(GetCurrencyID());
 
     int64_t lScale = GetScale();
 
     // In this way we generate a unique ID that will always be consistent
     // for the same asset ID, currency ID, and market scale.
     strTemp.Format("ASSET TYPE:\n%s\nCURRENCY TYPE:\n%s\nMARKET SCALE:\n%lld\n",
                    strAsset.Get(), strCurrency.Get(), lScale);
 
     theIdentifier.CalculateDigest(strTemp);
 }

const int64_t& opentxs::OTOffer::GetMinimumIncrement ( )

inline

Definition at line 294 of file OTOffer.hpp.

     {
         if (m_lMinimumIncrement < 1) m_lMinimumIncrement = 1;
         return m_lMinimumIncrement;
     }

const int64_t& opentxs::OTOffer::GetPriceLimit ( ) const

inline

Definition at line 282 of file OTOffer.hpp.

     {
         return m_lPriceLimit;
     }

const int64_t& opentxs::OTOffer::GetScale ( ) const

inline

Definition at line 299 of file OTOffer.hpp.

     {
         return m_lScale;
     }

const int64_t& opentxs::OTOffer::GetTotalAssetsOnOffer ( ) const

inline

Definition at line 286 of file OTOffer.hpp.

     {
         return m_lTotalAssetsOffer;
     }

OTTrade* opentxs::OTOffer::GetTrade ( )

inline

Definition at line 328 of file OTOffer.hpp.

     {
         return m_pTrade;
     }

const int64_t& opentxs::OTOffer::GetTransactionNum ( ) const

inline

Definition at line 277 of file OTOffer.hpp.

     {
         return m_lTransactionNum;
     }

void opentxs::OTOffer::IncrementFinishedSoFar ( const int64_t & lFinishedSoFar )

inline

Definition at line 268 of file OTOffer.hpp.

     {
         m_lFinishedSoFar += lFinishedSoFar;
     }

void opentxs::OTOffer::InitOffer ( )

Definition at line 574 of file OTOffer.cpp.

 {
     m_strContractType.Set(
         "OFFER"); // in practice should never appear. BID/ASK will overwrite.
 
     // This pointer will get wiped anytime Release() is called... which means
     // anytime LoadContractFromString()
     // is called. For some objects, that screws them up because suddenly the
     // pointer went nullptr when they needed it.
     // In the case of this object, the pointer is reset whenever Cron processes,
     // so this is safe. But in
     // the case of other objects, it's better not to initialize the pointer
     // here, but in the constructor instead.
     // FYI. For example, OTCron has a pointer to m_pServerNym. LoadCron() and
     // the pointer is nullptr. Can't have that!
     // So I moved it to the constructor in that case.
 
     m_bSelling = false;
     m_lPriceLimit = 0;
     m_lTransactionNum = 0;
     m_lTotalAssetsOffer = 0;
     m_lFinishedSoFar = 0;
     m_lMinimumIncrement = 1; // This must be 1 or greater. Enforced.
     SetScale(1);             // This must be 1 or greater. Enforced.
 }

bool opentxs::OTOffer::IsAsk ( )

inline

Definition at line 318 of file OTOffer.hpp.

     {
         return m_bSelling;
     }

bool opentxs::OTOffer::IsBid ( )

inline

Definition at line 314 of file OTOffer.hpp.

     {
         return !m_bSelling;
     }

bool opentxs::OTOffer::IsLimitOrder ( ) const

Definition at line 225 of file OTOffer.cpp.

 {
     return (0 != GetPriceLimit());
 }

bool opentxs::OTOffer::IsMarketOrder ( ) const

Definition at line 220 of file OTOffer.cpp.

 {
     return (0 == GetPriceLimit());
 }

bool opentxs::OTOffer::MakeOffer	(	bool	bBuyingOrSelling,
		const int64_t &	lPriceLimit,
		const int64_t &	lTotalAssetsOffer,
		const int64_t &	lMinimumIncrement,
		const int64_t &	lTransactionNum,
		const time64_t &	VALID_FROM = `OT_TIME_ZERO`,
		const time64_t &	VALID_TO = `OT_TIME_ZERO`
	)

Definition at line 434 of file OTOffer.cpp.

 {
     m_bSelling = bBuyingOrSelling; // Bid or Ask?
     SetTransactionNum(lTransactionNum);
     SetTotalAssetsOnOffer(lTotalAssetsOffer); // 500 bushels for sale.
 
     m_strContractType.Set((m_bSelling ? "ASK" : "BID"));
 
     // Make sure minimum increment isn't bigger than total Assets.
     // (If you pass them into this function as the same value, it's functionally
     // a "FILL OR KILL" order.)
     int64_t lRealMinInc = lMinimumIncrement;
     if (lMinimumIncrement > lTotalAssetsOffer) // Once the total, minus finish
                                                // so far, is smaller than the
                                                // minimum increment,
         lRealMinInc = lTotalAssetsOffer; // then the OTTrade object I am linked
                                          // to will expire and remove me from
                                          // the market.
     // OR it could set the minimum increment to the remainder. But then need to
     // calc price.
 
     SetMinimumIncrement(lRealMinInc); // Must sell in 50 bushel increments.
                                       // (Perhaps on the 10-bushel market it
                                       // will sell in 5 increments of 10.)
     SetPriceLimit(lPriceLimit);       // Won't sell for any less than $10 per
     // increment. (Always get best market price.)
     SetFinishedSoFar(0); // So far have already sold 350 bushels. Actual amount
                          // available is (total - finished).
 
     time64_t REAL_VALID_FROM = VALID_FROM;
     time64_t REAL_VALID_TO = VALID_TO;
 
     if (OT_TIME_ZERO >= VALID_FROM) {
         REAL_VALID_FROM =
             OTTimeGetCurrentTime(); // This time is set to TODAY NOW
     }
 
     if (OT_TIME_ZERO >= VALID_TO) {
         // (All offers default to a "DAY ORDER" if valid dates not specified.)
         REAL_VALID_TO = OTTimeAddTimeInterval(
             REAL_VALID_FROM,
             OTTimeGetSecondsFromTime(OT_TIME_DAY_IN_SECONDS)); // 1 day.
     }
 
     SetValidFrom(REAL_VALID_FROM);
     SetValidTo(REAL_VALID_TO);
 
     return true;
 }

int32_t opentxs::OTOffer::ProcessXMLNode ( irr::io::IrrXMLReader *& xml )

virtual

Reimplemented from opentxs::OTInstrument.

Definition at line 231 of file OTOffer.cpp.

 {
     int32_t nReturnVal = 0;
 
     // Here we call the parent class first.
     // If the node is found there, or there is some error,
     // then we just return either way.  But if it comes back
     // as '0', then nothing happened, and we'll continue executing.
     //
     // -- Note you can choose not to call the parent if
     // you don't want to use any of those xml tags.
     // As I do below, in the case of OTAccount.
     // if (nReturnVal = OTContract::ProcessXMLNode(xml))
     //    return nReturnVal;
 
     if (!strcmp("marketOffer", xml->getNodeName())) {
         m_strVersion = xml->getAttributeValue("version");
 
         OTString strIsSelling;
         strIsSelling = xml->getAttributeValue("isSelling");
         if (strIsSelling.Compare("true"))
             m_bSelling = true;
         else
             m_bSelling = false;
 
         m_strContractType.Set((m_bSelling ? "ASK" : "BID"));
 
         const OTString strServerID(xml->getAttributeValue("serverID")),
             strAssetTypeID(xml->getAttributeValue("assetTypeID")),
             strCurrencyTypeID(xml->getAttributeValue("currencyTypeID"));
 
         const OTIdentifier SERVER_ID(strServerID), ASSET_ID(strAssetTypeID),
             CURRENCY_TYPE_ID(strCurrencyTypeID);
 
         SetServerID(SERVER_ID);
         SetAssetID(ASSET_ID);
         SetCurrencyID(CURRENCY_TYPE_ID);
 
         const OTString strScale = xml->getAttributeValue("marketScale");
         const int64_t lScale = strScale.Exists() ? atol(strScale.Get())
                                                  : 0; // if it doesn't exist,
                                                       // the 0 here causes the
                                                       // below error to fire.
 
         if (!isPowerOfTen(lScale)) {
             otOut << "OTOffer::ProcessXMLNode: Failure: marketScale *must* be "
                      "1, or a power of 10. Instead I got: " << lScale << ".\n";
             return (-1);
         }
         else
             SetScale(lScale);
 
         const OTString strPriceLimit = xml->getAttributeValue("priceLimit");
         const int64_t lPriceLimit = strPriceLimit.Exists()
                                         ? atol(strPriceLimit.Get())
                                         : 0; // if it doesn't exist, the 0 here
                                              // causes the below error to fire.
 
         // NOTE: Market Orders (new) have a 0 price, so this error condition was
         // changed.
         if (!strPriceLimit.Exists())
         //      if (lPriceLimit < 1)
         {
             otOut << "OTOffer::ProcessXMLNode: Failure: priceLimit *must* be "
                      "provided(" << lPriceLimit << ").\n";
             return (-1);
         }
         else
             SetPriceLimit(lPriceLimit);
 
         const OTString strTotal = xml->getAttributeValue("totalAssetsOnOffer");
         const int64_t lTotal = strTotal.Exists() ? atol(strTotal.Get())
                                                  : 0; // if it doesn't exist,
                                                       // the 0 here causes the
                                                       // below error to fire.
         if (lTotal < 1) {
             otOut << "OTOffer::ProcessXMLNode: Failure: totalAssetsOnOffer "
                      "*must* be larger than 0. Instead I got: " << lTotal
                   << ".\n";
             return (-1);
         }
         else
             SetTotalAssetsOnOffer(lTotal);
 
         const OTString strFinished = xml->getAttributeValue("finishedSoFar");
         const int64_t lFinished = strFinished.Exists()
                                       ? atol(strFinished.Get())
                                       : 0; // if it doesn't exist, the 0 here
                                            // causes the below error to fire.
         if (lFinished < 0) {
             otOut << "OTOffer::ProcessXMLNode: Failure: finishedSoFar *must* "
                      "be 0 or larger. Instead I got: " << lFinished << ".\n";
             return (-1);
         }
         else
             SetFinishedSoFar(lFinished);
 
         const OTString strMinInc = xml->getAttributeValue("minimumIncrement");
         const int64_t lMinInc = strMinInc.Exists() ? atol(strMinInc.Get())
                                                    : 0; // if it doesn't exist,
                                                         // the 0 here causes the
                                                         // below error to fire.
         if ((lMinInc < 1) || (lMinInc > lTotal)) // Minimum increment cannot
                                                  // logically be higher than the
                                                  // total assets on offer...
         {
             otOut << "OTOffer::ProcessXMLNode: Failure: minimumIncrement "
                      "*must* be 1 or larger, \n"
                      "and must also be less than the total assets on offer. "
                      "Instead I got: " << lMinInc << ".\n";
             return (-1);
         }
         else
             SetMinimumIncrement(lMinInc);
 
         const OTString strTransNum = xml->getAttributeValue("transactionNum");
         const int64_t lTransNum =
             strTransNum.Exists() ? atol(strTransNum.Get()) : 0;
 
         SetTransactionNum(lTransNum);
 
         const OTString str_valid_from = xml->getAttributeValue("validFrom");
         const OTString str_valid_to = xml->getAttributeValue("validTo");
 
         int64_t tValidFrom =
             str_valid_from.Exists() ? str_valid_from.ToLong() : 0;
         int64_t tValidTo = str_valid_to.Exists() ? str_valid_to.ToLong() : 0;
 
         if ((tValidTo < tValidFrom) && (tValidTo != 0)) {
             otOut << "OTOffer::" << __FUNCTION__ << ": Failure: validTo date ("
                   << tValidFrom << ") cannot be earlier than "
                                    "validFrom date (" << tValidTo << ").\n";
             return (-1);
         }
 
         SetValidFrom(OTTimeGetTimeFromSeconds(tValidFrom));
         SetValidTo(OTTimeGetTimeFromSeconds(tValidTo));
 
         otLog4 << "\n\nOffer. Transaction Number: " << m_lTransactionNum
                << "\n Valid From: " << tValidFrom << "\n Valid To: " << tValidTo
                << "\n"
                   " AssetTypeID: " << strAssetTypeID
                << "\n  CurrencyTypeID: " << strCurrencyTypeID
                << "\n ServerID: " << strServerID
                << "\n"
                   " Price Limit: " << GetPriceLimit()
                << ",  Total Assets on Offer: " << GetTotalAssetsOnOffer()
                << ",  " << (m_bSelling ? "sold" : "bought")
                << " so far: " << GetFinishedSoFar() << "\n "
                                                        " Scale: " << GetScale()
                << ".   Minimum Increment: " << GetMinimumIncrement()
                << ".  This offer is a" << (m_bSelling ? "n ASK" : " BID")
                << ".\n";
 
         nReturnVal = 1;
     }
 
     return nReturnVal;
 }

void opentxs::OTOffer::Release ( void )

virtual

Reimplemented from opentxs::OTInstrument.

Definition at line 562 of file OTOffer.cpp.

 {
     // If there were any dynamically allocated objects, clean them up here.
     Release_Offer();
 
     ot_super::Release(); // since I've overridden the base class, I call it
                          // now...
 
     // Then I call this to re-initialize everything
     InitOffer();
 }

void opentxs::OTOffer::Release_Offer ( )

Definition at line 556 of file OTOffer.cpp.

 {
     // If there were any dynamically allocated objects, clean them up here.
     m_CURRENCY_TYPE_ID.Release();
 }

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

virtual

Reimplemented from opentxs::OTInstrument.

Definition at line 600 of file OTOffer.cpp.

 {
     return true;
 }

void opentxs::OTOffer::SetCurrencyID ( const OTIdentifier & CURRENCY_ID )

inline

Definition at line 308 of file OTOffer.hpp.

     {
         m_CURRENCY_TYPE_ID = CURRENCY_ID;
     }

void opentxs::OTOffer::SetDateAddedToMarket ( time64_t tDate )

Definition at line 504 of file OTOffer.cpp.

 {
     m_tDateAddedToMarket = tDate;
 }

void opentxs::OTOffer::SetFinishedSoFar ( const int64_t & lFinishedSoFar )

inlineprotected

Definition at line 240 of file OTOffer.hpp.

     {
         m_lFinishedSoFar = lFinishedSoFar;
     }

void opentxs::OTOffer::SetMinimumIncrement ( const int64_t & lMinIncrement )

inlineprotected

Definition at line 244 of file OTOffer.hpp.

     {
         m_lMinimumIncrement = lMinIncrement;
         if (m_lMinimumIncrement < 1) m_lMinimumIncrement = 1;
     }

void opentxs::OTOffer::SetPriceLimit ( const int64_t & lPriceLimit )

inlineprotected

Definition at line 232 of file OTOffer.hpp.

     {
         m_lPriceLimit = lPriceLimit;
     }

void opentxs::OTOffer::SetScale ( const int64_t & lScale )

inlineprotected

Definition at line 249 of file OTOffer.hpp.

     {
         m_lScale = lScale;
         if (m_lScale < 1) m_lScale = 1;
     }

void opentxs::OTOffer::SetTotalAssetsOnOffer ( const int64_t & lTotalAssets )

inlineprotected

Definition at line 236 of file OTOffer.hpp.

     {
         m_lTotalAssetsOffer = lTotalAssets;
     }

void opentxs::OTOffer::SetTrade ( const OTTrade & theTrade )

inline

Definition at line 332 of file OTOffer.hpp.

     {
         m_pTrade = &((OTTrade&)theTrade);
     }

void opentxs::OTOffer::SetTransactionNum ( const int64_t & lTransactionNum )

inlineprotected

Definition at line 228 of file OTOffer.hpp.

     {
         m_lTransactionNum = lTransactionNum;
     }

void opentxs::OTOffer::UpdateContents ( )

virtual

Reimplemented from opentxs::OTScriptable.

Definition at line 391 of file OTOffer.cpp.

 {
     const OTString SERVER_ID(GetServerID()), ASSET_TYPE_ID(GetAssetID()),
         CURRENCY_TYPE_ID(GetCurrencyID());
 
     const int64_t lFrom = OTTimeGetSecondsFromTime(GetValidFrom());
     const int64_t lTo = OTTimeGetSecondsFromTime(GetValidTo());
     const int64_t lPriceLimit = GetPriceLimit();
     const int64_t lTotalAssetsOnOffer = GetTotalAssetsOnOffer();
     const int64_t lFinishedSoFar = GetFinishedSoFar();
     const int64_t lScale = GetScale();
     const int64_t lMinimumIncrement = GetMinimumIncrement();
     const int64_t lTransactionNum = GetTransactionNum();
 
     // I release this because I'm about to repopulate it.
     m_xmlUnsigned.Release();
 
     m_xmlUnsigned.Concatenate("<?xml version=\"%s\"?>\n\n", "1.0");
 
     m_xmlUnsigned.Concatenate(
         "<marketOffer\n version=\"%s\"\n"
         " isSelling=\"%s\"\n" // true or false.
         " serverID=\"%s\"\n"
         " assetTypeID=\"%s\"\n"
         " currencyTypeID=\"%s\"\n"
         " priceLimit=\"%lld\"\n"
         " totalAssetsOnOffer=\"%lld\"\n"
         " finishedSoFar=\"%lld\"\n"
         " marketScale=\"%lld\"\n"
         " minimumIncrement=\"%lld\"\n"
         " transactionNum=\"%lld\"\n"
         " validFrom=\"%" PRId64 "\"\n"
         " validTo=\"%" PRId64 "\""
         " />\n\n", //  <=== the tag ends here.
         m_strVersion.Get(),
         (IsBid() ? "false" : "true"), SERVER_ID.Get(), ASSET_TYPE_ID.Get(),
         CURRENCY_TYPE_ID.Get(), lPriceLimit, lTotalAssetsOnOffer,
         lFinishedSoFar, lScale, lMinimumIncrement, lTransactionNum, lFrom, lTo);
 
     //    m_xmlUnsigned.Concatenate("</marketOffer>\n");    // ^^^ Tag already
     // ended above.
 }

Member Data Documentation

bool opentxs::OTOffer::m_bSelling

protected

Definition at line 203 of file OTOffer.hpp.

OTIdentifier opentxs::OTOffer::m_CURRENCY_TYPE_ID

protected

Definition at line 201 of file OTOffer.hpp.

int64_t opentxs::OTOffer::m_lFinishedSoFar

protected

Definition at line 216 of file OTOffer.hpp.

int64_t opentxs::OTOffer::m_lMinimumIncrement

protected

Definition at line 221 of file OTOffer.hpp.

int64_t opentxs::OTOffer::m_lPriceLimit

protected

Definition at line 208 of file OTOffer.hpp.

int64_t opentxs::OTOffer::m_lScale

protected

Definition at line 219 of file OTOffer.hpp.

int64_t opentxs::OTOffer::m_lTotalAssetsOffer

protected

Definition at line 214 of file OTOffer.hpp.

int64_t opentxs::OTOffer::m_lTransactionNum

protected

Definition at line 213 of file OTOffer.hpp.

OTTrade* opentxs::OTOffer::m_pTrade

protected

Definition at line 198 of file OTOffer.hpp.

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

/usr/local/src/opentxs/include/opentxs/core/trade/OTOffer.hpp
/usr/local/src/opentxs/src/core/trade/OTOffer.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation