STL+ C++ Library Collection
STLplus is a collection of libraries containing reusable C++ components. The library collection is intended for developers already familiar with the STL. It contains abstract data types to extend the STL, reusable subsystems, data persistence and portability components. The collection is general-purpose and portable between Windows and many different Unix platforms including MacOS X.
STLplus contains 5 libraries, most of which can be used independently of the other libraries in the collection. For details of dependencies between libraries and how to use libraries stand-alone, see the Building Guidelines.
Note: STLplus version 3 is not backwards-compatible with STLplus version 2. You should only make the changeover if you are prepared to do some porting work or if you are starting a new project.
Use at Your Own Risk: STLplus version 3 is currently classified as an alpha release. Although it is based on STLplus version 2, which was a stable release, there is enough reworking for all sorts of errors to have crept in. Furthermore, I have not yet ported any significant applications to version 3, so only small test programs have been written so far.
These documents explain how to build and use the STLplus library collection and how to split the collection into stand-alone libraries. It also explains the set of platforms the libraries run on, the versions available and the license terms under which you can use the collection.
These documents some of the principles that have been used in building the STLplus librray collection for those that are interested.
As far as is reasonable, the STLplus libraries have been designed to be used separately. However, some of the libraries use the STLplus containers and portability libraries to make them easier to code and to make them portable too. Also, two of the libraries (persistence and strings) provide additional functionality for some of the other components and therefore are dependent on them. The following table lists the dependencies:
| Library | Required |
|---|---|
| portability | |
| containers | |
| subsystems | containers, portability |
| persistence | containers |
| strings | containers, portability |
The Italicised dependencies are optional. They are on by default, but can be switched off if the required library is not installed. For example, if you want to use the persistence library as a stand-alone library for making C++ types persistent but are not interested in the STLplus containers library, then that can be done. How to do this is explained in the section on building the collection.
The other dependencies that are not italicised are hard dependencies - you must have the required libraries installed.
The portability library provides platform-independent interfaces to platform-specific features. This is so that programs can be written to be inherently portable by using this library to access those features. The target platforms for portability are Windows NT/2k/XP/Vista and all flavours of Posix-compliant Unix, including all the flavours of Linux on PCs, MacOS X on the Apple Macintosh, plus Solaris, HP-UX and AIX on engineering workstations. The target architectures are either 32-bit or 64-bit CPUs. The target compilers are Gnu's gcc (for Linux, MacOS and Windows) and Microsoft's Visual Studio (for Windows).
The components provided are:
The portability library can be used as a stand-alone library since it does not use any features of the rest of the collection.
The containers library contains abstract data classes which expand on the STL as the name STLplus suggests. The data types provided are:
The containers library can be used as a stand-alone library since it does not use any features of the rest of the collection.
The subsystems library contains components to build up applications in a modular way. They provide commonly-used functionality. The subsystems provided are:
The subsystems library requires at least the containers and portability libraries to be installed. This is a hard dependency.
The persistence library contains a solution to the problem of data persistence for C++ data structures. The library allows any well-structured data structure to be dumped and restored. The same library can be used to store data structures in files or to transmit them over network connections. The persistence format is platform-independent (i.e. independent of the compiler, operating system and CPU architecture) and so can be used to transfer data structures between platforms.
The persistence library has a soft dependency on the containers library. In stand-alone mode it will make all C and C++ types including the STL classes persistent. If it is compiled with the dependencies, then it will make the classes of the STLplus containers persistent as well as all the other types supported.
The strings library provides a set of functions that can be used to build up string representations of data structures for printing or for diagnostic text dumps. They use similar concepts to the persistence library in that they form a kit of parts which can be assembled to print any data structure.
The strings library requires the portability library to be installed. It also has soft dependencies on the containers library. Without the containers library, the library provides string representations of all C and C++ types including the STL classes. With the containers library it also makes the STLplus classes in the containers library printable.