spl Standard Portable Library

0.4.0

Introduction

The Standard Portable Library (SPL) is a smart pointer based cross platform application framework. SPL is intended to be used instead of STL and has an API that should be familiar to dot net and java programmers. It includes basic types such as Date and DateTime, runtime pointer debugging, collection templates, file IO, networking, database access, threading, and XML parsing. Sourceforge site

Things You Might Not Like About SPL

SPL should be considered as beta quality, i.e. feature complete but not necessarily ready for production. At this point, the only missing planned features are XPath, XmlNode.SelectSingle(), XmlNode.SelectNodes(), and fixed width file handling.
Pascal/C# naming conventions are used, so member functions start with an upper case letter.
Prefix type notation, such as lpcstrzMyVar, is not used.
Unit test code coverage is only about 30% or 40%.
Smart pointers of templated types don't have typedef'ed short names. For example the String smart pointer has a typedef of StringPtr. However, a List of Strings must be declared using RefCountPtr<List<String> >
DEBUG builds of applications with numerous memory allocations can run slowly due to extensive runtime pointer validation.

Application Organization

There are a few steps to setup and teardown the library. The skeleton below is for command line applications.

#include <spl/Debug.h>
#include <spl/configuration/CommandLine.h>
#include <spl/Log.h>
#include <spl/UnitTest.h>
#include <spl/net/Socket.h>

int main(int argc, char **argv)
{
        try
        {
                CommandLine args(argc, (const char **)argv);
                
                //
                // Do stuff.
                //
                
                ASSERT_MEM_FREE();
                Socket::ShutdownService();
                DEBUG_TEAR_DOWN(true);
                
                return (Log::SMessageCount() > 0) ? 20 : 0;
        }
        catch ( Exception *ex )
        {
                Log::SWrite( ex );
                delete ex;
        }
        catch ( OutOfMemoryException mex )
        {
                Log::SWrite( mex );
        }
        return 20;
}

Windows Development

If you're doing windozes development, be sure to include stdafx, windows top level headers, and #import's prior to including SPL headers. SPL uses an abrievated set of windows headers to get networking to work. If you susequently include <windows.h>, you'll get a lot of errors.

Smart Pointers

There are three templates used to implement smart pointers: RefCountPtr, RefCountPtrCast, and WeakReference. RefCountPointer overloads "->", so variables declared with it can be used just like orginary pointers. The raw pointer is also available if needed.

RefCountPtr<String> pstr(new String("Hi"));

// Call String member function.
int len = pstr->Length();

// Use the raw String pointer.
len = pstr.Get()->Length();

When you need to cast from pointer type to another, define a RefCountPtrCast. For example, let's say that you have a class SuperString that inherits from String. Putting the following definitions in SuperString's header will allow the compliler to automaticly convert the pointers.

#include <spl/String.h>

class SuperString : public String
{
};

typedef RefCountPtrCast<SuperString, String, StringPtr> SuperStringPtr;

To avoid circular references that would prevent the pointer from being released, use WeakReference. Let's say the A creates an instance of B and B holds a back pointer to A. A should use RefCountPtr<B> and B should use WeakReference<A> You'll also need to use an interface to break the compiler dependancy loop.

Packages

Synchronization Primitives

Text

Web

XML

SPL includes source code from the sources below (see the source file headers for

specific attributions and modification notices).

John Garrison
Writing Solid Code
bouncycastle.org
commonc++
GNU Classpath
PCRE
SQLITE
TinyXml
Brian Parker. "Poor Man's typeof() Implementation," Comp.std.c++, 10 November 1997