#include <OTAssetContract.hpp>

Inheritance diagram for opentxs::OTAssetContract:

Collaboration diagram for opentxs::OTAssetContract:

Public Member Functions
EXPORT	OTAssetContract ()

EXPORT	OTAssetContract (OTString &name, OTString &foldername, OTString &filename, OTString &strID)

virtual EXPORT	~OTAssetContract ()

virtual EXPORT void	CreateContents ()

EXPORT bool	IsShares () const

EXPORT bool	AddAccountRecord (const OTAccount &theAccount) const

EXPORT bool	EraseAccountRecord (const OTIdentifier &theAcctID) const

EXPORT bool	VisitAccountRecords (AccountVisitor &visitor) const

EXPORT bool	FormatAmount (int64_t amount, std::string &str_output) const

EXPORT bool	StringToAmount (int64_t &amount, const std::string &str_input) const

EXPORT const OTString &	GetBasketInfo () const

EXPORT const OTString &	GetCurrencyName () const

EXPORT const OTString &	GetCurrencyFraction () const

EXPORT const OTString &	GetCurrencySymbol () const

EXPORT const OTString &	GetCurrencyTLA () const

virtual EXPORT bool	SaveContractWallet (OTString &strContents) const

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

virtual EXPORT bool	DisplayStatistics (OTString &strContents) 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 ()

virtual EXPORT void	Release ()

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

EXPORT void	CreateInnerContents ()

virtual EXPORT bool	SaveContents (std::ofstream &ofs) 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 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 std::string	formatLongAmount (int64_t lValue, int32_t nFactor=100, int32_t nPower=2, const char szCurrencySymbol="", const char szThousandSeparator=",", const char *szDecimalPoint=".")

static EXPORT bool	ParseFormatted (int64_t &lResult, const std::string &str_input, int32_t nFactor=100, int32_t nPower=2, const char szThousandSeparator=",", const char szDecimalPoint=".")

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
virtual EXPORT int32_t	ProcessXMLNode (irr::io::IrrXMLReader *&xml)

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

Protected Attributes
OTString	m_strBasketInfo

OTString	m_strIssueCompany

OTString	m_strIssueEmail

OTString	m_strIssueContractURL

OTString	m_strIssueType

OTString	m_strIssueDate

OTString	m_strCurrencyName

OTString	m_strCurrencyType

OTString	m_strCurrencySymbol

OTString	m_strCurrencyTLA

OTString	m_strCurrencyFactor

OTString	m_strCurrencyDecimalPower

OTString	m_strCurrencyFraction

bool	m_bIsCurrency

bool	m_bIsShares

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 OTAssetContract.hpp.

Constructor & Destructor Documentation

opentxs::OTAssetContract::OTAssetContract ( )

Definition at line 433 of file OTAssetContract.cpp.

     : OTContract()
     , m_bIsCurrency(true)
     , m_bIsShares(false)
 {
 }

opentxs::OTAssetContract::OTAssetContract	(	OTString &	name,
		OTString &	foldername,
		OTString &	filename,
		OTString &	strID
	)

Definition at line 440 of file OTAssetContract.cpp.

     : OTContract(name, foldername, filename, strID)
     , m_bIsCurrency(true)
     , m_bIsShares(false)
 {
 }

opentxs::OTAssetContract::~OTAssetContract ( )

virtual

Definition at line 448 of file OTAssetContract.cpp.

449 {

450 }

Member Function Documentation

bool opentxs::OTAssetContract::AddAccountRecord ( const OTAccount & theAccount ) const

Definition at line 598 of file OTAssetContract.cpp.

 {
     //  Load up account list StringMap. Create it if doesn't already exist.
     //  See if account is already there in the map. Add it otherwise.
     //  Save the StringMap back again. (The account records list for a given
     // asset type.)
 
     const char* szFunc = "OTAssetContract::AddAccountRecord";
 
     if (theAccount.GetAssetTypeID() != m_ID) {
         otErr << szFunc << ": Error: theAccount doesn't have the same asset "
                            "type ID as *this does.\n";
         return false;
     }
 
     const OTIdentifier theAcctID(theAccount);
     const OTString strAcctID(theAcctID);
 
     OTString strAssetTypeID, strAcctRecordFile;
     GetIdentifier(strAssetTypeID);
     strAcctRecordFile.Format("%s.a", strAssetTypeID.Get());
 
     OTDB::Storable* pStorable = nullptr;
     std::unique_ptr<OTDB::Storable> theAngel;
     OTDB::StringMap* pMap = nullptr;
 
     if (OTDB::Exists(OTFolders::Contract().Get(),
                      strAcctRecordFile.Get())) // the file already exists; let's
                                                // try to load it up.
         pStorable = OTDB::QueryObject(OTDB::STORED_OBJ_STRING_MAP,
                                       OTFolders::Contract().Get(),
                                       strAcctRecordFile.Get());
     else // the account records file (for this asset type) doesn't exist.
         pStorable = OTDB::CreateObject(
             OTDB::STORED_OBJ_STRING_MAP); // this asserts already, on failure.
 
     theAngel.reset(pStorable);
     pMap = (nullptr == pStorable) ? nullptr
                                   : dynamic_cast<OTDB::StringMap*>(pStorable);
 
     // It exists.
     //
     if (nullptr == pMap) {
         otErr << szFunc
               << ": Error: failed trying to load or create the account records "
                  "file for asset type: " << strAssetTypeID << "\n";
         return false;
     }
 
     auto& theMap = pMap->the_map;
     auto map_it = theMap.find(strAcctID.Get());
 
     if (theMap.end() != map_it) // we found it.
     {                           // We were ADDING IT, but it was ALREADY THERE.
         // (Thus, we're ALREADY DONE.)
         // Let's just make sure the right asset type ID is associated with this
         // account
         // (it better be, since we loaded the account records file based on the
         // asset type ID as its filename...)
         //
         const std::string& str2 =
             map_it->second; // Containing the asset type ID. (Just in case
                             // someone copied the wrong file here,
         // --------------------------------          // every account should map
         // to the SAME asset ID.)
 
         if (false ==
             strAssetTypeID.Compare(str2.c_str())) // should never happen.
         {
             otErr << szFunc
                   << ": Error: wrong asset type found in account records "
                      "file...\n For asset type: " << strAssetTypeID
                   << "\n "
                      "For account: " << strAcctID
                   << "\n Found wrong asset type: " << str2 << "\n";
             return false;
         }
 
         return true; // already there (no need to add.) + the asset type ID
                      // matches.
     }
 
     // it wasn't already on the list...
 
     // ...so add it.
     //
     theMap[strAcctID.Get()] = strAssetTypeID.Get();
 
     // Then save it back to local storage:
     //
     if (!OTDB::StoreObject(*pMap, OTFolders::Contract().Get(),
                            strAcctRecordFile.Get())) {
         otErr << szFunc
               << ": Failed trying to StoreObject, while saving updated "
                  "account records file for asset type: " << strAssetTypeID
               << "\n to contain account ID: " << strAcctID << "\n";
         return false;
     }
 
     // Okay, we saved the updated file, with the account added. (done, success.)
     //
     return true;
 }

void opentxs::OTAssetContract::CreateContents ( )

virtual

Reimplemented from opentxs::OTContract.

Reimplemented in opentxs::BasketContract.

Definition at line 787 of file OTAssetContract.cpp.

 {
     m_strVersion = "2.0"; // 2.0 since adding credentials.
 
     m_xmlUnsigned.Release();
     m_xmlUnsigned.Concatenate("<?xml version=\"%s\"?>\n", "1.0");
 
     m_xmlUnsigned.Concatenate("<%s version=\"%s\">\n\n", "digitalAssetContract",
                               m_strVersion.Get());
 
     // Entity
     m_xmlUnsigned.Concatenate("<entity shortname=\"%s\"\n"
                               " longname=\"%s\"\n"
                               " email=\"%s\"/>\n\n",
                               m_strEntityShortName.Get(),
                               m_strEntityLongName.Get(),
                               m_strEntityEmail.Get());
 
     // Issue
     m_xmlUnsigned.Concatenate("<issue company=\"%s\"\n"
                               " email=\"%s\"\n"
                               " contractUrl=\"%s\"\n"
                               " type=\"%s\"/>\n\n",
                               m_strIssueCompany.Get(), m_strIssueEmail.Get(),
                               m_strIssueContractURL.Get(),
                               m_strIssueType.Get());
 
     // [currency|shares]
     if (m_bIsCurrency)
         m_xmlUnsigned.Concatenate(
             "<currency name=\"%s\" tla=\"%s\" symbol=\"%s\" type=\"%s\" "
             "factor=\"%s\" decimal_power=\"%s\" fraction=\"%s\" />\n\n",
             m_strCurrencyName.Get(), m_strCurrencyTLA.Get(),
             m_strCurrencySymbol.Get(), m_strCurrencyType.Get(),
             m_strCurrencyFactor.Get(), m_strCurrencyDecimalPower.Get(),
             m_strCurrencyFraction.Get());
     else if (m_bIsShares)
         m_xmlUnsigned.Concatenate(
             "<shares name=\"%s\" symbol=\"%s\" type=\"%s\" "
             "issuedate=\"%s\" />\n\n",
             m_strCurrencyName.Get(), m_strCurrencySymbol.Get(),
             m_strCurrencyType.Get(), m_strIssueDate.Get());
 
     // This is where OTContract scribes m_xmlUnsigned with its keys, conditions,
     // etc.
     CreateInnerContents();
 
     m_xmlUnsigned.Concatenate("</%s>\n", "digitalAssetContract");
 }

bool opentxs::OTAssetContract::DisplayStatistics ( OTString & strContents ) const

virtual

Reimplemented from opentxs::OTContract.

Definition at line 452 of file OTAssetContract.cpp.

 {
     const OTString strID(m_ID);
 
     strContents.Concatenate(" Asset Type:  %s\n"
                             " AssetTypeID: %s\n"
                             "\n",
                             m_strName.Get(), strID.Get());
     return true;
 }

bool opentxs::OTAssetContract::EraseAccountRecord ( const OTIdentifier & theAcctID ) const

Definition at line 710 of file OTAssetContract.cpp.

 {
     //  Load up account list StringMap. Create it if doesn't already exist.
     //  See if account is already there in the map. Erase it, if it is.
     //  Save the StringMap back again. (The account records list for a given
     // asset type.)
 
     const char* szFunc = "OTAssetContract::EraseAccountRecord";
 
     const OTString strAcctID(theAcctID);
 
     OTString strAssetTypeID, strAcctRecordFile;
     GetIdentifier(strAssetTypeID);
     strAcctRecordFile.Format("%s.a", strAssetTypeID.Get());
 
     OTDB::Storable* pStorable = nullptr;
     std::unique_ptr<OTDB::Storable> theAngel;
     OTDB::StringMap* pMap = nullptr;
 
     if (OTDB::Exists(OTFolders::Contract().Get(),
                      strAcctRecordFile.Get())) // the file already exists; let's
                                                // try to load it up.
         pStorable = OTDB::QueryObject(OTDB::STORED_OBJ_STRING_MAP,
                                       OTFolders::Contract().Get(),
                                       strAcctRecordFile.Get());
     else // the account records file (for this asset type) doesn't exist.
         pStorable = OTDB::CreateObject(
             OTDB::STORED_OBJ_STRING_MAP); // this asserts already, on failure.
 
     theAngel.reset(pStorable);
     pMap = (nullptr == pStorable) ? nullptr
                                   : dynamic_cast<OTDB::StringMap*>(pStorable);
 
     // It exists.
     //
     if (nullptr == pMap) {
         otErr << szFunc
               << ": Error: failed trying to load or create the account records "
                  "file for asset type: " << strAssetTypeID << "\n";
         return false;
     }
 
     // Before we can erase it, let's see if it's even there....
     //
     auto& theMap = pMap->the_map;
     auto map_it = theMap.find(strAcctID.Get());
 
     // we found it!
     if (theMap.end() != map_it) //  Acct ID was already there...
     {
         theMap.erase(map_it); // remove it
     }
 
     // it wasn't already on the list...
     // (So it's like success, since the end result is, acct ID will not appear
     // on this list--whether
     // it was there or not beforehand, it's definitely not there now.)
 
     // Then save it back to local storage:
     //
     if (!OTDB::StoreObject(*pMap, OTFolders::Contract().Get(),
                            strAcctRecordFile.Get())) {
         otErr << szFunc
               << ": Failed trying to StoreObject, while saving updated "
                  "account records file for asset type: " << strAssetTypeID
               << "\n to erase account ID: " << strAcctID << "\n";
         return false;
     }
 
     // Okay, we saved the updated file, with the account removed. (done,
     // success.)
     //
     return true;
 }

bool opentxs::OTAssetContract::FormatAmount	(	int64_t	amount,
		std::string &	str_output
	)		const

Definition at line 348 of file OTAssetContract.cpp.

 {
     int32_t nFactor = atoi(
         m_strCurrencyFactor.Get()); // default is 100  (100 cents in a dollar)
     if (nFactor < 1) nFactor = 1;
     OT_ASSERT(nFactor > 0); // should be 1, 10, 100, etc.
 
     int32_t nPower = atoi(m_strCurrencyDecimalPower.Get()); // default is 2.
                                                             // ($5.05 is moved 2
                                                             // decimal places.)
     if (nPower < 0) nPower = 0;
     OT_ASSERT(nPower >= 0); // should be 0, 1, 2, etc.
 
     // Lookup separator and decimal point symbols based on locale.
 
     // Get a moneypunct facet from the global ("C") locale
     //
     // NOTE: Turns out moneypunct kind of sucks.
     // As a result, for internationalization purposes,
     // these values have to be set here before compilation.
     //
     static OTString strSeparator(OT_THOUSANDS_SEP);
     static OTString strDecimalPoint(OT_DECIMAL_POINT);
 
     // NOTE: from web searching, I've determined that locale / moneypunct has
     // internationalization problems. Therefore it looks like if you want to
     // build OT for various languages / regions, you're just going to have to
     // edit stdafx.hpp and change the OT_THOUSANDS_SEP and OT_DECIMAL_POINT
     // variables.
     //
     // The best improvement I can think on that is to check locale and then use
     // it to choose from our own list of hardcoded values. Todo.
 
     str_output = OTAssetContract::formatLongAmount(
         amount, nFactor, nPower, m_strCurrencySymbol.Get(), strSeparator.Get(),
         strDecimalPoint.Get());
     return true;
 }

std::string opentxs::OTAssetContract::formatLongAmount	(	int64_t	lValue,
		int32_t	nFactor = `100`,
		int32_t	nPower = `2`,
		const char *	szCurrencySymbol = `""`,
		const char *	szThousandSeparator = `","`,
		const char *	szDecimalPoint = `"."`
	)

static

Definition at line 312 of file OTAssetContract.cpp.

 {
     std::stringstream sss;
 
     // Handle negative values
     if (lValue < 0) {
         sss << "-";
         lValue = -lValue;
     }
 
     sss << szCurrencySymbol << " ";
 
     // For example, if 506 is supposed to be $5.06, then dividing by a factor of
     // 100 results in 5 dollars (integer value) and 6 cents (fractional value).
 
     // Handle integer value with thousand separaters
     separateThousands(sss, lValue / nFactor, szThousandSeparator);
 
     // Handle fractional value
     if (1 < nFactor) {
         sss << szDecimalPoint << std::setfill('0') << std::setw(nPower)
             << (lValue % nFactor);
     }
 
     return sss.str();
 }

EXPORT const OTString& opentxs::OTAssetContract::GetBasketInfo ( ) const

inline

Definition at line 199 of file OTAssetContract.hpp.

     {
         return m_strBasketInfo;
     }

EXPORT const OTString& opentxs::OTAssetContract::GetCurrencyFraction ( ) const

inline

Definition at line 208 of file OTAssetContract.hpp.

     {
         return m_strCurrencyFraction;
     } // "cents"    (for example)

EXPORT const OTString& opentxs::OTAssetContract::GetCurrencyName ( ) const

inline

Definition at line 204 of file OTAssetContract.hpp.

     {
         return m_strCurrencyName;
     } // "dollars"  (for example)

EXPORT const OTString& opentxs::OTAssetContract::GetCurrencySymbol ( ) const

inline

Definition at line 212 of file OTAssetContract.hpp.

     {
         return m_strCurrencySymbol;
     } // "$"        (for example)

EXPORT const OTString& opentxs::OTAssetContract::GetCurrencyTLA ( ) const

inline

Definition at line 216 of file OTAssetContract.hpp.

     {
         return m_strCurrencyTLA;
     } // "USD""     (for example)

EXPORT bool opentxs::OTAssetContract::IsShares ( ) const

inline

Definition at line 163 of file OTAssetContract.hpp.

     {
         return m_bIsShares;
     }

bool opentxs::OTAssetContract::ParseFormatted	(	int64_t &	lResult,
		const std::string &	str_input,
		int32_t	nFactor = `100`,
		int32_t	nPower = `2`,
		const char *	szThousandSeparator = `","`,
		const char *	szDecimalPoint = `"."`
	)

static

Definition at line 154 of file OTAssetContract.cpp.

 {
     OT_ASSERT(nullptr != szThousandSeparator);
     OT_ASSERT(nullptr != szDecimalPoint);
 
     lResult = 0;
 
     char theSeparator = szThousandSeparator[0];
     char theDecimalPoint = szDecimalPoint[0];
 
     int64_t lDollars = 0;
     int64_t lCents = 0;
     int64_t lOutput = 0;
     int64_t lSign = 1;
 
     bool bHasEnteredDollars = false;
     bool bHasEnteredCents = false;
 
     int32_t nDigitsCollectedBeforeDot = 0;
     int32_t nDigitsCollectedAfterDot = 0;
 
     // BUG: &mp isn't used.
     // const std::moneypunct<char, false> &mp = std::use_facet<
     // std::moneypunct<char, false> >(std::locale ());
 
     std::deque<int64_t> deque_cents;
 
     for (uint32_t uIndex = 0; uIndex < str_input.length(); ++uIndex) {
         char theChar = str_input[uIndex];
 
         if (iscntrl(theChar)) // Break at any newline or other control
                               // character.
             break;
 
         if (0 == isdigit(theChar)) // if it's not a numerical digit.
         {
             if (theSeparator == theChar) continue;
 
             if (theDecimalPoint == theChar) {
                 if (bHasEnteredCents) {
                     // There shouldn't be ANOTHER decimal point if we are
                     // already in the cents.
                     // Therefore, we're done here. Break.
                     //
                     break;
                 }
 
                 // If we HAVEN'T entered the cents yet, then this decimal point
                 // marks the spot where we DO.
                 //
                 bHasEnteredDollars = true;
                 bHasEnteredCents = true;
                 continue;
             } // theChar is the decimal point
 
             // Once a negative sign appears, it's negative, period.
             // If you put two or three negative signs in a row, it's STILL
             // negative.
 
             if ('-' == theChar) {
                 lSign = -1;
                 continue;
             }
 
             // Okay, by this point, we know it's not numerical, and it's not a
             // separator or decimal point, or
             // sign.
             // We allow letters and symbols BEFORE the numbers start, but not
             // AFTER (that would terminate the
             // number.) Therefore we need to see if the dollars or cents have
             // started yet. If they have, then
             // this is the end, and we break. Otherwise if they haven't, then
             // we're still at the beginning, so
             // we continue.
             //
             if (bHasEnteredDollars || bHasEnteredCents)
                 break;
             else
                 continue;
         } // not numerical
 
         // By this point, we KNOW that it's a numeric digit.
         // Are we collecting cents yet? How about dollars?
         // Also, if nPower is 2, then we only collect 2 digits
         // after the decimal point. If we've already collected
         // those, then we need to break.
         //
         if (bHasEnteredCents) {
             ++nDigitsCollectedAfterDot;
 
             // If "cents" occupy 2 digits after the decimal point,
             // and we are now on the THIRD digit -- then we're done.
             if (nDigitsCollectedAfterDot > nPower) break;
 
             // Okay, we're in the cents, so let's add this digit...
             //
             deque_cents.push_back(static_cast<int64_t>(theChar - '0'));
 
             continue;
         }
 
         // Okay, it's a digit, and we haven't started processing cents yet.
         // How about dollars?
         //
         if (!bHasEnteredDollars) bHasEnteredDollars = true;
 
         ++nDigitsCollectedBeforeDot;
 
         // Let's add this digit...
         //
         lDollars *=
             10; // Multiply existing dollars by 10, and then add the new digit.
         lDollars += static_cast<int64_t>(theChar - '0');
     }
 
     // Time to put it all together...
     //
     lOutput += lDollars;
     lOutput *= static_cast<int64_t>(nFactor); // 1 dollar becomes 100 cents.
 
     int32_t nTempPower = nPower;
 
     while (nTempPower > 0) {
         --nTempPower;
 
         if (deque_cents.size() > 0) {
             lCents += deque_cents.front();
             deque_cents.pop_front();
         }
 
         lCents *= 10;
     }
     lCents /= 10; // There won't be any rounding errors here, since the last
                   // thing we did in the loop was multiply by 10.
 
     lOutput += lCents;
 
     lResult = (lOutput * lSign);
 
     return true;
 }

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

protectedvirtual

Reimplemented from opentxs::OTContract.

Reimplemented in opentxs::BasketContract.

Definition at line 839 of file OTAssetContract.cpp.

 {
     int32_t nReturnVal = OTContract::ProcessXMLNode(xml);
 
     // 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.
 
     if (nReturnVal == 1 || nReturnVal == (-1)) return nReturnVal;
 
     const OTString strNodeName(xml->getNodeName());
 
     if (strNodeName.Compare("digitalAssetContract")) {
         m_strVersion = xml->getAttributeValue("version");
 
         otWarn << "\n"
                   "===> Loading XML portion of asset contract into memory "
                   "structures...\n\n"
                   "Digital Asset Contract: " << m_strName
                << "\nContract version: " << m_strVersion << "\n----------\n";
         nReturnVal = 1;
     }
     else if (strNodeName.Compare("issue")) {
         m_strIssueCompany = xml->getAttributeValue("company");
         m_strIssueEmail = xml->getAttributeValue("email");
         m_strIssueContractURL = xml->getAttributeValue("contractUrl");
         m_strIssueType = xml->getAttributeValue("type");
 
         otInfo << "Loaded Issue company: " << m_strIssueCompany
                << "\nEmail: " << m_strIssueEmail
                << "\nContractURL: " << m_strIssueContractURL
                << "\nType: " << m_strIssueType << "\n----------\n";
         nReturnVal = 1;
     }
     // TODO security validation: validate all the above and below values.
     else if (strNodeName.Compare("currency")) {
         m_bIsCurrency = true; // silver grams
         m_bIsShares = false;
 
         m_strName = xml->getAttributeValue("name");
         m_strCurrencyName = xml->getAttributeValue("name");
         m_strCurrencySymbol = xml->getAttributeValue("symbol");
         m_strCurrencyType = xml->getAttributeValue("type");
 
         m_strCurrencyTLA = xml->getAttributeValue("tla");
         m_strCurrencyFactor = xml->getAttributeValue("factor");
         m_strCurrencyDecimalPower = xml->getAttributeValue("decimal_power");
         m_strCurrencyFraction = xml->getAttributeValue("fraction");
 
         otInfo << "Loaded " << strNodeName << ", Name: " << m_strCurrencyName
                << ", TLA: " << m_strCurrencyTLA
                << ", Symbol: " << m_strCurrencySymbol
                << "\n"
                   "Type: " << m_strCurrencyType
                << ", Factor: " << m_strCurrencyFactor
                << ", Decimal Power: " << m_strCurrencyDecimalPower
                << ", Fraction: " << m_strCurrencyFraction << "\n----------\n";
         nReturnVal = 1;
     }
 
     //  share_type some type, for example, A or B, or NV (non voting)
     //
     //  share_name this is the int64_t legal name of the company
     //
     //  share_symbol this is the trading name (8 chars max), as it might be
     //      displayed in a market contect, and should be unique within some
     // given market
     //
     //  share_issue_date date of start of this share item (not necessarily IPO)
     else if (strNodeName.Compare("shares")) {
         m_bIsShares = true; // shares of pepsi
         m_bIsCurrency = false;
 
         m_strName = xml->getAttributeValue("name");
         m_strCurrencyName = xml->getAttributeValue("name");
         m_strCurrencySymbol = xml->getAttributeValue("symbol");
         m_strCurrencyType = xml->getAttributeValue("type");
 
         m_strIssueDate = xml->getAttributeValue("issuedate");
 
         otInfo << "Loaded " << strNodeName << ", Name: " << m_strCurrencyName
                << ", Symbol: " << m_strCurrencySymbol
                << "\n"
                   "Type: " << m_strCurrencyType
                << ", Issue Date: " << m_strIssueDate << "\n----------\n";
         nReturnVal = 1;
     }
 
     return nReturnVal;
 }

bool opentxs::OTAssetContract::SaveContractWallet ( OTString & strContents ) const

virtual

Reimplemented from opentxs::OTContract.

Definition at line 463 of file OTAssetContract.cpp.

 {
     const OTString strID(m_ID);
 
     OTASCIIArmor ascName;
 
     if (m_strName.Exists()) // name is in the clear in memory, and base64 in
                             // storage.
     {
         ascName.SetString(m_strName, false); // linebreaks == false
     }
 
     strContents.Concatenate("<assetType name=\"%s\"\n"
                             " assetTypeID=\"%s\" />\n\n",
                             m_strName.Exists() ? ascName.Get() : "",
                             strID.Get());
 
     return true;
 }

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

virtual

Implements opentxs::OTContract.

Definition at line 483 of file OTAssetContract.cpp.

 {
     OTString strOutput;
 
     if (SaveContractWallet(strOutput)) {
         ofs << strOutput;
         return true;
     }
 
     return false;
 }

bool opentxs::OTAssetContract::StringToAmount	(	int64_t &	amount,
		const std::string &	str_input
	)		const

Definition at line 394 of file OTAssetContract.cpp.

 {
     int32_t nFactor = atoi(
         m_strCurrencyFactor.Get()); // default is 100  (100 cents in a dollar)
     if (nFactor < 1) nFactor = 1;
     OT_ASSERT(nFactor > 0); // should be 1, 10, 100, etc.
 
     int32_t nPower = atoi(m_strCurrencyDecimalPower.Get()); // default is 2.
                                                             // ($5.05 is moved 2
                                                             // decimal places.)
     if (nPower < 0) nPower = 0;
     OT_ASSERT(nPower >= 0); // should be 0, 1, 2, etc.
 
     // Lookup separator and decimal point symbols based on locale.
 
     // Get a moneypunct facet from the global ("C") locale
     //
 
     // NOTE: from web searching, I've determined that locale / moneypunct has
     // internationalization problems. Therefore it looks like if you want to
     // build OT for various languages / regions, you're just going to have to
     // edit stdafx.hpp and change the OT_THOUSANDS_SEP and OT_DECIMAL_POINT
     // variables.
     //
     // The best improvement I can think on that is to check locale and then use
     // it to choose from our own list of hardcoded values. Todo.
 
     static OTString strSeparator(",");
     static OTString strDecimalPoint(".");
 
     bool bSuccess = OTAssetContract::ParseFormatted(amount, str_input, nFactor,
                                                     nPower, strSeparator.Get(),
                                                     strDecimalPoint.Get());
 
     return bSuccess;
 }

bool opentxs::OTAssetContract::VisitAccountRecords ( AccountVisitor & visitor ) const

Definition at line 498 of file OTAssetContract.cpp.

 {
     OTString strAssetTypeID, strAcctRecordFile;
     GetIdentifier(strAssetTypeID);
     strAcctRecordFile.Format("%s.a", strAssetTypeID.Get());
 
     std::unique_ptr<OTDB::Storable> pStorable(OTDB::QueryObject(
         OTDB::STORED_OBJ_STRING_MAP, OTFolders::Contract().Get(),
         strAcctRecordFile.Get()));
 
     OTDB::StringMap* pMap = dynamic_cast<OTDB::StringMap*>(pStorable.get());
 
     // There was definitely a StringMap loaded from local storage.
     // (Even an empty one, possibly.) This is the only block that matters in
     // this function.
     //
     if (nullptr != pMap) {
         OTIdentifier* pServerID = visitor.GetServerID();
         OT_ASSERT_MSG(nullptr != pServerID,
                       "Assert: nullptr Server ID on functor. "
                       "(How did you even construct the "
                       "thing?)");
 
         auto& theMap = pMap->the_map;
 
         // todo: optimize: will probably have to use a database for this,
         // int64_t term.
         // (What if there are a million acct IDs in this flat file? Not
         // scaleable.)
         //
         for (auto& it : theMap) {
             const std::string& str_acct_id =
                 it.first; // Containing the account ID.
             const std::string& str_asset_id =
                 it.second; // Containing the asset type ID. (Just in case
                            // someone copied the wrong file here...)
 
             if (!strAssetTypeID.Compare(str_asset_id.c_str())) {
                 otErr << "OTAssetContract::VisitAccountRecords: Error: wrong "
                          "asset type ID (" << str_asset_id
                       << ") when expecting: " << strAssetTypeID << "\n";
             }
             else {
                 OTAccount* pAccount = nullptr;
                 std::unique_ptr<OTAccount> theAcctAngel;
 
                 const OTIdentifier theAccountID(str_acct_id.c_str());
 
                 // Before loading it from local storage, let's first make sure
                 // it's not already loaded.
                 // (visitor functor has a list of 'already loaded' accounts,
                 // just in case.)
                 //
                 mapOfAccounts* pLoadedAccounts = visitor.GetLoadedAccts();
 
                 if (nullptr !=
                     pLoadedAccounts) // there are some accounts already loaded,
                 { // let's see if the one we're looking for is there...
                     auto found_it = pLoadedAccounts->find(str_acct_id);
 
                     if (pLoadedAccounts->end() != found_it) // FOUND IT.
                     {
                         pAccount = found_it->second;
                         OT_ASSERT(nullptr != pAccount);
 
                         if (theAccountID != pAccount->GetPurportedAccountID()) {
                             otErr << "Error: the actual account didn't have "
                                      "the ID that the std::map SAID it had! "
                                      "(Should never happen.)\n";
                             pAccount = nullptr;
                         }
                     }
                 }
 
                 // I guess it wasn't already loaded...
                 // Let's try to load it.
                 //
                 if (nullptr == pAccount) {
                     pAccount = OTAccount::LoadExistingAccount(theAccountID,
                                                               *pServerID);
                     theAcctAngel.reset(pAccount);
                 }
 
                 bool bSuccessLoadingAccount =
                     ((pAccount != nullptr) ? true : false);
                 if (bSuccessLoadingAccount) {
                     bool bTriggerSuccess = visitor.Trigger(*pAccount);
                     if (!bTriggerSuccess)
                         otErr << __FUNCTION__ << ": Error: Trigger Failed.";
                 }
                 else {
                     otErr << __FUNCTION__ << ": Error: Failed Loading Account!";
                 }
             }
         }
         return true;
     }
     return true;
 }

Member Data Documentation

bool opentxs::OTAssetContract::m_bIsCurrency

protected

Definition at line 259 of file OTAssetContract.hpp.

bool opentxs::OTAssetContract::m_bIsShares

protected

Definition at line 260 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strBasketInfo

protected

Definition at line 231 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strCurrencyDecimalPower

protected

Definition at line 253 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strCurrencyFactor

protected

Definition at line 251 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strCurrencyFraction

protected

Definition at line 257 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strCurrencyName

protected

Definition at line 243 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strCurrencySymbol

protected

Definition at line 246 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strCurrencyTLA

protected

Definition at line 249 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strCurrencyType

protected

Definition at line 245 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strIssueCompany

protected

Definition at line 234 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strIssueContractURL

protected

Definition at line 236 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strIssueDate

protected

Definition at line 240 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strIssueEmail

protected

Definition at line 235 of file OTAssetContract.hpp.

OTString opentxs::OTAssetContract::m_strIssueType

protected

Definition at line 237 of file OTAssetContract.hpp.

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation