--- /dev/null
+#ifndef STLPLUS_LIBRARY_MANAGER\r
+#define STLPLUS_LIBRARY_MANAGER\r
+////////////////////////////////////////////////////////////////////////////////\r
+\r
+// Author: Andy Rushton\r
+// Copyright: (c) Southampton University 1999-2004\r
+// (c) Andy Rushton 2004-2009\r
+// License: BSD License, see ../docs/license.html\r
+\r
+// Generalised library manager.\r
+\r
+// Manages library units in a set of library directories. A unit is both a file\r
+// on-disk and a data-structure in memory. To use the library manager, you need\r
+// to:\r
+\r
+// - design a type based on lm_unit with serialising functions read/write \r
+// - decide on a file extension for the type\r
+// - decide on a description of the type\r
+// - write a create callback for this type\r
+// - register the file extension, description and callback with the library manager\r
+\r
+////////////////////////////////////////////////////////////////////////////////\r
+#include "subsystems_fixes.hpp"\r
+#include "ini_manager.hpp"\r
+#include "smart_ptr.hpp"\r
+#include <iostream>\r
+#include <string>\r
+#include <vector>\r
+#include <list>\r
+#include <map>\r
+#include <time.h>\r
+\r
+namespace stlplus\r
+{\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // Internals\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+ class lm_library;\r
+ class library_manager;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // unit names\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+ class lm_unit_name\r
+ {\r
+ public:\r
+ lm_unit_name(const std::string& name = std::string(), const std::string& type = std::string());\r
+ ~lm_unit_name(void);\r
+\r
+ const std::string& name(void) const;\r
+ void set_name(const std::string& name);\r
+ void lowercase(void);\r
+\r
+ const std::string& type(void) const;\r
+ void set_type(const std::string& type);\r
+\r
+ bool write(std::ostream& context) const;\r
+ bool read(std::istream& context);\r
+\r
+ std::string to_string(void) const;\r
+ bool print(std::ostream&) const;\r
+\r
+ private:\r
+ std::string m_name;\r
+ std::string m_type;\r
+ };\r
+\r
+ std::ostream& operator << (std::ostream&, const lm_unit_name&);\r
+ bool operator == (const lm_unit_name& l, const lm_unit_name& r);\r
+ bool operator < (const lm_unit_name& l, const lm_unit_name& r);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // dependencies\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+ // dependencies on external files\r
+\r
+ class lm_file_dependency\r
+ {\r
+ public:\r
+ lm_file_dependency(void);\r
+ lm_file_dependency(const std::string& library_path, const std::string& path, unsigned line = 0, unsigned column = 0);\r
+ ~lm_file_dependency(void);\r
+\r
+ // a path can be retrieved as either a relative path to the library or as a\r
+ // full path by providing the library path as an argument\r
+ const std::string& path(void) const;\r
+ std::string path_full(const std::string& library_path) const;\r
+ void set_path(const std::string& library_path, const std::string& path);\r
+\r
+ unsigned line(void) const;\r
+ void set_line(unsigned line = 0);\r
+\r
+ unsigned column(void) const;\r
+ void set_column(unsigned column = 0);\r
+\r
+ bool write(std::ostream& context) const;\r
+ bool read(std::istream& context);\r
+\r
+ bool print(std::ostream&) const;\r
+\r
+ private:\r
+ std::string m_path; // file dependencies are stored as paths relative to the containing library\r
+ unsigned m_line; // line - starts at 1, 0 means no line/column information\r
+ unsigned m_column; // column - starts at 0\r
+ };\r
+\r
+ std::ostream& operator <<(std::ostream&, const lm_file_dependency&);\r
+\r
+ // dependencies on other units\r
+\r
+ class lm_unit_dependency\r
+ {\r
+ public:\r
+ lm_unit_dependency(void);\r
+ lm_unit_dependency(const std::string& library, const lm_unit_name& name);\r
+ ~lm_unit_dependency(void);\r
+\r
+ const std::string& library(void) const;\r
+ void set_library(const std::string& library);\r
+\r
+ const lm_unit_name& unit_name(void) const;\r
+ void set_unit_name(const lm_unit_name& unit_name);\r
+\r
+ const std::string& name(void) const;\r
+ void set_name(const std::string& name);\r
+\r
+ const std::string& type(void) const;\r
+ void set_type(const std::string& type);\r
+\r
+ bool write(std::ostream& context) const;\r
+ bool read(std::istream& context);\r
+\r
+ bool print(std::ostream&) const;\r
+\r
+ private:\r
+ std::string m_library;\r
+ lm_unit_name m_name;\r
+ };\r
+\r
+ std::ostream& operator<<(std::ostream&, const lm_unit_dependency&);\r
+\r
+ // the set of all dependencies\r
+\r
+ class lm_dependencies\r
+ {\r
+ public:\r
+ lm_dependencies(void);\r
+ lm_dependencies(const lm_dependencies&);\r
+ lm_dependencies& operator=(const lm_dependencies&);\r
+ ~lm_dependencies(void);\r
+\r
+ // source file dependency\r
+ void set_source_file(const lm_file_dependency&);\r
+ bool source_file_present(void) const;\r
+ const lm_file_dependency& source_file(void) const;\r
+\r
+ // other file dependencies\r
+ unsigned file_add(const lm_file_dependency& dependency);\r
+ unsigned file_size(void) const;\r
+ const lm_file_dependency& file_dependency(unsigned) const;\r
+ void file_erase(unsigned);\r
+\r
+ // unit dependencies\r
+ unsigned unit_add(const lm_unit_dependency& dependency);\r
+ unsigned unit_size(void) const;\r
+ const lm_unit_dependency& unit_dependency(unsigned) const;\r
+ void unit_erase(unsigned);\r
+\r
+ void clear(void);\r
+ bool empty(void) const;\r
+\r
+ bool write(std::ostream& context) const;\r
+ bool read(std::istream& context);\r
+\r
+ bool print(std::ostream&) const;\r
+\r
+ private:\r
+ lm_file_dependency* m_source; // source file dependency (optional)\r
+ std::vector<lm_file_dependency> m_files; // other file dependencies\r
+ std::vector<lm_unit_dependency> m_units; // unit dependencies\r
+ };\r
+\r
+ std::ostream& operator << (std::ostream&, const lm_dependencies&);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // library unit superclass\r
+ // user's units must be derivatives of lm_unit and overload all the virtuals\r
+\r
+ class lm_unit\r
+ {\r
+ friend class lm_library;\r
+ public:\r
+ ////////////////////////////////////////\r
+ // constructor/destructor\r
+\r
+ lm_unit(const lm_unit_name& name, lm_library* library);\r
+ virtual ~lm_unit(void);\r
+\r
+ ////////////////////////////////////////\r
+ // Header data\r
+\r
+ // unit name\r
+ const lm_unit_name& unit_name(void) const;\r
+ const std::string& name(void) const;\r
+ const std::string& type(void) const;\r
+\r
+ // dependencies\r
+ // all file dependencies are converted for internal use to a path relative to the library\r
+ // they can be retrieved either in this form or as a full path\r
+\r
+ // source file dependency\r
+ void set_source_file(const lm_file_dependency&);\r
+ bool source_file_present(void) const;\r
+ const lm_file_dependency& source_file(void) const;\r
+\r
+ // other file dependencies\r
+ unsigned file_add(const lm_file_dependency& dependency);\r
+ unsigned file_size(void) const;\r
+ const lm_file_dependency& file_dependency(unsigned) const;\r
+ void file_erase(unsigned);\r
+\r
+ // unit dependencies\r
+ unsigned unit_add(const lm_unit_dependency& dependency);\r
+ unsigned unit_size(void) const;\r
+ const lm_unit_dependency& unit_dependency(unsigned) const;\r
+ void unit_erase(unsigned);\r
+\r
+ const lm_dependencies& dependencies(void) const;\r
+ void set_dependencies(const lm_dependencies&);\r
+ void clear_dependencies(void);\r
+ bool empty_dependencies(void) const;\r
+\r
+ // dependency checking\r
+\r
+ bool out_of_date(void) const;\r
+ bool up_to_date(void) const;\r
+ lm_dependencies out_of_date_reason(void) const;\r
+\r
+ // supplementary data\r
+\r
+ const std::string& supplementary_data(void) const;\r
+ void set_supplementary_data(const std::string& data);\r
+\r
+ ////////////////////////////////////////\r
+ // unit data management\r
+\r
+ bool load(void);\r
+ bool save(void);\r
+ bool loaded(void) const;\r
+ void mark(void);\r
+\r
+ // file modified time - only changes after a save\r
+\r
+ time_t modified(void) const;\r
+\r
+ ////////////////////////////////////////\r
+ // containing library manager details\r
+\r
+ // get the owning library\r
+ const lm_library* library(void) const;\r
+ lm_library* library(void);\r
+\r
+ // owning library name and path\r
+ const std::string& library_name(void) const;\r
+ const std::string& library_path(void) const;\r
+\r
+ ////////////////////////////////////////\r
+ // error handling - these apply to the last read/write operation\r
+\r
+ bool error(void) const;\r
+\r
+ ////////////////////////////////////////\r
+ // functions that customise subclasses of this superclass\r
+ // You MUST provide at least:\r
+ // - read - either read operation can be overloaded\r
+ // - write - either write operation can be overloaded\r
+ // - clone\r
+\r
+ // read(filename) is the one actually called to read your data\r
+ // the default read(filename) simply calls read(istream) to actually read the file\r
+ // the default read(istream) does nothing but fail by returning false so you must overload one or other\r
+\r
+ // you can just overload read(istream) if you want to use IOstream, or you\r
+ // can overload read(filename) to use any I/O system\r
+\r
+ virtual bool read(const std::string& filename, void* type_data);\r
+ virtual bool read(std::istream& file, void* type_data);\r
+\r
+ // as above, but for writing the data type\r
+\r
+ // write(filename) is the one actually called to write your data\r
+ // the default write(filename) simply calls write(ostream) to actually write the file\r
+ // the default write(ostream) does nothing but fail by returning false so you must overload one or other\r
+\r
+ // you can just overload write(ostream) if you want to use IOstream, or you\r
+ // can overload write(filename) to use any I/O system\r
+\r
+ virtual bool write(const std::string& filename, void* type_data);\r
+ virtual bool write(std::ostream& file, void* type_data);\r
+\r
+ // purge clears any memory associated with the unit - makes the unit unloaded\r
+ // the default does nothing\r
+ virtual bool purge(void);\r
+\r
+ // the clone function creates a new-ed copy of the subclass\r
+ virtual lm_unit* clone(void) const;\r
+\r
+ // the default print routines print header-only information\r
+ // you can overload these to provide a debug printout of the data structure\r
+ virtual bool print(std::ostream&) const;\r
+ virtual bool print_long(std::ostream&) const;\r
+\r
+ protected:\r
+ // header file management\r
+ std::string filename(void) const;\r
+ std::string header_filename(void) const;\r
+ bool write_header(void);\r
+ bool read_header(void);\r
+\r
+ private:\r
+ // header fields\r
+ lm_unit_name m_name; // name\r
+ lm_dependencies m_dependencies; // file and unit dependencies\r
+ std::string m_supplement; // supplementary data\r
+ bool m_header_modified; // header modified\r
+\r
+ // internal fields\r
+ bool m_loaded; // loaded flag\r
+ bool m_marked; // mark - determines whether the unit needs saving\r
+\r
+ // library manager fields\r
+ lm_library* m_library; // parent library\r
+\r
+ // error handling fields\r
+ bool m_error; // error flag if load or save fails - from IOstream\r
+ };\r
+\r
+ // Iostream print calls the short print method\r
+ std::ostream& operator << (std::ostream& str, const lm_unit& u);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // other types used in the library manager\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+ // user types\r
+\r
+ typedef smart_ptr_nocopy<lm_unit> lm_unit_ptr;\r
+ typedef lm_unit* (*lm_create_callback)(const lm_unit_name& unit_name, lm_library* parent_library, void* type_data);\r
+\r
+ // internal types used in the library manager but made global because they are shared\r
+\r
+ struct lm_callback_entry\r
+ {\r
+ lm_create_callback m_callback;\r
+ std::string m_description;\r
+ void* m_type_data;\r
+\r
+ lm_callback_entry(lm_create_callback callback = 0, const std::string& description = std::string(), void* type_data = 0) :\r
+ m_callback(callback), m_description(description), m_type_data(type_data) {}\r
+ };\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // Library\r
+ // Must be contained in a library_manager\r
+ // Manages objects of class lm_unit and its subclasses\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+ class lm_library\r
+ {\r
+ public:\r
+ friend class library_manager;\r
+ friend class lm_unit;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // constructors/destructor - lm_library should only ever be constructed by library_manager\r
+\r
+ lm_library(library_manager* manager);\r
+ lm_library(const lm_library&);\r
+ lm_library& operator = (const lm_library&);\r
+ ~lm_library(void);\r
+\r
+ public:\r
+\r
+ const library_manager* manager(void) const;\r
+ library_manager* manager(void);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // initialisers\r
+\r
+ bool create(const std::string& name, const std::string& path, bool writable);\r
+ bool open(const std::string& path);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // management of types\r
+\r
+ bool load_type(const std::string& type);\r
+ bool load_types(void);\r
+ bool remove_type(const std::string& type);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // whole library operations\r
+\r
+ bool load(void);\r
+ bool save(void);\r
+ bool purge(void);\r
+ bool close(void);\r
+ bool erase(void);\r
+\r
+ const std::string& name(void) const;\r
+ const std::string& path(void) const;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // managing read/write status\r
+\r
+ bool set_read_write(bool writable);\r
+ bool set_writable(void);\r
+ bool set_read_only(void);\r
+ bool writable(void) const;\r
+ bool read_only(void) const;\r
+ bool os_writable(void) const;\r
+ bool os_read_only(void) const;\r
+ bool lm_writable(void) const;\r
+ bool lm_read_only(void) const;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // unit management\r
+\r
+ bool exists(const lm_unit_name& name) const;\r
+ lm_unit_ptr create(const lm_unit_name&);\r
+ bool loaded(const lm_unit_name& name) const;\r
+ bool load(const lm_unit_name& unit);\r
+ bool purge(const lm_unit_name& unit);\r
+ bool save(const lm_unit_name& unit);\r
+ bool erase(const lm_unit_name& name);\r
+ bool mark(const lm_unit_name& name);\r
+ time_t modified(const lm_unit_name& name) const;\r
+\r
+ bool erase_by_source(const std::string& source_file);\r
+\r
+ const lm_unit_ptr find(const lm_unit_name& name) const;\r
+ lm_unit_ptr find(const lm_unit_name& name);\r
+\r
+ std::vector<lm_unit_name> names(void) const;\r
+ std::vector<std::string> names(const std::string& type) const;\r
+ std::vector<lm_unit_ptr> handles(void) const;\r
+ std::vector<lm_unit_ptr> handles(const std::string& type) const;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // dependency checking\r
+\r
+ bool out_of_date(const lm_unit_name& name) const;\r
+ bool up_to_date(const lm_unit_name& name) const;\r
+ lm_dependencies out_of_date_reason(const lm_unit_name& name) const;\r
+\r
+ std::pair<bool,unsigned> tidy(void);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // do-everything print function\r
+\r
+ bool pretty_print(std::ostream& str,\r
+ bool print_units = false, // print the unit names not just the library names\r
+ const std::string& type = std::string()) const; // print just this type ("" means all)\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // diagnostic print routines\r
+\r
+ bool print(std::ostream& str) const;\r
+ bool print_long(std::ostream& str) const;\r
+\r
+ private:\r
+\r
+ std::map<lm_unit_name,lm_unit_ptr>::iterator local_find(const lm_unit_name& name);\r
+ std::map<lm_unit_name,lm_unit_ptr>::const_iterator local_find(const lm_unit_name& name) const;\r
+\r
+ std::string m_name; // name\r
+ std::string m_path; // path\r
+ bool m_writable; // writable\r
+ std::map<lm_unit_name,lm_unit_ptr> m_units; // units\r
+ library_manager* m_manager; // parent library manager\r
+ };\r
+\r
+ std::ostream& operator << (std::ostream& str, const lm_library& lib);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // Library Manager\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+ class library_manager\r
+ {\r
+ public:\r
+ friend class lm_library;\r
+ friend class lm_unit;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // static functions allow you to test whether a directory is a library before opening it\r
+ // you can also find the library's name without opening it\r
+\r
+ static bool is_library(const std::string& path, const std::string& owner);\r
+ static std::string library_name(const std::string& path, const std::string& owner);\r
+\r
+ // non-static forms test for libraries with the same owner as the library manager\r
+\r
+ bool is_library(const std::string& path);\r
+ std::string library_name(const std::string& path);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // tructors\r
+\r
+ explicit library_manager(const std::string& owner, bool library_case = false, bool unit_case = false);\r
+ ~library_manager(void);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // case sensitivity\r
+\r
+ bool library_case(void) const;\r
+ void set_library_case(bool library_case);\r
+\r
+ bool unit_case(void) const;\r
+ void set_unit_case(bool library_case);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // type handling\r
+ // only units of types added in this way will be recognised\r
+\r
+ bool add_type(const std::string& type,\r
+ const std::string& description,\r
+ lm_create_callback fn = 0,\r
+ void* type_data = 0);\r
+ bool remove_type(const std::string& type);\r
+ std::vector<std::string> types(void) const;\r
+\r
+ std::string description(const std::string& type) const;\r
+ lm_create_callback callback(const std::string& type) const;\r
+ void* type_data(const std::string& type) const;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // Library mappings\r
+ // The library manager implements two different styles of library mappings\r
+ // - mapping file\r
+ // - ini file\r
+ // mapping file handling uses a simple text file to store the mappings in an internally-defined format\r
+ // ini file handling stores library mappings using the ini_manager component\r
+ // These modes are switched on by simply specifying a mapping file or an ini file to hold the mappings\r
+\r
+ // mapping file methods\r
+\r
+ // set but do not load - use this when you want to create a new mapping file\r
+ void set_mapping_file(const std::string& mapping_file);\r
+ // set and load - use this with an existing mapping file\r
+ bool load_mappings (const std::string& mapping_file);\r
+ // return the mapping file string\r
+ std::string mapping_file();\r
+\r
+ // ini file methods - the ini manager must be pre-loaded with the list of ini files to manage\r
+\r
+ // set and load - this will create the relevant sections in the local ini file if not present already\r
+ bool set_ini_manager(ini_manager* ini_files, const std::string& library_section, const std::string& work_section);\r
+ ini_manager* get_ini_manager(void) const;\r
+\r
+ // save to the library mapping handler, whichever kind it is\r
+ bool save_mappings (void);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // library management\r
+\r
+ // operations on a single library\r
+ // test whether a named library exists\r
+ bool exists(const std::string& name) const;\r
+ // create a new libarry in the specified directory\r
+ lm_library* create(const std::string& name, const std::string& path, bool writable = true);\r
+ // open an existing library\r
+ lm_library* open(const std::string& path);\r
+ // load all units in the library\r
+ bool load(const std::string& name);\r
+ // save all marked units in the library\r
+ bool save(const std::string& name);\r
+ // purge all loaded units in the library\r
+ bool purge(const std::string& name);\r
+ // close the library - remove it from the manager but leave on disk\r
+ bool close(const std::string& name);\r
+ // erase the library - delete the directory and remove the library from the manager\r
+ bool erase(const std::string& name);\r
+\r
+ // operations on all libraries - as above but applied to all the libraries in the manager\r
+ bool load(void);\r
+ bool save(void);\r
+ bool purge(void);\r
+ bool close(void);\r
+ bool erase(void);\r
+\r
+ // get name and path of a library - name can differ in case if the library manager is case-insensitive\r
+ std::string name(const std::string& library) const;\r
+ std::string path(const std::string& library) const;\r
+\r
+ // control and test read/write status\r
+ bool set_writable(const std::string& library);\r
+ bool set_read_only(const std::string& library);\r
+ bool writable(const std::string& library) const;\r
+ bool read_only(const std::string& library) const;\r
+ bool os_writable(const std::string& library) const;\r
+ bool os_read_only(const std::string& library) const;\r
+ bool lm_writable(const std::string& library) const;\r
+ bool lm_read_only(const std::string& library) const;\r
+\r
+ // find a library in the manager - returns null if not found\r
+ lm_library* find(const std::string& name);\r
+ const lm_library* find(const std::string& name) const;\r
+\r
+ // get the set of all library names\r
+ std::vector<std::string> names(void) const;\r
+ // get the set of all libraries\r
+ std::vector<const lm_library*> handles(void) const;\r
+ std::vector<lm_library*> handles(void);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // current library management\r
+\r
+ bool setwork(const std::string& library);\r
+ bool unsetwork(void);\r
+ const lm_library* work(void) const;\r
+ lm_library* work(void);\r
+ std::string work_name(void) const;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // unit management within a library\r
+ // Note: you can also manipulate the library class through a handle returned by find() or handles()\r
+\r
+ bool exists(const std::string& library, const lm_unit_name& name) const;\r
+ lm_unit_ptr create(const std::string& library, const lm_unit_name& name);\r
+ bool loaded(const std::string& library, const lm_unit_name& name) const;\r
+ bool load(const std::string& library, const lm_unit_name& name);\r
+ bool purge(const std::string& library, const lm_unit_name& name);\r
+ bool save(const std::string& library, const lm_unit_name& name);\r
+ bool erase(const std::string& library, const lm_unit_name& name);\r
+ bool mark(const std::string& library, const lm_unit_name& name);\r
+ time_t modified(const std::string& library, const lm_unit_name& name) const;\r
+\r
+ bool erase_by_source(const std::string& source_file);\r
+\r
+ const lm_unit_ptr find(const std::string& library, const lm_unit_name& name) const;\r
+ lm_unit_ptr find(const std::string& library, const lm_unit_name& name);\r
+\r
+ std::vector<lm_unit_name> names(const std::string& library) const;\r
+ std::vector<std::string> names(const std::string& library, const std::string& type) const;\r
+ std::vector<lm_unit_ptr> handles(const std::string& library) const;\r
+ std::vector<lm_unit_ptr> handles(const std::string& library, const std::string& type) const;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // dependency checking\r
+\r
+ bool out_of_date(const std::string& library, const lm_unit_name& name) const;\r
+ bool up_to_date(const std::string& library, const lm_unit_name& name) const;\r
+ lm_dependencies out_of_date_reason(const std::string& library, const lm_unit_name& name) const;\r
+\r
+ // delete out of date units from a library or all libraries\r
+ // return the number of units tidied and a flag to say whether all units were successfully tidied\r
+ std::pair<bool,unsigned> tidy(const std::string& library);\r
+ std::pair<bool,unsigned> tidy(void);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // do-everything print routine!\r
+\r
+ bool pretty_print(std::ostream& str,\r
+ bool print_units = false, // print the unit names not just the library names\r
+ const std::string& library = std::string(), // print just the specified library ("" means all)\r
+ const std::string& type = std::string()) const; // print just this type ("" means all)\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // diagnostic print routines\r
+\r
+ bool print(std::ostream& str) const;\r
+ bool print_long(std::ostream& str) const;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // internals\r
+\r
+ private:\r
+ // NOT a copyable object\r
+ library_manager(const library_manager&);\r
+ library_manager& operator = (const library_manager&);\r
+\r
+ protected:\r
+ std::list<lm_library>::iterator local_find(const std::string& name);\r
+ std::list<lm_library>::const_iterator local_find(const std::string& name) const;\r
+\r
+ std::string m_owner; // owner application name\r
+ std::string m_mapping_file; // mapping file method of library management\r
+ ini_manager* m_ini_files; // ini manager method of library management\r
+ std::string m_ini_section; // ini manager method of library management\r
+ std::string m_ini_work; // ini manager method of library management\r
+ std::list<lm_library> m_libraries; // libraries\r
+ std::string m_work; // work library\r
+ std::map<std::string,lm_callback_entry> m_callbacks; // callbacks\r
+ bool m_library_case; // case sensitivity for library names\r
+ bool m_unit_case; // case sensitivity for unit names\r
+ };\r
+\r
+ std::ostream& operator << (std::ostream& str, const library_manager& libraries);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+} // end namespace stlplus\r
+\r
+#endif\r
projects / chaz / yoink / blobdiff