kolibrios/contrib/media/updf/include/lispstring.h
right-hearted 4f7ee97ec9 uPDF with buttons
git-svn-id: svn://kolibrios.org@4680 a494cfbc-eb01-0410-851d-a64ba20cac60
2014-03-22 21:00:40 +00:00

118 lines
4.1 KiB
C++

/** \file lispstring.h
* Defining a string class.
*/
#ifndef __lispstring_h__
#define __lispstring_h__
#include "yacasbase.h"
#include "grower.h"
#include "refcount.h"
class LispStringSmartPtr;
/** \class LispString : zero-terminated byte-counted string.
* Also keeps a reference count for any one interested.
* LispString is derived from CArrayGrower, so the function
* Size returns the length of the buffer. Since the string
* is also zero-terminated (for better interfacing with the normal
* c functions), the string length is Size()-1.
*
* This class also allows the string to point to a buffer which is owned
* by another part of the system, in which case it cannot be resized.
* The array will then not be freed by this class.
*/
class LispString : public CArrayGrower<LispChar,ArrOpsPOD<LispChar> >
{
public:
// Constructors
// The constructors allow the caller to specify whether the storage is owned externally.
// Use the assignment operators to set the string after this.
inline LispString(LispBoolean aStringOwnedExternally=LispFalse);
inline LispString(LispString &aString, LispBoolean aStringOwnedExternally=LispFalse);
inline LispString(LispChar * aString, LispBoolean aStringOwnedExternally);
inline LispString(const LispChar * aString);
// Assignment
// This assignment abides by earlier functions setting the string as owned externally.
inline LispString& operator=(LispChar * aString);
// Assignments (with modifications). This string cannot be owned externally.
// Set string by taking part of another string.
void SetStringCounted(const LispChar * aString, LispInt aLength);
// Set string from other string, adding quotes around the string.
void SetStringUnStringified(const LispChar * aString);
// Set string from other string, removing quotes around the string.
void SetStringStringified(const LispChar * aString);
// Access
inline LispChar * c_str() const; // pointer to asciz 'C-string'
// Comparison
// If the string is in the hash table it is faster to compare the pointers to the strings
// (instead of calling this routine), since in that case if they
// are equal they should in fact be literally the same object.
LispInt operator==(const LispString& aString);
~LispString();
private:
inline void SetString(LispChar * aString, LispBoolean aStringOwnedExternally);
void SetString(const LispChar * aString);
public:
ReferenceCount iReferenceCount;
};
/** \class LispStringSmartPtr for managing strings outside
of normal objects. This is the equivalent of LispPtr, maintaining
a reference count for the string object.
*/
class LispStringSmartPtr
{
public:
// Default constructor (not explicit, so it auto-initializes)
LispStringSmartPtr() : iString(NULL) {}
// Construct from pointer to LispString
LispStringSmartPtr(LispString * aString) : iString(NULL)
{
this->operator=(aString);
}
// Copy constructor
LispStringSmartPtr(const LispStringSmartPtr& aOther) : iString()
{
this->operator=(aOther.iString);
}
// Destructor
~LispStringSmartPtr();
// Assignment from pointer. (PDG - new method)
// (we return void, not *this).
LispStringSmartPtr& operator=(LispString * aString);
// Assignment from another (the *default* simply assigns members, not what we want).
// (we return void, not *this).
LispStringSmartPtr& operator=(const LispStringSmartPtr &aOther) { this->operator=(aOther.iString); return *this; }
// Expected pointer behavior.
operator LispString*() const { return iString; } // implicit conversion to pointer to T
LispString *operator->() const { return iString; } // so (smartPtr->member) accesses T's member
// Operators below are not used yet, so they are commented out. If you want to use them you need to test if they work.
//LispString &operator*() const { return *iString; } // so (*smartPtr) is a reference to T
//LispString *ptr() const { return iString; } // so (smartPtr.ptr()) returns the pointer to T (boost calls this method 'get')
//bool operator!() const { return !iString; } // is null pointer
private:
LispString * iString;
};
#include "lispstring.inl"
#endif