Tanl Linguistic Pipeline

search/ixe/Common/item.h

/*
**      IXE
**      Common/item.h: field values
** ----------------------------------------------------------------------
**      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_ITEM_H
#define IXE_ITEM_H

// Settings
#include "platform.h"

// standard
#include <cstdlib>
#include <iostream>
#include <string>

// local
#include "include/ixe.h"
#include "include/sql.h"

namespace IXE {

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

class Item {

public:
  virtual ~Item() {}
  virtual Size packSize() = 0;
  virtual byte* value() const = 0;
# if 0
  virtual Item const & operator =(char const *newval) = 0;
# endif
  template <typename T>
  T& operator *() { return (T)(*value()); }

  template <typename T>
  operator T() { return (T)(*value()); }

  template <typename T>
  operator T*() { return *(T**)value(); }
};

#if 0
template <class T>
T convert(char const *newval) { return (T)(newval); }

template <>
int convert<int>(char const *newval) { return atoi(newval); }

template <>
long convert<long>(char const *newval) { return atol(newval); }

template <>
float convert<float>(char const *newval) { return (float)atof(newval); }

template <>
double convert<double>(char const *newval) { return atof(newval); }
#endif

template <class T>
class ItemOf : public Item {
public:
  T value_;

  ItemOf() {}
  ItemOf(T const value) : value_(value) { }
  virtual ~ItemOf() {}
  Size packSize() { return sizeof(T); }
# if 0
  virtual Item const & operator =(char const *newval) {
    value_ = convert<T>(newval);
    return *this;
  }
# endif
  T const & operator =(T const &newval) { return value_ = newval; }
  T & operator *() { return value_; }
  virtual byte* value() const { return (byte*)&value_; }
};

template<class T>
std::ostream& operator<< (std::ostream& s, const ItemOf<T>& t) {
  return s << *t;
}

} // namespace IXE

// Mechanism to keep .cpp file separate
# ifndef NON_TEMPLATE
# include "item.cpp"
# endif

#endif // IXE_ITEM_H

 

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