uint64_t ledger_recalc_addrinfos(char *retbuf,int32_t maxlen,struct ledger_info *ledger,int32_t numrichlist)
{
struct ledger_addrinfo *addrinfo;
uint32_t i,n,addrind,itemlen; int32_t len; float *sortbuf; uint64_t balance,addrsum; char coinaddr[128],itembuf[128];
addrsum = n = 0;
if ( numrichlist == 0 || retbuf == 0 || maxlen == 0 )
{
for (addrind=1; addrind<=ledger->addrs.ind; addrind++)
{
//printf("recalc.%d of %d\n",addrind,ledger->addrs.ind);
if ( (addrinfo= ledger_addrinfo(0,ledger,0,addrind)) != 0 )
{
if ( addrinfo->notify != 0 )
printf("notification active addind.%d count.%d size.%d\n",addrind,addrinfo->count,addrinfo_size(addrinfo->count)); addrsum += addrinfo->balance;
}
}
}
else
{
sortbuf = calloc(ledger->addrs.ind,sizeof(float)+sizeof(uint32_t));
for (addrind=1; addrind<=ledger->addrs.ind; addrind++)
{
//printf("recalc.%d of %d\n",addrind,ledger->addrs.ind);
if ( (addrinfo= ledger_addrinfo(0,ledger,0,addrind)) != 0 )
{
balance = addrinfo->balance;
addrsum += balance;
sortbuf[n << 1] = dstr(balance);
memcpy(&sortbuf[(n << 1) + 1],&addrind,sizeof(addrind));
n++;
}
}
if ( n > 0 )
{
revsortfs(sortbuf,n,sizeof(*sortbuf) * 2);
sprintf(retbuf,"{\"supply\":%.8f,\"richlist\":[",dstr(addrsum)), len = (int32_t)strlen(retbuf);
if ( numrichlist > 0 && n > 0 )
{
for (i=0; i<numrichlist&&i<n; i++)
{
memcpy(&addrind,&sortbuf[(i << 1) + 1],sizeof(addrind));
addrinfo = ledger_addrinfo(0,ledger,0,addrind);
ledger_coinaddr(ledger,coinaddr,sizeof(coinaddr),addrind);
sprintf(itembuf,"%s[\"%s\", \"%.8f\"],",i==0?"":" ",coinaddr,sortbuf[i << 1]);
itemlen = (int32_t)strlen(itembuf);
if ( len+itemlen < maxlen-32 )
{
memcpy(retbuf+len,itembuf,itemlen+1);
len += itemlen;
}
}
} else strcat(retbuf," ");
strcat(retbuf + strlen(retbuf) - 1,"]}");
//printf("(%s) top.%d of %d\n",retbuf,i,n);
}
free(sortbuf);
}
return(addrsum);
}
ostream& operator<< ( ostream& o, const predicate& p ) {
if ( p.args.size() == 2 ) {
// o << "{ ";
o << dstr(p.args[0]->pred);
if ( dict[p.pred] == implication ) o << " <= ";
else o << ' ' << dstr(p.pred) << ' ';
return o << dstr(p.args[1]->pred) << " .";
}
o << dstr(p.pred);
return p.args.empty() ? o : o << p.args;
}
cJSON *iguana_unspentjson(struct supernet_info *myinfo,struct iguana_info *coin,int32_t hdrsi,uint32_t unspentind,struct iguana_txid *T,struct iguana_unspent *up,uint8_t rmd160[20],char *coinaddr,uint8_t *pubkey33)
{
/*{
"txid" : "d54994ece1d11b19785c7248868696250ab195605b469632b7bd68130e880c9a",
"vout" : 1,
"address" : "mgnucj8nYqdrPFh2JfZSB1NmUThUGnmsqe",
"account" : "test label",
"scriptPubKey" : "76a9140dfc8bafc8419853b34d5e072ad37d1a5159f58488ac",
"amount" : 0.00010000,
"confirmations" : 6210,
"spendable" : true
},*/
//struct iguana_unspent { uint64_t value; uint32_t txidind,pkind,prevunspentind; uint16_t hdrsi:12,type:4,vout; } __attribute__((packed));
struct iguana_waccount *wacct; struct iguana_waddress *waddr; int32_t height; char scriptstr[8192],asmstr[sizeof(scriptstr)+1024]; cJSON *item; uint32_t checkind;
item = cJSON_CreateObject();
jaddbits256(item,"txid",T[up->txidind].txid);
jaddnum(item,"vout",up->vout);
jaddstr(item,"address",coinaddr);
if ( iguana_scriptget(coin,scriptstr,asmstr,sizeof(scriptstr),hdrsi,unspentind,T[up->txidind].txid,up->vout,rmd160,up->type,pubkey33) != 0 )
jaddstr(item,"scriptPubKey",scriptstr);
jaddnum(item,"amount",dstr(up->value));
if ( (checkind= iguana_unspentindfind(coin,0,0,0,0,&height,T[up->txidind].txid,up->vout,coin->bundlescount-1)) != 0 )
{
jaddnum(item,"confirmations",coin->blocks.hwmchain.height - height + 1);
jaddnum(item,"checkind",checkind);
}
if ( (waddr= iguana_waddresssearch(myinfo,coin,&wacct,coinaddr)) != 0 )
{
jaddstr(item,"account",wacct->account);
jadd(item,"spendable",jtrue());
} else jadd(item,"spendable",jfalse());
jadd(item,"unspent",ramchain_unspentjson(up,unspentind));
return(item);
}
cJSON *gecko_paymentsobj(struct supernet_info *myinfo,cJSON *txjson,cJSON *valsobj,int32_t reusedaddrs)
{
cJSON *item,*array; char *coinaddr; uint64_t satoshis; uint8_t addrtype,pubkey33[33],rmd160[20],outputscript[512]; int32_t i,n,scriptlen; uint32_t locktime,txversion; struct iguana_waddress *waddr; struct iguana_waccount *wacct;
locktime = jint(valsobj,"locktime");
if ( (txversion= juint(valsobj,"txversion")) == 0 )
txversion = (locktime == 0) ? IGUANA_NORMAL_TXVERSION : IGUANA_LOCKTIME_TXVERSION;
if ( txjson == 0 )
txjson = bitcoin_txcreate(1,locktime,txversion);
if ( (array= jarray(&n,valsobj,"payments")) != 0 && n > 0 )
{
for (i=0; i<n; i++)
{
item = jitem(array,i);
if ( (coinaddr= jfieldname(item)) != 0 && (satoshis= j64bits(item,coinaddr)) > 0 )
{
printf("payment.%s <- %.8f\n",coinaddr,dstr(satoshis));
bitcoin_addr2rmd160(&addrtype,rmd160,coinaddr);
scriptlen = 0;
if ( reusedaddrs == 0 )
{
if ( (waddr= iguana_waddresssearch(myinfo,&wacct,coinaddr)) != 0 )
{
if ( bitcoin_pubkeylen(waddr->pubkey) > 0 )
scriptlen = bitcoin_pubkeyspend(outputscript,0,pubkey33);
}
}
if ( scriptlen == 0 )
scriptlen = bitcoin_standardspend(outputscript,0,rmd160);
bitcoin_txoutput(txjson,outputscript,scriptlen,satoshis);
}
}
}
return(txjson);
}
int64_t _calc_cointx_inputs(struct ramchain_info *ram,struct cointx_info *cointx,int64_t amount)
{
int64_t remainder,sum = 0;
int32_t i;
struct cointx_input *vin;
cointx->inputsum = cointx->numinputs = 0;
remainder = amount + ram->txfee;
for (i=0; i<ram->MGWnumunspents&&i<((int)(sizeof(cointx->inputs)/sizeof(*cointx->inputs)))-1; i++)
{
if ( (vin= _find_bestfit(ram,remainder)) != 0 )
{
sum += vin->value;
remainder -= vin->value;
vin->used = 1;
cointx->inputs[cointx->numinputs++] = *vin;
if ( sum >= (amount + ram->txfee) )
{
cointx->amount = amount;
cointx->change = (sum - amount - ram->txfee);
cointx->inputsum = sum;
fprintf(stderr,"numinputs %d sum %.8f vs amount %.8f change %.8f -> miners %.8f\n",cointx->numinputs,dstr(cointx->inputsum),dstr(amount),dstr(cointx->change),dstr(sum - cointx->change - cointx->amount));
return(cointx->inputsum);
}
} else printf("no bestfit found i.%d of %d\n",i,ram->MGWnumunspents);
}
fprintf(stderr,"error numinputs %d sum %.8f\n",cointx->numinputs,dstr(cointx->inputsum));
return(0);
}
int32_t ram_markspent(struct ramchain_info *ram,struct rampayload *txpayload,struct address_entry *spendbp,uint32_t txid_rawind)
{ // bitcoin
struct rampayload *ram_getpayloadi(struct ramchain_hashptr **addrptrp,struct ramchain_info *ram,char type,uint32_t rawind,uint32_t i);
struct ramchain_hashptr *addrptr;
struct rampayload *addrpayload;
txpayload->spentB = *spendbp; // now all fields are set for the payloads from the tx
// now we need to update the addrpayload
if ( (addrpayload= ram_getpayloadi(&addrptr,ram,'a',txpayload->otherind,txpayload->extra)) != 0 )
{
if ( txid_rawind == addrpayload->otherind && txpayload->value == addrpayload->value )
{
if ( txpayload->value != 0 )
{
ram->S.totalspends += txpayload->value;
ram->S.numspends++;
addrpayload->spentB = *spendbp;
addrpayload->B.spent = 1;
addrptr->unspent -= addrpayload->value;
addrptr->numunspent--;
//printf("SPENT %.8f\n",dstr(addrpayload->value));
//printf("MATCH: spendtxid_rawind.%u == %u addrpayload->otherind for (%d %d %d)\n",txid_rawind,addrpayload->otherind,spendbp->blocknum,spendbp->txind,spendbp->v);
}
} else printf("FATAL: txpayload.%p[%d] addrpayload.%p spendtxid_rawind.%u != %u addrpayload->otherind for (%d %d %d)\n",txpayload,txpayload->extra,addrpayload,txid_rawind,addrpayload->otherind,spendbp->blocknum,spendbp->txind,spendbp->v);
} else printf("FATAL: ram_markspent cant find addpayload (%d %d %d) addrind.%d i.%d | txpayload.%p txid_rawind.%u\n",spendbp->blocknum,spendbp->txind,spendbp->v,txpayload->otherind,txpayload->extra,txpayload,txid_rawind);
if ( addrpayload->value != txpayload->value )
printf("FATAL: addrpayload %.8f vs txpayload %.8f\n",dstr(addrpayload->value),dstr(txpayload->value));
return(-1);
}
struct ledger_blockinfo *ledger_setblocknum(struct ledger_info *ledger,struct alloc_space *mem,uint32_t startblocknum)
{
uint32_t addrind; int32_t modval,lastmodval,allocsize = sizeof(ledger->getbuf); uint64_t balance = 0;
struct ledger_blockinfo *block; struct ledger_addrinfo *addrinfo;
startblocknum = ledger_startblocknum(ledger,-1);
if ( startblocknum < 1 )
{
ledger->numsyncs = 1;
return(0);
}
if ( (block= ledger_getblock((struct ledger_blockinfo *)ledger->getbuf,&allocsize,ledger,startblocknum)) != 0 )
{
if ( block->allocsize == allocsize && block_crc16(block) == block->crc16 )
{
printf("%.8f startmilli %.0f start.%u block.%u ledger block.%u, inds.(txid %d addrs %d scripts %d vouts %d vins %d)\n",dstr(ledger->voutsum)-dstr(ledger->spendsum),milliseconds(),startblocknum,block->blocknum,ledger->blocknum,ledger->txids.ind,ledger->addrs.ind,ledger->scripts.ind,ledger->unspentmap.ind,ledger->spentbits.ind);
lastmodval = -1;
for (addrind=1; addrind<=ledger->addrs.ind; addrind++)
{
modval = ((100. * addrind) / (ledger->addrs.ind + 1));
if ( modval != lastmodval )
printf("%d%% ",modval), fflush(stdout), lastmodval = modval;
if ( (addrind % 1000) == 0 )
fprintf(stderr,".");
if ( (addrinfo= ledger_addrinfo(0,ledger,0,addrind)) != 0 )
balance += addrinfo->balance;
}
printf("balance %.8f endmilli %.0f\n",dstr(balance),milliseconds());
} else printf("mismatched block: %u %u, crc16 %u %u\n",block->allocsize,allocsize,block_crc16(block),block->crc16), debugstop();
} else printf("couldnt load block.%u\n",startblocknum), debugstop();
return(block);
}
void FBTestPluginAPI::getURLCallback(const FB::JSObjectPtr& callback, bool success,
const FB::HeaderMap& headers, const boost::shared_array<uint8_t>& data, const size_t size) {
FB::VariantMap outHeaders;
for (FB::HeaderMap::const_iterator it = headers.begin(); it != headers.end(); ++it) {
if (headers.count(it->first) > 1) {
if (outHeaders.find(it->first) != outHeaders.end()) {
outHeaders[it->first].cast<FB::VariantList>().push_back(it->second);
} else {
outHeaders[it->first] = FB::VariantList(FB::variant_list_of(it->second));
}
} else {
outHeaders[it->first] = it->second;
}
}
if (success) {
std::string dstr(reinterpret_cast<const char*>(data.get()), size);
callback->InvokeAsync("", FB::variant_list_of
(true)
(outHeaders)
(dstr)
);
} else {
callback->InvokeAsync("", FB::variant_list_of(false));
}
}
void run_bootloader(){
init_hw();
led_flash_run_bootloader();
//initialize link and run link update
dstr("Link Start\n");
boot_link_update((void*)boot_board_config.link_transport_driver);
}
char *_sign_and_sendmoney(char *cointxid,struct ramchain_info *ram,struct cointx_info *cointx,char *othersignedtx,uint64_t *redeems,uint64_t *amounts,int32_t numredeems)
{
uint64_t get_sender(uint64_t *amountp,char *txidstr);
void *extract_jsonkey(cJSON *item,void *arg,void *arg2);
void set_MGW_moneysentfname(char *fname,char *NXTaddr);
int32_t jsonstrcmp(void *ref,void *item);
char txidstr[64],NXTaddr[64],jsonstr[4096],*retstr = 0;
int32_t i;
uint64_t amount,senderbits,redeemtxid;
fprintf(stderr,"achieved consensus and sign! (%s)\n",othersignedtx);
if ( (retstr= _submit_withdraw(ram,cointx,othersignedtx)) != 0 )
{
if ( is_hexstr(retstr) != 0 )
{
strcpy(cointxid,retstr);
//*AMtxidp = _broadcast_moneysentAM(ram,height);
for (i=0; i<numredeems; i++)
{
if ( (redeemtxid = redeems[i]) != 0 && amounts[i] != 0 )
{
printf("signed and sent.%d: %llu %.8f\n",i,(long long)redeemtxid,dstr(amounts[i]));
_ram_update_redeembits(ram,redeemtxid,0,cointxid,0);
expand_nxt64bits(txidstr,redeemtxid);
senderbits = get_sender(&amount,txidstr);
expand_nxt64bits(NXTaddr,senderbits);
sprintf(jsonstr,"{\"NXT\":\"%s\",\"redeemtxid\":\"%llu\",\"amount\":\"%.8f\",\"coin\":\"%s\",\"cointxid\":\"%s\",\"vout\":\"%d\"}",NXTaddr,(long long)redeemtxid,dstr(amounts[i]),ram->name,txidstr,i);
update_MGW_jsonfile(set_MGW_moneysentfname,extract_jsonkey,jsonstrcmp,0,jsonstr,"redeemtxid",0);
update_MGW_jsonfile(set_MGW_moneysentfname,extract_jsonkey,jsonstrcmp,NXTaddr,jsonstr,"redeemtxid",0);
}
}
//backupwallet(cp,ram->coinid);
}
else
{
for (i=0; i<numredeems; i++)
printf("(%llu %.8f) ",(long long)redeems[i],dstr(amounts[i]));
printf("_sign_and_sendmoney: unexpected return.(%s)\n",retstr);
exit(1);
}
return(retstr);
}
else printf("sign_and_sendmoney: error sending rawtransaction %s\n",othersignedtx);
return(0);
}
void init_hw(){
boot_event(BOOT_EVENT_INIT_CLOCK, 0);
mcu_core_initclock(1);
#if defined DEBUG_BOOTLOADER
if( mcu_debug_init() < 0 ){
sos_led_root_error(0);
}
dsetmode(0);
dsetwritefunc(debug_write_func);
dstr("STACK:"); dhex((u32)stack_ptr); dstr("\n");
dstr("APP:"); dhex((u32)app_reset); dstr("\n");
#endif
cortexm_delay_ms(50);
cortexm_enable_interrupts(); //Enable the interrupts
boot_event(BOOT_EVENT_INIT, 0);
}
bool NoteStat::toEpoch(const char* datetime, time_t *epochTime)
{
string delms("-_:");
string dstr(datetime);
istringstream iss(datetime);
if (string::npos == dstr.find_first_of(delms)) {
// datetime is in epoch format
iss >> *epochTime;
}
void LP_sendtoaddress_line(char *validaddress,char *assetname,uint64_t satoshis,uint64_t txnum)
{
char line[1024],lowerstr[64];
if ( strcmp(assetname,"SUPERNETx2") == 0 )
{
sprintf(line,"fiat/supernet sendtoaddress %s %.8f # txnum.%llu",validaddress,dstr(satoshis),(long long)txnum);
printf("%s\n",line);
sprintf(line,"fiat/revs sendtoaddress %s %.8f # txnum.%llu",validaddress,dstr(satoshis),(long long)txnum);
}
else
{
if ( strcmp(assetname,"TOKEN") == 0 )
strcpy(lowerstr,"supernet");
else strcpy(lowerstr,assetname);
tolowercase(lowerstr);
sprintf(line,"sleep 1; fiat/%s sendtoaddress %s %.8f # txnum.%llu",lowerstr,validaddress,dstr(satoshis),(long long)txnum);
}
printf("%s\n",line);
}
cJSON *generators_json(struct consensus_model *model,struct crypto777_node *nn,uint64_t sortbuf[MAXPEERS+1][4],int32_t n,uint32_t blocknum,uint64_t mymetric)
{
int32_t i;
char numstr[64];
cJSON *array,*json = cJSON_CreateObject();
cJSON_AddItemToObject(json,"cmd",cJSON_CreateString("generators"));
cJSON_AddItemToObject(json,"blocknum",cJSON_CreateNumber(blocknum));
sprintf(numstr,"%llu",(long long)mymetric), cJSON_AddItemToObject(json,"metric",cJSON_CreateString(numstr));
array = cJSON_CreateArray();
for (i=0; i<n; i++)
cJSON_AddItemToArray(array,cJSON_CreateNumber(sortbuf[i][1]));
cJSON_AddItemToObject(json,"accts",array);
array = cJSON_CreateArray();
cJSON_AddItemToArray(array,cJSON_CreateNumber(dstr(sortbuf[0][0])));
for (i=1; i<8&&blocknum>i; i++)
if ( (blocknum - i) > 0 && model->blocks[blocknum-i] != 0 )
cJSON_AddItemToArray(array,cJSON_CreateNumber(dstr(model->blocks[blocknum-i]->gen.metric)));
cJSON_AddItemToObject(json,"metrics",array);
return(json);
}
void * link_update(void * arg){
int err;
link_data_t data;
data.op.cmd = 0;
err = 0;
dstr("Enter update loop\n");
while(1){
//Wait for data to arrive on the USB
while( 1 ){
if ( (err = link_protocol_slaveread(phy_handle, &data.op, sizeof(link_op_t), NULL, NULL)) < 0 ){
continue;
core_reset(0);
}
if( err > 0 ){
break;
}
}
dstr("EXEC CMD: "); dint(data.op.cmd); dstr("\n");
if ( data.op.cmd < LINK_BOOTLOADER_CMD_TOTAL ){
link_cmd_func_table[data.op.cmd](&data);
} else {
data.reply.err = -1;
data.reply.err_number = EINVAL;
}
//send the reply
if( data.op.cmd != 0 ){
link_protocol_slavewrite(phy_handle, &data.reply, sizeof(data.reply), NULL, NULL);
data.op.cmd = 0;
}
}
return NULL;
}
void OfficeDriveAPI::connectCallback(const bool success, const FB::HeaderMap& headers,
const boost::shared_array<uint8_t>& data, const size_t size) {
if (success) {
m_host->htmlLog("Success");
std::string dstr(reinterpret_cast<const char*>(data.get()), size);
m_host->htmlLog(dstr);
call(dstr);
} else {
m_host->htmlLog("Fail");
}
}
extern "C" bool pNXT_sendmoney(currency::simple_wallet *wallet,int32_t numfakes,char *dest,uint64_t amount)
{
std::vector<std::string> args;
char buf[512];
args.reserve(3);
wallet->sync_wallet();
printf("sending %.8f pNXT to (%s) ",dstr(amount),dest);
wallet->show_balance();
sprintf(buf,"%d",numfakes);
args.push_back(buf);
args.push_back(dest);
sprintf(buf,"%.8f",(double)amount/SATOSHIDEN);
args.push_back(buf);
return(wallet->transfer(args));
}
uint64_t get_satoshi_obj(cJSON *json,char *field)
{
int32_t i,n;
uint64_t prev,satoshis,mult = 1;
char numstr[128],checkstr[128];
cJSON *numjson;
numjson = cJSON_GetObjectItem(json,field);
copy_cJSON(numstr,numjson);
satoshis = prev = 0; mult = 1; n = (int32_t)strlen(numstr);
for (i=n-1; i>=0; i--,mult*=10)
{
satoshis += (mult * (numstr[i] - '0'));
if ( satoshis < prev )
printf("get_satoshi_obj numstr.(%s) i.%d prev.%llu vs satoshis.%llu\n",numstr,i,(unsigned long long)prev,(unsigned long long)satoshis);
prev = satoshis;
}
sprintf(checkstr,"%llu",(long long)satoshis);
if ( strcmp(checkstr,numstr) != 0 )
{
printf("SATOSHI GREMLIN?? numstr.(%s) -> %.8f -> (%s)\n",numstr,dstr(satoshis),checkstr);
}
return(satoshis);
}
TWO_STRINGS_AND_TWO_DOUBLES(iguana,balance,activecoin,address,lastheightd,minconfd)
{
int32_t lastheight,minconf,maxconf=SATOSHIDEN; int64_t total=0; uint8_t rmd160[20],pubkey33[33],addrtype;
struct iguana_pkhash *P; cJSON *array,*retjson = cJSON_CreateObject();
if ( activecoin != 0 && activecoin[0] != 0 )
coin = iguana_coinfind(activecoin);
if ( coin != 0 )
{
if ( (minconf= minconfd) <= 0 )
minconf = 1;
lastheight = lastheightd;
jaddstr(retjson,"address",address);
if ( bitcoin_validaddress(coin,address) < 0 )
{
jaddstr(retjson,"error","illegal address");
return(jprint(retjson,1));
}
if ( bitcoin_addr2rmd160(&addrtype,rmd160,address) < 0 )
{
jaddstr(retjson,"error","cant convert address");
return(jprint(retjson,1));
}
memset(pubkey33,0,sizeof(pubkey33));
P = calloc(coin->bundlescount,sizeof(*P));
array = cJSON_CreateArray();
//printf("Start %s balance.(%s) height.%d\n",coin->symbol,address,lastheight);
if ( lastheight == 0 )
lastheight = IGUANA_MAXHEIGHT;
iguana_pkhasharray(myinfo,coin,array,minconf,maxconf,&total,P,coin->bundlescount,rmd160,address,pubkey33,lastheight,0,0,0);
free(P);
jadd(retjson,"unspents",array);
jaddnum(retjson,"balance",dstr(total));
if ( lastheight > 0 )
jaddnum(retjson,"lastheight",lastheight);
}
return(jprint(retjson,1));
}
static int deldupc(char *s, char c)
{
int util[3];
compt_c = 0;
compt = -1;
if (s[0] != c)
compt_c++;
while (s[++compt] != '\0')
{
if (s[compt] == c)
{
compt_c++;
if (s[compt + 1] == c || s[compt + 1] == '\0')
{
dstr(compt, s);
compt--;
}
}
}
return (compt_c);
}
void ram_update_MGWunspents(struct ramchain_info *ram,char *addr,int32_t vout,uint32_t txid_rawind,uint32_t script_rawind,uint64_t value)
{
struct cointx_input *vin;
if ( ram->MGWnumunspents >= ram->MGWmaxunspents )
{
ram->MGWmaxunspents += 512;
ram->MGWunspents = realloc(ram->MGWunspents,sizeof(*ram->MGWunspents) * ram->MGWmaxunspents);
memset(&ram->MGWunspents[ram->MGWnumunspents],0,(ram->MGWmaxunspents - ram->MGWnumunspents) * sizeof(*ram->MGWunspents));
}
vin = &ram->MGWunspents[ram->MGWnumunspents++];
if ( ram_script(vin->sigs,ram,script_rawind) != 0 && ram_txid(vin->tx.txidstr,ram,txid_rawind) != 0 )
{
strcpy(vin->coinaddr,addr);
vin->value = value;
vin->tx.vout = vout;
} else printf("ram_update_MGWunspents: decode error for (%s) vout.%d txid.%d script.%d (%.8f)\n",addr,vout,txid_rawind,script_rawind,dstr(value));
}
uint64_t _find_pending_transfers(uint64_t *pendingredeemsp,struct mgw777 *mgw)
{
int32_t j,disable_newsends,specialsender,specialreceiver,numpending = 0;
char sender[64],receiver[64],txidstr[512],withdrawaddr[512],*destaddr;
struct NXT_assettxid *tp;
struct NXT_asset *ap;
struct cointx_info *cointx;
uint64_t orphans = 0;
*pendingredeemsp = 0;
disable_newsends = ((mgw->numpendingsends > 0) || (mgw->S.gatewayid < 0));
if ( (ap= mgw->ap) == 0 )
{
printf("no NXT_asset for %s\n",mgw->coinstr);
return(0);
}
for (j=0; j<ap->num; j++)
{
tp = ap->txids[j];
//if ( strcmp(mgw->coinstr,"BITS") == 0 )
//printf("%d of %d: check %s.%llu completed.%d\n",j,ap->num,mgw->coinstr,(long long)tp->redeemtxid,tp->completed);
if ( tp->completed == 0 )
{
expand_nxt64bits(sender,tp->senderbits);
specialsender = _in_specialNXTaddrs(mgw,sender);
expand_nxt64bits(receiver,tp->receiverbits);
specialreceiver = _in_specialNXTaddrs(mgw,receiver);
if ( (specialsender ^ specialreceiver) == 0 || tp->cointxid != 0 )
{
printf("autocomplete: %llu cointxid.%p\n",(long long)tp->redeemtxid,tp->cointxid);
_complete_assettxid(tp);
}
else
{
if ( _is_limbo_redeem(mgw,tp->redeemtxid) != 0 )
{
printf("autocomplete: limbo %llu cointxid.%p\n",(long long)tp->redeemtxid,tp->cointxid);
_complete_assettxid(tp);
}
//printf("receiver.%llu vs MGW.%llu\n",(long long)tp->receiverbits,(long long)mgw->MGWbits);
if ( tp->receiverbits == mgw->MGWbits ) // redeem start
{
destaddr = "coinaddr";
if ( _valid_txamount(mgw,tp->U.assetoshis,0) > 0 && (tp->convwithdrawaddr != 0 || (destaddr= _parse_withdraw_instructions(withdrawaddr,sender,mgw,tp,ap)) != 0) )
{
if ( tp->convwithdrawaddr == 0 )
tp->convwithdrawaddr = clonestr(destaddr);
if ( tp->redeemstarted == 0 )
{
printf("find_pending_transfers: redeem.%llu started %s %.8f for NXT.%s to %s\n",(long long)tp->redeemtxid,mgw->coinstr,dstr(tp->U.assetoshis),sender,destaddr!=0?destaddr:"no withdraw address");
tp->redeemstarted = (uint32_t)time(NULL);
}
else
{
int32_t i,numpayloads;
struct ramchain_hashptr *addrptr;
struct rampayload *payloads;
if ( (payloads= ram_addrpayloads(&addrptr,&numpayloads,mgw,destaddr)) != 0 && addrptr != 0 && numpayloads > 0 )
{
for (i=0; i<numpayloads; i++)
if ( (dstr(tp->U.assetoshis) - dstr(payloads[i].value)) == .0101 ) // historical BTCD parameter
{
printf("(autocomplete.%llu payload.i%d >>>>>>>> %.8f <<<<<<<<<) ",(long long)tp->redeemtxid,i,dstr(payloads[i].value));
_complete_assettxid(tp);
}
}
}
if ( tp->completed == 0 && tp->convwithdrawaddr != 0 )
{
(*pendingredeemsp) += tp->U.assetoshis;
printf("%s NXT.%llu withdraw.(%llu %.8f).rt%d_%d_%d_%d.g%d -> %s elapsed %.1f minutes | pending.%d\n",mgw->coinstr,(long long)tp->senderbits,(long long)tp->redeemtxid,dstr(tp->U.assetoshis),mgw->S.enable_withdraws,mgw->S.is_realtime,(tp->height + mgw->withdrawconfirms) <= mgw->S.NXT_RTblocknum,mgw->S.MGWbalance >= 0,(int32_t)(tp->senderbits % NUM_GATEWAYS),tp->convwithdrawaddr,(double)(time(NULL) - tp->redeemstarted)/60,mgw->numpendingsends);
numpending++;
if ( disable_newsends == 0 )
{
if ( (cointx= _calc_cointx_withdraw(mgw,tp->convwithdrawaddr,tp->U.assetoshis,tp->redeemtxid)) != 0 )
{
if ( ram_MGW_ready(mgw,0,tp->height,0,tp->U.assetoshis) > 0 )
{
ram_send_cointx(mgw,cointx);
mgw->numpendingsends++;
//ram_add_pendingsend(0,ram,tp,cointx);
// disable_newsends = 1;
} else printf("not ready to withdraw yet\n");
}
else if ( mgw->S.enable_withdraws != 0 && mgw->S.is_realtime != 0 && mgw->S.NXT_is_realtime != 0 )
{
//tp->completed = 1; // ignore malformed requests for now
}
}
if ( mgw->S.gatewayid >= 0 && ram_check_consensus(txidstr,mgw,tp) != 0 )
printf("completed redeem.%llu with cointxid.%s\n",(long long)tp->redeemtxid,txidstr);
//printf("(%llu %.8f).%d ",(long long)tp->redeemtxid,dstr(tp->U.assetoshis),(int32_t)(time(NULL) - tp->redeemstarted));
} else printf("%llu %.8f: completed.%d withdraw.%p destaddr.%p\n",(long long)tp->redeemtxid,dstr(tp->U.assetoshis),tp->completed,tp->convwithdrawaddr,destaddr);
}
else if ( tp->completed == 0 && _valid_txamount(mgw,tp->U.assetoshis,0) > 0 )
printf("incomplete but skipped.%llu: %.8f destaddr.%s\n",(long long)tp->redeemtxid,dstr(tp->U.assetoshis),destaddr);
else printf("%s.%llu %.8f is too small, thank you for your donation to MGW\n",mgw->coinstr,(long long)tp->redeemtxid,dstr(tp->U.assetoshis)), tp->completed = 1;
}
else if ( tp->completed == 0 && specialsender != 0 ) // deposit complete w/o cointxid (shouldnt happen normally)
{
orphans += tp->U.assetoshis;
_complete_assettxid(tp);
printf("find_pending_transfers: internal transfer.%llu limbo.%d complete %s %.8f to NXT.%s\n",(long long)tp->redeemtxid,_is_limbo_redeem(mgw,tp->redeemtxid),mgw->coinstr,dstr(tp->U.assetoshis),receiver);
} else tp->completed = 1; // this is some independent tx
}
}
}
if ( numpending == 0 && mgw->numpendingsends != 0 )
{
printf("All pending withdraws done!\n");
mgw->numpendingsends = 0;
}
return(orphans);
}
void _complete_assettxid(struct NXT_assettxid *tp)
{
if ( tp->completed == 0 && tp->redeemstarted != 0 )
{
printf("pending redeem %llu %.8f completed | elapsed %d seconds\n",(long long)tp->redeemtxid,dstr(tp->U.assetoshis),(uint32_t)(time(NULL) - tp->redeemstarted));
tp->redeemstarted = (uint32_t)(time(NULL) - tp->redeemstarted);
}
tp->completed = 1;
}
void gecko_miner(struct supernet_info *myinfo,struct iguana_info *btcd,struct iguana_info *virt,int32_t maxmillis,uint8_t *minerpubkey33)
{
struct iguana_zblock newblock; uint32_t prevtimestamp,nBits; int64_t reward = 0; int32_t txn_count; char *blockstr,*space[256]; struct gecko_memtx **txptrs; void *ptr; //struct iguana_bundle *bp;
#ifndef __APPLE__
int32_t i,gap;
if ( virt->virtualchain == 0 || RELAYID < 0 || NUMRELAYS < 1 )
{
//printf("skip non-virtual chain.%s\n",virt->symbol);
return;
}
if ( virt->blocks.hwmchain.height < virt->longestchain-1 )
return;
if ( (virt->blocks.hwmchain.height % NUMRELAYS) != RELAYID )
{
//if ( NUMRELAYS < 3 )
// return;
gap = (int32_t)(time(NULL) - virt->blocks.hwmchain.RO.timestamp) / 60;//virt->chain->estblocktime;
for (i=0; i<gap; i++)
{
if ( ((virt->blocks.hwmchain.height+i) % NUMRELAYS) == RELAYID )
break;
}
if ( i == gap )
return;
printf("backup block generator RELAYID.%d gap.%d ht.%d i.%d num.%d\n",RELAYID,gap,virt->blocks.hwmchain.height,i,NUMRELAYS);
}
#endif
/*if ( virt->newblockstr != 0 )
{
gecko_blocksubmit(myinfo,btcd,virt,virt->newblockstr,virt->newblock.RO.hash2,virt->newblock.height);
memset(&virt->newblock,0,sizeof(virt->newblock));
free(virt->newblockstr);
virt->newblockstr = 0;
return;
}*/
memset(&newblock,0,sizeof(newblock));
newblock.height = virt->blocks.hwmchain.height + 1;
newblock.RO.prev_block = virt->blocks.hwmchain.RO.hash2;
newblock.RO.version = GECKO_DEFAULTVERSION;
newblock.RO.allocsize = iguana_ROallocsize(virt);
if ( (nBits= gecko_nBits(virt,&prevtimestamp,(void *)&newblock,GECKO_DIFFITERS)) != 0 )
{
if ( (newblock.RO.bits= nBits) > GECKO_EASIESTDIFF )
newblock.RO.bits = GECKO_EASIESTDIFF;
char str[65]; printf("mine.%s %s nBits.%x ht.%d maxmillis.%d\n",virt->symbol,bits256_str(str,bits256_from_compact(newblock.RO.bits)),nBits,newblock.height,maxmillis);
txptrs = gecko_mempool_txptrs(myinfo,virt,&reward,&txn_count,&ptr,space,(int32_t)(sizeof(space)/sizeof(*space)),newblock.height);
//char str[65]; printf("HWM.%s %p\n",bits256_str(str,newblock.RO.prev_block),&newblock.RO.prev_block);
if ( (blockstr= gecko_createblock(myinfo,virt->chain->estblocktime,prevtimestamp,btcd,virt->chain->isPoS,(void *)&newblock,virt->symbol,txptrs,txn_count,maxmillis,minerpubkey33,reward)) != 0 )
{
char str[65];
printf("tx0.%s\n",bits256_str(str,newblock.RO.merkle_root));
printf(">>>>>>>>>>>>>>>>> MINED %s.%x %s %u %d %.8f %d\n",virt->symbol,newblock.RO.bits,bits256_str(str,newblock.RO.hash2),newblock.RO.timestamp,newblock.height,dstr(reward),newblock.RO.txn_count);
if ( gecko_blocksubmit(myinfo,btcd,virt,blockstr,newblock.RO.hash2,newblock.height) == 0 )
free(blockstr);
else
{
//virt->newblockstr = blockstr;
//virt->newblock = newblock;
free(blockstr);
}
} else printf("didnt find %s.block\n",virt->symbol);
if ( txptrs != (void *)space )
free(txptrs);
}
}
int32_t iguana_pkhasharray(struct supernet_info *myinfo,struct iguana_info *coin,cJSON *array,int32_t minconf,int32_t maxconf,int64_t *totalp,struct iguana_pkhash *P,int32_t max,uint8_t rmd160[20],char *coinaddr,uint8_t *pubkey33,int32_t lastheight,int64_t *unspents,int32_t *numunspentsp,int32_t maxunspents)
{
int32_t i,n,m,numunspents; int64_t spent,deposits,netbalance,total; uint32_t lastunspentind; struct iguana_pkhash *p,_p; struct iguana_ramchain *ramchain; struct iguana_bundle *bp;
if ( 0 && coin->RTramchain_busy != 0 )
{
printf("iguana_pkhasharray: unexpected access when RTramchain_busy\n");
return(-1);
}
numunspents = numunspentsp != 0 ? *numunspentsp : 0;
if ( lastheight == 0 )
lastheight = IGUANA_MAXHEIGHT;
if ( max > coin->bundlescount )
max = coin->bundlescount;
for (total=n=i=0; i<max; i++)
{
if ( (bp= coin->bundles[i]) == 0 )
continue;
if ( lastheight > 0 && bp->bundleheight+bp->n > lastheight )
break;
if ( (coin->blocks.hwmchain.height - (bp->bundleheight + bp->n - 1)) > maxconf )
continue;
if ( (coin->blocks.hwmchain.height - bp->bundleheight) < minconf )
break;
if ( iguana_pkhashfind(coin,&ramchain,&deposits,&lastunspentind,P != 0 ? &P[n] : &_p,rmd160,i,i) != 0 )
{
m = maxunspents >> 1;
p = (P == 0) ? &_p : &P[n];
if ( (netbalance= iguana_pkhashbalance(myinfo,coin,array,&spent,unspents != 0 ? &unspents[numunspents << 1] : 0,&m,ramchain,p,lastunspentind,rmd160,coinaddr,pubkey33,i,lastheight,minconf,maxconf)) != deposits-spent && lastheight == IGUANA_MAXHEIGHT && minconf == 1 && maxconf > coin->blocks.hwmchain.height )
{
printf("pkhash balance mismatch from m.%d check %.8f vs %.8f spent %.8f [%.8f]\n",m,dstr(netbalance),dstr(deposits),dstr(spent),dstr(deposits)-dstr(spent));
}
else
{
//printf("%s pkhash balance.[%d] from m.%d check %.8f vs %.8f spent %.8f [%.8f]\n",coinaddr,i,m,dstr(netbalance),dstr(deposits),dstr(spent),dstr(deposits)-dstr(spent));
total += netbalance;
n++;
}
if ( maxunspents > 0 )
{
maxunspents -= m;
if ( maxunspents <= 0 )
break;
}
numunspents += m;
//printf("%d: balance %.8f, lastunspent.%u m.%d num.%d max.%d\n",i,dstr(total),lastunspentind,m,numunspents,maxunspents);
}
}
int64_t iguana_pkhashbalance(struct supernet_info *myinfo,struct iguana_info *coin,cJSON *array,int64_t *spentp,int64_t *unspents,int32_t *nump,struct iguana_ramchain *ramchain,struct iguana_pkhash *p,uint32_t lastunspentind,uint8_t rmd160[20],char *coinaddr,uint8_t *pubkey33,int32_t hdrsi,int32_t lastheight,int32_t minconf,int32_t maxconf)
{
struct iguana_unspent *U; struct iguana_utxo *U2; struct iguana_spend *S; int32_t max,uheight,spentheight; uint32_t pkind=0,unspentind; int64_t spent = 0,checkval,deposits = 0; struct iguana_txid *T; struct iguana_account *A2; struct iguana_ramchaindata *rdata = 0; int64_t RTspend = 0;
max = *nump;
*spentp = *nump = 0;
if ( 0 && coin->RTramchain_busy != 0 )
{
printf("iguana_pkhashbalance: unexpected access when RTramchain_busy\n");
return(0);
}
if ( ramchain->Uextras == 0 || (rdata= ramchain->H.data) == 0 )
{
printf("iguana_pkhashbalance: unexpected null spents.%p or rdata.%p\n",ramchain->Uextras,rdata);
return(0);
}
unspentind = lastunspentind;
U = RAMCHAIN_PTR(rdata,Uoffset);
T = RAMCHAIN_PTR(rdata,Toffset);
//U = (void *)(long)((long)rdata + rdata->Uoffset);
//T = (void *)(long)((long)rdata + rdata->Toffset);
RTspend = 0;
if ( lastheight == 0 )
lastheight = IGUANA_MAXHEIGHT;
while ( unspentind > 0 )
{
uheight = iguana_uheight(coin,ramchain->height,T,rdata->numtxids,&U[unspentind]);
if ( lastheight <= 0 || uheight < lastheight )
{
deposits += U[unspentind].value;
if ( iguana_spentflag(coin,&RTspend,&spentheight,ramchain,hdrsi,unspentind,lastheight,minconf,maxconf,U[unspentind].value) == 0 )
{
if ( *nump < max && unspents != 0 )
{
unspents[*nump << 1] = ((uint64_t)hdrsi << 32) | unspentind;
unspents[(*nump << 1) + 1] = U[unspentind].value;
}
//printf("%.8f ",dstr(U[unspentind].value));
(*nump)++;
if ( array != 0 )
jaddi(array,iguana_unspentjson(myinfo,coin,hdrsi,unspentind,T,&U[unspentind],rmd160,coinaddr,pubkey33));
}
else
{
//printf("-%.8f ",dstr(U[unspentind].value));
spent += U[unspentind].value;
}
if ( p->pkind != U[unspentind].pkind )
printf("warning: [%d] p->pkind.%u vs U->pkind.%u for u%d\n",hdrsi,p->pkind,U[unspentind].pkind,unspentind);
}
pkind = p->pkind;
unspentind = U[unspentind].prevunspentind;
}
if ( lastheight > 0 && (A2= ramchain->A2) != 0 && (U2= ramchain->Uextras) != 0 )
{
S = RAMCHAIN_PTR(rdata,Soffset);
//S = (void *)(long)((long)rdata + rdata->Soffset);
unspentind = A2[pkind].lastunspentind;
checkval = 0;
while ( unspentind > 0 )
{
uheight = iguana_uheight(coin,ramchain->height,T,rdata->numtxids,&U[unspentind]);
if ( uheight < lastheight )
{
checkval += U[unspentind].value;
//printf("u%u %.8f spentflag.%d prev.%u fromheight.%d\n",unspentind,dstr(U[unspentind].value),U2[unspentind].spentflag,U2[unspentind].prevunspentind,U2[unspentind].fromheight);
}
unspentind = U2[unspentind].prevunspentind;
}
if ( llabs(spent - checkval - RTspend) > SMALLVAL )
printf("spend %s: [%d] deposits %.8f spent %.8f check %.8f (%.8f) vs A2[%u] %.8f\n",lastheight==IGUANA_MAXHEIGHT?"checkerr":"",hdrsi,dstr(deposits),dstr(spent),dstr(checkval)+dstr(RTspend),dstr(*spentp),pkind,dstr(A2[pkind].total));
}
(*spentp) = spent;
//printf("(%s) spent %.8f, RTspent %.8f deposits %.8f\n",coinaddr,dstr(spent),dstr(RTspend),dstr(deposits));
return(deposits - spent);
}
To duration_cast(duration const& d) {
rational dstr(To::period::num, To::period::den);
rational tr = d.ratio() / dstr;
return To(tr.numerator() / tr.denominator());
}
void OfficeDriveAPI::updateDaemonCallback(const FB::JSObjectPtr& callback, bool success,
const FB::HeaderMap& headers, const boost::shared_array<uint8_t>& data, const size_t size) {
int ret = -1;
if (success) {
std::string dstr(reinterpret_cast<const char*>(data.get()), size);
// m_host->htmlLog(std::string(headers));
m_host->htmlLog("Downloading new OfficeDriveClient.jar");
char jarFile[512];
memset(&jarFile, 0, sizeof(jarFile));
char * appData;
#ifdef FB_WIN
appData = getenv("LOCALAPPDATA");
sprintf(jarFile, "%s\\OfficeDrive\\OfficeDriveClient.jar", appData);
#endif
#ifdef FB_MACOSX
appData = getenv("HOME");
sprintf(jarFile, "%s/LocalAppData/OfficeDrive/OfficeDriveClient.jar", appData);
/*
char launchAgent[512];
char launchAgent_src[512];
memset(&launchAgent, 0, sizeof(launchAgent));
memset(&launchAgent, 0, sizeof(launchAgent_src));
sprintf(launchAgent, "%s/Library/LaunchAgents/net.officedrive.agent.plist", appData);
sprintf(launchAgent, "%s/LocalAppData/OfficeDrive/net.officedrive.agent.plist", appData);
boost::filesystem::fstream xml_file_in(launchAgent_src ,std::ios::in);
boost::filesystem::fstream xml_file_out(launchAgent ,std::ios::out);
xml_file_out.write(reinterpret_cast<const char*>(xml_file_in.get()), sizeof(xml_file_in));
xml_file_out.close();
xml_file_in.close();
*/
#endif
boost::filesystem::fstream binary_file(jarFile ,std::ios::out|std::ios::binary);
binary_file.write(reinterpret_cast<const char*>(data.get()), size);
binary_file.close();
m_host->htmlLog("Finished downloading: " + std::string(jarFile));
ret = size;
callback->Invoke("",FB::variant_list_of(ret));
//#ifdef FB_MACOSX
// <key>LimitLoadToSessionType</key>
// <string>Aqua</string>
// <key>ProgramArguments</key>
// <array>
// <string>/usr/bin/java</string>
// <string>-jar</string>
// <string>LocalAppData/OfficeDrive/OfficeDriveClient.jar</string>
// </array>
// <key>RunAtLoad</key>
// <true/>
// <key>StartInterval</key>
// <integer>1337</integer>
// <key>StandardErrorPath</key>
// <string>OfficeDriveClient.stderr.log</string>
// <key>StandardOutPath</key>
// <string>OfficeDriveClient.stdout.log</string>
//</dict>
//</plist>
//#endif
//
} else {
callback->Invoke("",FB::variant_list_of(ret));
// The request could not be completed
}
}
struct crypto777_block *parse_block777(struct consensus_model *model,struct crypto777_node *nn,struct crypto777_block *block,int32_t len,uint32_t peerid)
{
char *blockstr = (char *)block->rawblock;
uint64_t metric;
int32_t bestacct;
cJSON *json;
uint32_t timestamp,blocknum = 0;
if ( (bestacct= validate_block(block)) >= 0 && peerid < nn->numpeers && (json= cJSON_Parse(blockstr)) != 0 )
{
blocknum = juint(json,"blocknum");
timestamp = juint(json,"timestamp");
metric = get_API_nxt64bits(cJSON_GetObjectItem(json,"metric"));
model->peermetrics[blocknum][peerid] = metric;
model->peerblocknum[peerid] = blocknum;
free_json(json);
if ( block->blocknum == blocknum ) // block->gen.metric == metric &&
return(block);
else printf("error parse.(%s) metric %.8f vs %.8f blocknum %u vs %u\n",blockstr,dstr(block->gen.metric),dstr(metric),block->blocknum,blocknum);
}
else
{
int i;
for (i=0; i<len; i++)
printf("%02x ",((uint8_t *)block)[i]);
printf("block.%d (%s) peerid.%d numpeers.%d\n",block->blocknum,blockstr,peerid,nn->numpeers);
}
return(0);
}
// ===========================================================================
// method definitions
// ===========================================================================
// ---------------------------------------------------------------------------
// static methods
// ---------------------------------------------------------------------------
void
NWWriter_OpenDrive::writeNetwork(const OptionsCont& oc, NBNetBuilder& nb) {
// check whether an opendrive-file shall be generated
if (!oc.isSet("opendrive-output")) {
return;
}
const NBNodeCont& nc = nb.getNodeCont();
const NBEdgeCont& ec = nb.getEdgeCont();
const bool origNames = oc.getBool("output.original-names");
const bool lefthand = oc.getBool("lefthand");
const double straightThresh = DEG2RAD(oc.getFloat("opendrive-output.straight-threshold"));
// some internal mapping containers
int nodeID = 1;
int edgeID = nc.size() * 10; // distinct from node ids
StringBijection<int> edgeMap;
StringBijection<int> nodeMap;
//
OutputDevice& device = OutputDevice::getDevice(oc.getString("opendrive-output"));
device << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
device.openTag("OpenDRIVE");
time_t now = time(0);
std::string dstr(ctime(&now));
const Boundary& b = GeoConvHelper::getFinal().getConvBoundary();
// write header
device.openTag("header");
device.writeAttr("revMajor", "1");
device.writeAttr("revMinor", "4");
device.writeAttr("name", "");
device.writeAttr("version", "1.00");
device.writeAttr("date", dstr.substr(0, dstr.length() - 1));
device.writeAttr("north", b.ymax());
device.writeAttr("south", b.ymin());
device.writeAttr("east", b.xmax());
device.writeAttr("west", b.xmin());
/* @note obsolete in 1.4
device.writeAttr("maxRoad", ec.size());
device.writeAttr("maxJunc", nc.size());
device.writeAttr("maxPrg", 0);
*/
device.closeTag();
// write optional geo reference
const GeoConvHelper& gch = GeoConvHelper::getFinal();
if (gch.usingGeoProjection()) {
if (gch.getOffsetBase() == Position(0,0)) {
device.openTag("geoReference");
device.writePreformattedTag(" <![CDATA[\n "
+ gch.getProjString()
+ "\n]]>\n");
device.closeTag();
} else {
WRITE_WARNING("Could not write OpenDRIVE geoReference. Only unshifted Coordinate systems are supported (offset=" + toString(gch.getOffsetBase()) + ")");
}
}
// write normal edges (road)
for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
const NBEdge* e = (*i).second;
const int fromNodeID = e->getIncomingEdges().size() > 0 ? getID(e->getFromNode()->getID(), nodeMap, nodeID) : INVALID_ID;
const int toNodeID = e->getConnections().size() > 0 ? getID(e->getToNode()->getID(), nodeMap, nodeID) : INVALID_ID;
writeNormalEdge(device, e,
getID(e->getID(), edgeMap, edgeID),
fromNodeID, toNodeID,
origNames, straightThresh);
}
device.lf();
// write junction-internal edges (road). In OpenDRIVE these are called 'paths' or 'connecting roads'
OutputDevice_String junctionOSS(false, 3);
for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
NBNode* n = (*i).second;
int connectionID = 0; // unique within a junction
const int nID = getID(n->getID(), nodeMap, nodeID);
if (n->numNormalConnections() > 0) {
junctionOSS << " <junction name=\"" << n->getID() << "\" id=\"" << nID << "\">\n";
}
std::vector<NBEdge*> incoming = (*i).second->getIncomingEdges();
if (lefthand) {
std::reverse(incoming.begin(), incoming.end());
}
for (NBEdge* inEdge : incoming) {
std::string centerMark = "none";
const int inEdgeID = getID(inEdge->getID(), edgeMap, edgeID);
// group parallel edges
const NBEdge* outEdge = 0;
bool isOuterEdge = true; // determine where a solid outer border should be drawn
int lastFromLane = -1;
std::vector<NBEdge::Connection> parallel;
std::vector<NBEdge::Connection> connections = inEdge->getConnections();
if (lefthand) {
std::reverse(connections.begin(), connections.end());
}
for (const NBEdge::Connection& c : connections) {
assert(c.toEdge != 0);
if (outEdge != c.toEdge || c.fromLane == lastFromLane) {
if (outEdge != 0) {
if (isOuterEdge) {
addPedestrianConnection(inEdge, outEdge, parallel);
}
connectionID = writeInternalEdge(device, junctionOSS, inEdge, nID,
getID(parallel.back().getInternalLaneID(), edgeMap, edgeID),
inEdgeID,
getID(outEdge->getID(), edgeMap, edgeID),
connectionID,
parallel, isOuterEdge, straightThresh, centerMark);
parallel.clear();
isOuterEdge = false;
}
outEdge = c.toEdge;
}
lastFromLane = c.fromLane;
parallel.push_back(c);
}
if (isOuterEdge) {
addPedestrianConnection(inEdge, outEdge, parallel);
}
if (!parallel.empty()) {
if (!lefthand && (n->geometryLike() || inEdge->isTurningDirectionAt(outEdge))) {
centerMark = "solid";
}
connectionID = writeInternalEdge(device, junctionOSS, inEdge, nID,
getID(parallel.back().getInternalLaneID(), edgeMap, edgeID),
inEdgeID,
getID(outEdge->getID(), edgeMap, edgeID),
connectionID,
parallel, isOuterEdge, straightThresh, centerMark);
parallel.clear();
}
}
if (n->numNormalConnections() > 0) {
junctionOSS << " </junction>\n";
}
}
device.lf();
// write junctions (junction)
device << junctionOSS.getString();
for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
NBNode* n = (*i).second;
const std::vector<NBEdge*>& incoming = n->getIncomingEdges();
// check if any connections must be written
int numConnections = 0;
for (std::vector<NBEdge*>::const_iterator j = incoming.begin(); j != incoming.end(); ++j) {
numConnections += (int)((*j)->getConnections().size());
}
if (numConnections == 0) {
continue;
}
for (std::vector<NBEdge*>::const_iterator j = incoming.begin(); j != incoming.end(); ++j) {
const NBEdge* inEdge = *j;
const std::vector<NBEdge::Connection>& elv = inEdge->getConnections();
for (std::vector<NBEdge::Connection>::const_iterator k = elv.begin(); k != elv.end(); ++k) {
const NBEdge::Connection& c = *k;
const NBEdge* outEdge = c.toEdge;
if (outEdge == 0) {
continue;
}
}
}
}
device.closeTag();
device.close();
}
