object.hh

Go to the documentation of this file.

#ifndef __LOUT_OBJECT_HH__
#define __LOUT_OBJECT_HH__
 
#include <stdlib.h>
#include <string.h>
 
#include "misc.hh"
 
namespace lout {
 
namespace object {
 
class Object
{
public:
   virtual ~Object();
   virtual bool equals(Object *other);
   virtual int hashValue();
   virtual Object *clone();
   virtual void intoStringBuffer(misc::StringBuffer *sb);
   const char *toString();
   virtual size_t sizeOf();
};
 
class Comparable: public Object
{
public:
   virtual int compareTo(Comparable *other) = 0;
};
 
class Comparator: public Object
{
public:
   virtual int compare(Object *o1, Object *o2) = 0;
 
   static Comparator *compareFunComparator;
   static int compareFun(const void *p1, const void *p2);
};
 
class StandardComparator: public Comparator
{
public:
   int compare(Object *o1, Object *o2);
};
 
extern StandardComparator standardComparator;
 
class Pointer: public Object
{
private:
   void *value;
 
public:
   Pointer(void *value) { this->value = value; }
   bool equals(Object *other);
   int hashValue();
   void intoStringBuffer(misc::StringBuffer *sb);
   inline void *getValue() { return value; }
};
 
template <class T> class TypedPointer: public Pointer
{
public:
   inline TypedPointer(T *value) : Pointer ((void*)value) { }
   inline T *getTypedValue() { return (T*)getValue(); }
};
 
 
class Integer: public Comparable
{
   int value;
 
public:
   Integer(int value) { this->value = value; }
   bool equals(Object *other);
   int hashValue();
   void intoStringBuffer(misc::StringBuffer *sb);
   int compareTo(Comparable *other);
   inline int getValue() { return value; }
};
 
 
class Boolean: public Comparable
{
   bool value;
 
public:
   Boolean(bool value) { this->value = value; }
   bool equals(Object *other);
   int hashValue();
   void intoStringBuffer(misc::StringBuffer *sb);
   int compareTo(Comparable *other);
   inline bool getValue() { return value; }
};
 
 
class ConstString: public Comparable
{
protected:
   const char *str;
 
public:
   ConstString(const char *str) { this->str = str; }
   bool equals(Object *other);
   int hashValue();
   int compareTo(Comparable *other);
   void intoStringBuffer(misc::StringBuffer *sb);
 
   inline const char *chars() { return str; }
 
   static int hashValue(const char *str);
};
 
 
class String: public ConstString
{
public:
   String(const char *str);
   ~String();
};
 
class PairBase: public Object
{
protected:
   Object *first, *second;
 
public:
   PairBase(Object *first, Object *second);
   ~PairBase();
 
   bool equals(Object *other);
   int hashValue();
   void intoStringBuffer(misc::StringBuffer *sb);
   size_t sizeOf();
};
 
class Pair: public PairBase
{
public:
   Pair(Object *first, Object *second): PairBase (first, second) { }
 
   inline Object *getFirst () { return first; }
   inline Object *getSecond () { return second; }
};
 
template <class F, class S> class TypedPair: public PairBase
{
public:
   TypedPair(F *first, S *second): PairBase (first, second) { }
 
   inline F *getFirst () { return first; }
   inline S *getSecond () { return second; }
};
 
} // namespace object
 
} // namespace lout
 
#endif // __LOUT_OBJECT_HH__