bool addUnique(const std::shared_ptr<T> &o, std::vector<std::shared_ptr<T>> &list)
{
bool retry = false;
int dupeCount = 0;
std::string baseName = o->name();
if (baseName.empty())
return true;
for (int i = 1; !baseName.empty() && isdigit(baseName.back()); i *= 10, baseName.pop_back())
dupeCount += i*(baseName.back() - '0');
std::string newName = o->name();
do {
retry = false;
for (const std::shared_ptr<T> &m : list) {
if (m.get() == o.get())
return false;
if (m->name() == newName) {
newName = tfm::format("%s%d", baseName, ++dupeCount);
retry = true;
break;
}
}
} while (retry);
o->setName(newName);
list.push_back(o);
return true;
}
void unity_global::save_model(std::shared_ptr<model_base> model,
const std::string& model_wrapper,
const std::string& url) {
logstream(LOG_INFO) << "Save model to " << sanitize_url(url) << std::endl;
logstream(LOG_INFO) << "Model name: " << model->name() << std::endl;
try {
dir_archive dir;
dir.open_directory_for_write(url);
dir.set_metadata("contents", "model");
oarchive oarc(dir);
oarc.write(CLASS_MAGIC_HEADER, strlen(CLASS_MAGIC_HEADER));
oarc << model->name();
oarc << model_wrapper;
oarc << *model;
if (dir.get_output_stream()->fail()) {
std::string message = "Fail to write.";
log_and_throw_io_failure(message);
}
dir.close();
} catch (std::ios_base::failure& e) {
std::string message = "Unable to save model to " + sanitize_url(url) + ": " + e.what();
log_and_throw_io_failure(message);
} catch (std::string& e) {
log_and_throw(std::string("Unable to save model to ") + sanitize_url(url) + ": " + e);
} catch (...) {
log_and_throw(std::string("Unknown Error: Unable to save model to ") + sanitize_url(url));
}
}
Status SessionImpl::addRestraint(std::shared_ptr<gmxapi::MDModule> module)
{
GMX_ASSERT(runner_, "SessionImpl invariant implies valid Mdrunner handle.");
Status status {
false
};
if (module != nullptr)
{
const auto &name = module->name();
if (restraints_.find(name) == restraints_.end())
{
auto restraint = module->getRestraint();
if (restraint != nullptr)
{
restraints_.emplace(std::make_pair(name, restraint));
auto sessionResources = createResources(module);
if (!sessionResources)
{
status = false;
}
else
{
runner_->addPotential(restraint, module->name());
status = true;
}
}
}
}
return status;
}
Config::JobStatus Config::addJob(
std::shared_ptr<Job> job,
const Config* prev_config) {
auto p = jobs.emplace(job->name(), job);
if (!p.second) {
throw BistroException("Adding a job that already exists: ", job->name());
}
if (prev_config) {
auto it = prev_config->jobs.find(job->name());
if (it != prev_config->jobs.end()) {
auto new_d = job->toDynamic(*this);
// Slower than a dedicated comparator, but less likely to have bugs.
if (new_d == it->second->toDynamic(*prev_config)) {
return Config::JobStatus::UNCHANGED;
}
// This and the next log both seem useful for all config loaders.
LOG(INFO) << "Job " << job->name() << " was modified: "
<< folly::toJson(new_d);
return Config::JobStatus::UPDATED;
}
LOG(INFO) << "Job " << job->name() << " was added: "
<< folly::toJson(job->toDynamic(*this));
return Config::JobStatus::ADDED;
}
return Config::JobStatus::NEW_CONFIG;
}
void ParserRecord::addItem(std::shared_ptr< const ParserItem > item) {
if (m_dataRecord)
throw std::invalid_argument("Record is already marked as DataRecord - can not add items");
if (m_itemMap.find(item->name()) == m_itemMap.end()) {
m_items.push_back(item);
m_itemMap[item->name()] = item;
} else
throw std::invalid_argument("Itemname: " + item->name() + " already exists.");
}
int PropertyFS::compare(const std::shared_ptr<base::IProperty> &other) const {
int cmp = 0;
if (!name().empty() && !other->name().empty()) {
cmp = (name()).compare(other->name());
}
if (cmp == 0) {
cmp = id().compare(other->id());
}
return cmp;
}
void nl_convert_base_t::add_device(std::shared_ptr<dev_t> dev)
{
for (auto & d : m_devs)
if (d->name() == dev->name())
{
out("ERROR: Duplicate device {1} ignored.", dev->name());
return;
}
m_devs.push_back(dev);
}
void Context::removeVariable(std::shared_ptr<Variable> variable){
auto iter = variables.find(variable->name());
auto end = variables.end();
auto parent = m_parent;
while(iter == end){
iter = parent->variables.find(variable->name());
end = parent->variables.end();
parent = parent->m_parent;
}
variables.erase(iter);
}
void
Annotator::annotate(std::shared_ptr<ParamNode> node)
{
if (fPhase == kRegister) {
if (!fScope->checkForRedefinition(node->srcpos(),
Scope::kNormal, node->name()))
fScope->registerVar(node->srcpos(), node->name(), node);
}
if (node->initExpr()) {
node->initExpr()->setIsSingleTypeRequired(true);
annotateNode(node->initExpr());
}
}
std::shared_ptr<ListItemController> createListItemController(std::shared_ptr<ListBoxController> container, std::shared_ptr<ListItem> listItem) {
std::shared_ptr<ListItemController> controller;
if (listItem->getType() == "TextListItem") {
auto textListItem = std::dynamic_pointer_cast<TextListItem>( listItem );
if (!textListItem) {
throw Error( "Can not create list-item '" + listItem->name() + "'" );
}
controller = createTextListItemController (container, textListItem);
} else {
throw Error( "Can not create list-item '" + listItem->name() + "' unknown type '" + listItem->getType() + "'" );
}
return controller;
}
void MidiRouter::addDevice(std::shared_ptr<MidiDevice> device) {
_deviceNameToId[device->name()] = device->id();
_devices[device->id()] = device;
device->messageReceived += [&](MidiReceivedEventArgs& event) {
onInputMessage(event);
};
}
// return rate/sec
size_t bench_as(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
{
cout << log->name() << "...\t\t" << flush;
std::atomic<int> msg_counter{0};
vector<thread> threads;
auto start = system_clock::now();
for (int t = 0; t < thread_count; ++t)
{
threads.push_back(std::thread([&]() {
for (;;)
{
int counter = ++msg_counter;
if (counter > howmany)
break;
log->info("Hello logger: msg number {}", counter);
}
}));
}
for (auto &t : threads)
{
t.join();
}
auto delta = system_clock::now() - start;
auto delta_d = duration_cast<duration<double>>(delta).count();
auto per_sec = size_t(howmany / delta_d);
cout << format(per_sec) << "/sec" << endl;
return per_sec;
}
void
TransitionEditorWindow::on_pointsTable_currentItemChanged(QTableWidgetItem* current, QTableWidgetItem* /*previous*/)
{
if (model_ == nullptr) return;
if (transition_ == nullptr) return;
if (current == nullptr) return;
int row = ui_->pointsTable->row(current);
qDebug("on_pointsTable_currentItemChanged row=%d", row);
ui_->transitionWidget->setSelectedPointIndex(row);
const std::shared_ptr<TRMControlModel::Equation> timeExpression(pointList_[row].timeExpression.lock());
if (timeExpression) {
unsigned int groupIndex;
unsigned int equationIndex;
if (model_->findEquationIndex(timeExpression->name(), groupIndex, equationIndex)) {
QTreeWidgetItem* topLevelItem = ui_->equationsTree->topLevelItem(groupIndex);
if (topLevelItem == nullptr) {
qCritical("[TransitionEditorWindow::on_pointsTable_currentItemChanged]: Invalid group index: %u.", groupIndex);
return;
}
QTreeWidgetItem* item = topLevelItem->child(equationIndex);
if (item == nullptr) {
qCritical("[TransitionEditorWindow::on_pointsTable_currentItemChanged]: Invalid index: %u for groupIndex: %u.", equationIndex, groupIndex);
return;
}
ui_->equationsTree->setCurrentItem(item);
}
} else {
ui_->equationsTree->setCurrentItem(nullptr);
}
}
void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
{
using namespace std::chrono;
using chrono::high_resolution_clock;
using chrono::milliseconds;
using chrono::nanoseconds;
cout << log->name() << "...\t\t" << flush;
vector<thread> threads;
std::atomic<nanoseconds::rep> total_nanos{0};
for (int t = 0; t < thread_count; ++t)
{
threads.push_back(std::thread([&]() {
for (int j = 0; j < howmany / thread_count; j++)
{
auto start = high_resolution_clock::now();
log->info("Hello logger: msg number {}", j);
auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
total_nanos += delta_nanos.count();
}
}));
}
for (auto &t : threads)
{
t.join();
};
auto avg = total_nanos / howmany;
cout << format(avg) << " ns/call" << endl;
}
void ObjectManager::update_player_state(std::shared_ptr<IObject>& object,
PlayerState& player_state)
{
assert(object->type() == ObjType::player);
// Get the player number from the name
std::string name = object->name();
int player_id = name[name.length() - 1] - (int)'0';
player_state.set_energy(player_id, object->energy());
player_state.set_energy_max(player_id, object->energy_max());
player_state.set_score(player_id, object->score());
//Ship* s = (Ship*)object;
std::shared_ptr<Ship> s = std::dynamic_pointer_cast<Ship>(object);
if (s->main_weapon_) {
player_state.set_main_weapon(player_id, s->main_weapon_->name);
player_state.set_main_weapon_level(player_id, s->main_weapon_->level());
}
if (s->extra_weapon_) {
player_state.set_extra_weapon(player_id, s->extra_weapon_->name);
player_state.set_extra_weapon_count(player_id, s->extra_weapon_->count());
} else player_state.set_extra_weapon(player_id, "none");
if (object->energy() == 0)
player_state.set_energy_max(player_id, 0);
}
void OutputFile::add_type(const std::shared_ptr<Type>& t)
{
auto name = t->name();
if (type_ptrs_.count(name) == 0)
{
type_ptrs_[name] = t;
}
}
void Scene :: deserialize_node(std::shared_ptr<Node>& node, const std::shared_ptr<Meta>& doc)
{
string name = doc->at<string>("name", string());
node->name(name);
auto mat = doc->at<shared_ptr<Meta>>("matrix");
*node->matrix() = deserialize_matrix(mat);
}
void
MooseApp::addRelationshipManager(std::shared_ptr<RelationshipManager> relationship_manager)
{
auto name = relationship_manager->name();
if (hasRelationshipManager(name))
mooseError("Duplicate RelationshipManager added: \"", name, "\"");
_relationship_managers.emplace_back(relationship_manager);
}
void saveXMLFile(std::shared_ptr<XMLElement> rootElement, const char *filename, const char *dtdFilename) {
assert(filename != nullptr);
assert(rootElement.get() != nullptr);
ofstream file(filename, ios::out | ios::trunc);
file << "<?xml version=\"1.0\"?>" << endl;
if (dtdFilename != nullptr) {
file << "<!DOCTYPE " << rootElement->name() << " SYSTEM \"" << dtdFilename << "\">" << std::endl;
}
file << rootElement->toString();
}
void GroupTree::printTree(std::ostream &os , std::shared_ptr< GroupTreeNode > fromNode) const {
os << fromNode->name() << "(" << fromNode.get() << ")";
std::map<std::string, std::shared_ptr< GroupTreeNode > >::const_iterator iter = fromNode->begin();
while (iter != fromNode->end()) {
const auto& child = (*iter).second;
os << "<-" << child->name() << "(" << child.get() << ")" << std::endl;
printTree(os , child);
++iter;
}
}
void cs6300::SymbolTable::addParameter(std::string id,
std::shared_ptr<Type> type)
{
auto found = m_variables.find(id);
if (found == m_variables.end())
{
LOG(DEBUG) << "adding parameter " << id << "::" << type->name();
m_variables[id] = std::make_shared<Symbol>(id, type, m_param_offset, FRAME);
m_param_offset += type->size();
}
}
void dictionary_entry_formatter::write_phoneme_entry(const std::shared_ptr<cainteoir::buffer> &word,
std::shared_ptr<tts::phoneme_writer> &writer,
const std::list<tts::phoneme> &phonemes,
const char *line_separator)
{
fprintf(stdout, "\"%s\" => /", word->str().c_str());
for (auto p : phonemes)
writer->write(p);
writer->flush();
fprintf(stdout, "/ [%s]%s", writer->name(), line_separator);
}
void
state_machine_t::migrate(std::shared_ptr<state_t> desired) {
BOOST_ASSERT(desired);
state.apply([=](std::shared_ptr<state_t>& state){
COCAINE_LOG_DEBUG(log, "slave has changed its state from '%s' to '%s'",
state ? state->name() : "null", desired->name()
);
state = std::move(desired);
});
}
void cs6300::SymbolTable::addVariable(std::string id,
std::shared_ptr<Type> type)
{
auto found = m_variables.find(id);
if (found == m_variables.end())
{
LOG(DEBUG) << "adding variable " << id << "::" << type->name();
m_variables[id] =
std::make_shared<Symbol>(id, type, m_memory_offset, m_memorylocation);
m_memory_offset += type->size();
}
}
void
Annotator::annotate(std::shared_ptr<FuncDefNode> node, bool isLocal)
{
if (fPhase == kRegister) {
if (isLocal) {
fScope->registerFunction(node->srcpos(), node->name(), node);
}
else if (node->isMethod()) {
auto var = node->scope()->lookupVarOrFunc(node->name(),
K(showAmbiguousSymDef));
if (!var) {
errorf(node->srcpos(), E_NoGenericFunction,
"No generic function definition found for method");
}
else if (auto funcdef = dynamic_cast<const FuncDefNode*>(var)) {
if (!funcdef->isGeneric()) {
errorf(node->srcpos(), E_BadGenericReferrer,
"Bad method binding type (referred symbol is not a generic function).");
errorf(var->srcpos(), E_BadGenericReferrer,
"Referred function definition was here");
}
}
else {
errorf(node->srcpos(), E_BadGenericReferrer,
"Bad method binding type (referred symbol is not a generic function).");
errorf(var->srcpos(), E_BadGenericReferrer,
"Referred symbol definition was here");
}
}
}
ScopeHelper scopeHelper(fScope, !K(doExport), K(isInnerScope),
kScopeL_Function);
annotateNodeList(node->params(), !K(markTailPos), K(markSingleType));
if (node->body()) {
node->body()->setIsInTailPos(true);
annotateNode(node->body());
}
}
Node::Node (const Point<float>& com, const size_t vol, const size_t pixheight, std::shared_ptr< MR::Image::BufferScratch<bool> >& image) :
centre_of_mass (com),
volume (vol),
mask (image),
name (image->name()),
size (1.0f),
colour (0.5f, 0.5f, 0.5f),
alpha (1.0f),
visible (true),
pixmap (pixheight, pixheight)
{
pixmap.fill (QColor (128, 128, 128));
}
bool Module::initializeBase(std::shared_ptr<ModuleWrapper> wrapper,
logging::Level minLogLevel) {
m_datamanager = &wrapper->runtime()->dataManager();
m_executionManager = &wrapper->runtime()->executionManager();
m_messaging = &m_executionManager->messaging();
m_wrapper = wrapper;
logger.name = wrapper->runtime()->name() + "." + wrapper->name();
logger.threshold = minLogLevel;
return true;
}
void ExpressionFactory::registerExpression(std::shared_ptr<Expression> expr) {
if (!expr) {
LOG(ERROR) << "registered expression is NULL";
return;
}
exprs.insert(std::make_pair(expr->name(), expr));
auto alias = expr->alias();
if (alias) {
auto len = sizeof(alias) / sizeof(std::string);
for (int i = 0; i < len; ++ i) {
exprs.insert(std::make_pair(alias[i], expr));
}
}
}
std::shared_ptr< GroupTreeNode > GroupTree::getNode(const std::string& nodeName, std::shared_ptr< GroupTreeNode > current) const {
if (current->name() == nodeName) {
return current;
} else {
std::map<std::string, std::shared_ptr< GroupTreeNode >>::const_iterator iter = current->begin();
while (iter != current->end()) {
std::shared_ptr< GroupTreeNode > result = getNode(nodeName, (*iter).second);
if (result) {
return result;
}
++iter;
}
return std::shared_ptr< GroupTreeNode >();
}
}
std::shared_ptr< GroupTreeNode > GroupTree::getParent(const std::string& childName, std::shared_ptr< GroupTreeNode > currentChild, std::shared_ptr< GroupTreeNode > parent) const {
if (currentChild->name() == childName) {
return parent;
} else {
std::map<std::string, std::shared_ptr< GroupTreeNode >>::const_iterator iter = currentChild->begin();
while (iter != currentChild->end()) {
std::shared_ptr< GroupTreeNode > result = getParent(childName, (*iter).second, currentChild);
if (result) {
return result;
}
++iter;
}
return std::shared_ptr< GroupTreeNode >();
}
}
