snake_casing file system plugin

diff --git a/examples/s4u/io-file-remote/s4u-io-file-remote.cpp b/examples/s4u/io-file-remote/s4u-io-file-remote.cpp
index 429addc..6cbd818 100644 (file)
--- a/examples/s4u/io-file-remote/s4u-io-file-remote.cpp
+++ b/examples/s4u/io-file-remote/s4u-io-file-remote.cpp
@@ -14,7 +14,7 @@ XBT_LOG_NEW_DEFAULT_CATEGORY(remote_io, "Messages specific for this io example")
 static int host(int argc, char* argv[])
 {
   simgrid::s4u::File file(argv[1], nullptr);
-  const char* filename = file.getPath();
+  const char* filename = file.get_path();
   XBT_INFO("Opened file '%s'", filename);
   file.dump();
 
@@ -27,7 +27,7 @@ static int host(int argc, char* argv[])
 
   if (argc > 5) {
     simgrid::s4u::File remoteFile(argv[2], nullptr);
-    filename = remoteFile.getPath();
+    filename = remoteFile.get_path();
     XBT_INFO("Opened file '%s'", filename);
     XBT_INFO("Try to write %llu MiB to '%s'", remoteFile.size() / 1024, filename);
     sg_size_t write = remoteFile.write(remoteFile.size() * 1024);
@@ -36,11 +36,11 @@ static int host(int argc, char* argv[])
     if (std::stoi(argv[5]) != 0) {
       XBT_INFO("Move '%s' (of size %llu) from '%s' to '%s'", filename, remoteFile.size(),
                simgrid::s4u::Host::current()->get_cname(), argv[3]);
-      remoteFile.remoteMove(simgrid::s4u::Host::by_name(argv[3]), argv[4]);
+      remoteFile.remote_move(simgrid::s4u::Host::by_name(argv[3]), argv[4]);
     } else {
       XBT_INFO("Copy '%s' (of size %llu) from '%s' to '%s'", filename, remoteFile.size(),
                simgrid::s4u::Host::current()->get_cname(), argv[3]);
-      remoteFile.remoteCopy(simgrid::s4u::Host::by_name(argv[3]), argv[4]);
+      remoteFile.remote_copy(simgrid::s4u::Host::by_name(argv[3]), argv[4]);
     }
   }
 

diff --git a/examples/s4u/io-file-system/s4u-io-file-system.cpp b/examples/s4u/io-file-system/s4u-io-file-system.cpp
index 6f0f84b..3f18c14 100644 (file)
--- a/examples/s4u/io-file-system/s4u-io-file-system.cpp
+++ b/examples/s4u/io-file-system/s4u-io-file-system.cpp
@@ -58,12 +58,12 @@ public:
 
     // Now rename file from ./tmp/data.txt to ./tmp/simgrid.readme
     std::string newpath = "/home/tmp/simgrid.readme";
-    XBT_INFO("Move '%s' to '%s'", file->getPath(), newpath.c_str());
+    XBT_INFO("Move '%s' to '%s'", file->get_path(), newpath.c_str());
     file->move(newpath);
 
     // Test attaching some user data to the file
-    file->setUserdata(new std::string("777"));
-    std::string* file_data = static_cast<std::string*>(file->getUserdata());
+    file->set_userdata(new std::string("777"));
+    std::string* file_data = static_cast<std::string*>(file->get_userdata());
     XBT_INFO("User data attached to the file: %s", file_data->c_str());
     delete file_data;
 
@@ -82,7 +82,7 @@ public:
 
     // Reopen the file and then unlink it
     file = new simgrid::s4u::File("/home/tmp/simgrid.readme", nullptr);
-    XBT_INFO("Unlink file: '%s'", file->getPath());
+    XBT_INFO("Unlink file: '%s'", file->get_path());
     file->unlink();
     delete file; // Unlinking the file on "disk" does not free the object
 

diff --git a/include/simgrid/plugins/file_system.h b/include/simgrid/plugins/file_system.h
index 429d1a6..1a5ea1c 100644 (file)
--- a/include/simgrid/plugins/file_system.h
+++ b/include/simgrid/plugins/file_system.h
@@ -93,7 +93,7 @@ public:
   ~File();
 
   /** Retrieves the path to the file */
-  const char* getPath() { return fullpath_.c_str(); }
+  const char* get_path() { return fullpath_.c_str(); }
 
   /** Simulates a local read action. Returns the size of data actually read */
   sg_size_t read(sg_size_t size);
@@ -102,9 +102,9 @@ public:
   sg_size_t write(sg_size_t size);
 
   /** Allows to store user data on that host */
-  void setUserdata(void* data) { userdata_ = data; }
+  void set_userdata(void* data) { userdata_ = data; }
   /** Retrieves the previously stored data */
-  void* getUserdata() { return userdata_; }
+  void* get_userdata() { return userdata_; }
 
   sg_size_t size();
   void seek(sg_offset_t pos);             /** Sets the file head to the given position. */
@@ -113,14 +113,14 @@ public:
 
   /** Rename a file. WARNING: It is forbidden to move the file to another mount point */
   void move(std::string fullpath);
-  int remoteCopy(sg_host_t host, const char* fullpath);
-  int remoteMove(sg_host_t host, const char* fullpath);
+  int remote_copy(sg_host_t host, const char* fullpath);
+  int remote_move(sg_host_t host, const char* fullpath);
 
   int unlink(); /** Remove a file from the contents of a disk */
   void dump();
 
   int desc_id = 0;
-  Storage* localStorage;
+  Storage* local_storage_;
   std::string mount_point_;
 
 private:
@@ -136,16 +136,16 @@ public:
   static simgrid::xbt::Extension<Storage, FileSystemStorageExt> EXTENSION_ID;
   explicit FileSystemStorageExt(Storage* ptr);
   ~FileSystemStorageExt();
-  std::map<std::string, sg_size_t>* parseContent(std::string filename);
-  std::map<std::string, sg_size_t>* getContent() { return content_; }
-  sg_size_t getSize() { return size_; }
-  sg_size_t getUsedSize() { return usedSize_; }
-  void decrUsedSize(sg_size_t size) { usedSize_ -= size; }
-  void incrUsedSize(sg_size_t size) { usedSize_ += size; }
+  std::map<std::string, sg_size_t>* parse_content(std::string filename);
+  std::map<std::string, sg_size_t>* get_content() { return content_; }
+  sg_size_t get_size() { return size_; }
+  sg_size_t get_used_size() { return used_size_; }
+  void decr_used_size(sg_size_t size) { used_size_ -= size; }
+  void incr_used_size(sg_size_t size) { used_size_ += size; }
 
 private:
   std::map<std::string, sg_size_t>* content_;
-  sg_size_t usedSize_ = 0;
+  sg_size_t used_size_ = 0;
   sg_size_t size_     = 0;
 };
 

diff --git a/src/plugins/file_system/s4u_FileSystem.cpp b/src/plugins/file_system/s4u_FileSystem.cpp
index d636541..056ffa9 100644 (file)
--- a/src/plugins/file_system/s4u_FileSystem.cpp
+++ b/src/plugins/file_system/s4u_FileSystem.cpp
@@ -3,7 +3,6 @@
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
-
 #include "simgrid/plugins/file_system.h"
 #include "simgrid/s4u/Actor.hpp"
 #include "src/surf/HostImpl.hpp"
@@ -49,7 +48,7 @@ File::File(std::string fullpath, sg_host_t host, void* userdata) : fullpath_(ful
   } else
     xbt_die("Can't find mount point for '%s' on '%s'", fullpath.c_str(), host->get_cname());
 
-  localStorage = st;
+  local_storage_ = st;
 
   // assign a file descriptor id to the newly opened File
   FileDescriptorHostExt* ext = host->extension<simgrid::s4u::FileDescriptorHostExt>();
@@ -62,7 +61,7 @@ File::File(std::string fullpath, sg_host_t host, void* userdata) : fullpath_(ful
   ext->file_descriptor_table->pop_back();
 
   XBT_DEBUG("\tOpen file '%s'", path_.c_str());
-  std::map<std::string, sg_size_t>* content = localStorage->extension<FileSystemStorageExt>()->getContent();
+  std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
   // if file does not exist create an empty file
   auto sz = content->find(path_);
   if (sz != content->end()) {
@@ -88,7 +87,7 @@ void File::dump()
            "\t\tStorage Id: '%s'\n"
            "\t\tStorage Type: '%s'\n"
            "\t\tFile Descriptor Id: %d",
-           getPath(), size_, mount_point_.c_str(), localStorage->get_cname(), localStorage->getType(), desc_id);
+           get_path(), size_, mount_point_.c_str(), local_storage_->get_cname(), local_storage_->getType(), desc_id);
 }
 
 sg_size_t File::read(sg_size_t size)
@@ -97,10 +96,10 @@ sg_size_t File::read(sg_size_t size)
     return 0;
 
   /* Find the host where the file is physically located and read it */
-  Host* host = localStorage->getHost();
-  XBT_DEBUG("READ %s on disk '%s'", getPath(), localStorage->get_cname());
+  Host* host = local_storage_->getHost();
+  XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
   // if the current position is close to the end of the file, we may not be able to read the requested size
-  sg_size_t read_size = localStorage->read(std::min(size, size_ - current_position_));
+  sg_size_t read_size = local_storage_->read(std::min(size, size_ - current_position_));
   current_position_ += read_size;
 
   if (strcmp(host->get_cname(), Host::current()->get_cname())) {
@@ -128,7 +127,7 @@ sg_size_t File::write(sg_size_t size)
     return 0;
 
   /* Find the host where the file is physically located (remote or local)*/
-  Host* host = localStorage->getHost();
+  Host* host = local_storage_->getHost();
 
   if (strcmp(host->get_cname(), Host::current()->get_cname())) {
     /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
@@ -140,19 +139,19 @@ sg_size_t File::write(sg_size_t size)
     this_actor::parallel_execute(2, m_host_list, flops_amount, bytes_amount);
   }
 
-  XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu'", getPath(), localStorage->get_cname(), size, size_);
+  XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu'", get_path(), local_storage_->get_cname(), size, size_);
   // If the storage is full before even starting to write
-  if (sg_storage_get_size_used(localStorage) >= sg_storage_get_size(localStorage))
+  if (sg_storage_get_size_used(local_storage_) >= sg_storage_get_size(local_storage_))
     return 0;
   /* Substract the part of the file that might disappear from the used sized on the storage element */
-  localStorage->extension<FileSystemStorageExt>()->decrUsedSize(size_ - current_position_);
+  local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_ - current_position_);
 
-  sg_size_t write_size = localStorage->write(size);
-  localStorage->extension<FileSystemStorageExt>()->incrUsedSize(write_size);
+  sg_size_t write_size = local_storage_->write(size);
+  local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
 
   current_position_ += write_size;
   size_ = current_position_;
-  std::map<std::string, sg_size_t>* content = localStorage->extension<FileSystemStorageExt>()->getContent();
+  std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
 
   content->erase(path_);
   content->insert({path_, size_});
@@ -196,7 +195,7 @@ void File::move(std::string fullpath)
 {
   /* Check if the new full path is on the same mount point */
   if (not strncmp(mount_point_.c_str(), fullpath.c_str(), mount_point_.length())) {
-    std::map<std::string, sg_size_t>* content = localStorage->extension<FileSystemStorageExt>()->getContent();
+    std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
     auto sz = content->find(path_);
     if (sz != content->end()) { // src file exists
       sg_size_t new_size = sz->second;
@@ -215,14 +214,14 @@ void File::move(std::string fullpath)
 int File::unlink()
 {
   /* Check if the file is on local storage */
-  std::map<std::string, sg_size_t>* content = localStorage->extension<FileSystemStorageExt>()->getContent();
+  std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
 
   if (content->find(path_) == content->end()) {
-    XBT_WARN("File %s is not on disk %s. Impossible to unlink", path_.c_str(), localStorage->get_cname());
+    XBT_WARN("File %s is not on disk %s. Impossible to unlink", path_.c_str(), local_storage_->get_cname());
     return -1;
   } else {
-    XBT_DEBUG("UNLINK %s on disk '%s'", path_.c_str(), localStorage->get_cname());
-    localStorage->extension<FileSystemStorageExt>()->decrUsedSize(size_);
+    XBT_DEBUG("UNLINK %s on disk '%s'", path_.c_str(), local_storage_->get_cname());
+    local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_);
 
     // Remove the file from storage
     content->erase(fullpath_);
@@ -231,15 +230,15 @@ int File::unlink()
   }
 }
 
-int File::remoteCopy(sg_host_t host, const char* fullpath)
+int File::remote_copy(sg_host_t host, const char* fullpath)
 {
   /* Find the host where the file is physically located and read it */
-  Storage* storage_src = localStorage;
+  Storage* storage_src = local_storage_;
   Host* src_host       = storage_src->getHost();
   seek(0, SEEK_SET);
-  XBT_DEBUG("READ %s on disk '%s'", getPath(), localStorage->get_cname());
+  XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
   // if the current position is close to the end of the file, we may not be able to read the requested size
-  sg_size_t read_size = localStorage->read(size_);
+  sg_size_t read_size = local_storage_->read(size_);
   current_position_ += read_size;
 
   /* Find the host that owns the storage where the file has to be copied */
@@ -274,23 +273,23 @@ int File::remoteCopy(sg_host_t host, const char* fullpath)
 
   /* Create file on remote host, write it and close it */
   File* fd = new File(fullpath, dst_host, nullptr);
-  sg_size_t write_size = fd->localStorage->write(read_size);
-  fd->localStorage->extension<FileSystemStorageExt>()->incrUsedSize(write_size);
-  (*(fd->localStorage->extension<FileSystemStorageExt>()->getContent()))[path_] = size_;
+  sg_size_t write_size = fd->local_storage_->write(read_size);
+  fd->local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
+  (*(fd->local_storage_->extension<FileSystemStorageExt>()->get_content()))[path_] = size_;
   delete fd;
   return 0;
 }
 
-int File::remoteMove(sg_host_t host, const char* fullpath)
+int File::remote_move(sg_host_t host, const char* fullpath)
 {
-  int res = remoteCopy(host, fullpath);
+  int res = remote_copy(host, fullpath);
   unlink();
   return res;
 }
 
 FileSystemStorageExt::FileSystemStorageExt(simgrid::s4u::Storage* ptr)
 {
-  content_ = parseContent(ptr->getImpl()->content_name);
+  content_ = parse_content(ptr->getImpl()->content_name);
   size_    = ptr->getImpl()->size_;
 }
 
@@ -299,7 +298,7 @@ FileSystemStorageExt::~FileSystemStorageExt()
   delete content_;
 }
 
-std::map<std::string, sg_size_t>* FileSystemStorageExt::parseContent(std::string filename)
+std::map<std::string, sg_size_t>* FileSystemStorageExt::parse_content(std::string filename)
 {
   if (filename.empty())
     return nullptr;
@@ -318,7 +317,7 @@ std::map<std::string, sg_size_t>* FileSystemStorageExt::parseContent(std::string
       xbt_assert(tokens.size() == 2, "Parse error in %s: %s", filename.c_str(), line.c_str());
       sg_size_t size = std::stoull(tokens.at(1));
 
-      usedSize_ += size;
+      used_size_ += size;
       parse_content->insert({tokens.front(), size});
     }
   } while (not fs->eof());
@@ -331,17 +330,17 @@ std::map<std::string, sg_size_t>* FileSystemStorageExt::parseContent(std::string
 using simgrid::s4u::FileSystemStorageExt;
 using simgrid::s4u::FileDescriptorHostExt;
 
-static void onStorageCreation(simgrid::s4u::Storage& st)
+static void on_storage_creation(simgrid::s4u::Storage& st)
 {
   st.extension_set(new FileSystemStorageExt(&st));
 }
 
-static void onStorageDestruction(simgrid::s4u::Storage& st)
+static void on_storage_destruction(simgrid::s4u::Storage& st)
 {
   delete st.extension<FileSystemStorageExt>();
 }
 
-static void onHostCreation(simgrid::s4u::Host& host)
+static void on_host_creation(simgrid::s4u::Host& host)
 {
   host.extension_set<FileDescriptorHostExt>(new FileDescriptorHostExt());
 }
@@ -355,13 +354,13 @@ void sg_storage_file_system_init()
 
   if (not FileSystemStorageExt::EXTENSION_ID.valid()) {
     FileSystemStorageExt::EXTENSION_ID = simgrid::s4u::Storage::extension_create<FileSystemStorageExt>();
-    simgrid::s4u::Storage::onCreation.connect(&onStorageCreation);
-    simgrid::s4u::Storage::onDestruction.connect(&onStorageDestruction);
+    simgrid::s4u::Storage::onCreation.connect(&on_storage_creation);
+    simgrid::s4u::Storage::onDestruction.connect(&on_storage_destruction);
   }
 
   if (not FileDescriptorHostExt::EXTENSION_ID.valid()) {
     FileDescriptorHostExt::EXTENSION_ID = simgrid::s4u::Host::extension_create<FileDescriptorHostExt>();
-    simgrid::s4u::Host::onCreation.connect(&onHostCreation);
+    simgrid::s4u::Host::onCreation.connect(&on_host_creation);
   }
 }
 
@@ -388,7 +387,7 @@ void sg_file_close(sg_file_t fd)
 const char* sg_file_get_name(sg_file_t fd)
 {
   xbt_assert((fd != nullptr), "Invalid file descriptor");
-  return fd->getPath();
+  return fd->get_path();
 }
 
 sg_size_t sg_file_get_size(sg_file_t fd)
@@ -403,12 +402,12 @@ void sg_file_dump(sg_file_t fd)
 
 void* sg_file_get_data(sg_file_t fd)
 {
-  return fd->getUserdata();
+  return fd->get_userdata();
 }
 
 void sg_file_set_data(sg_file_t fd, void* data)
 {
-  fd->setUserdata(data);
+  fd->set_userdata(data);
 }
 
 /**
@@ -451,7 +450,7 @@ void sg_file_unlink(sg_file_t fd)
  */
 int sg_file_rcopy(sg_file_t file, sg_host_t host, const char* fullpath)
 {
-  return file->remoteCopy(host, fullpath);
+  return file->remote_copy(host, fullpath);
 }
 
 /**
@@ -463,27 +462,27 @@ int sg_file_rcopy(sg_file_t file, sg_host_t host, const char* fullpath)
  */
 int sg_file_rmove(sg_file_t file, sg_host_t host, const char* fullpath)
 {
-  return file->remoteMove(host, fullpath);
+  return file->remote_move(host, fullpath);
 }
 
 sg_size_t sg_storage_get_size_free(sg_storage_t st)
 {
-  return st->extension<FileSystemStorageExt>()->getSize() - st->extension<FileSystemStorageExt>()->getUsedSize();
+  return st->extension<FileSystemStorageExt>()->get_size() - st->extension<FileSystemStorageExt>()->get_used_size();
 }
 
 sg_size_t sg_storage_get_size_used(sg_storage_t st)
 {
-  return st->extension<FileSystemStorageExt>()->getUsedSize();
+  return st->extension<FileSystemStorageExt>()->get_used_size();
 }
 
 sg_size_t sg_storage_get_size(sg_storage_t st)
 {
-  return st->extension<FileSystemStorageExt>()->getSize();
+  return st->extension<FileSystemStorageExt>()->get_size();
 }
 
 xbt_dict_t sg_storage_get_content(sg_storage_t storage)
 {
-  std::map<std::string, sg_size_t>* content = storage->extension<simgrid::s4u::FileSystemStorageExt>()->getContent();
+  std::map<std::string, sg_size_t>* content = storage->extension<simgrid::s4u::FileSystemStorageExt>()->get_content();
   // Note: ::operator delete is ok here (no destructor called) since the dict elements are of POD type sg_size_t.
   xbt_dict_t content_as_dict = xbt_dict_new_homogeneous(::operator delete);
 

diff --git a/teshsuite/s4u/storage_client_server/storage_client_server.cpp b/teshsuite/s4u/storage_client_server/storage_client_server.cpp
index 166d134..2cdf4b7 100644 (file)
--- a/teshsuite/s4u/storage_client_server/storage_client_server.cpp
+++ b/teshsuite/s4u/storage_client_server/storage_client_server.cpp
@@ -60,7 +60,7 @@ static void hsm_put(const std::string& remote_host, const std::string& src, cons
 static void display_storage_content(simgrid::s4u::Storage* storage)
 {
   XBT_INFO("Print the content of the storage element: %s", storage->get_cname());
-  std::map<std::string, sg_size_t>* content = storage->extension<simgrid::s4u::FileSystemStorageExt>()->getContent();
+  std::map<std::string, sg_size_t>* content = storage->extension<simgrid::s4u::FileSystemStorageExt>()->get_content();
   if (not content->empty()) {
     for (auto const& entry : *content)
       XBT_INFO("\t%s size: %llu bytes", entry.first.c_str(), entry.second);