Tanl Linguistic Pipeline

search/ixe/Common/metaclass.h

/*
**      IXE
**      Common/metaclass.h: introspection
** ----------------------------------------------------------------------
**      Copyright (c) 2000  Ideare SpA. All rights reserved.
**      Copyright (c) 2000  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  IXE is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef IXE_metaclass_H
#define IXE_metaclass_H

// Settings
#include "platform.h"

// standard
#include <cassert>
#include <cstdio>               // sprintf()
#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>             // RTTI
#include <limits.h>

#if defined(__GNUC__) && __GNUC__ > 2
#include <ext/algorithm>
namespace std {
  using __gnu_cxx::copy_n;
}
#else
#include <algorithm>
#endif

// local
#include "include/ixe.h"
#include "include/sql.h"
#include "Common/item.h"
#include "text/Normalizer.h"

namespace IXE {

#if defined(_WIN32) || defined(__DECCXX) || defined(__GNUC__)
// Avoid wasted bytes
#pragma pack(push, 4)
#endif

// ----------------------------------------------------------------------
// Elements for persistent classes

class Array {
protected:
public:
  Array() : len(0) { }

  Size len;

  Size length() const { return len; }
  void const* base() const { return *(void**)(this+1); }
};

template<class T>
class ArrayOf : public Array {
public:
  typedef T elementType;

  ArrayOf() : data(0) { }

  T const& operator [](Size index) const {
    assert(index < this->len);
    return data[index];
  }

  ~ArrayOf() { delete [] data; }

  T*     data;
};

template <class T>
class Indexable {
public:
  virtual T     operator [](int) const = 0;
};

template <class T>
class Reference {
public:
  Indexable<T>* table;
  DocID         id;

  // Allow any pointer as table, since it can be
  Reference(DocID id = 0, byte* table = 0) :
    table((Indexable<T>*)table), id(id) { }

  Reference&    operator = (Reference const& ref) {
    table = ref.table;
    id = ref.id;
    return *this;
  }

  // Behave as referenced object
  T*            operator ->() { return &table[id]; }
};

// ----------------------------------------------------------------------
// Metalevel primitives

// Base types
struct NullType {};
struct TrueType {};

// Conditional
template <class Cond, class Positive, class Negative = NullType>
struct If { typedef Positive VAL; };

template <class Positive, class Negative>
struct If<NullType, Positive, Negative> { typedef Negative VAL; };

// Check if a type is a pointer
template <class T> struct isPointer { typedef NullType VAL; };
template <class T> struct isPointer<T*> { typedef TrueType VAL; };

// Check if a type is Reference
template <class T> struct isReference { typedef NullType VAL; };
template <class T> struct isReference<Reference<T> > { typedef TrueType VAL; };

// Check class type

template <class T> struct isClass { typedef TrueType VAL; };
template <class T> struct isClass<T*> { typedef NullType VAL; };
template <> struct isClass<bool> { typedef NullType VAL; };
template <> struct isClass<char> { typedef NullType VAL; };
template <> struct isClass<signed char> { typedef NullType VAL; };
template <> struct isClass<short int> { typedef NullType VAL; };
template <> struct isClass<int> { typedef NullType VAL; };
template <> struct isClass<long int> { typedef NullType VAL; };
template <> struct isClass<float> { typedef NullType VAL; };
template <> struct isClass<double> { typedef NullType VAL; };
template <> struct isClass<long double> { typedef NullType VAL; };

template <> struct isClass<unsigned char> { typedef NullType VAL; };
template <> struct isClass<unsigned short int> { typedef NullType VAL; };
template <> struct isClass<unsigned int> { typedef NullType VAL; };
template <> struct isClass<unsigned long int> { typedef NullType VAL; };

template <> struct isClass<const bool> { typedef NullType VAL; };
template <> struct isClass<const char> { typedef NullType VAL; };
template <> struct isClass<const short int> { typedef NullType VAL; };
template <> struct isClass<const int> { typedef NullType VAL; };
template <> struct isClass<const long int> { typedef NullType VAL; };
template <> struct isClass<const float> { typedef NullType VAL; };
template <> struct isClass<const double> { typedef NullType VAL; };
template <> struct isClass<const long double> { typedef NullType VAL; };

template <> struct isClass<const unsigned char> { typedef NullType VAL; };
template <> struct isClass<const unsigned short int> { typedef NullType VAL; };
template <> struct isClass<const unsigned int> { typedef NullType VAL; };
template <> struct isClass<const unsigned long int> { typedef NullType VAL; };

#ifdef _MSC_VER
template <> struct isClass<signed __int64> { typedef NullType VAL; };
template <> struct isClass<unsigned __int64> { typedef NullType VAL; };

template <> struct isClass<const signed __int64> { typedef NullType VAL; };
template <> struct isClass<const unsigned __int64> { typedef NullType VAL; };
#else
template <> struct isClass<signed long long int> { typedef NullType VAL; };
template <> struct isClass<unsigned long long int> { typedef NullType VAL; };

template <> struct isClass<const signed long long int> { typedef NullType VAL; };
template <> struct isClass<const unsigned long long int> { typedef NullType VAL; };
#endif

// STL
template <class T> struct isClass<std::vector<T> > { typedef NullType VAL; };
template <> struct isClass<std::string> { typedef NullType VAL; };

// Check Array
template <class T>
struct isArray { typedef NullType VAL; };

template <class T> struct ArrayType { typedef NullType VAL; };

template <class T>
struct isArray<ArrayOf<T> > { typedef TrueType VAL; };
template <class T> struct ArrayType<ArrayOf<T> > { typedef T VAL; };
template <class T> struct ArrayType<std::vector<T> > { typedef T VAL; };

template <class T>
struct isArray<std::vector<T> > { typedef TrueType VAL; };

// Dereference pointer type
template <class P> struct deref { typedef NullType VAL; };
template <class T> struct deref<T*> { typedef T VAL; };

// ----------------------------------------------------------------------
// Field Descriptors

// don't use offsetof from stddef.h, since some compilers complain
// about its usage from non-POD type classes.
#if (__GNUC__ >= 3)
// Use pointer to member (-1 from experiments)
// Unfortunately does not work for subfields, e.g. FIELD(_digest.d0) in MD5
// which would become &MD5::_digest.d0
//# define offsetOf(type, field) ((size_t)&type::field - 1)
// so we stick with:
# define offsetOf(type, field) (((size_t)&((type *)8)->field) - 8)
#else
# define offsetOf(type, field) (static_cast<IXE::Size>(((size_t)&((type *)0)->field)))
#endif

// Since we just need a pointer to an object of the type of x,
// any pointer works (64 rather 0, to fool GCC which complains about NULL).
// Macro third argument is index type, optional fourth argument is column name:
// KEY0(x, varsize, index)
// KEY0(x, varsize, index, merge)
#define KEY0(x, varsize, index, merge) \
   createField(#x, varsize, offsetOf(_CLASS_, x), &((_CLASS_*)64)->x, index, merge)

#define KEY(x, index) KEY0(x, 0, index, 0)
#define KEYMERGE(x, index, merge) KEY0(x, 0, index, #merge)
#define FIELD(x) KEY0(x, 0, Field::none, 0)
#define VARFIELD(x, varsize) KEY0(x, varsize, Field::none, 0)
#define VARKEY(x, s, index) KEY0(x, s, index, 0)
#define VARKEYMERGE(x, s, index, merge) KEY0(x, s, index, #merge)

#define META(class, fields) \
    META_DEFS(class) \
    static Field* _createFields() { return &fields; }

#define META_DEFS(class) \
    typedef class _CLASS_; \
    static void _factory(void* dst) { *(class*)dst = class(); } \
    static MetaClass _metaClass; \
 \
    int _serialize(char* dst) {byte* p=(byte*)dst; return _metaClass.store(p, (byte*)this) - (byte*)dst; } \
 \
    int _deserialize(char* src) {byte* p=(byte*)src; return _metaClass.fetch((byte*)this, p) - (byte*)src; } \
 \
    void _clear() { \
      for (Field* fd = _metaClass.fields(); fd; fd = fd->next) \
        fd->clear((void**)FieldOf(this, fd));                  \
      } \
    virtual MetaClass*  metaClass() const { return &_metaClass; }

#define META_DECL(class) \
    META_DEFS(class) \
    static Field* _createFields();

#define META_DEF(class, fields) \
    Field* class::_createFields() { return &fields; }

#define SUPERCLASS(class) (*class::_createFields())

#define CLASS_OF(class) (&class::_metaClass)

#ifdef _MSC_VER
#define REGISTER(class) \
    IXE::MetaClass class::_metaClass(#class, \
                                     class::_createFields(), \
                                     sizeof(class), \
                                     class::_factory)
#else
#define REGISTER(class) \
    template<> IXE::MetaClass class::_metaClass(#class, \
                                     class::_createFields(), \
                                     sizeof(class), \
                                     class::_factory)
#endif

template <typename T>
  class HasMetaClass
  {
    typedef char one;
    typedef struct { char a[2]; } two;

    template <typename U> static two test(...);
    template <typename U> static one test(typename U::_CLASS_*);
  public:
    enum { VAL = sizeof(test<T>(0)) == 1 };
  };

class MetaClass;

template <typename T, int>
  struct MetaClassOf {
    static MetaClass* get() { return 0; }
  };
template <typename T>
  struct MetaClassOf<T, 1> {
    static MetaClass* get() { return CLASS_OF(T); }
  };
template <typename T>
  static MetaClass* classOf() {
  return MetaClassOf<T, HasMetaClass<T>::VAL>::get();
 }
 
class Field {
  public:

  enum Type {
    Int,
    Float,
    String,
    Pointer,
    Composite,
    Date,
    Array
  };

  enum IndexType {
    none = 0,
    primary,
    autoincrement,              // primary, auto increment
    mapped,                     // stored in separate mapped file

    fulltext = 4,               // used also as bit mask for all fulltext fields
    fulltextMerged = 5,         // text is added to index of another field
    facet = 6,                  // fulltext plus forward list

    indexed = 8,                // used also as bit mask for all indexed fields
    unique = 9,                 // indexed, but no duplicate values
    uniqueHash = 10    // same as unique, but index uses hash instead of btree
  };

  Field*                next;   
  char const*           name;   
  std::type_info const* type;   
  IndexType             indexType; 
  Size                  offset; 
  Count                 position; 
  char const*           merge;  
  Text::Normalizer*     normalizer; 

  Field(char const* name, Size offset, IndexType indexType,
        char const* merge = 0) :
    next(0), name(name), indexType(indexType),
    offset(offset), position(0), merge(merge),
    maxLength_(1), normalizer(0)
  {
    // convert type to Field::fulltextMerged when merge contains
    // name of field to merge with
    if (indexType == Field::fulltext && merge)
      this->indexType = Field::fulltextMerged;
    if (indexType & Field::fulltext)
      normalizer = Text::Normalizer::Default;
  }

  Field() { }

  virtual Field*        clone() const = 0;

  virtual ~Field() { delete next; }

  virtual void clear(void** fieldPtr) { if (isPointer()) *fieldPtr = 0; }

  virtual Size          size() = 0;

  virtual inline Size   length(byte* base) { return size(); }

  Size                  maxLength_;
  inline Size&          maxLength() { return maxLength_; }

  virtual Size          packSize(byte* base) = 0;

  virtual std::ostream& print(std::ostream& out) = 0;

  virtual bool isType(Type t) {
    switch (t) {
    case Int:
      return (*type == typeid(short) ||
              *type == typeid(unsigned short) ||
              *type == typeid(int) ||
              *type == typeid(unsigned int) ||
              *type == typeid(long) ||
              *type == typeid(unsigned long));
    case Float:
      return (*type == typeid(float) ||
              *type == typeid(double));
    case Date:
      return (*type == typeid(int) || // time32_t
              *type == typeid(time_t));
    }
    return false;
  }

  virtual bool          isReference() { return false; }

  virtual bool          isPointer() { return false; }

  virtual Item*         item() = 0;

  virtual MetaClass*    itemClass() const { return 0; }

  virtual inline Size   itemSize() { return 0; }

  virtual byte*         fetch(byte* dst, byte*& src) = 0;

  virtual byte*         fetchKey(byte* dst, byte* src) = 0;

  virtual byte*         store(byte*& dst, byte* src) = 0;

  virtual Size          storeKey(byte* dst, byte* src) = 0;

  virtual void          setKey(byte* row, int8 const value) { }
  virtual void          setKey(byte* row, byte const* value, Size& len,
                               Size maxLen) {
    ::memcpy(row, value, len);
  }

  // used for combining KEY descriptors in macro META
  Field&                operator,(Field& field) {
    // append
    Field *fd = this;
    while (fd->next) fd = fd->next;
    fd->next = &field;
    //field.prev = fd;
    return *this;
  }

  // Meta Reflection (to be implemented)
  static MetaClass _metaClass;  // needed by ClassOf()
};

#define FieldOf(obj, fd)        ((byte*)(obj) + fd->offset)

//=============================================================================
//=============================================================================

// This is not a template, or else we would have to instantiate it
// for each class
class CompositeField : public Field {

public:
  CompositeField(char const* name, Size offset, Size fsize,
                 IndexType indexType, MetaClass* metaClass,
                 std::type_info const* type, char const* merge = 0) :
    Field(name, offset, indexType, merge),
    metaClass(metaClass),
    fsize(fsize)
  {
    this->type = type;
  }

  virtual Field*        clone() const { return new CompositeField(*this); }

  virtual void clear(void** fieldPtr);

  virtual inline Size   size() { return fsize; }

  virtual Size          packSize(byte*);

  virtual bool          isType(Type t) { return (t == Composite); }

  virtual Item*         item() { return 0; } // FIXME

  virtual MetaClass*    itemClass() const { return metaClass; }

  virtual byte*         store(byte*& dst, byte* src);
  virtual Size          storeKey(byte* dst, byte* src) {
    return 0;                   // FIXME
  }

  virtual byte*         fetch(byte* dst, byte*& src);
  virtual byte*         fetchKey(byte* dst, byte* src) {
    return dst = src;           // FIXME: should fetch the composite
  }

  virtual std::ostream& print(std::ostream &out);

protected:

  MetaClass*    metaClass;
  Size          fsize;
};

//=============================================================================
// storeBigEndian()
// Converts from machine order to BigEndian order 
//
template <Size size>
inline void storeBigEndian(byte* dst, byte* src) { ::memcpy(dst, src, size); }
template <> inline void storeBigEndian<1>(byte* dst, byte* src) {
  *dst = *src;
}
template <> inline void storeBigEndian<2>(byte* dst, byte* src) {
#ifdef WORDS_BIGENDIAN
  // Can't use
  // *(short*)dst = *(short*)src;
  // since BigEndians tipically require word alignemnt
  dst[0] = src[0]; dst[1] = src[1];
#else
  dst[1] = src[0]; dst[0] = src[1];
#endif
}
template <> inline void storeBigEndian<4>(byte* dst, byte* src) {
#ifdef WORDS_BIGENDIAN
  dst[0] = *src++; dst[1] = *src++; dst[2] = *src++; dst[3] = *src;
#else
  dst[3] = *src++; dst[2] = *src++; dst[1] = *src++; dst[0] = *src;
#endif
}
#ifndef WORDS_BIGENDIAN
template <> inline void storeBigEndian<8>(byte* dst, byte* src) {
  dst[7] = *src++; dst[6] = *src++; dst[5] = *src++; dst[4] = *src++;
  dst[3] = *src++; dst[2] = *src++; dst[1] = *src++; dst[0] = *src;
}
#endif

//=============================================================================
// fetchBigEndian()
// Converts from BigEndian order to machine order 
//
template <int size>
inline void fetchBigEndian(byte* dst, byte* src) {
  storeBigEndian<size>(dst, src);
}

//=============================================================================
// storeLittleEndian()
// Converts from machine order to LittleEndian order
//
template <int size>
inline void storeLittleEndian(byte* dst, byte* src) {
  ::memcpy(dst, src, size); }
template <> inline void storeLittleEndian<1>(byte* dst, byte* src) {
  *dst = *src; }
template <> inline void storeLittleEndian<2>(byte* dst, byte* src) {
#ifdef WORDS_BIGENDIAN
  dst[1] = src[0]; dst[0] = src[1];
#else
# ifdef BYTE_ALIGN
  *(ushort*)(dst) = *(ushort*)(src);
# else
  dst[0] = src[0]; dst[1] = src[1];
# endif
#endif
}
template <> inline void storeLittleEndian<4>(byte* dst, byte* src) {
#ifdef WORDS_BIGENDIAN
  dst[3] = *src++; dst[2] = *src++; dst[1] = *src++; dst[0] = *src;
#else
# ifdef BYTE_ALIGN
  *(uint*)(dst) = *(uint*)src;
# else
  dst[0] = *src++; dst[1] = *src++; dst[2] = *src++; dst[3] = *src;
# endif
#endif
}
template <> inline void storeLittleEndian<8>(byte* dst, byte* src) {
#ifdef WORDS_BIGENDIAN
  dst[7] = *src++; dst[6] = *src++; dst[5] = *src++; dst[4] = *src++;
  dst[3] = *src++; dst[2] = *src++; dst[1] = *src++; dst[0] = *src;
#else
# ifdef BYTE_ALIGN
  *(ulonglong*)(dst) = *(ulonglong*)(src);
# else
  dst[0] = *src++; dst[1] = *src++; dst[2] = *src++; dst[3] = *src++;
  dst[4] = *src++; dst[5] = *src++; dst[6] = *src++; dst[7] = *src;
# endif
#endif
}

//=============================================================================
// fetchLittleEndian()
// Converts from LittleEndian order to machine order
//
template <int size>
inline void fetchLittleEndian(byte* dst, byte* src) {
  storeLittleEndian<size>(dst, src);
}

//=============================================================================
template <class T>
class FixedField : public Field {
public:

  typedef T     value_type;

  FixedField(char const* name, Size offset, Size maxLength,
             IndexType indexType, char const* merge = 0) :
    Field(name, offset, indexType, merge)
  {
    maxLength_ = 1;             // has to be 1
    type = &typeid(T);
  }

  virtual Field*        clone() const { return new FixedField<T>(*this); }

  virtual MetaClass*    itemClass() const { return classOf<T>(); }

  virtual inline Size   size() { return sizeof(T); }

  // we need to specialize it later
  virtual inline Size   length(byte* base) { return size(); }

  //  virtual inline Size       maxLength() { return 1; }

  virtual Size          packSize(byte*) { return sizeof(T); }

  virtual std::ostream& print(std::ostream& out) {
    char buf[128];
    sprintf(buf, "%-16s%-14s %2d %4d %4d\n",
            name, type->name(), indexType, offset, size());
    return out << buf;
  }

  virtual Item*         item() { return new ItemOf<T>(); }

  virtual byte*         fetch(byte* dst, byte*& src) {
    //src = ALIGN(src, size);
    fetchLittleEndian<sizeof(T)>(dst, src);
    src += sizeof(T);
    return src;
  }

  virtual byte*         fetchKey(byte* dst, byte* src) {
    //src = ALIGN(src, size);
    fetchLittleEndian<sizeof(T)>(dst, src);
    return dst;
  }

  virtual byte*         store(byte*& dst, byte* src) {
    storeLittleEndian<sizeof(T)>(dst, src);
    dst += sizeof(T);
    return dst;
  }

  virtual Size          storeKey(byte* dst, byte* src) {
    storeLittleEndian<sizeof(T)>(dst, src);
    return sizeof(T);
  }

  // FIXME: doesn't work with T = char*
  virtual void          setKey(byte* dst, int8 const value) {
#   ifdef _MSC_VER
    storeLittleEndian<sizeof(T)>(dst, (byte*)&value);
#   else
    T tmp = (T)value;           // convert to proper size (or it looses sign)
    storeLittleEndian<sizeof(T)>(dst, (byte*)&tmp);
#   endif
  }
};

#ifdef _MSC_VER
template <>
  void  FixedField<int>::setKey(byte* dst, int8 const value) {
  int tmp = (int)value;         // convert to proper size (or it looses sign)
  storeLittleEndian<sizeof(int)>(dst, (byte*)&tmp);
 }
#endif

//=============================================================================
//=============================================================================

template <class T>
class VarField : public Field {

public:
  VarField(char const* name, Size offset, Size maxLength,
           IndexType indexType, char const* merge = 0) :
    Field(name, offset, indexType, merge) {
    maxLength_ = maxLength;
    type = &typeid(T);
  }

  virtual Field*        clone() const { return new VarField<T>(*this); }

  virtual bool          isType(Type t) { return t == Pointer; }

  virtual MetaClass*    itemClass() const { return classOf<T>(); }

  virtual bool          isPointer() { return true; }

  virtual inline Size   size() { return sizeof(T*); }
  virtual inline Size   itemSize() { return (Size)(size_t)&((T*)0)[1]; }

  virtual inline Size   length(byte* base) { return maxLength_; }

  //  virtual inline Size       maxLength() { return maxLength_; }

  virtual Size          packSize(byte* base) {
    Size maxlen = maxLength();
    Size len = base ? length(base + offset) : maxlen;
    if (len > maxlen) len = maxlen;
    // log(256, maxLength())
    return ((maxlen < 256) ? 1 :
            (maxlen < 65536) ? 2 : 4) + len * sizeof(T);
  }

  virtual std::ostream& print(std::ostream &out) {
    char line[128];
    sprintf(line, "%-16svar %s(%d) %2d %4d %4d\n",
            name, type->name(), maxLength_, indexType, offset, size());
    return out << line;
  }

  virtual Item*         item() { return new ItemOf<T*>(); }

  virtual byte*         fetch(byte* dst, byte*& src) {
    Size length;
    Size maxlen = maxLength();
    if (maxlen < 256) {
      length = *src;
      src += 1;
    } else if (maxlen < 65536) {
      length = uint2get(src);
      src += 2;
    } else {
      length = uint4get(src);
      src += 4;
    }
    if (length) {
      *(T**)(dst) = (T*)src;    // no copy
      src += sizeof(T) * length;
    } else
      *(T**)(dst) = 0;          // NULL field
    return src;
  }

  virtual byte*         fetchKey(byte* dst, byte* src) {
    *(T**)(dst) = (T*)src;      // no copy
    return dst;
  }

  virtual byte*         store(byte*& dst, byte* src) {
    Size len = length(src);
    Size maxlen = maxLength();
    if (len > maxlen) len = maxlen;
    if (maxlen < 256) {
      dst[0] = len;
      dst += 1;
    } else if (maxlen < 65536) {
      int2store(dst, len);
      dst += 2;
    } else {
      int4store(dst, len);
      dst += 4;
    }
    len *= sizeof(T);
    ::memcpy((void*)dst, *(void const **)(src), len);
    dst += len;
    return dst;
  }

  virtual Size          storeKey(byte* dst, byte* src) {
    Size len = length(src);
    len *= sizeof(T);
    ::memcpy((void*)dst, *(void const **)src, len);
    return len;
  }

  virtual void          setKey(byte* dst, byte const* value, Size& len,
                               Size maxLen) {
    Size newLen = MIN(length((byte*)&value), maxLen);
    len = newLen * sizeof(T);
    ::memcpy((void*)dst, (void*)value, len);
  }
};

//=============================================================================
//=============================================================================

// ======================================================================
// string
// ======================================================================

#ifdef _MSC_VER
// FIXHIM: putting definitions in metaclass.cpp does not work in VC 8

template <>
Size    FixedField<std::string>::length(byte* base) {
  return ((std::string*)base)->size();
}

template <>
byte* FixedField<std::string>::fetch(byte* dst, byte*& row)
{
  Size length;
  Size maxlen = maxLength();
  if (maxlen < 256) {
    length = *row;
    row += 1;
  } else if (maxlen < 65536) {
    length = uint2get(row);
    row += 2;
  } else {
    length = uint4get(row);
    row += 4;
  }
  *(std::string*)(dst) = std::string((char*)row, length);
  row += sizeof(char) * length;
  return row;
}

template <>
byte* FixedField<std::string>::store(byte*& row, byte* src)
{
  Size len = length(src);
  Size maxlen = maxLength();
  if (len > maxlen) len = maxlen;
  if (maxlen < 256) {
    row[0] = len;
    row += 1;
  } else if (maxlen < 65536) {
    int2store(row, len);
    row += 2;
  } else {
    int4store(row, len);
    row += 4;
  }
  len *= sizeof(char);
  ::memcpy((void*)row, ((std::string*)src)->c_str(), len);
  row += len;
  return row;
}

template <>
Size    FixedField<std::string>::packSize(byte* base) {
  Size maxlen = maxLength();
  Size len = base ? length(base + offset) : maxlen;
  if (len > maxlen) len = maxlen;
  // log(256, maxLength())
  return ((maxlen < 256) ? 1 :
          (maxlen < 65536) ? 2 : 4) + len * sizeof(value_type::value_type);
}

#else // !MSC_VER

template <>
  Size  FixedField<std::string>::length(byte* base);

template <>
  byte* FixedField<std::string>::fetch(byte* dst, byte*& row);

template <>
  byte* FixedField<std::string>::store(byte*& row, byte* src);

template <>
  Size  FixedField<std::string>::packSize(byte* base);
#endif


//=============================================================================
//=============================================================================

template <>
bool VarField<char>::isType(Type t);

template <>
bool VarField<char const>::isType(Type t);

template <>
Size VarField<char>::length(byte* base);

template <>
Size VarField<char const>::length(byte* base);

//=============================================================================
//=============================================================================

template <class T>
class ReferenceField : public Field {

public:

  ReferenceField(char const* name, Size offset, Size maxLength,
                 IndexType indexType, char const*  merge = 0) :
    Field(name, offset, Field::mapped, merge) {
    type = &typeid(T*);
  }

  virtual Field*        clone() const { return new ReferenceField<T>(*this); }

  virtual bool          isType(Type t) { return false; }

  virtual bool          isReference() { return true; }

  virtual bool          isPointer() { return true; }

  virtual MetaClass*    itemClass() const { return classOf<T>(); }

  virtual inline Size   size() { return sizeof(T*); }
  // compute size including padding
  virtual inline Size   itemSize() { return (Size)(size_t)&((T*)0)[1]; }

  virtual inline Size   length(byte* base) { return maxLength_; }

  //  virtual inline Size       maxLength() { return 1; }

  virtual Size          packSize(byte*) { return 0; }

  virtual std::ostream& print(std::ostream &out) {
    char line[128];
    sprintf(line, "%-16svar %s(%d) %2d %4d %4d\n",
            name, type->name(), maxLength_, indexType, offset, size());
    return out << line;
  }

  virtual Item*         item() { return new ItemOf<T*>(); }

  virtual byte*         fetch(byte* dst, byte*& src) {
    *(byte**)dst = src;
    return src;
  }

  virtual byte*         fetchKey(byte* dst, byte* src) {
    return dst = src;
  }

  // dont store anything in record: field is stored separately.
  virtual byte*         store(byte*& dst, byte* src) { return dst; }

  virtual Size  storeKey(byte* dst, byte* src) { return 0; }
};

//=============================================================================
//=============================================================================

template <class ArrayType> 
class ArrayField : public Field {
};

template <class T> 
class ArrayField<ArrayOf<T> > : public Field {
  typedef T elementType;

  ArrayField() {}
public:
  ArrayField(char const* name, Size offset, Size maxLength,
           IndexType indexType, char const* merge = 0) :
    Field(name, offset, indexType, merge) {
    maxLength_ = maxLength;
    type = &typeid(ArrayOf<T>);
  }

  virtual Field*        clone() const { return new ArrayField<ArrayOf<T> >(*this); }

  virtual void          clear(void** fieldPtr) { ((ArrayOf<T>*)fieldPtr)->data = 0; }

  virtual bool          isType(Type t) { return (t == Array); }

  virtual inline Size   size() { return sizeof(ArrayOf<T>); }
  virtual inline Size   itemSize() { return sizeof(T); }

  virtual inline Size   length(byte* base) { return ((ArrayOf<T>*)base)->length(); }

  //  virtual inline Size       maxLength() { return maxLength_; }

  virtual Size          packSize(byte* base) {
    Size maxlen = maxLength();
    Size len = base ? length(base + offset) : maxlen;
    if (len > maxlen) len = maxlen;
    // log(256, maxLength())
    return ((maxlen < 256) ? 1 :
            (maxlen < 65536) ? 2 : 4) + len * sizeof(elementType);
  }

  virtual std::ostream& print(std::ostream &out) {
    char line[128];
    sprintf(line, "%-16svar %s(%d) %2d %4d %4d\n",
            name, type->name(), maxLength_, indexType, offset, size());
    return out << line;
  }

  virtual Item*         item() { return 0; } // FIXME

  virtual byte*         fetch(byte* dst, byte*& src) {
    Size length;
    Size maxlen = maxLength();
    if (maxlen < 256) {
      length = *src;
      src += 1;
    } else if (maxlen < 65536) {
      length = uint2get(src);
      src += 2;
    } else {
      length = uint4get(src);
      src += 4;
    }
    ((ArrayOf<T>*)dst)->len = length;
    ((ArrayOf<T>*)dst)->data = (elementType*)src;
    src += sizeof(elementType) * length;
    return src;
  }

  virtual byte*         fetchKey(byte* dst, byte* src) {
    Size length;
    Size maxlen = maxLength();
    if (maxlen < 256) {
      length = *src;
      src += 1;
    } else if (maxlen < 65536) {
      length = uint2get(src);
      src += 2;
    } else {
      length = uint4get(src);
      src += 4;
    }
    ((ArrayOf<T>*)dst)->len = length / sizeof(elementType);
    ((ArrayOf<T>*)dst)->data = (elementType*)src;
    return dst;
  }

  virtual byte*         store(byte*& dst, byte* src) {
    Size len = length(src);
    Size maxlen = maxLength();
    if (len > maxlen) len = maxlen;
    if (maxlen < 256) {
      dst[0] = len;
      dst += 1;
    } else if (maxlen < 65536) {
      int2store(dst, len);
      dst += 2;
    } else {
      int4store(dst, len);
      dst += 4;
    }
    len *= sizeof(elementType);
    ::memcpy((void*)dst, ((ArrayOf<T>*)src)->data, len);
    dst += len;
    return dst;
  }

  virtual Size          storeKey(byte* dst, byte* src) {
    Size len = length(src);
    len *= sizeof(elementType);
    ::memcpy((void*)dst, ((ArrayOf<T>*)src)->data, len);
    return len;
  }

  virtual void          setKey(byte* dst, byte const* value, Size& len,
                               Size maxSize) {
    Size newSize = MIN(Size(length((byte*)value) * sizeof(elementType)),
                       maxSize);
    len = newSize;
    ::memcpy((void*)dst, ((ArrayOf<T>*)value)->data, newSize);
  }
};

/* wrong:
template <>
bool ArrayField<char>::isType(Type t) { return (t == String); }

template <>
bool ArrayField<char const>::isType(Type t) { return (t == String); }
*/

/*---------------------------------------------------------------------------*
 * support for vectors
 *
 * WARNING: due to a bug in GCC 2.96, we cant just provide specialized
 * versions for fetch() and store() methods.
 *---------------------------------------------------------------------------*/

template <class T>
class ArrayField<std::vector<T> >  : public Field {
  typedef T     elementType;

public:
  ArrayField(char const* name, Size offset, Size maxLength,
           IndexType indexType, char const* merge = 0) :
    Field(name, offset, indexType, merge) {
    maxLength_ = maxLength;
    type = &typeid(std::vector<T>);
  }

  virtual Field*        clone() const { return new ArrayField<std::vector<T> >(*this); }

  virtual bool  isType(Type t) { return (t == Array); }

  virtual inline Size   size() { return sizeof(std::vector<T>); }
  virtual inline Size   itemSize() { return sizeof(T); }

  virtual inline Size   length(byte* base) { return ((std::vector<T>*)base)->size(); }

  //  virtual inline Size       maxLength() { return maxLength_; }

  virtual Size          packSize(byte* base) {
    Size maxlen = maxLength();
    if (maxlen == 0)
      maxlen = UINT_MAX;        // allow unlimited length
    Size len = base ? length(base + offset) : maxlen;
    if (len > maxlen) len = maxlen;
    // log(256, maxLength())
    return ((maxlen < 256) ? 1 :
            (maxlen < 65536) ? 2 : 4) + len * sizeof(elementType);
  }

  virtual std::ostream& print(std::ostream &out) {
    char line[128];
    sprintf(line, "%-16svar %s(%d) %2d %4d %4d\n",
            name, type->name(), maxLength_, indexType, offset, size());
    return out << line;
  }

  virtual Item*         item() { return 0; } // FIXME

  virtual byte*         fetch(byte* dst, byte*& src) {
    Size length;
    Size maxlen = maxLength();
    if (maxlen == 0)
      maxlen = UINT_MAX;        // allow unlimited length
    if (maxlen < 256) {
      length = *src;
      src += 1;
    } else if (maxlen < 65536) {
      length = uint2get(src);
      src += 2;
    } else {
      length = uint4get(src);
      src += 4;
    }
    ((std::vector<T>*)dst)->resize(length);
    std::copy((T*)src, (T*)src + length, ((std::vector<T>*)dst)->begin());
    src += sizeof(T) * length;
    return src;
  }

  virtual byte*         fetchKey(byte* dst, byte* src) {
    Size length;
    Size maxlen = maxLength();
    if (maxlen < 256) {
      length = *src;
      src += 1;
    } else if (maxlen < 65536) {
      length = uint2get(src);
      src += 2;
    } else {
      length = uint4get(src);
      src += 4;
    }
    std::copy((T*)src, (T*)src + length, ((std::vector<T>*)dst)->begin());
    return dst;
  }

  virtual byte*         store(byte*& dst, byte* src) {
    Size len = ((std::vector<T>*)src)->size();
    Size maxlen = maxLength();
    if (maxlen == 0)
      maxlen = UINT_MAX;        // allow unlimited length
    if (len > maxlen) len = maxlen;
    if (maxlen < 256) {
      dst[0] = len;
      dst += 1;
    } else if (maxlen < 65536) {
      int2store(dst, len);
      dst += 2;
    } else {
      int4store(dst, len);
      dst += 4;
    }
    std::copy(((std::vector<T>*)src)->begin(), ((std::vector<T>*)src)->end(), (T*)dst);
    dst += len * sizeof(T);
    return dst;
  }

  virtual Size          storeKey(byte* dst, byte* src) {
    Size len = ((std::vector<T>*)src)->size();
    std::copy(((std::vector<T>*)src)->begin(), ((std::vector<T>*)src)->end(),(T*)dst);
    return len * sizeof(T);
  }

  virtual void          setKey(byte* dst, byte const* value, Size& len,
                               Size maxSize) {
    len = MIN(length((byte*)&value), maxSize / Size(sizeof(T)));
    typename std::vector<T>::iterator begin = ((std::vector<T>*)value)->begin();
    std::copy(begin, begin + len, (T*)dst);
  }
};

//  FIXHIM: vector<string>or vector<char*> are not supported with Visual C++ 7.0,
//  because of lack of template specialization

template<>
class ArrayField<std::vector<std::string> >  : public Field {
  typedef std::string   elementType;

  ArrayField() {}
public:

  virtual Size          packSize(byte* base) {
    Size maxlen = maxLength();
    Size len = base ? length(base + offset) : maxlen;
    if (len > maxlen) len = maxlen;
    // log(256, maxLength())
    int tot = ((maxlen < 256) ? 1 :
               (maxlen < 65536) ? 2 : 4);
    std::vector<std::string>& v = *(std::vector<std::string>*)(base + offset);
    for (Size i = 0; i < len; i++)
      tot += packSize<2>(v[i]);
    return tot;
  }

  template<int maxlen>
  static Size packSize(std::string& s) {
    Size len = s.size();
    return ((maxlen < 256) ? 1 :
            (maxlen < 65536) ? 2 : 4) + len * sizeof(std::string::value_type);
  }

  virtual byte*         fetch(byte* dst, byte*& src) {
    Size length;
    Size maxlen = maxLength();
    if (maxlen < 256) {
      length = *src;
      src += 1;
    } else if (maxlen < 65536) {
      length = uint2get(src);
      src += 2;
    } else {
      length = uint4get(src);
      src += 4;
    }
    ((std::vector<std::string>*)dst)->resize(length);
    std::vector<std::string>& v = *(std::vector<std::string>*)dst;
    for (Size i = 0; i < length; i++)
      src = fetch<2>(v[i], src);
    return src;
  }

  template <int maxlen>
    byte* fetch(std::string& dst, byte*& row) {
    Size length;
    if (maxlen < 256) {
      length = *row;
      row += 1;
    } else if (maxlen < 65536) {
      length = uint2get(row);
      row += 2;
    } else {
      length = uint4get(row);
      row += 4;
    }
    dst = std::string((char*)row, length);
    row += sizeof(std::string::value_type) * length;
    return row;
  }

  virtual byte*         store(byte*& dst, byte* src) {
    Size len = ((std::vector<std::string>*)src)->size();
    Size maxlen = maxLength();
    if (len > maxlen) len = maxlen;
    if (maxlen < 256) {
      dst[0] = len;
      dst += 1;
    } else if (maxlen < 65536) {
      int2store(dst, len);
      dst += 2;
    } else {
      int4store(dst, len);
      dst += 4;
    }
    std::vector<std::string>& v = *(std::vector<std::string>*)src;
    for (Size i = 0; i < len; i++)
      dst = store<2>(dst, v[i]);
    return dst;
  }

  template<int maxlen>
    byte* store(byte*& row, std::string& src) {
    Size len = src.size();
    if (maxlen < 256) {
      row[0] = len;
      row += 1;
    } else if (maxlen < 65536) {
      int2store(row, len);
      row += 2;
    } else {
      int4store(row, len);
      row += 4;
    }
    len *= sizeof(std::string::value_type);
    ::memcpy((void*)row, src.c_str(), len);
    row += len;
    return row;
  }
};

template<>
class ArrayField<std::vector<char const*> >  : public Field {
  typedef char* elementType;
  typedef std::vector<char const*> T;

public:
  ArrayField(char const* name, Size offset, Size maxLength,
           IndexType indexType, char const* merge = 0) :
    Field(name, offset, indexType, merge) {
    maxLength_ = maxLength;
    type = &typeid(T);
  }

  virtual Field*        clone() const { return new ArrayField<std::vector<char const*> >(*this); }

  virtual inline Size   size() { return sizeof(std::vector<elementType>); }
  virtual inline Size   itemSize() { return sizeof(T); }
  virtual byte*         fetchKey(byte* dst, byte* src) { return 0; }
  virtual Size          storeKey(byte*, byte*) { return 0; }
  virtual std::ostream& print(std::ostream &out) { return out; }
  virtual Item*         item() { return 0; }

  virtual Size          packSize(byte* base) {
    Size maxlen = maxLength();
    Size len = base ? length(base + offset) : maxlen;
    if (len > maxlen) len = maxlen;
    // log(256, maxLength())
    int tot = ((maxlen < 256) ? 1 :
               (maxlen < 65536) ? 2 : 4);
    if (base) {
      T& v = *(T*)(base + offset);
      for (size_t i = 0; i < v.size(); i++)
        tot += packSize<2>(v[i]);
    } else
      tot += len * 8;           // FIXME: arbitrary constant
    return tot;
  }

  template<int maxlen>
  static Size packSize(char const* s) {
    Size len = strlen(s) + 1;
    return ((maxlen < 256) ? 1 :
            (maxlen < 65536) ? 2 : 4) + len;
  }

  virtual byte*         fetch(byte* dst, byte*& src) {
    Size length;
    Size maxlen = maxLength();
    if (maxlen < 256) {
      length = *src;
      src += 1;
    } else if (maxlen < 65536) {
      length = uint2get(src);
      src += 2;
    } else {
      length = uint4get(src);
      src += 4;
    }
    ((T*)dst)->resize(length);
    T& v = *(T*)dst;
    for (Size i = 0; i < length; i++)
      src = fetch<2>(v[i], src);
    return src;
  }

  template <int maxlen>
    byte* fetch(char const*& dst, byte*& row) {
    Size length;
    if (maxlen < 256) {
      length = *row;
      row += 1;
    } else if (maxlen < 65536) {
      length = uint2get(row);
      row += 2;
    } else {
      length = uint4get(row);
      row += 4;
    }
    dst = (char const*)row;
    row += length;
    return row;
  }

  virtual byte*         store(byte*& dst, byte* src) {
    Size len = ((T*)src)->size();
    Size maxlen = maxLength();
    if (len > maxlen) len = maxlen;
    if (maxlen < 256) {
      dst[0] = len;
      dst += 1;
    } else if (maxlen < 65536) {
      int2store(dst, len);
      dst += 2;
    } else {
      int4store(dst, len);
      dst += 4;
    }
    std::vector<char*>& v = *(std::vector<char*>*)src;
    for (Size i = 0; i < len; i++)
      dst = store<2>(dst, v[i]);
    return dst;
  }

  template<int maxlen>
    byte* store(byte*& row, char const* src) {
    Size len = strlen(src) + 1;
    if (maxlen < 256) {
      row[0] = len;
      row += 1;
    } else if (maxlen < 65536) {
      int2store(row, len);
      row += 2;
    } else {
      int4store(row, len);
      row += 4;
    }
    ::memcpy((void*)row, src, len);
    row += len;
    return row;
  }
};

//=============================================================================
//=============================================================================

template <class T>
struct CompositeBuilder {
  static Field& factory(char const* name, Size offset, Size size,
                        Field::IndexType indexType, char const* merge)
  { return *new CompositeField(name, offset, sizeof(T), indexType,
                               CLASS_OF(T), &typeid(T), merge); }
};

template <class T>
struct FieldBuilder {
  static Field& factory(char const* name, Size offset, Size maxLength,
                        Field::IndexType indexType, char const* merge)
  {
    return *new T(name, offset, maxLength, indexType, merge); }
};

/*
 FIELD(T)       stored within object. If T is class type, must have MetaClass.
 FIELD(T*)      stored in separate table
 FIELD(T*)      stored in separate mapped file if T is value type
 VARFIELD(T*)   stored within object (length computed by VarField<T>::length())
 VARFIELD(ArrayOf<T>)   stored within object (length in ArrayOf).
                        VARFIELD is used to supply max size

 KEY(T)         = FIELD(T), plus inverted index
 VARKEY(T*)     = VARFIELD(T), plus inverted index
 KEY(ArrayOf<T>) not allowed
 KEY(T*)        not allowed

 Warning: Table::insert() does not preserve sharing.
*/
// Trick: use fourth argument to determine the type of field to create
template <class T>
inline Field& createField(char const* name, Size maxLength, Size offs,
                          T*, Field::IndexType const indexType,
                          char const* merge = 0)
{
  // handle VARFIELD(T*) or VARKEY(T*)
  if (maxLength)
    return
      If<typename isPointer<T>::VAL,
          FieldBuilder<VarField<typename deref<T>::VAL> >,
          typename If<typename isArray<T>::VAL,
                      FieldBuilder<ArrayField<T> >,
                      typename If<typename isClass<T>::VAL,
                                  CompositeBuilder<T>,
                                  FieldBuilder<FixedField<T> > >::VAL
                   >::VAL
      >::VAL::
      factory(name, offs, maxLength, indexType, merge);

  return
    If<typename isPointer<T>::VAL,
        FieldBuilder<ReferenceField<typename deref<T>::VAL> >,
          typename If<typename isArray<T>::VAL,
                      FieldBuilder<ArrayField<T> >,
                      typename If<typename isClass<T>::VAL,
                                  CompositeBuilder<T>,
                                  FieldBuilder<FixedField<T> > >::VAL
                   >::VAL
    >::VAL::
    factory(name, offs, 0, indexType, merge); // maxLength is 0
}

Field* makeField(char const* name, char const* typeName, Size& offs, Size maxLength);

class AnyObject;

//=============================================================================
//=============================================================================

class MetaClass {
  friend class AnyObject;

protected:

  char const*   name_;
  Field*        columns;
  Count         nColumns;
  Size          instanceSize;
  void          (*factory)(void* dst);

public:

  META(MetaClass,
       (VARFIELD(name_, 2048),
        FIELD(columns),
        FIELD(nColumns),
        FIELD(instanceSize)));

  MetaClass() { }

  MetaClass(char const* name, Field* columns, Size instanceSize,
            void (*factory)(void* dst) = 0);

  MetaClass(MetaClass const& mc) {
    *this = mc;
    Field** newfd = &columns;
    for (Field const* fd = mc.fields(); fd; fd = fd->next) {
      *newfd = fd->clone();
      newfd = &(*newfd)->next;
    }
  }

  ~MetaClass() {
    delete columns;
    //delete name;      // we don't make a local copy
  }

  char const*   name() { return name_; }

  Field*        fields() const { return columns; }

  Count         fieldCount() const { return nColumns; }

  void*         createInstance(void* dst) { factory(dst); }

  Size          size() { return instanceSize;  }

  Size          recordSize(byte* base = 0);
  Size          recordSize(AnyObject const * obj);

  Field*        find(char const* name);
  /*
  bool          equal(MetaClass* table);

  bool          match(MetaClass* table);

  void          store(MetaClass* table);
  */

  byte*         store(byte*& dst, byte* src) {
    for (Field* fd = columns; fd != NULL; fd = fd->next)
      dst = fd->store(dst, FieldOf(src, fd));
    return dst;
  }

  byte*         fetch(byte* dst, byte*& src) {
    for (Field* fd = columns; fd != NULL; fd = fd->next)
      src = fd->fetch(FieldOf(dst, fd), src);
    return src;
  }

  std::ostream& print(std::ostream &out) const {
    out << "\nClass: " << name_ << std::endl;
    out << "Field           Type          Key Offs Size\n";
    out << "-------------------------------------------\n";
    for (Field *fd = columns; fd; fd = fd->next)
      fd->print(out);
    return out;
  }
};

inline std::ostream& operator <<(std::ostream& s, const MetaClass& m)
{
  return m.print(s);
}

//=============================================================================
//=============================================================================

class AnyObject {
public: 
  MetaClass* _metaClass;                // metaclass information

  std::vector<Item*> values;            // field values

  AnyObject(MetaClass* table) : _metaClass(table) {
    values.reserve(table->nColumns);
    for (Field* fd = table->fields(); fd; fd = fd->next)
      values.push_back(fd->item());
  }

  // DynamicTable::Cursor requires later initialization
  AnyObject() { }

  MetaClass* metaClass() const { return _metaClass; }

  bool operator ==(AnyObject const &other) {
    std::vector<Item*>::const_iterator lv1 = values.begin();
    std::vector<Item*>::const_iterator lv2 = other.values.begin();
    std::vector<Item*>::const_iterator end1 = values.end();
    std::vector<Item*>::const_iterator end2 = other.values.end();
    for (; lv1 != end1 && lv2 != end2 ; lv1++, lv2++)
      if (*lv1 != *lv2)
        return false;
    return true;
  }

  void _clear() {
    // FIXME: should preserve field _metaClass, in case of reflection
    for (Field* fd = _metaClass->fields(); fd; fd = fd->next) {
      fd->clear((void**)FieldOf(this, fd));
    }
  }

  std::ostream& print(std::ostream& out) {
    for (std::vector<Item*>::const_iterator lv = values.begin();
         lv != values.end(); lv++) {
      out << (*lv) << '\t';             // MySQL batch format
    }
    return out;
  }

  template <class T>
  ItemOf<T>& field(char* fieldName) {
    std::vector<Item*>::const_iterator lv = values.begin();
    for (Field* fd = _metaClass->columns; fd; fd = fd->next, lv++)
      if (::strcmp(fieldName, fd->name) == 0)
        return *(ItemOf<T>*)*lv;
    return 0;
  }

  template <class T>
  ItemOf<T>& field(int i) {
    return *(ItemOf<T>*)values[i];
  }

  Item& operator [](int i) {
    return *values[i];
  }
};

#if defined(_WIN32) || defined(__DECCXX) || defined(__GNUC__)
#pragma pack(pop)
#endif

} // namespace IXE

#endif // IXE_metaclass_H

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.