src/storage.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : storage.cpp
* DESCRIPTION: Abstract storage, e.g. for persistant caching
* COPYRIGHT  : (C) 2011  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#include <basix/storage.hpp>
#include <basix/system.hpp>
namespace mmx {

static port connect_to_server ();

/******************************************************************************
* Disk storage prototypes
******************************************************************************/

class disk_storage_rep: public storage_rep {
private:
  port server;
  string root;

public:
  void write (const string& var, const string& val) const;
  string read (const string& var) const;
  void lock (const string& var) const;
  void unlock (const string& var) const;

  storage get_branch (const string& br) const;
  bool has_branch (const string& br) const;
  string get_file (const string& name) const;
  bool has_file (const string& name) const;

  vector<string> retrieve_data () const;
  vector<string> retrieve_branches () const;
  vector<string> retrieve_files () const;

public:
  inline disk_storage_rep (const string& root2):
    server (connect_to_server ()), root (root2) {}
  inline disk_storage_rep (const port& server2, const string& root2):
    server (server2), root (root2) {}
  inline ~disk_storage_rep () {}
  friend class storage;
};

/******************************************************************************
* Disk storage constructors
******************************************************************************/

static port
connect_to_server () {
  port server= socket_client_port ("localhost", 3124);
  if (error_flag (server)) {
    ASSERT (file_exists (path_name ("$PATH", "storage_server")),
            "storage server cannot be started");
    system ("storage_server&");
    nat pause= 1;
    while (error_flag (server)) {
      (void) wait_port_event (pause);
      server= socket_client_port ("localhost", 3124);
      pause *= 2;
      ASSERT (pause < 5000, 
              "storage server cannot be started");
    }
  }
  binary_write<string> (server, "connect");
  return server;
}

storage
disk_storage () {
  return (storage_rep*) new disk_storage_rep (user_dir () * "/cache");
}

storage
disk_storage (const string& root) {
  return (storage_rep*) new disk_storage_rep (root);
}

storage
disk_storage (const port& server, const string& root) {
  return (storage_rep*) new disk_storage_rep (server, root);
}

/******************************************************************************
* Disk storage implementation
******************************************************************************/

void
disk_storage_rep::write (const string& var, const string& val) const {
  binary_write<string> (server, root);
  binary_write<string> (server, "write");
  binary_write<string> (server, var);
  binary_write<string> (server, val);
}

string
disk_storage_rep::read (const string& var) const {
  binary_write<string> (server, root);
  binary_write<string> (server, "read");
  binary_write<string> (server, var);
  return binary_read<string> (server);
}

void
disk_storage_rep::lock (const string& var) const {
  binary_write<string> (server, root);
  binary_write<string> (server, "lock");
  binary_write<string> (server, var);
}

void
disk_storage_rep::unlock (const string& var) const {
  binary_write<string> (server, root);
  binary_write<string> (server, "unlock");
  binary_write<string> (server, var);
}

storage
disk_storage_rep::get_branch (const string& br) const {
  binary_write<string> (server, root);
  binary_write<string> (server, "get_branch");
  binary_write<string> (server, br);
  return disk_storage (server, binary_read<string> (server));
}

bool
disk_storage_rep::has_branch (const string& br) const {
  binary_write<string> (server, root);
  binary_write<string> (server, "has_branch");
  binary_write<string> (server, br);
  return binary_read<bool> (server);
}

string
disk_storage_rep::get_file (const string& name) const {
  binary_write<string> (server, root);
  binary_write<string> (server, "get_file");
  binary_write<string> (server, name);
  return binary_read<string> (server);
}

bool
disk_storage_rep::has_file (const string& name) const {
  binary_write<string> (server, root);
  binary_write<string> (server, "has_file");
  binary_write<string> (server, name);
  return binary_read<bool> (server);
}

vector<string>
disk_storage_rep::retrieve_data () const {
  binary_write<string> (server, root);
  binary_write<string> (server, "retrieve_data");
  return binary_read<vector<string> > (server);
}

vector<string>
disk_storage_rep::retrieve_branches () const {
  binary_write<string> (server, root);
  binary_write<string> (server, "retrieve_branches");
  return binary_read<vector<string> > (server);
}

vector<string>
disk_storage_rep::retrieve_files () const {
  binary_write<string> (server, root);
  binary_write<string> (server, "retrieve_files");
  return binary_read<vector<string> > (server);
}

/******************************************************************************
* Cached storage implementation
******************************************************************************/

storage
cached_storage (const storage& st) {
  return st;
}

} // namespace mmx

---