string unlines2(strings elems) {
  stringstream ss;
  std::for_each(elems.begin(), elems.end(), [&ss](const string& s) {
    ss << s << std::endl;
  });
  return ss.str();
}

std::map<std::string, int> encount(std::istream *in, const strings &searched)
{
	std::map<std::string,int> result;
	std::vector<s_info> watched;
	// insert all string from searched with 0 frequency
	for (s_citer iter = searched.begin(), end = searched.end(); iter != end; ++iter)
	{
		result[*iter] = 0;
		if (iter->begin() != iter->end())
			watched.push_back(s_info(&(*iter)));
	}

	char ch;
	while (in->get(ch))
	{
		for (std::vector<s_info>::iterator iter = watched.begin(), end = watched.end(); iter != end; ++iter)
		{
			if (ch == iter->curr())
			{
				iter->current++;
				if (iter->isEnd())
				{
					result[*(iter->pstr)]++;
					iter->reset();
				}
			}
			else iter->reset();
		}
	}

	return result;
}

void engine::filedrop_attachments_impl(std::string server, const std::string& key,
        const std::string& user, const std::string& subject,
        const std::string& message, const strings& fs, report_level s)
{
    curl_easy_setopt(m_curl, CURLOPT_URL, server.c_str());
    curl_header_guard hg(m_curl);
    std::string data = std::string(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\
  <message>\
    <api_key>") + key + std::string("</api_key>\
    <from>") + user + std::string("</from>\
    <subject>") + subject + std::string("</subject>\
    <message>") + message + std::string("</message>\
    <attachments type='array'>\
");
    for (strings::const_iterator i = fs.begin(); i != fs.end(); ++i) {
        data += "      <attachment>";
        data += *i;
        data += "</attachment>\n";
    }
    data += "    </attachments>\
  </message>\n";
    curl_easy_setopt(m_curl, CURLOPT_HTTPPOST, 0);
    curl_easy_setopt(m_curl, CURLOPT_POSTFIELDS, data.c_str());
    if (s >= NORMAL) {
        io::mout << "Sending message to filedrop" << io::endl;
    }
    process_filedrop_responce(perform(), s);
}

void Tpresets::listRegKeys(strings &l)
{
    l.clear();

    HKEY hKey;
    char_t rkey[MAX_PATH];
    tsnprintf_s(rkey, countof(rkey), _TRUNCATE, FFDSHOW_REG_PARENT _l("\\%s"), reg_child);
    RegOpenKeyEx(HKEY_CURRENT_USER,rkey,0,KEY_READ,&hKey);
    for (int i=0,retCode=ERROR_SUCCESS; retCode==ERROR_SUCCESS; i++) {
        char_t keyName[256];
        DWORD keyNameSize=255;
        FILETIME ftLastWriteTime;
        retCode = RegEnumKeyEx(hKey,
                               i,
                               keyName,
                               &keyNameSize,
                               NULL,
                               NULL,
                               NULL,
                               &ftLastWriteTime
                              );
        if (retCode==ERROR_SUCCESS) {
            l.push_back(ffstring(keyName));
        } else {
            break;
        }
    }
    RegCloseKey(hKey);
}

void GUIPlayer::listOggfiles(const string& dirPath, strings& oggFiles)
{
    DIR* dir;
    if ((dir = opendir(dirPath.data())) == NULL)
    {
        return;
    }

    struct dirent* entry;
    while ((entry = readdir(dir)) != NULL)
    {
        string name = entry->d_name;
        if (StringHelper::endsWith(upperCase(name), ".OGG"))
        {
            name = "/" + name;
            name = dirPath + name;
            oggFiles.push_back(name);
        }
    }

    // hack
    // we hope startup.ogg to be the first.
    reverse(oggFiles.begin(), oggFiles.end());
    closedir(dir);
}

 void HttpInterface::evReset(HttpRequest* req, strings& args)
 {
     for (NodesMap::iterator descIt = nodes.begin();
          descIt != nodes.end(); ++descIt)
     {
         bool ok;
         nodeId = getNodeId(descIt->second.name, 0, &ok);
         if (!ok)
             continue;
         string nodeName = WStringToUTF8(descIt->second.name);
         
         Reset(nodeId).serialize(asebaStream); // reset node
         asebaStream->flush();
         Run(nodeId).serialize(asebaStream);   // re-run node
         asebaStream->flush();
         if (nodeName.find("thymio-II") == 0)
         {
             strings args;
             args.push_back("motor.left.target");
             args.push_back("0");
             sendSetVariable(nodeName, args);
             args[0] = "motor.right.target";
             sendSetVariable(nodeName, args);
         }
         size_t eventPos;
         if (commonDefinitions.events.contains(UTF8ToWString("reset"), &eventPos))
         {
             strings data;
             data.push_back("reset");
             sendEvent(nodeName,data);
         }
         
         finishResponse(req, 200, "");
     }
 }

int Twindow::selectFromMenu(const strings &items,int id,bool translate,int columnHeight)
{
    Tstrptrs ptritems;
    for (strings::const_iterator s=items.begin(); s!=items.end(); s++) {
        ptritems.push_back(s->c_str());
    }
    ptritems.push_back(NULL);
    return selectFromMenu(&ptritems[0],id,translate,columnHeight);
}

bool nsUtils::runCmd(const string& cmd,
        const strings& input,
        strings& output)
{
    int childStdIn[2]; // child read 0, parent write 1
    int childStdOut[2]; // parent read 0, child write 1
    if (pipe(childStdIn) != 0) {
        std::cerr << "Failed to create pipe 1\n";
        return false;
    }
    if (pipe(childStdOut) != 0) {
        std::cerr << "Failed to create pipe 2\n";
        return false;
    }
    pid_t child(fork());
    if (child == -1) {
        std::cerr << "Failed to fork\n";
        close(childStdIn[0]);
        close(childStdIn[1]);
        close(childStdOut[0]);
        close(childStdOut[1]);
        return false;
    }
    if (child == 0) {
        // child
        close(childStdIn[1]);
        close(childStdOut[0]);
        dup2(childStdIn[0], 0);
        dup2(childStdOut[1], 1);
        execl(cmd.c_str(), cmd.c_str(), NULL);
        exit(1);
    }
    // parent
    close(childStdIn[0]);
    close(childStdOut[1]);
    char lineEnd('\n');
    for (size_t i = 0; i < input.size(); ++i) {
        write(childStdIn[1], input[i].c_str(), input[i].length());
        write(childStdIn[1], &lineEnd, 1);
    }
    close(childStdIn[1]);
    ssize_t readCount;
    const int bufferSize(512);
    char buffer[bufferSize + 1];
    while ((readCount = read(childStdOut[0], buffer, bufferSize)) > 0) {
        buffer[readCount] = '\0';
        if (buffer[readCount - 1] == '\n') {
            buffer[readCount - 1] = '\0';
        }
        output.push_back(string(buffer));
    }
    close(childStdOut[0]);
    wait(NULL);
    return true;
}

static void fixRelativePaths(strings &dirs, const char_t *basepath)
{
    for (strings::iterator d = dirs.begin(); d != dirs.end(); d++)
        if (PathIsRelative(d->c_str())) {
            char_t absdir[MAX_PATH];
            _makepath_s(absdir, countof(absdir), NULL, basepath, d->c_str(), NULL);
            char_t absdirC[MAX_PATH];
            PathCanonicalize(absdirC, absdir);
            *d = absdirC;
        }
}

void engine::attach(std::string server,
        const std::string& key,
        const strings& fs,
        report_level s,
        validate_cert v)
{
    init_curl(key, s, v);
    strings::const_iterator i = fs.begin();
    for (; i != fs.end(); ++i) {
        attach_impl(server, *i, s);
    }
}

void TsubtitlesFile::findPossibleSubtitles(const char_t *dir, strings &files)
{
    char_t autosubmask[MAX_PATH];
    _makepath_s(autosubmask, MAX_PATH, NULL, dir,/*name*/_l("*"), _l("*"));
    strings files0;
    findFiles(autosubmask, files0);
    for (strings::iterator f = files0.begin(); f != files0.end(); f++)
        if (extMatch(f->c_str())) {
            files.push_back(*f);
        }
    std::sort(files.begin(), files.end(), ffstring_iless());
}

 void load_volumes(strings& s,grids& vols,int skip,bool verbose)
 {
   vols.resize(s.size()-skip); //first column is eigenvalue
   for(int i=0;i<(s.size()-skip);i++)
   {
     /*if(verbose) 
       std::cout<<s[i+skip].c_str()<<" "<<std::flush;*/
     
     minc_1_reader rdr;
     rdr.open(s[i+skip].c_str());
     load_simple_volume(rdr,vols[i]);
   }
 }

 const std::string
 join (const strings& ss, const std::string& separator)
 {
   std::string s;
   for (strings::const_iterator ssi = ss.begin ();
        ssi != ss.end ();
        ++ssi)
   {
     s += *ssi;
     if ((ssi + 1) != ss.end ())
       s += separator;
   }
   return s;
 }

 void save_volumes(strings& s,volumes& vols,const char *like,const std::string & append_history)
 {
   for(int i=0;i<s.size();i++)
   {
     save_volume(vols[i],s[i].c_str(),like,append_history);
   }
 }

	int getDirectoryContent(const std::string& dir, strings &files, bool recursive)
	{
		DIR *dp;
		struct dirent *dirp;
	
		strings todo;

		if((dp = opendir(dir.c_str())) == NULL) 
		{
			return errno;
		}

		while ((dirp = readdir(dp)) != NULL) 
		{
			if (dirp->d_type == DT_REG)
			{
				files.push_back(dir + "/" + std::string(dirp->d_name));
			}
			else if (recursive && dirp->d_type == DT_DIR)
			{
				if (dirp->d_name[0] != '.')
				{
					todo.push_back(dir + "/" + dirp->d_name);				
				}
			}
		}
		closedir(dp);

		for (size_t u = 0; u < todo.size(); u++)
		{
			getDirectoryContent(todo[u], files, recursive);
		}

		return 0;
	}

RevKBCCTrainer::reverbdpoint RevKBCCTrainer::ReverberateNetwork( strings subView /*= strings(0)*/ )
{
    //changing the clean reverb to only threshold the outputs.
    //if the numcontexts is set above 0 then we'll get them from the dataset.
    int inSize = revNet->GetNumIn();
    if (revparams.numContexts > 0 || subView.size() > 0) {
        //assert(revparams.numContexts > 0);
        if(revparams.numContexts == 0) {
            revparams.numContexts = subView.size();
        }
        inSize -= revparams.numContexts;
    }

    vecDouble tmpIn(inSize);
    for (uint i = 0; i < tmpIn.size(); i++)
    {
        tmpIn[i] = revRand();
    }
    if (revparams.numContexts > 0) {
        vecDouble randContext;
        if (subView.size() > 0) {
            randContext = dynamic_pointer_cast<CSMTLDataset>(data)->GetRandContext(subView);
        }
        else {
            randContext = dynamic_pointer_cast<CSMTLDataset>(data)->GetRandContext();
        }
        tmpIn = ConcatVec(tmpIn,randContext);
    }
    revNet->Activate(tmpIn);
    for (uint i = 1; i < revparams.numRev; i++)
    {
        tmpIn = revNet->GetAutoAssocLayer()->GetOutput();
        revNet->Activate(tmpIn);
    }
    reverbdpoint retVal;
    retVal.inPoint = tmpIn;
    retVal.outPoint = revNet->GetNormOutLayer()->GetOutput();

    if(revparams.cleanReverb) { //This shouldn't be used when the outputs are real.
        retVal.outPoint = ApplyThreshold(retVal.outPoint);
    }

#ifdef _DEBUG
    cout << "in: " << retVal.inPoint << "out" << retVal.outPoint << endl;
#endif
    return retVal;
}

 void HttpInterface::evSubscribe(HttpRequest* req, strings& args)
 {
     // eventSubscriptions[conn] is an unordered set of strings
     if (args.size() == 1)
         eventSubscriptions[req].insert("*");
     else
         for (strings::iterator i = args.begin()+1; i != args.end(); ++i)
             eventSubscriptions[req].insert(*i);
     
     strings headers;
     headers.push_back("Content-Type: text/event-stream");
     headers.push_back("Cache-Control: no-cache");
     headers.push_back("Connection: keep-alive");
     addHeaders(req, headers);
     appendResponse(req,200,true,"");
     // connection must stay open!
 }

string join(strings strs, string glue)
{
    string result;
    for (auto it : strs) {
        if (it != *strs.begin()) result += glue;
        result += it;
    }
    return result;
}

void str2argv(const string src, strings &argv) {
	string arg;
	enum state {
		SYMBOL,
		SKIP,
		SKIP_UNTIL
	} s = SYMBOL;
	for (string::const_iterator i = src.begin(); i != src.end(); ++i) {
		switch (*i) {
			case '\\':
				s = SKIP;
				break;
			case '"':
				if (s == SKIP_UNTIL)
					s = SYMBOL;
				else
					s = SKIP_UNTIL;
				break;
			case ' ':
				switch (s) {
					case SKIP:
						s = SYMBOL;
						arg += *i;
						break;
					case SKIP_UNTIL:
						arg += *i;
						break;
					default:
						argv.push_back(arg);
						arg.clear();
						break;
				}
				break;
			default:
				if (s == SKIP)
					s = SYMBOL;
				arg += *i;
				break;
		}
	}
	if (!arg.empty())
		argv.push_back(arg);
}

 void HttpInterface::sendSetVariable(const std::string nodeName, const strings& args)
 {
     // get node id, variable position and length
     if (verbose)
         cerr << "setVariables " << nodeName << " " << args[0];
     unsigned nodePos, varPos;
     const bool exists(getNodeAndVarPos(nodeName, args[0], nodePos, varPos));
     if (!exists)
         return;
     
     if (verbose)
         cerr << " (" << nodePos << "," << varPos << "):" << args.size()-1 << endl;
     // send the message
     SetVariables::VariablesVector data;
     for (size_t i=1; i<args.size(); ++i)
         data.push_back(atoi(args[i].c_str()));
     SetVariables setVariables(nodePos, varPos, data);
     setVariables.serialize(asebaStream);
     asebaStream->flush();
 }