GPStreamADF::GPStreamADF(const GPTreeNode* n, const GPFunctionDataBase* base)
{
auto children = n->getChildren();
GPASSERT(3 == children.size());
mSources.clear();
/*Source*/
std::map<std::string, Point*> sp_map;
{
auto source = children[0];
GPASSERT(source->name() == "Source");
for (auto types : source->getChildren())
{
auto source_name = types->name();
auto type_name = types->attr();
auto spoint = new SP(base->vQueryType(type_name));
mSources.push_back(spoint);
sp_map.insert(std::make_pair(source_name, spoint));
}
for (int i=0; i<mSources.size(); ++i)
{
mInputPos.push_back(i);
}
}
std::map<std::string, GPPtr<Point>> cp_map;
/*ComputePoints*/
{
auto computepoints_info = children[1];
GPASSERT(computepoints_info->name() == "ComputePoint");
/*Collect all points firstly*/
for (auto compute_info : computepoints_info->getChildren())
{
auto function = base->vQueryFunction(GPStringHelper::cleanString(compute_info->attr()));
if (NULL == function)
{
FUNC_PRINT_ALL(compute_info->attr().c_str(), s);
}
GPASSERT(NULL!=function);
auto node = new CP(new GPComputePoint(function));
mFunctions.push_back(node);
cp_map.insert(std::make_pair(compute_info->name(), node));
}
/*Now Connect*/
for (auto compute_info : computepoints_info->getChildren())
{
auto function = base->vQueryFunction(GPStringHelper::cleanString(compute_info->attr()));
auto this_node = cp_map.find(compute_info->name())->second;
for (auto info : compute_info->getChildren())
{
if (info->name() == "Input")
{
auto node_names = GPStringHelper::divideString(info->attr());
for (int i=0; i<node_names.size(); ++i)
{
auto name = node_names[i];
auto s_iter = sp_map.find(name);
if (s_iter != sp_map.end())
{
s_iter->second->connectOutput(this_node, 0);
this_node->connectInput(s_iter->second, i);
continue;
}
auto c_iter = cp_map.find(name);
GPASSERT(c_iter!=cp_map.end());
this_node->connectInput(c_iter->second.get(), i);
}
}
if (info->name() == "Output")
{
auto node_names = GPStringHelper::divideString(info->attr());
GPASSERT(function->outputType.size() == node_names.size());
auto n = function->outputType.size();
for (size_t i=0; i<n; ++i)
{
auto name = node_names[i];
auto cp_iter = cp_map.find(name);
if (cp_iter!=cp_map.end())
{
auto output = cp_iter->second;
this_node->connectOutput(output, 0);
continue;
}
auto dst = new DP(function->outputType[i]);
mDest.push_back(dst);
dst->connectInput(this_node.get(), 0);
this_node->connectOutput(dst, 0);
dst->addRef();
}
}
}
}
}
/*Load Status*/
{
auto status_tn = children[2];
GPASSERT(status_tn->name() == "Status");
auto status_values = GPStringHelper::divideString(status_tn->attr());
if (status_values.size() > 0)
{
GPASSERT(status_values.size() == this->vMap(NULL));
GPPtr<GPParameter> para = new GPParameter((int)(status_values.size()));
for (int i=0; i<status_values.size(); ++i)
{
std::istringstream number(status_values[i]);
number >> para->attach()[i];
}
this->vMap(para.get());
}
}
void array_base::put(object const& indices, object const& values)
{
attr("put")(indices, values);
}
object array_base::repeat(object const& repeats, long axis)
{
return attr("repeat")(repeats, axis);
}
bool array_base::iscontiguous() const
{
return extract<bool>(attr("iscontiguous")());
}
long array_base::nelements() const
{
return extract<long>(attr("nelements")());
}
object array_base::getflat() const
{
return attr("getflat")();
}
object array_base::getshape() const
{
return attr("getshape")();
}
void array_base::byteswap()
{
attr("byteswap")();
}
object array_base::copy() const
{
return attr("copy")();
}
object array_base::argsort(long axis)
{
return attr("argsort")(axis);
}
object array_base::astype(object const& type)
{
return attr("astype")(type);
}
object array_base::argmin(long axis)
{
return attr("argmin")(axis);
}
void sbbs_t::telnet_gate(char* destaddr, ulong mode, char* client_user_name, char* server_user_name, char* term_type)
{
char* p;
uchar buf[512];
int i;
int rd;
uint attempts;
ulong l;
bool gotline;
ushort port;
ulong ip_addr;
ulong save_console;
SOCKET remote_socket;
SOCKADDR_IN addr;
if(mode&TG_RLOGIN)
port=513;
else
port=IPPORT_TELNET;
p=strchr(destaddr,':');
if(p!=NULL) {
*p=0;
port=atoi(p+1);
}
ip_addr=resolve_ip(destaddr);
if(ip_addr==INADDR_NONE) {
lprintf(LOG_NOTICE,"!TELGATE Failed to resolve address: %s",destaddr);
bprintf("!Failed to resolve address: %s\r\n",destaddr);
return;
}
if((remote_socket = open_socket(SOCK_STREAM, client.protocol)) == INVALID_SOCKET) {
errormsg(WHERE,ERR_OPEN,"socket",0);
return;
}
memset(&addr,0,sizeof(addr));
addr.sin_addr.s_addr = htonl(startup->telnet_interface);
addr.sin_family = AF_INET;
if((i=bind(remote_socket, (struct sockaddr *) &addr, sizeof (addr)))!=0) {
lprintf(LOG_NOTICE,"!TELGATE ERROR %d (%d) binding to socket %d",i, ERROR_VALUE, remote_socket);
bprintf("!ERROR %d (%d) binding to socket\r\n",i, ERROR_VALUE);
close_socket(remote_socket);
return;
}
memset(&addr,0,sizeof(addr));
addr.sin_addr.s_addr = ip_addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
if((i=connect(remote_socket, (struct sockaddr *)&addr, sizeof(addr)))!=0) {
lprintf(LOG_NOTICE,"!TELGATE ERROR %d (%d) connecting to server: %s"
,i,ERROR_VALUE, destaddr);
bprintf("!ERROR %d (%d) connecting to server: %s\r\n"
,i,ERROR_VALUE, destaddr);
close_socket(remote_socket);
return;
}
l=1;
if((i = ioctlsocket(remote_socket, FIONBIO, &l))!=0) {
lprintf(LOG_NOTICE,"!TELGATE ERROR %d (%d) disabling socket blocking"
,i, ERROR_VALUE);
close_socket(remote_socket);
return;
}
lprintf(LOG_INFO,"Node %d %s gate to %s port %u on socket %d"
,cfg.node_num
,mode&TG_RLOGIN ? "RLogin" : "Telnet"
,destaddr,port,remote_socket);
if(!(mode&TG_CTRLKEYS))
console|=CON_RAW_IN;
if(mode&TG_RLOGIN) {
p=(char*)buf;
*(p++)=0;
p+=sprintf(p,"%s",client_user_name==NULL ? useron.alias : client_user_name);
p++; // Add NULL
p+=sprintf(p,"%s",server_user_name==NULL ? useron.name : server_user_name);
p++; // Add NULL
if(term_type!=NULL)
p+=sprintf(p,"%s",term_type);
else
p+=sprintf(p,"%s/%u",terminal, cur_rate);
p++; // Add NULL
l=p-(char*)buf;
sendsocket(remote_socket,(char*)buf,l);
mode|=TG_NOLF; /* Send LF (to remote host) when Telnet client sends CRLF (when not in binary mode) */
}
/* This is required for gating to Unix telnetd */
if(mode&TG_NOTERMTYPE)
request_telnet_opt(TELNET_DONT,TELNET_TERM_TYPE, 3000); // Re-negotiation of terminal type
/* Text/NVT mode by default */
request_telnet_opt(TELNET_DONT,TELNET_BINARY_TX, 3000);
if(!(telnet_mode&TELNET_MODE_OFF) && (mode&TG_PASSTHRU))
telnet_mode|=TELNET_MODE_GATE; // Pass-through telnet commands
while(online) {
if(!(mode&TG_NOCHKTIME))
gettimeleft();
rd=RingBufRead(&inbuf,buf,sizeof(buf));
if(rd) {
#if 0
if(memchr(buf,TELNET_IAC,rd)) {
char dump[2048];
dump[0];
p=dump;
for(int i=0;i<rd;i++)
p+=sprintf(p,"%u ",buf[i]);
lprintf(LOG_DEBUG,"Node %d Telnet cmd from client: %s", cfg.node_num, dump);
}
#endif
if(telnet_remote_option[TELNET_BINARY_TX]!=TELNET_WILL) {
if(*buf==0x1d) { // ^]
save_console=console;
console&=~CON_RAW_IN; // Allow Ctrl-U/Ctrl-P
CRLF;
while(online) {
SYNC;
mnemonics("\1n\r\n\1h\1bTelnet Gate: \1y~D\1wisconnect, "
"\1y~E\1wcho toggle, \1y~L\1wist Users, \1y~P\1wrivate message, "
"\1y~Q\1wuit: ");
switch(getkeys("DELPQ",0)) {
case 'D':
closesocket(remote_socket);
break;
case 'E':
mode^=TG_ECHO;
bprintf(text[EchoIsNow]
,mode&TG_ECHO
? text[ON]:text[OFF]);
continue;
case 'L':
whos_online(true);
continue;
case 'P':
nodemsg();
continue;
}
break;
}
attr(LIGHTGRAY);
console=save_console;
}
else if(*buf<' ' && (mode&TG_CTRLKEYS))
handle_ctrlkey(*buf, K_NONE);
gotline=false;
if((mode&TG_LINEMODE) && buf[0]!='\r') {
ungetkey(buf[0]);
l=K_CHAT;
if(!(mode&TG_ECHO))
l|=K_NOECHO;
rd=getstr((char*)buf,sizeof(buf)-1,l);
if(!rd)
continue;
strcat((char*)buf,crlf);
rd+=2;
gotline=true;
}
if((mode&TG_CRLF) && buf[rd-1]=='\r')
buf[rd++]='\n';
else if((mode&TG_NOLF) && buf[rd-1]=='\n')
rd--;
if(!gotline && (mode&TG_ECHO) && rd) {
RingBufWrite(&outbuf,buf,rd);
}
} /* Not Telnet Binary mode */
if(rd > 0) {
for(attempts=0;attempts<60 && online; attempts++) /* added retry loop here, Jan-20-2003 */
{
if((i=sendsocket(remote_socket,(char*)buf,rd))>=0)
break;
if(ERROR_VALUE!=EWOULDBLOCK)
break;
mswait(500);
}
if(i<0) {
lprintf(LOG_NOTICE,"!TELGATE ERROR %d sending on socket %d",ERROR_VALUE,remote_socket);
break;
}
}
}
rd=recv(remote_socket,(char*)buf,sizeof(buf),0);
if(rd<0) {
if(ERROR_VALUE==EWOULDBLOCK) {
if(mode&TG_NODESYNC) {
SYNC;
} else {
// Check if the node has been interrupted
getnodedat(cfg.node_num,&thisnode,0);
if(thisnode.misc&NODE_INTR)
break;
}
YIELD();
continue;
}
lprintf(LOG_NOTICE,"!TELGATE ERROR %d receiving on socket %d",ERROR_VALUE,remote_socket);
break;
}
if(!rd) {
lprintf(LOG_INFO,"Node %d Telnet gate disconnected",cfg.node_num);
break;
}
#if 0
if(memchr(buf,TELNET_IAC,rd)) {
char dump[2048];
dump[0];
p=dump;
for(int i=0;i<rd;i++)
p+=sprintf(p,"%u ",buf[i]);
lprintf(LOG_DEBUG,"Node %d Telnet cmd from server: %s", cfg.node_num, dump);
}
#endif
RingBufWrite(&outbuf,buf,rd);
}
console&=~CON_RAW_IN;
telnet_mode&=~TELNET_MODE_GATE;
/* Disable Telnet Terminal Echo */
request_telnet_opt(TELNET_WILL,TELNET_ECHO);
close_socket(remote_socket);
lprintf(LOG_INFO,"Node %d Telnet gate to %s finished",cfg.node_num,destaddr);
}
OBBase* OBMol::DoTransformations(const std::map<std::string, std::string>* pOptions, OBConversion* pConv)
{
// Perform any requested transformations
// on a OBMol
//The input map has option letters or name as the key and
//any associated text as the value.
//For normal(non-filter) transforms:
// returns a pointer to the OBMol (this) if ok or NULL if not.
//For filters returns a pointer to the OBMol (this) if there is a match,
//and NULL when not and in addition the OBMol object is deleted NULL.
//This is now a virtual function. The OBBase version just returns the OBMol pointer.
//This is declared in mol.h
//The filter options, s and v allow a obgrep facility.
//Used together they must both be true to allow a molecule through.
//Parse GeneralOptions
if(pOptions->empty())
return this;
// DoOps calls Do() for each of the plugin options in the map
// It normally returns true, even if there are no options but
// can return false if one of the options decides that the
// molecule should not be output. If it is a filtering op, it
// should delete the molecule itself (unlike the -s, --filter options,
// which delete it in this function).
if(!OBOp::DoOps(this, pOptions, pConv))
return (OBBase *)NULL;
bool ret=true;
map<string,string>::const_iterator itr, itr2;
if(pOptions->find("b")!=pOptions->end())
if(!ConvertDativeBonds())
ret=false;
if(pOptions->find("d")!=pOptions->end())
if(!DeleteHydrogens())
ret=false;
if(pOptions->find("h")!=pOptions->end())
if(!AddHydrogens(false, false))
ret=false;
if(pOptions->find("r")!=pOptions->end()) {
StripSalts();
ret = true;
}
itr = pOptions->find("p");
if(itr!=pOptions->end()) {
double pH = strtod(itr->second.c_str(), 0);
if(!AddHydrogens(false, true, pH))
ret=false;
}
if(pOptions->find("c")!=pOptions->end())
Center();
itr = pOptions->find("title"); //Replaces title
if(itr!=pOptions->end())
SetTitle(itr->second.c_str());
itr = pOptions->find("addtotitle"); //Appends text to title
if(itr!=pOptions->end())
{
string title(GetTitle());
title += itr->second;
SetTitle(title.c_str());
}
/* itr = pOptions->find("addformula"); //Appends tab + formula to title
if(itr!=pOptions->end())
{
string title(GetTitle());
title += '\t' + GetSpacedFormula(1,"");//actually unspaced
SetTitle(title.c_str());
}
*/
//Add an extra property to the molecule.
//Parameter has atrribute and value separated by a space
itr = pOptions->find("property");
if(itr!=pOptions->end())
{
string txt(itr->second);
string::size_type pos = txt.find(' ');
if(pos==string::npos)
{
obErrorLog.ThrowError(__FUNCTION__, "Missing property value", obError);
ret=false;
}
else
{
string attr(txt.substr(0,pos)), val(txt.substr(pos+1));
//Update value if it already exists
OBPairData* dp = dynamic_cast<OBPairData*>(GetData(attr));
if(dp) {
dp->SetValue(val);
dp->SetOrigin(userInput);
}
else {
// Pair did not exist; make new one
dp = new OBPairData;
dp->SetAttribute(attr);
dp->SetValue(val);
dp->SetOrigin(userInput);
SetData(dp);
}
}
}
itr = pOptions->find("add"); //adds new properties from descriptors in list
if(itr!=pOptions->end())
OBDescriptor::AddProperties(this, itr->second);
itr = pOptions->find("delete"); //deletes the specified properties
if(itr!=pOptions->end())
OBDescriptor::DeleteProperties(this, itr->second);
itr = pOptions->find("append"); //Appends values of descriptors or properties to title
if(itr!=pOptions->end())
{
string title(GetTitle());
title += OBDescriptor::GetValues(this, itr->second);
if(ispunct(title[0]))
title[0]=' ';//a leading punct char is used only as a separator, not at start
SetTitle(Trim(title).c_str());
}
//Filter using OBDescriptor comparison and (older) SMARTS tests
//Continue only if previous test was true.
bool fmatch = true;
itr = pOptions->find("filter");
if(itr!=pOptions->end())
{
std::istringstream optionText(itr->second);
fmatch = OBDescriptor::FilterCompare(this, optionText, false);
}
if(fmatch)
{
itr = pOptions->find("v");
if(itr!=pOptions->end() && !itr->second.empty())
{
//inverse match quoted SMARTS string which follows
OBSmartsPattern sp;
sp.Init(itr->second);
fmatch = !sp.Match(*this); //(*pmol) ;
}
}
if(fmatch)
{
itr = pOptions->find("s");
if(itr!=pOptions->end() && !itr->second.empty())
{
//SMARTS filter
//If exactmatch option set (probably in fastsearchformat) the
//number of atoms in the pattern (passed as a string in the option text)
//has to be the same as in the molecule.
itr2 = pOptions->find("exactmatch");
if(itr2!=pOptions->end() && NumHvyAtoms()!=atoi(itr2->second.c_str()))
fmatch=false;
else
{
//match quoted SMARTS string which follows
OBSmartsPattern sp;
sp.Init(itr->second.c_str());
fmatch = sp.Match(*this);
}
}
}
if(!fmatch)
{
//filter failed: delete OBMol and return NULL
delete this;
return NULL;
}
else
{
if(ret==false)
{
obErrorLog.ThrowError(__FUNCTION__, "Error executing an option", obError);
delete this; //added 9March2006
return NULL;
}
else
return this;
}
}
object array_base::type() const
{
return attr("type")();
}
object array_base::diagonal(long offset, long axis1, long axis2) const
{
return attr("diagonal")(offset, axis1, axis2);
}
char array_base::typecode() const
{
return extract<char>(attr("typecode")());
}
void array_base::info() const
{
attr("info")();
}
long array_base::getrank() const
{
return extract<long>(attr("getrank")());
}
bool array_base::is_c_array() const
{
return extract<bool>(attr("is_c_array")());
}
bool array_base::isaligned() const
{
return extract<bool>(attr("isaligned")());
}
bool array_base::isbyteswapped() const
{
return extract<bool>(attr("isbyteswapped")());
}
long array_base::itemsize() const
{
return extract<long>(attr("itemsize")());
}
array array_base::new_(object type) const
{
return extract<array>(attr("new")(type))();
}
object array_base::nonzero() const
{
return attr("nonzero")();
}
void array_base::sort()
{
attr("sort")();
}
void array_base::ravel()
{
attr("ravel")();
}
object array_base::trace(long offset, long axis1, long axis2) const
{
return attr("trace")(offset, axis1, axis2);
}
void array_base::resize(object const& shape)
{
attr("resize")(shape);
}
int Message2::errorCode() const
{
if (!isError() || isEmpty())
return 0;
return attr("code").toInt();
}
