#include "ot_otapi_ot.hpp"
#include "ot_utility_ot.hpp"
#include "../core/script/OTVariable.hpp"
#include "../core/OTLog.hpp"

Include dependency graph for ot_otapi_ot.cpp:

Functions
string	GetVariable (const char *name)

OT_OTAPI_OT OTDB::OfferListNym *	loadNymOffers (const string &serverID, const string &nymID)

OT_OTAPI_OT MapOfMaps *	convert_offerlist_to_maps (OTDB::OfferListNym &offerList)

OT_OTAPI_OT int32_t	output_nymoffer_data (const OTDB::OfferDataNym &offer_data, int32_t nIndex, const MapOfMaps &, const SubMap &, the_lambda_struct &)

OT_OTAPI_OT int32_t	find_strange_offers (const OTDB::OfferDataNym &offer_data, const int32_t, const MapOfMaps &, const SubMap &, the_lambda_struct &extra_vals)

OT_OTAPI_OT int32_t	iterate_nymoffers_sub_map (const MapOfMaps &map_of_maps, SubMap &sub_map, LambdaFunc the_lambda)

OT_OTAPI_OT int32_t	iterate_nymoffers_sub_map (const MapOfMaps &map_of_maps, SubMap &sub_map, LambdaFunc the_lambda, the_lambda_struct &extra_vals)

OT_OTAPI_OT int32_t	iterate_nymoffers_maps (MapOfMaps &map_of_maps, LambdaFunc the_lambda)

OT_OTAPI_OT int32_t	iterate_nymoffers_maps (MapOfMaps &map_of_maps, LambdaFunc the_lambda, the_lambda_struct &extra_vals)

Variables
string	Args

string	HisAcct

string	HisNym

string	HisPurse

string	MyAcct

string	MyNym

string	MyPurse

string	Server

Function Documentation

OT_OTAPI_OT MapOfMaps* convert_offerlist_to_maps ( OTDB::OfferListNym & offerList )

Definition at line 1385 of file ot_otapi_ot.cpp.

 {
     string strLocation = "convert_offerlist_to_maps";
 
     MapOfMaps* map_of_maps = nullptr;
 
     // LOOP THROUGH THE OFFERS and sort them into a map_of_maps, key is:
     // scale-assetID-currencyID
     // the value for each key is a sub-map, with the key: transaction ID and
     // value: the offer data itself.
     //
     int32_t nCount = offerList.GetOfferDataNymCount();
     int32_t nTemp = nCount;
 
     if (nCount > 0) {
         for (int32_t nIndex = 0; nIndex < nCount; ++nIndex) {
             nTemp = nIndex;
             OTDB::OfferDataNym* offerDataPtr = offerList.GetOfferDataNym(nTemp);
 
             if (!offerDataPtr) {
                 otOut << strLocation << ": Unable to reference (nym) offerData "
                                         "on offerList, at index: " << nIndex
                       << "\n";
                 return map_of_maps;
             }
 
             OTDB::OfferDataNym& offerData = *offerDataPtr;
             string strScale = offerData.scale;
             string strAssetTypeID = offerData.asset_type_id;
             string strCurrencyTypeID = offerData.currency_type_id;
             string strSellStatus = offerData.selling ? "SELL" : "BUY";
             string strTransactionID = offerData.transaction_id;
 
             string strMapKey =
                 strScale + "-" + strAssetTypeID + "-" + strCurrencyTypeID;
 
             SubMap* sub_map = nullptr;
             if (nullptr != map_of_maps && !map_of_maps->empty() &&
                 (map_of_maps->count(strMapKey) > 0)) {
                 sub_map = (*map_of_maps)[strMapKey];
             }
 
             if (nullptr != sub_map) {
                 otWarn << strLocation << ": The sub-map already exists!\n";
 
                 // Let's just add this offer to the existing submap
                 // (There must be other offers already there for the same
                 // market,
                 // since the submap already exists.)
                 //
                 // the sub_map for this market is mapped by BUY/SELL ==> the
                 // actual
                 // offerData.
                 //
 
                 (*sub_map)[strTransactionID] = &offerData;
             }
             else // submap does NOT already exist for this market. (Create
                    // it...)
             {
                 otWarn << strLocation
                        << ": The sub-map does NOT already exist!\n";
                 //
                 // Let's create the submap with this new offer, and add it
                 // to the main map.
                 //
                 sub_map = new SubMap();
                 (*sub_map)[strTransactionID] = &offerData;
 
                 if (nullptr != map_of_maps) {
                     map_of_maps = new MapOfMaps;
                 }
                 (*map_of_maps)[strMapKey] = sub_map;
             }
 
             // Supposedly by this point I have constructed a map keyed by the
             // market, which returns a sub_map for each market. Each sub map
             // uses the key "BUY" or "SELL" and that points to the actual
             // offer data. (Like a Multimap.)
             //
             // Therefore we have sorted out all the buys and sells for each
             // market. Later on, we can loop through the main map, and for each
             // market, we can loop through all the buys and sells.
         } // for (constructing the map_of_maps and all the sub_maps, so that the
           // offers are sorted
           // by market and buy/sell status.
     }
 
     return map_of_maps;
 }

OT_OTAPI_OT int32_t find_strange_offers	(	const OTDB::OfferDataNym &	offer_data,
		const int32_t	,
		const MapOfMaps &	,
		const SubMap &	,
		the_lambda_struct &	extra_vals
	)

Definition at line 1537 of file ot_otapi_ot.cpp.

 {
     string strLocation = "find_strange_offers";
     /*
     me: How about this — when you do "opentxs newoffer" I can alter that
     script to automatically cancel any sell offers for a lower amount
     than my new buy offer, if they're on the same market at the same scale.
     and vice versa. Vice versa meaning, cancel any bid offers for a higher
     amount than my new sell offer.
 
     knotwork: yeah that would work.
 
     So when placing a buy offer, check all the other offers I already have at
     the same scale,
     same asset and currency ID. (That is, the same "market" as denoted by
     strMapKey in "opentxs showmyoffers")
     For each, see if it's a sell offer and if so, if the amount is lower than
     the amount on
     the new buy offer, then cancel that sell offer from the market. (Because I
     don't want to buy-high, sell low.)
 
     Similarly, if placing a sell offer, then check all the other offers I
     already have at the
     same scale, same asset and currency ID, (the same "market" as denoted by
     strMapKey....) For
     each, see if it's a buy offer and if so, if the amount is higher than the
     amount of my new
     sell offer, then cancel that buy offer from the market. (Because I don't
     want some old buy offer
     for $10 laying around for the same stock that I'm SELLING for $8! If I dump
     100 shares, I'll receive
     $800--I don't want my software to automatically turn around and BUY those
     same shares again for $1000!
     That would be a $200 loss.)
 
     This is done here. This function gets called once for each offer that's
     active for this Nym.
     extra_vals contains the relevant info we're looking for, and offer_data
     contains the current
     offer (as we loop through ALL this Nym's offers, this function gets called
     for each one.)
     So here we just need to compare once, and add to the list if the comparison
     matches.
     */
     /*
     attr the_lambda_struct::the_vector        // used for returning a list of
     something.
     attr the_lambda_struct::the_asset_acct    // for newoffer, we want to remove
     existing offers for the same accounts in certain cases.
     attr the_lambda_struct::the_currency_acct // for newoffer, we want to remove
     existing offers for the same accounts in certain cases.
     attr the_lambda_struct::the_scale         // for newoffer as well.
     attr the_lambda_struct::the_price         // for newoffer as well.
     attr the_lambda_struct::bSelling          // for newoffer as well.
     */
     otLog4 << strLocation << ": About to compare the new potential offer "
                              "against one of the existing ones...";
 
     if ((extra_vals.the_asset_acct == offer_data.asset_acct_id) &&
         (extra_vals.the_currency_acct == offer_data.currency_acct_id) &&
         (extra_vals.the_scale == offer_data.scale)) {
         otLog4 << strLocation << ": the account IDs and the scale match...";
 
         // By this point we know the current offer_data has the same asset acct,
         // currency acct, and scale
         // as the offer we're comparing to all the rest.
         //
         // But that's not enough: we also need to compare some prices:
         //
         // So when placing a buy offer, check all the other offers I already
         // have.
         // For each, see if it's a sell offer and if so, if the amount is lower
         // than the amount on
         // the new buy offer, then cancel that sell offer from the market.
         // (Because I don't want to buy-high, sell low.)
         //
         if (!extra_vals.bSelling && offer_data.selling &&
             (stoll(offer_data.price_per_scale) < stoll(extra_vals.the_price))) {
             extra_vals.the_vector.push_back(offer_data.transaction_id);
         }
         // Similarly, when placing a sell offer, check all the other offers I
         // already have.
         // For each, see if it's a buy offer and if so, if the amount is higher
         // than the amount of my new
         // sell offer, then cancel that buy offer from the market.
         //
         else if (extra_vals.bSelling && !offer_data.selling &&
                  (stoll(offer_data.price_per_scale) >
                   stoll(extra_vals.the_price))) {
             extra_vals.the_vector.push_back(offer_data.transaction_id);
         }
     }
     // We don't actually do the removing here, since we are still looping
     // through the maps.
     // So we just add the IDs to a vector so that the caller can do the removing
     // once this loop is over.
 
     return 1;
 }

string GetVariable ( const char * name )

Definition at line 161 of file ot_otapi_ot.cpp.

 {
     OTVariable* pVar = OT_ME::FindVariable2(name);
     return pVar == nullptr ? "" : pVar->GetValueString();
 }

OT_OTAPI_OT int32_t iterate_nymoffers_maps	(	MapOfMaps &	map_of_maps,
		LambdaFunc	the_lambda
	)

Definition at line 1720 of file ot_otapi_ot.cpp.

 {
     the_lambda_struct extra_vals;
     return iterate_nymoffers_maps(map_of_maps, the_lambda, extra_vals);
 }

OT_OTAPI_OT int32_t iterate_nymoffers_maps	(	MapOfMaps &	map_of_maps,
		LambdaFunc	the_lambda,
		the_lambda_struct &	extra_vals
	)

Definition at line 1733 of file ot_otapi_ot.cpp.

 {
     // the_lambda must be good (assumed) and must have the parameter profile
     // like this sample:
     // def the_lambda(offer_data, nIndex, map_of_maps, sub_map, extra_vals)
     // //
     // if 10 offers are printed for the SAME market, nIndex will be 0..9
 
     string strLocation = "iterate_nymoffers_maps";
 
     // Next let's loop through the map_of_maps and output the offers for each
     // market therein...
     //
     // var range_map_of_maps = map_of_maps.range();
     MapOfMaps* map_of_mapsPtr = &map_of_maps;
     if (!map_of_mapsPtr) {
         otOut << strLocation << ": No range retrieved from map_of_maps.\n";
         return -1;
     }
     if (map_of_maps.empty()) {
         otOut << strLocation << ": A range was retrieved for the map_of_maps, "
                                 "but the range is empty.\n";
         return -1;
     }
 
     int32_t nMainIndex = -1;
     for (auto it = map_of_maps.begin(); it != map_of_maps.end(); ++it) {
         ++nMainIndex; // so we can output a header on the FIRST one only.
 
         // var sub_map_pair = range_map_of_maps.front();
         if (nullptr == it->second) {
             otOut << strLocation << ": Looping through map_of_maps range, and "
                                     "first sub_map_pair fails to verify.\n";
             return -1;
         }
 
         string strMapKey = it->first;
 
         SubMap& sub_map = *it->second;
         if (sub_map.empty()) {
             otOut << strLocation << ": Error: Sub_map is empty (Then how is it "
                                     "even here?? Submaps are only added based "
                                     "on existing offers.)\n";
             return -1;
         }
 
         if (0 == nMainIndex) // this is the first iteration of the main output
                              // loop...
         {
             //          otOut << "\n** MY OFFERS **\n\n")
         }
 
         int32_t nSubMap = iterate_nymoffers_sub_map(map_of_maps, sub_map,
                                                     the_lambda, extra_vals);
         if (-1 == nSubMap) {
             otOut << strLocation
                   << ": Error: while trying to iterate_nymoffers_sub_map.\n";
             return -1;
         }
     }
     map_of_maps.clear();
 
     return 1;
 }

OT_OTAPI_OT int32_t iterate_nymoffers_sub_map	(	const MapOfMaps &	map_of_maps,
		SubMap &	sub_map,
		LambdaFunc	the_lambda
	)

Definition at line 1642 of file ot_otapi_ot.cpp.

 {
     the_lambda_struct extra_vals;
     return iterate_nymoffers_sub_map(map_of_maps, sub_map, the_lambda,
                                      extra_vals);
 }

OT_OTAPI_OT int32_t iterate_nymoffers_sub_map	(	const MapOfMaps &	map_of_maps,
		SubMap &	sub_map,
		LambdaFunc	the_lambda,
		the_lambda_struct &	extra_vals
	)

Definition at line 1656 of file ot_otapi_ot.cpp.

 {
     // the_lambda must be good (assumed) and must have the parameter profile
     // like this sample:
     // def the_lambda(offer_data, nIndex, map_of_maps, sub_map, extra_vals)
     //
     // if 10 offers are printed for the SAME market, nIndex will be 0..9
 
     string strLocation = "iterate_nymoffers_sub_map";
 
     // Looping through the map_of_maps, we are now on a valid sub_map in this
     // iteration.
     // Therefore let's loop through the offers on that sub_map and output them!
     //
     // var range_sub_map = sub_map.range();
 
     SubMap* sub_mapPtr = &sub_map;
     if (!sub_mapPtr) {
         otOut << strLocation << ": No range retrieved from sub_map. It must be "
                                 "non-existent, I guess.\n";
         return -1;
     }
     if (sub_map.empty()) {
         // Should never happen since we already made sure all the sub_maps
         // have data on them. Therefore if this range is empty now, it's a
         // chaiscript
         // bug (extremely unlikely.)
         //
         otOut << strLocation << ": Error: A range was retrieved for the "
                                 "sub_map, but the range is empty.\n";
         return -1;
     }
 
     int32_t nIndex = -1;
     for (auto it = sub_map.begin(); it != sub_map.end(); ++it) {
         ++nIndex;
         // var offer_data_pair = range_sub_map.front();
 
         if (nullptr == it->second) {
             otOut << strLocation << ": Looping through range_sub_map range, "
                                     "and first offer_data_pair fails to "
                                     "verify.\n";
             return -1;
         }
 
         OTDB::OfferDataNym& offer_data = *it->second;
         int32_t nLambda =
             (*the_lambda)(offer_data, nIndex, map_of_maps, sub_map,
                           extra_vals); // if 10 offers are printed for the SAME
                                        // market, nIndex will be 0..9;
         if (-1 == nLambda) {
             otOut << strLocation << ": Error: the_lambda failed.\n";
             return -1;
         }
     }
     sub_map.clear();
 
     return 1;
 }

OT_OTAPI_OT OTDB::OfferListNym* loadNymOffers	(	const string &	serverID,
		const string &	nymID
	)

Definition at line 1354 of file ot_otapi_ot.cpp.

 {
     OTDB::OfferListNym* offerList = nullptr;
 
     if (OTDB::Exists("nyms", serverID, "offers", nymID + ".bin")) {
         otWarn << "Offers file exists... Querying nyms...\n";
         OTDB::Storable* storable =
             OTDB::QueryObject(OTDB::STORED_OBJ_OFFER_LIST_NYM, "nyms", serverID,
                               "offers", nymID + ".bin");
 
         if (nullptr == storable) {
             otOut << "Unable to verify storable object. Probably doesn't "
                      "exist.\n";
             return nullptr;
         }
 
         otWarn << "QueryObject worked. Now dynamic casting from storable to a "
                   "(nym) offerList...\n";
         offerList = dynamic_cast<OTDB::OfferListNym*>(storable);
 
         if (nullptr == offerList) {
             otOut
                 << "Unable to dynamic cast a storable to a (nym) offerList.\n";
             return nullptr;
         }
     }
 
     return offerList;
 }

OT_OTAPI_OT int32_t output_nymoffer_data	(	const OTDB::OfferDataNym &	offer_data,
		int32_t	nIndex,
		const MapOfMaps &	,
		const SubMap &	,
		the_lambda_struct &
	)

Definition at line 1477 of file ot_otapi_ot.cpp.

 { // extra_vals unused in this function, but not in others that share this
     // parameter profile.
     // (It's used as a lambda.)
 
     string strScale = offer_data.scale;
     string strAssetTypeID = offer_data.asset_type_id;
     string strCurrencyTypeID = offer_data.currency_type_id;
     string strSellStatus = offer_data.selling ? "SELL" : "BUY";
     string strTransactionID = offer_data.transaction_id;
     string strAvailableAssets = to_string(stoll(offer_data.total_assets) -
                                           stoll(offer_data.finished_so_far));
 
     if (0 == nIndex) // first iteration! (Output a header.)
     {
         otOut << "Scale:\t\t" << strScale << "\n";
         otOut << "Asset:\t\t" << strAssetTypeID << "\n";
         otOut << "Currency:\t" << strCurrencyTypeID << "\n";
         otOut << "\nIndex\tTrans#\tType\tPrice\tAvailable\n";
     }
 
     //
     // Okay, we have the offer_data, so let's output it!
     //
     cout << (nIndex) << "\t" << offer_data.transaction_id << "\t"
          << strSellStatus << "\t" << offer_data.price_per_scale << "\t"
          << strAvailableAssets << "\n";
 
     return 1;
 }

Variable Documentation

string Args

Definition at line 141 of file ot_otapi_ot.cpp.

string HisAcct

Definition at line 142 of file ot_otapi_ot.cpp.

string HisNym

Definition at line 143 of file ot_otapi_ot.cpp.

string HisPurse

Definition at line 144 of file ot_otapi_ot.cpp.

string MyAcct

Definition at line 145 of file ot_otapi_ot.cpp.

string MyNym

Definition at line 146 of file ot_otapi_ot.cpp.

string MyPurse

Definition at line 147 of file ot_otapi_ot.cpp.

string Server

Definition at line 148 of file ot_otapi_ot.cpp.

Functions

Variables

Function Documentation

Variable Documentation