Tanl Linguistic Pipeline

search/ixe/Common/metaclass.cpp

/*
**      IXE
**      Common/metaclass.cpp: introspection
** ----------------------------------------------------------------------
**      Copyright (c) 2000  Ideare SpA. All rights reserved.
**      Copyright (c) 2000  Giuseppe Attardi (attardi@di.unipi.it),
**                          Antonio Cisternino (cisterni@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/>.
**  ----------------------------------------------------------------------
*/

// local
#include "Common/metaclass.h"

// standard
#include <cstdio>               // sprintf()

namespace IXE {
using namespace std;

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

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

#ifndef _MSC_VER

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);
}
#endif

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

template <>
bool VarField<char>::isType(Type t) { return (t == Field::String); }

template <>
bool VarField<char const>::isType(Type t) { return (t == Field::String); }

template <>
Size VarField<char>::length(byte* base)
{
  // include trailing null
  return base ?
    (*(char**)base ?
     ::strlen(*(char**)(base)) + 1
     : 0)                       // NULL field
    : maxLength();
}

template <>
Size VarField<char const>::length(byte* base)
{
  // include trailing null
  return base ?
    (*(char**)base ?
     ::strlen(*(char**)(base)) + 1
     : 0)                       // NULL field
    : maxLength();
}

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

byte* CompositeField::store(byte*& row, byte* src)
{
  return metaClass->store(row, src);
}

byte* CompositeField::fetch(byte* dst, byte*& row)
{
  return metaClass->fetch(dst, row);
}

Size CompositeField::packSize(byte* base)
{
  return metaClass->recordSize(base ? base + offset : 0);
}

void CompositeField::clear(void** fieldPtr) {
  for (Field* fd = metaClass->fields(); fd; fd = fd->next)
    fd->clear((void**)FieldOf(fieldPtr, fd));
}

ostream& CompositeField::print(ostream &out)
{
  char buf[128];
  sprintf(buf, "%-16s%-14s %2d %4d %4d\n",
          name, type->name(), indexType, offset, size());
  out << buf;
  for (Field* fd = metaClass->fields(); fd != NULL; fd = fd->next) {
    out << '\t';
    fd->print(out);
  }
  return out;
}

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

Field* makeField(char const* name, char const* typeName, Size& offs,
          Size maxLength)
{
  Field* field = 0;
  if (!strcmp(typeName, "double")) {
    offs = ALIGN(offs, sizeof(double));
    field = &createField(name, 0, offs, (double*)0, Field::none);
  } else if (!strcmp(typeName, "float")) {
    offs = ALIGN(offs, sizeof(float));
    field = &createField(name, 0, offs, (float*)0, Field::none);
  } else if (!strcmp(typeName, "int")) {
    offs = ALIGN(offs, sizeof(int));
    field = &createField(name, 0, offs, (int*)0, Field::none);
  } else if (!strcmp(typeName, "int1")) {
    offs = ALIGN(offs, sizeof(int1));
    field = &createField(name, 0, offs, (int1*)0, Field::none);
  } else if (!strcmp(typeName, "int2")) {
    offs = ALIGN(offs, sizeof(int2));
    field = &createField(name, 0, offs, (int2*)0, Field::none);
  } else if (!strcmp(typeName, "int4")) {
    offs = ALIGN(offs, sizeof(int4));
    field = &createField(name, 0, offs, (int4*)0, Field::none);
  } else if (!strcmp(typeName, "int8")) {
    offs = ALIGN(offs, sizeof(int8));
    field = &createField(name, 0, offs, (int8*)0, Field::none);
  } else if (!strcmp(typeName, "nat1")) {
    offs = ALIGN(offs, sizeof(nat1));
    field = &createField(name, 0, offs, (nat1*)0, Field::none);
  } else if (!strcmp(typeName, "nat2")) {
    offs = ALIGN(offs, sizeof(nat2));
    field = &createField(name, 0, offs, (nat2*)0, Field::none);
  } else if (!strcmp(typeName, "nat4")) {
    offs = ALIGN(offs, sizeof(nat4));
    field = &createField(name, 0, offs, (nat4*)0, Field::none);
  } else if (!strcmp(typeName, "nat8")) {
    offs = ALIGN(offs, sizeof(nat8));
    field = &createField(name, 0, offs, (nat8*)0, Field::none);
  } else if (!strcmp(typeName, "real")) {
    offs = ALIGN(offs, sizeof(real));
    field = &createField(name, 0, offs, (real*)0, Field::none);
  } else if (!strcmp(typeName, "real4")) {
    offs = ALIGN(offs, sizeof(real4));
    field = &createField(name, 0, offs, (real4*)0, Field::none);
  } else if (!strcmp(typeName, "real8")) {
    offs = ALIGN(offs, sizeof(real8));
    field = &createField(name, 0, offs, (real8*)0, Field::none);
  } else if (!strcmp(typeName, "text")) {
    offs = ALIGN(offs, sizeof(char*));
    field = &createField(name, maxLength, offs, (char**)0, Field::none);
  } else if (!strcmp(typeName, "varchar")) {
    offs = ALIGN(offs, sizeof(char*));
    field = &createField(name, maxLength, offs, (char**)0, Field::none);
  }
  return field;
}

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

MetaClass::MetaClass(char const* name, Field* columns, Size instanceSize,
            void (*factory)(void* dst)) :
  name_(name), columns(columns), instanceSize(instanceSize),
  factory(factory)
{
  nColumns = 0;
  for (Field* fd = columns; fd; fd = fd->next)
    nColumns++;
}

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

Size MetaClass::recordSize(byte* base)
{
    Size size = 0;
    for (Field* fd = columns; fd; fd = fd->next)
      size += fd->packSize(base);
    return size;
}

Size MetaClass::recordSize(AnyObject const * obj)
{
    Size size = 0;
    //    FOR_EACH (vector<Item*>, obj->values, lv)
    for (vector<Item*>::const_iterator lv = (obj->values).begin();
         lv != (obj->values).end(); ++lv)
      size += (*lv)->packSize();
    return size;
}

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

Field* MetaClass::find(char const* name)
{
  for (Field* field = columns; field; field = field->next)
    if (!::strcmp(field->name, name))
      return field;
  return 0;
}

//----------------------------------------------------------------------------
// Create the MetaClass class object
//----------------------------------------------------------------------------

REGISTER(MetaClass);

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

} // namespace IXE

 

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