Add some constness to the basic classes
diff --git a/goo/GooString.cc b/goo/GooString.cc
index f76e7d1..10976e8 100644
--- a/goo/GooString.cc
+++ b/goo/GooString.cc
@@ -923,7 +923,7 @@
insert(0, (char)0xfe);
}
-GooString *GooString::sanitizedName(GBool psmode)
+GooString *GooString::sanitizedName(GBool psmode) const
{
GooString *name;
char buf[8];
diff --git a/goo/GooString.h b/goo/GooString.h
index 5d17ec8..a5418c3 100644
--- a/goo/GooString.h
+++ b/goo/GooString.h
@@ -168,7 +168,7 @@
// not contain any ( ) < > [ ] { } / %
// The postscript mode also has some more strict checks
// The caller owns the return value
- GooString *sanitizedName(GBool psmode);
+ GooString *sanitizedName(GBool psmode) const;
private:
GooString(const GooString &other);
diff --git a/poppler/Array.cc b/poppler/Array.cc
index c2c4040..94b8d66 100644
--- a/poppler/Array.cc
+++ b/poppler/Array.cc
@@ -65,7 +65,7 @@
#endif
}
-Object Array::copy(XRef *xrefA) {
+Object Array::copy(XRef *xrefA) const {
arrayLocker();
Array *a = new Array(xrefA);
for (int i = 0; i < length; ++i) {
@@ -114,7 +114,7 @@
memmove( elems + i, elems + i + 1, sizeof(elems[0]) * (length - i) );
}
-Object Array::get(int i, int recursion) {
+Object Array::get(int i, int recursion) const {
if (i < 0 || i >= length) {
#ifdef DEBUG_MEM
abort();
@@ -125,7 +125,7 @@
return elems[i].fetch(xref, recursion);
}
-Object Array::getNF(int i) {
+Object Array::getNF(int i) const {
if (i < 0 || i >= length) {
#ifdef DEBUG_MEM
abort();
@@ -136,7 +136,7 @@
return elems[i].copy();
}
-GBool Array::getString(int i, GooString *string)
+GBool Array::getString(int i, GooString *string) const
{
Object obj = getNF(i);
if (obj.isString()) {
diff --git a/poppler/Array.h b/poppler/Array.h
index 8043c83..d2cdf65 100644
--- a/poppler/Array.h
+++ b/poppler/Array.h
@@ -50,10 +50,10 @@
~Array();
// Get number of elements.
- int getLength() { return length; }
+ int getLength() const { return length; }
// Copy array with new xref
- Object copy(XRef *xrefA);
+ Object copy(XRef *xrefA) const;
// Add an element
// elem becomes a dead object after this call
@@ -63,9 +63,9 @@
void remove(int i);
// Accessors.
- Object get(int i, int resursion = 0);
- Object getNF(int i);
- GBool getString(int i, GooString *string);
+ Object get(int i, int resursion = 0) const;
+ Object getNF(int i) const;
+ GBool getString(int i, GooString *string) const;
private:
friend class Object; // for incRef/decRef
@@ -80,7 +80,7 @@
int length; // number of elements in array
int ref; // reference count
#if MULTITHREADED
- GooMutex mutex;
+ mutable GooMutex mutex;
#endif
};
diff --git a/poppler/Dict.cc b/poppler/Dict.cc
index 5c231d1..2bd86ab 100644
--- a/poppler/Dict.cc
+++ b/poppler/Dict.cc
@@ -163,7 +163,7 @@
++length;
}
-inline DictEntry *Dict::find(const char *key) {
+inline DictEntry *Dict::find(const char *key) const {
if (!sorted && length >= SORT_LENGTH_LOWER_LIMIT)
{
dictLocker();
@@ -187,7 +187,7 @@
return NULL;
}
-GBool Dict::hasKey(const char *key) {
+GBool Dict::hasKey(const char *key) const {
return find(key) != NULL;
}
@@ -247,25 +247,25 @@
}
-GBool Dict::is(const char *type) {
+GBool Dict::is(const char *type) const {
DictEntry *e;
return (e = find("Type")) && e->val.isName(type);
}
-Object Dict::lookup(const char *key, int recursion) {
+Object Dict::lookup(const char *key, int recursion) const {
DictEntry *e;
return (e = find(key)) ? e->val.fetch(xref, recursion) : Object(objNull);
}
-Object Dict::lookupNF(const char *key) {
+Object Dict::lookupNF(const char *key) const {
DictEntry *e;
return (e = find(key)) ? e->val.copy() : Object(objNull);
}
-GBool Dict::lookupInt(const char *key, const char *alt_key, int *value)
+GBool Dict::lookupInt(const char *key, const char *alt_key, int *value) const
{
GBool success = gFalse;
Object obj1 = lookup ((char *) key);
@@ -283,14 +283,14 @@
return success;
}
-char *Dict::getKey(int i) {
+char *Dict::getKey(int i) const {
return entries[i].key;
}
-Object Dict::getVal(int i) {
+Object Dict::getVal(int i) const {
return entries[i].val.fetch(xref);
}
-Object Dict::getValNF(int i) {
+Object Dict::getValNF(int i) const {
return entries[i].val.copy();
}
diff --git a/poppler/Dict.h b/poppler/Dict.h
index b775a57..1b922b0 100644
--- a/poppler/Dict.h
+++ b/poppler/Dict.h
@@ -57,7 +57,7 @@
~Dict();
// Get number of entries.
- int getLength() { return length; }
+ int getLength() const { return length; }
// Add an entry. NB: does not copy key.
// val becomes a dead object after the call
@@ -70,27 +70,27 @@
void remove(const char *key);
// Check if dictionary is of specified type.
- GBool is(const char *type);
+ GBool is(const char *type) const;
// Look up an entry and return the value. Returns a null object
// if <key> is not in the dictionary.
- Object lookup(const char *key, int recursion = 0);
- Object lookupNF(const char *key);
- GBool lookupInt(const char *key, const char *alt_key, int *value);
+ Object lookup(const char *key, int recursion = 0) const;
+ Object lookupNF(const char *key) const;
+ GBool lookupInt(const char *key, const char *alt_key, int *value) const;
// Iterative accessors.
- char *getKey(int i);
- Object getVal(int i);
- Object getValNF(int i);
+ char *getKey(int i) const;
+ Object getVal(int i) const;
+ Object getValNF(int i) const;
// Set the xref pointer. This is only used in one special case: the
// trailer dictionary, which is read before the xref table is
// parsed.
void setXRef(XRef *xrefA) { xref = xrefA; }
- XRef *getXRef() { return xref; }
+ XRef *getXRef() const { return xref; }
- GBool hasKey(const char *key);
+ GBool hasKey(const char *key) const;
private:
friend class Object; // for incRef/decRef
@@ -99,17 +99,17 @@
int incRef();
int decRef();
- GBool sorted;
+ mutable GBool sorted;
XRef *xref; // the xref table for this PDF file
DictEntry *entries; // array of entries
int size; // size of <entries> array
int length; // number of entries in dictionary
int ref; // reference count
#if MULTITHREADED
- GooMutex mutex;
+ mutable GooMutex mutex;
#endif
- DictEntry *find(const char *key);
+ DictEntry *find(const char *key) const;
};
#endif
diff --git a/poppler/Object.cc b/poppler/Object.cc
index 4fce012..d3adc44 100644
--- a/poppler/Object.cc
+++ b/poppler/Object.cc
@@ -160,11 +160,11 @@
type = objNone;
}
-const char *Object::getTypeName() {
+const char *Object::getTypeName() const {
return objTypeNames[type];
}
-void Object::print(FILE *f) {
+void Object::print(FILE *f) const {
Object obj;
int i;
diff --git a/poppler/Object.h b/poppler/Object.h
index 23c98a9..8b18af6 100644
--- a/poppler/Object.h
+++ b/poppler/Object.h
@@ -184,100 +184,100 @@
Object fetch(XRef *xref, int recursion = 0) const;
// Type checking.
- ObjType getType() { CHECK_NOT_DEAD; return type; }
- GBool isBool() { CHECK_NOT_DEAD; return type == objBool; }
- GBool isInt() { CHECK_NOT_DEAD; return type == objInt; }
- GBool isReal() { CHECK_NOT_DEAD; return type == objReal; }
- GBool isNum() { CHECK_NOT_DEAD; return type == objInt || type == objReal || type == objInt64; }
- GBool isString() { CHECK_NOT_DEAD; return type == objString; }
- GBool isName() { CHECK_NOT_DEAD; return type == objName; }
- GBool isNull() { CHECK_NOT_DEAD; return type == objNull; }
- GBool isArray() { CHECK_NOT_DEAD; return type == objArray; }
- GBool isDict() { CHECK_NOT_DEAD; return type == objDict; }
- GBool isStream() { CHECK_NOT_DEAD; return type == objStream; }
- GBool isRef() { CHECK_NOT_DEAD; return type == objRef; }
- GBool isCmd() { CHECK_NOT_DEAD; return type == objCmd; }
- GBool isError() { CHECK_NOT_DEAD; return type == objError; }
- GBool isEOF() { CHECK_NOT_DEAD; return type == objEOF; }
- GBool isNone() { CHECK_NOT_DEAD; return type == objNone; }
- GBool isInt64() { CHECK_NOT_DEAD; return type == objInt64; }
- GBool isIntOrInt64() { CHECK_NOT_DEAD; return type == objInt || type == objInt64; }
+ ObjType getType() const { CHECK_NOT_DEAD; return type; }
+ GBool isBool() const { CHECK_NOT_DEAD; return type == objBool; }
+ GBool isInt() const { CHECK_NOT_DEAD; return type == objInt; }
+ GBool isReal() const { CHECK_NOT_DEAD; return type == objReal; }
+ GBool isNum() const { CHECK_NOT_DEAD; return type == objInt || type == objReal || type == objInt64; }
+ GBool isString() const { CHECK_NOT_DEAD; return type == objString; }
+ GBool isName() const { CHECK_NOT_DEAD; return type == objName; }
+ GBool isNull() const { CHECK_NOT_DEAD; return type == objNull; }
+ GBool isArray() const { CHECK_NOT_DEAD; return type == objArray; }
+ GBool isDict() const { CHECK_NOT_DEAD; return type == objDict; }
+ GBool isStream() const { CHECK_NOT_DEAD; return type == objStream; }
+ GBool isRef() const { CHECK_NOT_DEAD; return type == objRef; }
+ GBool isCmd() const { CHECK_NOT_DEAD; return type == objCmd; }
+ GBool isError() const { CHECK_NOT_DEAD; return type == objError; }
+ GBool isEOF() const { CHECK_NOT_DEAD; return type == objEOF; }
+ GBool isNone() const { CHECK_NOT_DEAD; return type == objNone; }
+ GBool isInt64() const { CHECK_NOT_DEAD; return type == objInt64; }
+ GBool isIntOrInt64() const { CHECK_NOT_DEAD; return type == objInt || type == objInt64; }
// Special type checking.
- GBool isName(const char *nameA)
+ GBool isName(const char *nameA) const
{ return type == objName && !strcmp(cString, nameA); }
- GBool isDict(const char *dictType);
- GBool isStream(char *dictType);
- GBool isCmd(const char *cmdA)
+ GBool isDict(const char *dictType) const;
+ GBool isStream(char *dictType) const;
+ GBool isCmd(const char *cmdA) const
{ return type == objCmd && !strcmp(cString, cmdA); }
// Accessors.
- GBool getBool() { OBJECT_TYPE_CHECK(objBool); return booln; }
- int getInt() { OBJECT_TYPE_CHECK(objInt); return intg; }
- double getReal() { OBJECT_TYPE_CHECK(objReal); return real; }
+ GBool getBool() const { OBJECT_TYPE_CHECK(objBool); return booln; }
+ int getInt() const { OBJECT_TYPE_CHECK(objInt); return intg; }
+ double getReal() const { OBJECT_TYPE_CHECK(objReal); return real; }
// Note: integers larger than 2^53 can not be exactly represented by a double.
// Where the exact value of integers up to 2^63 is required, use isInt64()/getInt64().
- double getNum() { OBJECT_3TYPES_CHECK(objInt, objInt64, objReal);
+ double getNum() const { OBJECT_3TYPES_CHECK(objInt, objInt64, objReal);
return type == objInt ? (double)intg : type == objInt64 ? (double)int64g : real; }
- double getNum(bool *ok) {
+ double getNum(bool *ok) const {
if (unlikely(type != objInt && type != objInt64 && type != objReal)) {
*ok = false;
return 0.;
}
return type == objInt ? (double)intg : type == objInt64 ? (double)int64g : real;
}
- GooString *getString() { OBJECT_TYPE_CHECK(objString); return string; }
+ GooString *getString() const { OBJECT_TYPE_CHECK(objString); return string; }
// After takeString() the only method that should be called for the object is free()
// because the object it's not expected to have a NULL string.
GooString *takeString() {
OBJECT_TYPE_CHECK(objString); GooString *s = string; string = NULL; return s; }
- char *getName() { OBJECT_TYPE_CHECK(objName); return cString; }
- Array *getArray() { OBJECT_TYPE_CHECK(objArray); return array; }
- Dict *getDict() { OBJECT_TYPE_CHECK(objDict); return dict; }
- Stream *getStream() { OBJECT_TYPE_CHECK(objStream); return stream; }
- Ref getRef() { OBJECT_TYPE_CHECK(objRef); return ref; }
- int getRefNum() { OBJECT_TYPE_CHECK(objRef); return ref.num; }
- int getRefGen() { OBJECT_TYPE_CHECK(objRef); return ref.gen; }
- char *getCmd() { OBJECT_TYPE_CHECK(objCmd); return cString; }
- long long getInt64() { OBJECT_TYPE_CHECK(objInt64); return int64g; }
- long long getIntOrInt64() { OBJECT_2TYPES_CHECK(objInt, objInt64);
+ char *getName() const { OBJECT_TYPE_CHECK(objName); return cString; }
+ Array *getArray() const { OBJECT_TYPE_CHECK(objArray); return array; }
+ Dict *getDict() const { OBJECT_TYPE_CHECK(objDict); return dict; }
+ Stream *getStream() const { OBJECT_TYPE_CHECK(objStream); return stream; }
+ Ref getRef() const { OBJECT_TYPE_CHECK(objRef); return ref; }
+ int getRefNum() const { OBJECT_TYPE_CHECK(objRef); return ref.num; }
+ int getRefGen() const { OBJECT_TYPE_CHECK(objRef); return ref.gen; }
+ char *getCmd() const { OBJECT_TYPE_CHECK(objCmd); return cString; }
+ long long getInt64() const { OBJECT_TYPE_CHECK(objInt64); return int64g; }
+ long long getIntOrInt64() const { OBJECT_2TYPES_CHECK(objInt, objInt64);
return type == objInt ? intg : int64g; }
// Array accessors.
- int arrayGetLength();
+ int arrayGetLength() const;
void arrayAdd(Object &&elem);
void arrayRemove(int i);
- Object arrayGet(int i, int recursion);
- Object arrayGetNF(int i);
+ Object arrayGet(int i, int recursion) const;
+ Object arrayGetNF(int i) const;
// Dict accessors.
- int dictGetLength();
+ int dictGetLength() const;
void dictAdd(char *key, Object &&val);
void dictSet(const char *key, Object &&val);
void dictRemove(const char *key);
- GBool dictIs(const char *dictType);
- Object dictLookup(const char *key, int recursion = 0);
- Object dictLookupNF(const char *key);
- char *dictGetKey(int i);
- Object dictGetVal(int i);
- Object dictGetValNF(int i);
+ GBool dictIs(const char *dictType) const;
+ Object dictLookup(const char *key, int recursion = 0) const;
+ Object dictLookupNF(const char *key) const;
+ char *dictGetKey(int i) const;
+ Object dictGetVal(int i) const;
+ Object dictGetValNF(int i) const;
// Stream accessors.
- GBool streamIs(char *dictType);
+ GBool streamIs(char *dictType) const;
void streamReset();
void streamClose();
- int streamGetChar();
- int streamGetChars(int nChars, Guchar *buffer);
- int streamLookChar();
- char *streamGetLine(char *buf, int size);
- Goffset streamGetPos();
+ int streamGetChar() const;
+ int streamGetChars(int nChars, Guchar *buffer) const;
+ int streamLookChar() const;
+ char *streamGetLine(char *buf, int size) const;
+ Goffset streamGetPos() const;
void streamSetPos(Goffset pos, int dir = 0);
- Dict *streamGetDict();
+ Dict *streamGetDict() const;
// Output.
- const char *getTypeName();
- void print(FILE *f = stdout);
+ const char *getTypeName() const;
+ void print(FILE *f = stdout) const;
// Memory testing.
static void memCheck(FILE *f);
@@ -319,7 +319,7 @@
#include "Array.h"
-inline int Object::arrayGetLength()
+inline int Object::arrayGetLength() const
{ OBJECT_TYPE_CHECK(objArray); return array->getLength(); }
inline void Object::arrayAdd(Object &&elem)
@@ -328,10 +328,10 @@
inline void Object::arrayRemove(int i)
{ OBJECT_TYPE_CHECK(objArray); array->remove(i); }
-inline Object Object::arrayGet(int i, int recursion = 0)
+inline Object Object::arrayGet(int i, int recursion = 0) const
{ OBJECT_TYPE_CHECK(objArray); return array->get(i, recursion); }
-inline Object Object::arrayGetNF(int i)
+inline Object Object::arrayGetNF(int i) const
{ OBJECT_TYPE_CHECK(objArray); return array->getNF(i); }
//------------------------------------------------------------------------
@@ -340,7 +340,7 @@
#include "Dict.h"
-inline int Object::dictGetLength()
+inline int Object::dictGetLength() const
{ OBJECT_TYPE_CHECK(objDict); return dict->getLength(); }
inline void Object::dictAdd(char *key, Object &&val)
@@ -352,25 +352,25 @@
inline void Object::dictRemove(const char *key)
{ OBJECT_TYPE_CHECK(objDict); dict->remove(key); }
-inline GBool Object::dictIs(const char *dictType)
+inline GBool Object::dictIs(const char *dictType) const
{ OBJECT_TYPE_CHECK(objDict); return dict->is(dictType); }
-inline GBool Object::isDict(const char *dictType)
+inline GBool Object::isDict(const char *dictType) const
{ return type == objDict && dictIs(dictType); }
-inline Object Object::dictLookup(const char *key, int recursion)
+inline Object Object::dictLookup(const char *key, int recursion) const
{ OBJECT_TYPE_CHECK(objDict); return dict->lookup(key, recursion); }
-inline Object Object::dictLookupNF(const char *key)
+inline Object Object::dictLookupNF(const char *key) const
{ OBJECT_TYPE_CHECK(objDict); return dict->lookupNF(key); }
-inline char *Object::dictGetKey(int i)
+inline char *Object::dictGetKey(int i) const
{ OBJECT_TYPE_CHECK(objDict); return dict->getKey(i); }
-inline Object Object::dictGetVal(int i)
+inline Object Object::dictGetVal(int i) const
{ OBJECT_TYPE_CHECK(objDict); return dict->getVal(i); }
-inline Object Object::dictGetValNF(int i)
+inline Object Object::dictGetValNF(int i) const
{ OBJECT_TYPE_CHECK(objDict); return dict->getValNF(i); }
//------------------------------------------------------------------------
@@ -379,10 +379,10 @@
#include "Stream.h"
-inline GBool Object::streamIs(char *dictType)
+inline GBool Object::streamIs(char *dictType) const
{ OBJECT_TYPE_CHECK(objStream); return stream->getDict()->is(dictType); }
-inline GBool Object::isStream(char *dictType)
+inline GBool Object::isStream(char *dictType) const
{ return type == objStream && streamIs(dictType); }
inline void Object::streamReset()
@@ -391,25 +391,25 @@
inline void Object::streamClose()
{ OBJECT_TYPE_CHECK(objStream); stream->close(); }
-inline int Object::streamGetChar()
+inline int Object::streamGetChar() const
{ OBJECT_TYPE_CHECK(objStream); return stream->getChar(); }
-inline int Object::streamGetChars(int nChars, Guchar *buffer)
+inline int Object::streamGetChars(int nChars, Guchar *buffer) const
{ OBJECT_TYPE_CHECK(objStream); return stream->doGetChars(nChars, buffer); }
-inline int Object::streamLookChar()
+inline int Object::streamLookChar() const
{ OBJECT_TYPE_CHECK(objStream); return stream->lookChar(); }
-inline char *Object::streamGetLine(char *buf, int size)
+inline char *Object::streamGetLine(char *buf, int size) const
{ OBJECT_TYPE_CHECK(objStream); return stream->getLine(buf, size); }
-inline Goffset Object::streamGetPos()
+inline Goffset Object::streamGetPos() const
{ OBJECT_TYPE_CHECK(objStream); return stream->getPos(); }
inline void Object::streamSetPos(Goffset pos, int dir)
{ OBJECT_TYPE_CHECK(objStream); stream->setPos(pos, dir); }
-inline Dict *Object::streamGetDict()
+inline Dict *Object::streamGetDict() const
{ OBJECT_TYPE_CHECK(objStream); return stream->getDict(); }
#endif
