void HeartbeatInvoker::invoke(const InvokeRequest& req) {
_invokeId = req.invokeid;
_event.invokeid = _invokeId;
std::string intervalStr;
double interval = 0;
unsigned long intervalMs = 0;
InvokeRequest::params_t::const_iterator paramIter = req.params.begin();
while(paramIter != req.params.end()) {
if (iequals(paramIter->first, "interval")) {
intervalStr = paramIter->second.atom;
NumAttr intervalAttr(paramIter->second.atom);
interval = strTo<double>(intervalAttr.value);
if (false) {
} else if (iequals(intervalAttr.unit, "s")) {
intervalMs = interval * 1000;
} else if (iequals(intervalAttr.unit, "ms")) {
intervalMs = interval;
} else {
intervalMs = interval;
}
}
if (iequals(paramIter->first, "eventname")) {
_event.name = paramIter->second.atom;
}
paramIter++;
}
if (_event.name.length() == 0)
_event.name = std::string("heartbeat." + intervalStr);
if (intervalMs > 0) {
HeartbeatDispatcher::getInstance()->addEvent(toStr(this), HeartbeatInvoker::dispatch, intervalMs, this, true);
}
}
//
// W_GetIWADInfo
//
// Helper function that returns a pointer to the appropriate entry of
// doomwadnames for a given file name if it is an IWAD.
// Returns NULL if the given file name is not an IWAD.
//
static const gamewadinfo_t* W_GetIWADInfo(const std::string& filename, const std::string& hash)
{
if (filename.empty())
return NULL;
// find our match if there is one
for (size_t i = 0; !doomwadnames[i].name.empty(); i++)
{
if (!hash.empty())
{
// hash comparison
for (size_t j = 0; !doomwadnames[i].hash[j].empty(); j++)
{
// the hash is always right! even if the name is wrong..
if (iequals(hash, doomwadnames[i].hash[j]))
return &doomwadnames[i];
}
}
else
{
std::string base_filename, base_iwadname;
M_ExtractFileBase(filename, base_filename);
M_ExtractFileBase(doomwadnames[i].name, base_iwadname);
if (iequals(filename, doomwadnames[i].name) ||
iequals(base_filename, base_iwadname))
return &doomwadnames[i];
}
}
return NULL;
}
inline bool lexical_cast(const char * str)
{
Assert(str != NULL);
if (iequals(str, "true") || iequals(str, "yes") || equals(str, "1")) {
return true;
}
return false;
}
/**
* The constructor needs to scan the whole PTX file to find out the bounding box. Unluckily.
* TODO: during the scan all the points are read and transformed. Afterwards, during loading
* the points are read again and transformed again. It should be nice to save the
* transformed points in a temporary file. That would mean a LAS file or something similar.
* Unuseful. It's better to convert the PTX to LAS files.
* TODO: it seems theat the PTXPointReader is asked to produce the bounding box more than once.
* Maybe it should be saved somewhere. Chez moi, scanning 14m points needs 90 secs. The
* process speed of the PTX file is about 1m points every 50 secs.
*/
PTXPointReader::PTXPointReader(string path) {
this->path = path;
if (fs::is_directory(path)) {
// if directory is specified, find all ptx files inside directory
for (fs::directory_iterator it(path); it != fs::directory_iterator(); it++) {
fs::path filepath = it->path();
if (fs::is_regular_file(filepath)) {
if (iequals(fs::extension(filepath), ".ptx")) {
files.push_back(filepath.string());
}
}
}
} else {
files.push_back(path);
}
// open first file
this->currentFile = files.begin();
this->stream = new fstream(*(this->currentFile), ios::in);
this->currentChunk = 0;
skipline(*this->stream);
loadChunk(this->stream, this->currentChunk, this->tr);
}
static UString findSubDirectory_internal(const UString &directory, const UString &subDirectory,
bool caseInsensitive) {
try {
path dirPath(directory.c_str());
path subDirPath(subDirectory.c_str());
// Iterator over the directory's contents
directory_iterator itEnd;
for (directory_iterator itDir(dirPath); itDir != itEnd; ++itDir) {
if (is_directory(itDir->status())) {
// It's a directory. Check if it's the one we're looking for
if (caseInsensitive) {
if (iequals(itDir->path().filename(), subDirectory.c_str()))
return itDir->path().string();
} else {
if (equals(itDir->path().filename(), subDirectory.c_str()))
return itDir->path().string();
}
}
}
} catch (...) {
}
return "";
}
void CaseInsensitiveHashTable<T>::add_index(T* entry) {
size_t h = fnv1a_hash_lower(entry->name) & index_mask_;
if (index_[h] == NULL) {
index_[h] = entry;
} else {
// Use linear probing to find an open bucket
size_t start = h;
while (index_[h] != NULL && !iequals(entry->name, index_[h]->name)) {
h = (h + 1) & index_mask_;
if (h == start) {
return;
}
}
if (index_[h] == NULL) {
index_[h] = entry;
} else {
T* curr = index_[h];
while (curr->next != NULL) {
curr = curr->next;
}
curr->next = entry;
}
}
}
void FFMPEGInvoker::process(const SendRequest& req) {
std::string context;
Event::getParam(req.params, "context", context);
if (_encoders.find(context) == _encoders.end()) {
return;
}
EncodingContext* ctx = _encoders[context];
tthread::lock_guard<tthread::recursive_mutex> lock(ctx->mutex);
// finish encoding and return
if(iequals(req.name, "render.end")) {
finish(ctx, req);
delete _encoders[context];
_encoders.erase(context);
}
Data image;
Event::getParam(req.params, "frame", image);
if (image.empty()) {
return;
}
std::string format = "bmp";
Event::getParam(req.params, "format", format);
writeVideoFrame(ctx, ctx->formatCtx, ctx->videoStream, image.binary);
ctx->frame->pts += av_rescale_q(1, ctx->videoStream->codec->time_base, ctx->videoStream->time_base);
}
Globals::Globals(TiXmlElement *root)
:
nodeCounter(-1),
linkCounter(-1),
speciesCounter(-1)
{
cout << "Populating sigmoid table...";
for (int a=0; a<6001; a++)
{
signedSigmoidTable[a] = ((1 / (1+exp(-((a-3000)/1000.0)))) - 0.5)*2.0;
unsignedSigmoidTable[a] = 1 / (1+exp(-((a-3000)/1000.0)));
}
cout << "done!\n";
TiXmlAttribute *firstAttribute = root->FirstAttribute();
while (firstAttribute)
{
if (iequals(firstAttribute->Name(),"NodeCounter"))
{
nodeCounter = firstAttribute->IntValue();
}
else if (iequals(firstAttribute->Name(),"LinkCounter"))
{
linkCounter = firstAttribute->IntValue();
}
else if (iequals(firstAttribute->Name(),"SpeciesCounter"))
{
speciesCounter = firstAttribute->IntValue();
}
else
{
addParameter( firstAttribute->Name() , firstAttribute->DoubleValue());
}
firstAttribute = firstAttribute->Next();
}
if (nodeCounter==-1 || linkCounter==-1 || speciesCounter==-1)
{
throw CREATE_LOCATEDEXCEPTION_INFO("MALFORMED XML!");
}
cacheParameters();
initRandom();
}
BufferRef HttpRequest::requestHeader(const std::string& name) const
{
for (auto& i: requestHeaders)
if (iequals(i.name, name))
return i.value;
return BufferRef();
}
void book_author_search()
{
cout << "Enter the book's author:" << endl;
string name;
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');
getline(cin, name);
Category *tmp1 = beginning;
Book *tmp;
vector <Book *> list;
system("CLS");
cout << "Searching..." << endl;
int i = 0;
while (tmp1 != NULL)
{
tmp = tmp1->getHead();
while (tmp != NULL)
{
if (iequals(tmp->getAuthor(), name))
{
list.push_back(tmp);
i++;
cout << "Result no." << i << endl;
tmp->print();
}
tmp = tmp->getNext();
}
tmp1 = tmp1->getNext();
}
if (i == 0)
{
system("CLS");
cout << "No such ID was found." << endl;
cout << "Please try again" << endl;
}
else
{
cout << "Which of the results do you want to manage? (enter a number)" << endl;
stahp();
int ch;
cin >> ch;
ch--;
if (ch > 49 || list[ch] == NULL)
{
cout << "Invalid response. Please start again." << endl;
}
else
book_menu(list[ch]);
}
}
bool HttpConnection::onMessageHeader(const BufferRef& name, const BufferRef& value)
{
if (request_->isFinished()) {
// this can happen when the request has failed some checks and thus,
// a client error message has been sent already.
// we need to "parse" the remaining content anyways.
TRACE("onMessageHeader() skip \"%s\": \"%s\"", name.str().c_str(), value.str().c_str());
return true;
}
TRACE("onMessageHeader() \"%s\": \"%s\"", name.str().c_str(), value.str().c_str());
if (iequals(name, "Host")) {
auto i = value.find(':');
if (i != BufferRef::npos)
request_->hostname = value.ref(0, i);
else
request_->hostname = value;
TRACE(" -- hostname set to \"%s\"", request_->hostname.str().c_str());
} else if (iequals(name, "Connection")) {
if (iequals(value, "close"))
setShouldKeepAlive(false);
else if (iequals(value, "keep-alive"))
setShouldKeepAlive(true);
}
// limit the size of a single request header
if (name.size() + value.size() > worker().server().maxRequestHeaderSize()) {
TRACE("header too long. got %ld / %ld", name.size() + value.size(), worker().server().maxRequestHeaderSize());
request_->status = HttpError::RequestEntityTooLarge;
request_->finish();
return false;
}
// limit the number of request headers
if (request_->requestHeaders.size() > worker().server().maxRequestHeaderCount()) {
TRACE("header count exceeded. got %ld / %ld", request_->requestHeaders.size(), worker().server().maxRequestHeaderCount());
request_->status = HttpError::RequestEntityTooLarge;
request_->finish();
return false;
}
request_->requestHeaders.push_back(HttpRequestHeader(name, value));
return true;
}
XPathFunction<std::string>*
XPathFunctionResolver::resolveFunction(const std::string& namespace_uri,
const std::string& name,
const std::vector<XPathExpression<std::string> >& argExprs) const {
if (iequals(name, "in")) {
return new XPathFunctionIn(1, -1, argExprs, _interpreter);
}
return _xpathFuncRes.resolveFunction(namespace_uri, name, argExprs);
}
xcc_units::t_unit_data_entry* xcc_units::get_id(const string& s)
{
for (auto& ud : unit_data)
{
if (ud.flags & ud_flags_in_use && iequals(ud.short_name, s))
return &ud;
}
assert(false);
return NULL;
}
void FetchElement::enterElement(const Arabica::DOM::Element<std::string>& node) {
if (!HAS_ATTR(node, "src") && !HAS_ATTR(node, "srcexpr")) {
LOG(ERROR) << "Fetch element requires src or srcexpr";
return;
}
if (HAS_ATTR(node, "srcexpr") && !_interpreter->getDataModel()) {
LOG(ERROR) << "Fetch element with srcexpr requires datamodel";
return;
}
_source = (HAS_ATTR(node, "src") ? ATTR(node, "src") : _interpreter->getDataModel().evalAsString(ATTR(node, "srcexpr")));
if (!HAS_ATTR(node, "callback") && !HAS_ATTR(node, "callbackexpr")) {
LOG(ERROR) << "Fetch element requires callback or callbackexpr";
return;
}
if (HAS_ATTR(node, "callbackexpr") && !_interpreter->getDataModel()) {
LOG(ERROR) << "Fetch element with callbackexpr requires datamodel";
return;
}
_callback = (HAS_ATTR(node, "callback") ? ATTR(node, "callback") : _interpreter->getDataModel().evalAsString(ATTR(node, "callbackexpr")));
_type = (HAS_ATTR(node, "type") ? ATTR(node, "type") : "text");
if (!iequals(_type, "text") &&
!iequals(_type, "url") &&
!iequals(_type, "json") &&
!iequals(_type, "xml")) {
LOG(ERROR) << "Fetch element type attribute not one of text, url, json, xml.";
return;
}
_targetUrl = URL(_source);
if (!_targetUrl.isAbsolute()) {
if (!_targetUrl.toAbsolute(_interpreter->getBaseURL(node))) {
LOG(ERROR) << "Cannot transform " << _source << " into absolute URL";
return;
}
}
_targetUrl.addMonitor(this);
URLFetcher::fetchURL(_targetUrl);
}
void MChannelRuleMapList::Add(const StringView& strMapName)
{
for (int i = 0; i < MMATCH_MAP_MAX; i++)
{
if (iequals(strMapName, g_MapDesc[i].szMapName))
{
Add(i);
return;
}
}
}
bool FullMatch(const std::string& a, const std::string& b, bool icase)
{
if (icase)
{
return a == b? true : false;
}
else
{
return iequals(a,b);
}
}
void FetchElement::downloadCompleted(const URL& url) {
Event event;
event.name = _callback;
std::string content = url.getInContent();
std::map<std::string, std::string> headerFields = url.getInHeaderFields();
if (false) {
} else if (iequals(_type, "text")) {
event.data.atom = content;
event.data.type = Data::VERBATIM;
} else if (iequals(_type, "url")) {
} else if (iequals(_type, "json")) {
event.data = Data::fromJSON(content);
} else if (iequals(_type, "xml")) {
event = Event::fromXML(content);
}
_interpreter->receive(event);
}
GeneticNodeGene* GeneticIndividual::getNode(const string &name)
{
for(int a=0;a<(int)nodes.size();a++)
{
if(iequals(nodes[a].getName(),name))
{
return &nodes[a];
}
}
return NULL;
}
void TileData::loadFromFile(string line, FormattedFileIterator &iter)
{
while(!equals(line, "|"))
{
if(iequals(TileDataPropertyNames[FOOD_VALUE], line))
{
setFoodValue(lexical_cast<float>(*iter)); ++iter;
}
else if(iequals(TileDataPropertyNames[REGROWTH_VALUE], line))
{
setRegrowthRate(lexical_cast<float>(*iter)); ++iter;
}
else if(iequals(TileDataPropertyNames[MAX_FOOD_VALUE], line))
{
setMaxFoodValue(lexical_cast<float>(*iter)); ++iter;
}
line = *iter;
++iter;
}
}
// default "info" if unrecognized
el::Level
Logging::getLLfromString(std::string const& levelName)
{
if (iequals(levelName, "trace"))
{
return el::Level::Trace;
}
if (iequals(levelName, "debug"))
{
return el::Level::Debug;
}
if (iequals(levelName, "warning"))
{
return el::Level::Warning;
}
if (iequals(levelName, "fatal"))
{
return el::Level::Fatal;
}
if (iequals(levelName, "error"))
{
return el::Level::Error;
}
if (iequals(levelName, "none"))
{
return el::Level::Unknown;
}
return el::Level::Info;
}
void ExperimentRun::createPopulation(string populationString)
{
cout<<"createPopulation: "<<populationString<<endl;
if (iequals(populationString,""))
{
int popSize = (int)NEAT::Globals::getSingleton()->getParameterValue("PopulationSize");
population = shared_ptr<NEAT::GeneticPopulation>(experiments[currentSubExperiment]->createInitialPopulation(popSize));
}
else
{
population = shared_ptr<NEAT::GeneticPopulation>(new NEAT::GeneticPopulation(populationString));
}
}
DevicePtr ColladaBodyLoaderImpl::createSensor(DaeSensor* sensor)
{
DevicePtr device;
if (sensor->type.size() <= 0) {
device = new RateGyroSensor;
} else
if (iequals(sensor->type, "base_force6d")) {
device = new ForceSensor;
} else
if (iequals(sensor->type, "base_imu")) {
device = new AccelerationSensor;
} else
if (iequals(sensor->type, "base_pinhole_camera")) {
device = new Camera;
Camera* camera = static_cast<Camera*>(device.get());
camera->setResolution(sensor->imageDimensions[0], sensor->imageDimensions[1]);
camera->setNearDistance(sensor->focalLength);
camera->setFieldOfView (sensor->focalLength);
} else {
throwException((format(_("invalid sensor-type:%1%")) % sensor->type).str());
}
return device;
}
bool CAR_DKW_o::SetAsFixed(const TDenseVector &v, const std::string &which_one)
{
TIndex local_fixed_index;
int offset;
if (iequals(which_one, std::string("delta_options")) )
{
offset = CAR_DKW::NumberParameters();
local_fixed_index = FixedVariableParameter(delta_options, v, offset);
FixedIndex.UniqMerge(local_fixed_index);
if_variable_index_set = false;
return true;
}
else
return CAR_DKW::SetAsFixed(v, which_one);
}
/** callback, invoked on every successfully parsed response header.
*
* We will pass this header directly to the client's response,
* if that is NOT a connection-level header.
*/
bool HttpProxy::ProxyConnection::onMessageHeader(const BufferRef& name, const BufferRef& value)
{
TRACE("ProxyConnection(%p).onHeader('%s', '%s')", (void*)this, name.str().c_str(), value.str().c_str());
// XXX do not allow origin's connection-level response headers to be passed to the client.
if (iequals(name, "Connection"))
goto skip;
if (iequals(name, "Transfer-Encoding"))
goto skip;
if (cloak_ && iequals(name, "Server")) {
TRACE("skipping \"Server\"-header");
goto skip;
}
request_->responseHeaders.push_back(name.str(), value.str());
return true;
skip:
TRACE("skip (connection-)level header");
return true;
}
bool InterpreterDraft6::isWithinParallel(const Node<std::string>& transition) {
if (isTargetless(transition))
return false;
Node<std::string> source;
if (HAS_ATTR(transition, "type") && iequals(ATTR(transition, "type"), "internal")) {
source = getSourceState(transition);
} else {
source = getSourceState(transition).getParentNode();
}
NodeSet<std::string> targets = getTargetStates(transition);
targets.push_back(source);
Node<std::string> lcpa = findLCPA(targets);
return lcpa;
}
void cat_name_search()
{
cout << "Enter the category's name:" << endl;
string name;
cin >> name;
Category *tmp = beginning;
vector <Category *> list;
int ch, i = 0;
system("CLS");
cout << "Searching..." << endl;
while (tmp != NULL)
{
if (iequals(tmp->getName(), name))
{
list.push_back(tmp);
i++;
cout << "Result no." << i << endl;
tmp->print();
}
tmp = tmp->getNext();
}
if (i == 0)
{
system("CLS");
cout << "No such name was found." << endl;
cout << "Please try again." << endl;
}
else
{
cout << "Which of the categories do you want to manage? (enter a number)" << endl;
cin >> ch;
ch--;
if (ch > 49 || list[ch] == NULL)
{
cout << "Invalid response. Please start again." << endl;
}
else
cat_menu(list[ch]);
}
}
cvar_t *cvar_t::FindCVar (const char *var_name, cvar_t **prev)
{
cvar_t *var;
if (var_name == NULL)
return NULL;
var = ad.GetCVars();
*prev = NULL;
while (var)
{
if (iequals(var->m_Name, var_name))
break;
*prev = var;
var = var->m_Next;
}
return var;
}
bool MChannelRuleMapList::Exist(const StringView& pszMapName, bool bOnlyDuel)
{
for (auto itor = m_Set.begin(); itor != m_Set.end(); ++itor)
{
int id = (*itor);
if ((id >= 0) && (id < MMATCH_MAP_MAX))
{
if (iequals(pszMapName, g_MapDesc[id].szMapName))
{
if ( !bOnlyDuel && g_MapDesc[id].bOnlyDuelMap)
return false;
return true;
}
}
}
return false;
}
size_t CaseInsensitiveHashTable<T>::get_indices(StringRef name, IndexVec* result) const {
result->clear();
bool is_case_sensitive = false;
if (name.size() > 0 && name.front() == '"' && name.back() == '"') {
is_case_sensitive = true;
name = name.substr(1, name.size() - 2);
}
size_t h = fnv1a_hash_lower(name) & index_mask_;
size_t start = h;
while (index_[h] != NULL && !iequals(name, index_[h]->name)) {
h = (h + 1) & index_mask_;
if (h == start) {
return 0;
}
}
const T* entry = index_[h];
if (entry == NULL) {
return 0;
}
if (!is_case_sensitive) {
while (entry != NULL) {
result->push_back(entry->index);
entry = entry->next;
}
} else {
while (entry != NULL) {
if (name.equals(entry->name)) {
result->push_back(entry->index);
}
entry = entry->next;
}
}
return result->size();
}
void XPathDataModel::assign(const NodeSet<std::string>& key,
const std::string& value,
const Element<std::string>& assignElem) {
if (key.size() == 0)
return;
for (size_t i = 0; i < key.size(); i++) {
Node<std::string> node = key[i];
switch (node.getNodeType()) {
case Node_base::ATTRIBUTE_NODE: {
Attr<std::string> attr(node);
attr.setValue(value);
break;
}
case Node_base::TEXT_NODE: {
Text<std::string> text(node);
text.setNodeValue(value);
break;
}
case Node_base::ELEMENT_NODE: {
Element<std::string> element(node);
if (HAS_ATTR(assignElem, "type") && iequals(ATTR(assignElem, "type"), "addattribute")) {
// addattribute: Add an attribute with the name specified by 'attr'
// and value specified by 'expr' to the node specified by 'location'.
if (!HAS_ATTR(assignElem, "attr"))
ERROR_EXECUTION_THROW("Assign element is missing 'attr'");
element.setAttribute(ATTR(assignElem, "attr"), value);
} else {
/// test 547
while(element.hasChildNodes())
element.removeChild(element.getChildNodes().item(0));
Text<std::string> text = _doc.createTextNode(value);
element.appendChild(text);
}
break;
}
default:
ERROR_EXECUTION_THROW("Unsupported node type with assign");
break;
}
}
}
