---
name: "persistent_table"
section: "7rheolef"
platform: "linux"
package: "librheolef-dev"
version: "7.2-4"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/persistent_table"
---

# persistent\_table(7rheolef)

persistent data base (rheolef-7.2)

## NAME

persistent\_table - persistent data base (rheolef-7.2)

## DESCRIPTION

Here is a convenient way to implement a persistent data base of big object that are long to initialize and then used only in a read-only mode, via accessors, no modifiers. Examples of such objects in scientific computing are are finite element meshes (see **geo(2)**), that are long to load from file and requires large memory, or high-order polynomial basis (see **basis(2)**), that are long to initialize (e.g. Vandermonde matrix inversion). When such objects are created independently in different parts of a code, both memory size and computation time could be save by reusing them when these objects was already created.

The aim of the **persistent\_table** class is to automate the implementation of a persistent data base for a generic object, that could be e.g. a finite element mesh or a polynomial basis. It requires very few modification of a pre-existing object. The implementation of the **persistent\_table** class bases on those of **smart\_pointer(7)** class for handling reference counting. When shared object in the data base are not modifiable, the idea is to use the `smart_pointer_nocopy` class. Otherwise, when the object has to be modified, the name of the object, that is used as a key in an hashtable, should also be modified, in order to address the new modified object. Here is a small minimalist example of the class.

## EXAMPLE

```
struct A_rep {
  public:
    A_rep (const string& name1) : _name(name1) { /* long init */ }
    ~A_rep();
    string name() const { return _name; }
    static A_rep* make_ptr (const string& name) { return new A_rep (name); }
  // data:
  protected:
    string _name;
};
struct A : public smart_pointer_nocopy<A_rep>, public persistent_table<A> {
  public:
    using rep  = A_rep;
    using base = smart_pointer_nocopy<rep>;
    A (const string& name = "");
    string name() const { return base::data().name(); }
};
// implementation of members:
A::A (const string& name)
  : base(),
    persistent_table<A>()
{
  if (name == "") return;
  base::operator= (persistent_table<A>::load (name));
}
A_rep::~A_rep()
{
  persistent_table<A>::unload (_name);
}
int main() {
  persistent_table<A>::set_verbose (true); // trace table load/unload
  A a("a");     // "a" created
  {
    A b("b");   // "b" created
    A c("a");   // "a" reused from table
  }             // "b" destroyed and erased from table
  {
    A b("b");   // "b" created
    A c("a");   // "a" reused from table
  }             // "b" destroyed and erased from table
}               // "a" destroyed and erased from table
```

## IMPLEMENTATION

This documentation has been generated from file util/lib/persistent\_table.h

```
template<class A>
class persistent_table {
  public:
    static A    load   (const std::string& name);
    static void unload (const std::string& name);
    static bool verbose () { return _verbose; }
    static void set_verbose (bool v) { _verbose = v; }
  protected:
    using  loaded_map_type = std::unordered_map<std::string,void*>;
    static loaded_map_type& get_loaded_map() { return _loaded_map; }
  // data:
    static loaded_map_type     _loaded_map;
    static bool                _verbose;
};
```

## AUTHOR

Pierre  Saramito  \<Pierre.Saramito@imag.fr\>

## COPYRIGHT

Copyright   (C)  2000-2018  Pierre  Saramito  \<Pierre.Saramito@imag.fr\> GPLv3+: GNU GPL version 3 or later  \<http://gnu.org/licenses/gpl.html\>. This  is  free  software:  you  are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.