libprf1
Project home

The libprf1 library provides cross-platform, multi-language support for accessing the PRF 1.0 configuration files. PRF 1.0 (Preferences Registry Format) is an XML-based simple, yet very useful, extensible configuration file format.

Mission and Scope

What problem does this project address?

A search on the Web (using Google) for a cross-platform library for managing persistent application configuration data in Python or C/C++ (or even Java) didn't give any good results back in October 2003, when I needed it, writing a cross-platform GUI application in Python, so I decided to design a new simple format for helping managing configuration data and write a library for it.

So, answering the question, the problem of a lack of a simple, good, fairly independent (in sense of computer and OS platform) toolkit library for managing configuration data in applications has lead me to developing a new format and a new library. I liked the results I achieved, so I decided to make them public.

What is the goal of this project?

1. Provide programmers with a useful and easy to use design solution for storing configuration data everywhere. The basic idea of PRF 1.0 library's API is to abstract configuration data structures into a common "container" idiom and define interfaces, common to containers. NOTE: The resulting solution *must* be platform- and language-independent. Implementing as much variants of the same API as possible is encouraged.
2. Release at least two or three implementations of the PRF 1.0 API: in Python, C++ and Java programming languages, for this library to be useful in many operating and development environments.

What is the scope of this project?

We will be focused on developing the library, the API documentation and additional usage/implementation documentation. Developing the PRF format is also part of the effort (since the library is closely related to this format).

Status

Resources and schedule

What are the deadlines for this project?

• 06-05-2004: Released the first alpha version of the C++ implementation of the library
• 20-04-2004: Release a useful beta version of the Python module. Start implementing the C++ version of the library.
• 31-01-2004: Release the first alpha version of the libprf1-python. Start developing the C++ implementation of the library (libprf1-c++).
• 26-01-2004: PRF 1.0 API Specification and Implementation Notes completion and freeze. Start developing the Python implementation of the API (libprf1-python).

Who is working on this project?

• Andrei Sosnin (aka tomatensaft)

What capital resources are allocated to this project?

• Developers' home PCs
• Open-source software:
  • GNU/Linux operating system
  • Python interpreter
  • GNU Compilers Collection (g++)
  • GNU Emacs editor
  • ArgoUML design tool
• Freely redistributable software:
  • Java 2 SE SDK and Runtime Environment
  • Other software
• Open-source development community web-sites, such as Tigris.org
• Open standards and architectures: freely available technical documentation
• Tallinn Technical University Library with lots of IT and CS literature.

What are the main legal concerns for this project?

• Patents: we may use some technologies, that may be patented in some countries. Technologies potentially involved are: GIF, UML, XMI... We will try to avoid this, but nothing we can guarantee in this concern. Note, that the file format and algorithms, used in the library implementation are unlikely to be patented, though users could check that too, if they are concerned about it.

Software requirements

The Python module uses xml.dom PyXML DOM Level 2 extension to the Standard Python Library for accessing XML. More information can be found on PyXML web-site. It is recommended to use version 0.8.3 or later of PyXML package.

The C++ implementation (libprf1-c++) depends on the Apache Xerces-C++ library, namely, on its DOM Level 2 API implementation. The library occasionally makes use of the DOM Level 3 API as well. The version of the xerces-c library with which the libprf-c++ library is being developed is 2.3.0.

Implementations in other languages, if any, will have similar requirements.

Design

What are your ranked design goals?

The following goals apply:

1. Correctness: This design correctly matches the given requirements.
2. Feasibility: This design can be implemented and tested with the planned amount of time and effort.
3. Understandability: Developers can understand this design and correctly implement it.
4. Implementation phase guidance: This design divides the implementation into components or aspects that can correspond to reasonable implementation tasks.
5. Modularity: Concerns are clearly separated so that the impact of most design changes would be limited to only one or a few modules.
6. Extensibility: New features can be easily added later.
7. Testability: It is easy to test components of this design independently, and information is available to help diagnose defects.
8. Efficiency: The design enables the system to perform functions with an acceptable amount of time, storage space, bandwidth, and other resources.

Design documents

• PRF 1.0 API, Specification and Implementation Notes (Format: HTML, PDF)
• PRF 1.0 C++ API, (Format: HTML)
• PRF 1.0, Specification (Format: HTML, PDF)

Current UML class diagrams: