Engine* Engine::get_instance()
{
if (Engine::instance_ == nullptr) {
- auto e = new Engine(0, nullptr);
+ auto e = new Engine(nullptr, nullptr);
xbt_assert(Engine::instance_ == e);
}
return Engine::instance_;
* See also: :ref:`platform`.
* \endrst
*/
-void Engine::load_platform(const std::string& platf)
+void Engine::load_platform(const std::string& platf) const
{
double start = xbt_os_time();
parse_platform_file(platf);
XBT_DEBUG("PARSE TIME: %g", (end - start));
}
-void Engine::register_function(const std::string& name, int (*code)(int, char**)) // deprecated
+void Engine::register_function(const std::string& name, int (*code)(int, char**)) // XBT_ATTRIB_DEPRECATED_v329
{
kernel::actor::ActorCodeFactory code_factory = [code](std::vector<std::string> args) {
return xbt::wrap_main(code, std::move(args));
};
register_function(name, std::move(code_factory));
}
-void Engine::register_default(int (*code)(int, char**)) // deprecated
+void Engine::register_default(int (*code)(int, char**)) // XBT_ATTRIB_DEPRECATED_v329
{
register_default([code](std::vector<std::string> args) { return xbt::wrap_main(code, std::move(args)); });
}
* See also: :ref:`deploy`.
* \endrst
*/
-void Engine::load_deployment(const std::string& deploy)
+void Engine::load_deployment(const std::string& deploy) const
{
pimpl->load_deployment(deploy);
}
/** Returns the amount of hosts in the platform */
-size_t Engine::get_host_count()
+size_t Engine::get_host_count() const
{
return pimpl->hosts_.size();
}
-std::vector<Host*> Engine::get_all_hosts()
+std::vector<Host*> Engine::get_all_hosts() const
{
std::vector<Host*> res;
for (auto const& kv : pimpl->hosts_)
return res;
}
-std::vector<Host*> Engine::get_filtered_hosts(const std::function<bool(Host*)>& filter)
+std::vector<Host*> Engine::get_filtered_hosts(const std::function<bool(Host*)>& filter) const
{
std::vector<Host*> hosts;
for (auto const& kv : pimpl->hosts_) {
*
* @throw std::invalid_argument if the searched host does not exist.
*/
-Host* Engine::host_by_name(const std::string& name)
+Host* Engine::host_by_name(const std::string& name) const
{
- if (pimpl->hosts_.find(name) == pimpl->hosts_.end())
+ auto host = pimpl->hosts_.find(name);
+ if (host == pimpl->hosts_.end())
throw std::invalid_argument(std::string("Host not found: '") + name + std::string("'"));
- return pimpl->hosts_.at(name);
+ return host->second;
}
/** @brief Find a host from its name (or nullptr if that host does not exist) */
-Host* Engine::host_by_name_or_null(const std::string& name)
+Host* Engine::host_by_name_or_null(const std::string& name) const
{
auto host = pimpl->hosts_.find(name);
return host == pimpl->hosts_.end() ? nullptr : host->second;
*
* @throw std::invalid_argument if the searched link does not exist.
*/
-Link* Engine::link_by_name(const std::string& name)
+Link* Engine::link_by_name(const std::string& name) const
{
- if (pimpl->links_.find(name) == pimpl->links_.end())
+ auto link = pimpl->links_.find(name);
+ if (link == pimpl->links_.end())
throw std::invalid_argument(std::string("Link not found: ") + name);
-
- return pimpl->links_.at(name)->get_iface();
+ return link->second->get_iface();
}
-/** @brief Find an link from its name (or nullptr if that link does not exist) */
-Link* Engine::link_by_name_or_null(const std::string& name)
+/** @brief Find a link from its name (or nullptr if that link does not exist) */
+Link* Engine::link_by_name_or_null(const std::string& name) const
{
auto link = pimpl->links_.find(name);
return link == pimpl->links_.end() ? nullptr : link->second->get_iface();
}
/** @brief Returns the amount of storages in the platform */
-size_t Engine::get_storage_count()
+size_t Engine::get_storage_count() const
{
return pimpl->storages_.size();
}
/** @brief Returns the list of all storages found in the platform */
-std::vector<Storage*> Engine::get_all_storages()
+std::vector<Storage*> Engine::get_all_storages() const
{
std::vector<Storage*> res;
for (auto const& kv : pimpl->storages_)
*
* @throw std::invalid_argument if the searched storage does not exist.
*/
-Storage* Engine::storage_by_name(const std::string& name)
+Storage* Engine::storage_by_name(const std::string& name) const
{
- if (pimpl->storages_.find(name) == pimpl->storages_.end())
+ auto storage = pimpl->storages_.find(name);
+ if (storage == pimpl->storages_.end())
throw std::invalid_argument(std::string("Storage not found: ") + name);
-
- return pimpl->storages_.at(name)->get_iface();
+ return storage->second->get_iface();
}
/** @brief Find a storage from its name (or nullptr if that storage does not exist) */
-Storage* Engine::storage_by_name_or_null(const std::string& name)
+Storage* Engine::storage_by_name_or_null(const std::string& name) const
{
auto storage = pimpl->storages_.find(name);
return storage == pimpl->storages_.end() ? nullptr : storage->second->get_iface();
}
/** @brief Returns the amount of links in the platform */
-size_t Engine::get_link_count()
+size_t Engine::get_link_count() const
{
return pimpl->links_.size();
}
/** @brief Returns the list of all links found in the platform */
-std::vector<Link*> Engine::get_all_links()
+std::vector<Link*> Engine::get_all_links() const
{
std::vector<Link*> res;
for (auto const& kv : pimpl->links_)
return res;
}
-std::vector<Link*> Engine::get_filtered_links(const std::function<bool(Link*)>& filter)
+std::vector<Link*> Engine::get_filtered_links(const std::function<bool(Link*)>& filter) const
{
std::vector<Link*> filtered_list;
for (auto const& kv : pimpl->links_) {
return filtered_list;
}
-size_t Engine::get_actor_count()
+size_t Engine::get_actor_count() const
{
return simix_global->process_list.size();
}
-std::vector<ActorPtr> Engine::get_all_actors()
+std::vector<ActorPtr> Engine::get_all_actors() const
{
std::vector<ActorPtr> actor_list;
for (auto const& kv : simix_global->process_list) {
- actor_list.push_back(kv.second->iface());
+ actor_list.push_back(kv.second->get_iface());
}
return actor_list;
}
-std::vector<ActorPtr> Engine::get_filtered_actors(const std::function<bool(ActorPtr)>& filter)
+std::vector<ActorPtr> Engine::get_filtered_actors(const std::function<bool(ActorPtr)>& filter) const
{
std::vector<ActorPtr> actor_list;
for (auto const& kv : simix_global->process_list) {
- if (filter(kv.second->iface()))
- actor_list.push_back(kv.second->iface());
+ if (filter(kv.second->get_iface()))
+ actor_list.push_back(kv.second->get_iface());
}
return actor_list;
}
-void Engine::run()
+void Engine::run() const
{
/* Clean IO before the run */
fflush(stdout);
}
/** @brief Retrieve the root netzone, containing all others */
-s4u::NetZone* Engine::get_netzone_root()
+s4u::NetZone* Engine::get_netzone_root() const
{
return pimpl->netzone_root_->get_iface();
}
}
/** @brief Retrieve the NetZone of the given name (or nullptr if not found) */
-NetZone* Engine::netzone_by_name_or_null(const std::string& name)
+NetZone* Engine::netzone_by_name_or_null(const std::string& name) const
{
return netzone_by_name_recursive(get_netzone_root(), name);
}
/** @brief Retrieve the netpoint of the given name (or nullptr if not found) */
-kernel::routing::NetPoint* Engine::netpoint_by_name_or_null(const std::string& name)
+kernel::routing::NetPoint* Engine::netpoint_by_name_or_null(const std::string& name) const
{
auto netp = pimpl->netpoints_.find(name);
return netp == pimpl->netpoints_.end() ? nullptr : netp->second;
}
-std::vector<kernel::routing::NetPoint*> Engine::get_all_netpoints()
+std::vector<kernel::routing::NetPoint*> Engine::get_all_netpoints() const
{
std::vector<kernel::routing::NetPoint*> res;
for (auto const& kv : pimpl->netpoints_)
{
return simgrid::s4u::Engine::get_clock();
}
-int simgrid_get_actor_count()
+
+int simgrid_get_actor_count() // XBT_ATTRIB_DEPRECATED_v330
{
return simgrid::s4u::Engine::get_instance()->get_actor_count();
}
