/usr/include/yacas/lispstring.h is in yacas 1.3.6-2+b1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | /** \file lispstring.h
* Defining a string class.
*/
#ifndef YACAS_LISPSTRING_H
#define YACAS_LISPSTRING_H
#include "refcount.h"
#include <string>
class LispStringSmartPtr;
/** \class LispString : zero-terminated byte-counted string.
* Also keeps a reference count for any one interested.
*/
class LispString : public std::string
{
public:
explicit LispString(const std::string& = "");
public:
mutable ReferenceCount iReferenceCount;
};
inline LispString::LispString(const std::string& s):
std::string(s),
iReferenceCount(0)
{
}
/** \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(nullptr) {}
// Construct from pointer to LispString
LispStringSmartPtr(const LispString* aString) : iString(nullptr)
{
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 = (const 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 const LispString*() const { return iString; } // implicit conversion to pointer to T
const 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:
const LispString* iString;
};
inline
LispStringSmartPtr& LispStringSmartPtr::operator=(const LispString* aString)
{
// Increment first.
if (aString)
++aString->iReferenceCount;
if (iString)
{
--iString->iReferenceCount;
if (iString->iReferenceCount == 0) delete iString;
}
iString = aString;
return *this;
}
inline
LispStringSmartPtr::~LispStringSmartPtr()
{
if (iString && !--iString->iReferenceCount)
delete iString;
}
#endif
|