#ifndef __rf_vector_ih__
#define __rf_vector_ih__

#include "rf_vector.hh"
#include "rf_object.ih"
#include "rf_expr.ih"
#include "pxx_vector.ih"
#include <typeinfo>

namespace rftype
{

inline Vector::Vector (size_t _length /* = 0 */) :
  Object (),
  pxx::Vector<Expr> (_length)
{}

inline Vector::Vector (size_t _length, Expr const& _fill) :
  Object (),
  pxx::Vector<Expr> (_length)
{
  for (size_t i = 0; i < _length; i++) {
    self[i] = _fill;
  }
}

inline Vector::Vector (Expr const& _expr) :
  Object (),
  pxx::Vector<Expr> (0)
{
  Term* p = _expr.get_first();
  Term* q = _expr.get_last();
  size_t index = 0;
  for (; p < q; p++) {
    if (p->get_class() == term_ref) {
      self[index++] = Expr(p);
    } else {
      try {
        Vector& v = dynamic_cast<Vector&>(p->get_object());
        for (size_t i = 0; i < v.get_length(); i++) {
          self[index++] = v[i];
        }
      } catch (std::bad_cast&) {
        FATAL("Vector(): Argument expression contains non-vector object");
      }
    }
  }
}

inline unsigned Vector::get_type () const
{
  return reg.get_type();
}

//
// FIXME: Implement real hashing
inline uint32_t Vector::hash () const
{
  return 0;
}

inline bool Vector::operator == (Object const& _obj) const
{
  try {
    Vector const& v = dynamic_cast<Vector const&>(_obj);
    if (get_length() == v.get_length()) {
      for (size_t i = 0; i < get_length(); i++) {
        if (self[i] != v[i]) return false;
      }
      return true;
    }
    return false;
  } catch (std::bad_cast&) {
    return false;
  }
}

}

#endif // __rf_vector_ih__