uPDF with buttons

git-svn-id: svn://kolibrios.org@4680 a494cfbc-eb01-0410-851d-a64ba20cac60

contrib/media/updf/include/lispstring.h

@@ -0,0 +1,117 @@
+/** \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
+
+