void Strings::addStrings(const Strings& strings)
{
AutoUpdater autoUpdater(*this);
for (int i = 0; i < strings.getCount(); i++)
add(strings.getString(i).c_str(), strings.getData(i));
}
Strings dir_children(const std::string& d) {
Strings result;
fs::directory_iterator dir(d), end;
BOOST_FOREACH (const fs::path& child,
std::make_pair(dir, end)) {
result.push_back(child.string());
}
///---------------------------------------------------------------------------------
///
///---------------------------------------------------------------------------------
bool FindAllFilesOfType( const std::string& directory, const std::string& searchPattern, Strings& out_filesFound )
{
#ifdef WIN32
_finddata_t fd;
std::string searchPath = directory + searchPattern;
intptr_t searchHandle = _findfirst( searchPath.c_str(), &fd );
if (searchHandle != -1)
{
do
{
// ConsolePrintf( "%s %i\n", (directory + std::string(fd.name)).c_str(), fd.attrib );
out_filesFound.push_back( directory + std::string( fd.name ) );
} while (_findnext( searchHandle, &fd ) == 0);
}
else return false;
if (_findclose( searchHandle ) == 0 && out_filesFound.size() != 0)
return true;
return false;
#else
return false;
#endif
}
void ConfigTool::writeConfig() const
{
Global* global = Global::instance();
global->setConfigFAttribute( Config::FATTR_VERSION, 1.2f );
global->setWindowIAttribute( eq::server::Window::IATTR_HINT_FULLSCREEN,
eq::fabric::ON );
if( _mode != MODE_WALL )
{
global->setWindowIAttribute(eq::server::Window::IATTR_HINT_DOUBLEBUFFER,
eq::fabric::OFF );
global->setWindowIAttribute( eq::server::Window::IATTR_HINT_DRAWABLE,
eq::fabric::PBUFFER );
}
if( _mode >= MODE_DB && _mode <= MODE_DB_STREAM )
global->setWindowIAttribute( eq::server::Window::IATTR_PLANES_STENCIL,
eq::fabric::ON );
ServerPtr server = new eq::server::Server;
const Strings nodeNames = readNodenames( _nodesFile );
co::ConnectionDescriptionPtr desc = new ConnectionDescription;
if( !nodeNames.empty( ))
desc->setHostname( nodeNames.front( ));
server->addConnectionDescription( desc );
Config* config = new Config( server );
_writeResources( config, nodeNames );
_writeCompound( config );
lunchbox::Log::instance( "", 0 )
<< lunchbox::disableHeader << global << *server << std::endl
<< lunchbox::enableHeader << lunchbox::disableFlush;
}
void NeighbourJoining::buildTree(Matrix& distMatrix, const Strings& labels, Tree* tree)
{
// allocation space for temporary variables
m_separationSums = new double[distMatrix.size()];
m_separations = new double[distMatrix.size()];
m_numActiveClusters = distMatrix.size();
m_activeClusters = new bool[distMatrix.size()];
//calculate initial seperation rows
for(uint i = 0; i < distMatrix.size(); i++)
{
double sum = 0;
for(uint j = 0; j < distMatrix.size(); j++)
sum += distMatrix[i][j];
m_separationSums[i] = sum;
m_separations[i] = sum / (m_numActiveClusters-2);
m_activeClusters[i] = true;
}
// create initial singleton clusters
std::vector< Node* > clusters;
for(uint i = 0; i < labels.size(); ++i)
{
Node* node = new Node(labels.at(i));
clusters.push_back(node);
}
while(m_numActiveClusters > 2)
{
findNearestClusters(distMatrix);
updateClusters(distMatrix, clusters);
updateDistanceMatrix(distMatrix);
}
// finish by joining the two remaining clusters
int index1 = -1;
int index2 = -1;
// find the last nodes
for(uint i = 0; i < distMatrix.size(); i++)
{
if(m_activeClusters[i])
{
if(index1 == -1)
index1 = i;
else
{
index2 = i;
break;
}
}
}
// connect remaining subtrees and define arbitrary root of tree
clusters.at(index1)->addChild(clusters.at(index2));
clusters.at(index2)->distanceToParent(distMatrix[index1][index2]);
tree->root(clusters.at(index1));
}
Strings expandShellWildcard( const std::string& filename )
{
Strings expandedFilenames;
namespace fs = boost::filesystem;
const fs::path& filePath( filename );
const fs::path& parent = filePath.parent_path();
if( !fs::exists( parent ) || !fs::is_directory( parent ))
LBTHROW( std::runtime_error( "Not a valid path" ));
// Convert the filename with shell-like wildcard into a POSIX regex
const boost::regex regex = convertToRegex( filename );
for( fs::directory_iterator it( parent );
it != fs::directory_iterator(); ++it )
{
const std::string& candidate = it->path().string();
if( boost::regex_match( candidate, regex ))
expandedFilenames.push_back( candidate );
}
return expandedFilenames;
}
bool Client::initLocal( const int argc, char** argv )
{
if( _impl->name.empty() && argc > 0 && argv )
{
const boost::filesystem::path prog = argv[0];
setName( prog.stem().string( ));
}
const auto options = _getProgramOptions();
arg::variables_map vm;
try
{
Strings args;
for( int i = 0; i < argc; ++i )
if( strcmp( argv[i], "--" ) != 0 )
args.push_back( argv[i] );
arg::store( arg::command_line_parser( args )
.options( options ).allow_unregistered().run(), vm );
arg::notify( vm );
}
catch( const std::exception& e )
{
LBERROR << "Error in argument parsing: " << e.what() << std::endl;
return false;
}
const bool isClient = vm.count( "eq-client" );
std::string clientOpts;
if( vm.count( "eq-layout" ))
_impl->activeLayouts.push_back( vm["eq-layout"].as< std::string >( ));
if( vm.count( "eq-gpufilter" ))
_impl->gpuFilter = vm["eq-gpufilter"].as< std::string >();
if( vm.count( "eq-modelunit" ))
_impl->modelUnit = vm["eq-modelunit"].as< float >();
LBVERB << "Launching " << getNodeID() << std::endl;
if( !Super::initLocal( argc, argv ))
return false;
if( isClient )
{
LBVERB << "Client node started from command line with option "
<< clientOpts << std::endl;
if( !_setupClient( clientOpts ))
{
exitLocal();
return false;
}
_impl->running = true;
clientLoop();
exitClient();
}
_impl->initQt( argc, argv );
return true;
}
std::string
StringTools::wrap( const std::string &text,
int wrapColumn )
{
const char lineBreak = '\n';
Strings lines = split( text, lineBreak );
std::string wrapped;
for ( Strings::const_iterator it = lines.begin(); it != lines.end(); ++it )
{
if ( it != lines.begin() )
wrapped += lineBreak;
const std::string &line = *it;
unsigned int index =0;
while ( index < line.length() )
{
std::string lineSlice( line.substr( index, wrapColumn ) );
wrapped += lineSlice;
index += wrapColumn;
if ( index < line.length() )
wrapped += lineBreak;
}
}
return wrapped;
}
// Split string cs into a vector of strings.
// Character c is used to split the strings.
// Strings in the result vector do not include the c character.
Strings Split(const std::string& cs, char c)
{
Strings r;
std::string s(cs);
while (true)
{
int i = s.find(c);
if (i == std::string::npos)
{
// No special character found, so push back the entire string and finish.
r.push_back(s);
break;
}
else
{
// Found the special character.
// Push back whatever is before the character, then work on the remainder
// of the string.
r.push_back(s.substr(0, i));
s = s.substr(i + 1);
Trim(&s);
if (s.empty())
{
break;
}
}
}
return r;
}
void initComponents()
{
setBackground(BG_COLOR);
setBounds(120, 120, ICON_WIDTH * 3 + PROGRESS_SIZE + PADDING * 3 + 40, ICON_HEIGHT + PROGRESS_SIZE + 50);
statusLabel_ = new Label("ready");
statusLabel_->setBounds(START_X, START_Y, ICON_WIDTH * 4, ICON_HEIGHT);
statusLabel_->setBackground(BG_COLOR);
statusLabel_->setForeground(monagui::Color::gray);
add(statusLabel_);
playButton_ = new ImageSinkButton(playImage_, stopImage_, playImageFocused_);
playButton_->setBounds(ICON_WIDTH + PADDING + START_X, ICON_HEIGHT + START_Y + PADDING, ICON_WIDTH, ICON_HEIGHT);
add(playButton_);
backButton_ = new ImageButton(backImage_, backImageFocused_);
backButton_->setBounds(START_X, ICON_HEIGHT + START_Y + PADDING, ICON_WIDTH, ICON_HEIGHT);
add(backButton_);
forwardButton_ = new ImageButton(forwardImage_, forwardImageFocused_);
forwardButton_->setBounds(ICON_WIDTH * 2 + PADDING * 2 + START_X, ICON_HEIGHT + START_Y + PADDING, ICON_WIDTH, ICON_HEIGHT);
add(forwardButton_);
Strings icons;
icons.push_back(APPLICATION_DATA_DIR"/BAR0.JPG");
icons.push_back(APPLICATION_DATA_DIR"/BAR1.JPG");
icons.push_back(APPLICATION_DATA_DIR"/BAR2.JPG");
icons.push_back(APPLICATION_DATA_DIR"/BAR3.JPG");
icons.push_back(APPLICATION_DATA_DIR"/BAR4.JPG");
progressIcon_ = new ProgressIcon(icons, PROGRESS_SIZE, PROGRESS_SIZE);
progressIcon_->setBounds(ICON_WIDTH * 3 + PADDING * 3 + START_X, ICON_HEIGHT + START_Y + PADDING, PROGRESS_SIZE, PROGRESS_SIZE);
add(progressIcon_);
}
Position stringToHypergraph(Strings const& inputTokens, IMutableHypergraph<Arc>* pHgResult,
StringToHypergraphOptions const& opts = StringToHypergraphOptions(),
TokenWeights const& inputWeights = TokenWeights()) {
IVocabularyPtr const& pVoc = pHgResult->getVocabulary();
if (!pVoc) SDL_THROW_LOG(Hypergraph, InvalidInputException, "pHgResult hypergraph must contain vocabulary");
for (std::size_t i = 0, numNonlexicalStates = inputTokens.size() + 1; i < numNonlexicalStates; ++i)
pHgResult->addState();
pHgResult->setStart(0);
StateId prevState = 0;
typedef typename Arc::Weight Weight;
typedef FeatureInsertFct<Weight> FI;
Position i = 0, n = inputTokens.size();
for (; i != n; ++i) {
std::string const& token = inputTokens[i];
SDL_TRACE(Hypergraph.StringToHypergraph, i << ": " << token);
const Sym sym = opts.terminalMaybeUnk(pVoc.get(), token);
const StateId nextState = prevState + 1;
Arc* pArc = new Arc(nextState, Tails(prevState, pHgResult->addState(sym)));
Weight& weight = pArc->weight();
assert(opts.inputFeatures != NULL);
for (FeatureId featureId : opts.inputFeatures->getFeaturesForInputPosition(i)) {
FI::insertNew(&weight, featureId, 1);
if (opts.tokens) opts.tokens->insert(sym, featureId);
}
inputWeights.reweight(i, weight);
pHgResult->addArc(pArc);
prevState = nextState;
}
pHgResult->setFinal(prevState);
return n;
}
Strings PlayerInfoManager::GetPlayerNames() const
{
// TODO Sort strings in order of use, most recent first, i.e. descending order
typedef std::map<unsigned int, std::string, std::greater<unsigned int> > TimestampName;
TimestampName tn;
// Put names into map so they will be sorted, most recent first
for (PIMap::const_iterator it = m_map.begin(); it != m_map.end(); ++it)
{
unsigned int timestamp = it->second.first;
tn[timestamp] = it->first;
}
// Copy names in order into vector
Strings s;
for (TimestampName::const_iterator it = tn.begin(); it != tn.end(); ++it)
{
s.push_back(it->second);
}
// TODO something like
// std::copy(tn.begin, tn.end, std::back_inserter(s));
return s;
}
bool User_Program::Compile (string &text, bool list_flag)
{
Strings lines;
Str_Itr line_itr;
//---- split the text into lines ----
String_Ptr (text)->Parse (lines, "\n\r\f");
for (line_itr = lines.begin (); line_itr != lines.end (); line_itr++) {
line_num++;
if (list_flag) {
exe->Print (1, "\t") << *line_itr;
}
line_itr->Clean ();
if (line_itr->empty ()) continue;
if (declare_flag) {
if (!Initial_Declare (*line_itr)) break;
} else if (table_flag) {
if (!Initial_Table (*line_itr)) break;
} else {
while (Get_Token (*line_itr)) {
if (!Process_Token ()) break;
}
}
}
return (true);
}
co::ConnectionPtr _startLocalServer()
{
Strings dirNames;
dirNames.push_back( "" );
dirNames.push_back( "./" );
// Add path of current .so so search paths for EqualizerServer
#ifndef _WIN32
Dl_info dl_info;
dladdr((void *)_startLocalServer, &dl_info);
char libPath[1024];
strncpy(libPath, dl_info.dli_fname, 1024);
char* k = strrchr(libPath, '/');
*(k + 1) = '\0';
dirNames.push_back( libPath );
#endif
#ifdef EQ_BUILD_DIR
#ifdef NDEBUG
dirNames.push_back( std::string( EQ_BUILD_DIR ) + "libs/server/Release/" );
#else
dirNames.push_back( std::string( EQ_BUILD_DIR ) + "libs/server/Debug/" );
#endif
dirNames.push_back( std::string( EQ_BUILD_DIR ) + "libs/server/" );
#endif
#ifdef _MSC_VER
const std::string libName = "EqualizerServer.dll";
#elif defined (_WIN32)
const std::string libName = "libEqualizerServer.dll";
#elif defined (Darwin)
const std::string libName = "libEqualizerServer.dylib";
#else
const std::string libName = "libEqualizerServer.so";
#endif
while( !_libeqserver.isOpen() && !dirNames.empty( ))
{
_libeqserver.open( dirNames.back() + libName );
dirNames.pop_back();
}
if( !_libeqserver.isOpen( ))
{
EQWARN << "Can't open Equalizer server library" << std::endl;
return 0;
}
eqsStartLocalServer_t eqsStartLocalServer = (eqsStartLocalServer_t)
_libeqserver.getFunctionPointer( "eqsStartLocalServer" );
if( !eqsStartLocalServer )
{
EQWARN << "Can't find server entry function eqsStartLocalServer"
<< std::endl;
return 0;
}
return eqsStartLocalServer( Global::getConfigFile( ));
}
bool PlayerInfo::Load()
{
// FileExists doesn't append File::Root
if (FileExists(File::GetRoot() + m_filename))
{
#ifdef PI_DEBUG
std::cout << "Loading player info " << m_filename << "...\n";
#endif
}
else
{
#ifdef PI_DEBUG
std::cout << "Loading player info " << m_filename << " doesn't exist! - - it's a new file\n";
#endif
// We assume the player is new and has not saved any player info yet - this is OK.
return true;
}
#ifdef PI_DEBUG
std::cout << "Loading player info " << m_filename << "...\n";
#endif
File f;
if (!f.OpenRead(m_filename))
{
return false;
}
int num = 0;
if (!f.GetInteger(&num))
{
return false;
}
for (int i = 0; i < num; i++)
{
std::string s;
if (!f.GetDataLine(&s))
{
return false;
}
#ifdef PI_DEBUG
std::cout << " Got line: " << s << "\n";
#endif
Strings strs = Split(s, ',');
if (strs.size() != 2)
{
f.ReportError("Bad line in player info: " + s);
return false;
}
PISetString(strs[0], strs[1]);
}
#ifdef PI_DEBUG
std::cout << "End of player info load.\n";
#endif
return true;
}
// joining
String::String(Strings const& rList, String const& rSeparator) {
Strings::ConstIterator i_string;
for (i_string = rList.Begin(); i_string != rList.End(); i_string++) {
if (i_string != rList.Begin()) {
*this += rSeparator;
}
*this += *i_string;
}
}
Strings setup_from_argv(const Strings &iargv, std::string description,
std::string usage, int num_positional) {
char **argv = new char *[iargv.size()];
for (unsigned int i = 0; i < iargv.size(); ++i) {
argv[i] = const_cast<char *>(iargv[i].c_str());
}
return setup_from_argv(iargv.size(), &argv[0], description, usage,
num_positional);
}
void
ZStream::setZipFileSuffixes(Strings const& suffixes)
{
m_suffixes.clear();
m_suffixes.reserve(suffixes.size());
for (unsigned i = 0; i < suffixes.size(); ++i)
m_suffixes.push_back(suffixes[i].front() == '.' ? suffixes[i] : '.' + suffixes[i]);
}
// Find all strings
StringFinder::Strings
StringFinder::findAllStrings(MemoryMap::ConstConstraints where) const {
Strings retval;
while (Sawyer::Optional<String> string = findString(where)) {
retval.insert(string->address(), *string);
where = where.atOrAfter(string->address() + string->nBytes());
}
return retval;
}
void toHypergraph(std::string const& line, IMutableHypergraph<A>* phg, std::size_t lineNum = 0) const {
Strings words = parseTokens(line, (ParseTokensOptions const&)*this);
SDL_DEBUG(Hypergraph.HgConvertString, lineNum << ": " << printer(words, Util::RangeSep(" ", "", "")));
SDL_INFO(Hypergraph.HgConvertString, lineNum << ": len=" << words.size());
phg->clear(properties());
assert(phg->storesArcs());
assert(phg->getVocabulary());
stringToHypergraph(words, phg);
}
void CInPlaceList::UpdateText(const CString& text)
{
Strings strings;
SplitList(text, L"=", strings);
CString val = (strings.size() == 2)
? strings[0] : text;
SetWindowText(val);
}
const Strings
SqlSource::options() const
{
Strings options;
Strings k = keys();
for (size_t i = 0; i < k.size(); ++i)
if (!starts_with(k[i], _T("&")))
options.push_back(k[i]);
return options;
}
void FileUtils::close(Mapper * mapper) {
Strings * columnNames = mapper->getColumnNames();
for (Strings::iterator it = columnNames->begin(); it != columnNames->end();
++it) {
std::string columnName = *it;
BulkFileWriter * bulkFileWriter =
(*(mapper->getColumnsToWriters()))[columnName];
delete bulkFileWriter;
}
}
void AbstractAligner::align_block(Block* block) const {
TimeIncrementer ti(this);
if (!alignment_needed(block)) {
return;
}
Fragments fragments((block->begin()), block->end());
Strings rows;
BOOST_FOREACH (Fragment* f, fragments) {
rows.push_back(f->str(/* gap */ 0));
}
Strings getInstances() const
{
Strings instances;
for( InstanceMapCIter i = _instanceMap.begin();
i != _instanceMap.end(); ++i )
{
instances.push_back( i->first );
}
return instances;
}
static Strings split(const std::string &str, char delim)
{
Strings elems;
std::stringstream ss(str);
std::string item;
while(std::getline(ss, item, delim))
elems.push_back(item);
return elems;
}
//------------------------------------------------------------------------
MaterialTypes::Strings MaterialTypes::GetTypeNames() const
{
Strings result;
for( uint32_t i = 0, e = mEntries.Count(); i < e; i ++ )
{
result.push_back( mEntries[ i ].name.c_str() );
}
return result;
}
int String::Parse (Strings &result, const char *chars)
{
String element;
result.clear ();
while (Split (element, chars)) {
result.push_back (element);
}
return ((int) result.size ());
}
bool AbstractAligner::test(bool gaps) const {
Strings aln;
aln.push_back("AT");
aln.push_back(gaps ? "T" : "A");
try {
align_seqs(aln);
} catch (...) {
return false;
}
return aln[0] == "AT" && aln[1] == (gaps ? "-T" : "A-");
}
ProteinsAnchorsSamplingSpace get_part_of_sampling_space(
const ProteinsAnchorsSamplingSpace &prots_ss, const Strings &prot_names) {
ProteinsAnchorsSamplingSpace ret(multifit::get_partial_proteomics_data(
prots_ss.get_proteomics_data(), prot_names));
ret.set_anchors(prots_ss.get_anchors());
// add the paths
for (Strings::const_iterator it = prot_names.begin(); it != prot_names.end();
it++) {
ret.set_paths_for_protein(*it, prots_ss.get_paths_for_protein(*it));
}
return ret;
}
