source: to-imperative/trunk/runtime/rf_vector.ih @ 1048

#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, size_t _length) :
  Object (),
  pxx::Vector<Expr> (_length) 
{
  Term* p = _expr.get_first();
  Term* q = _expr.get_last();
  size_t index = 0;
  for (; p < q; p++) {
    if (p->is_ref()) {
      self[index++] = (Expr(p))();
    } else {
      FATAL("Invalid argument");               //  RF_LIB_ERROR - ??????
    }
  }
}

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


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;
  }
}

inline void Vector::vector_to_exp (Expr& _exp)
{
  for (size_t i = 0; i < get_length(); i++)
    _exp = _exp + self[i];
}

inline void Vector::vector_init (size_t _length, Expr const& _fill)
{
  size_t n = get_length();
  if (n < _length)  
      expand (_length - n);
  else
    if (n > _length) 
      decrease(n - _length);
   n = _length;
   for (  ; n  ; n--)
     self[n-1] = _fill();
} 

inline void Vector::vector_replace (size_t _length, Expr const& _exp)
{
  size_t n = get_length();
  if (n < _length)
    expand (_length - n);
  else
    if (n > _length) 
      decrease(n - _length);
  Term* p = _exp.get_first();
  Term* q = _exp.get_last();
  n = 0;
  for ( ; p < q ; p++) {
    if (p->is_ref()) {
      self[n++] = (Expr(p))();
    } else {
      FATAL("Invalid argument");     
    }
  }
}   

inline void  vector_meaning (Expr const& _exp, Expr& _result)
{
  Term* p = _exp.get_first();
  Term* q = _exp.get_last();
  for ( ; p < q; p++) {
    if (p->is_ref()) {
      _result = _result + (Expr(p))();
    } else {
      Vector* v = p->cast_to<Vector> (type_vector);
      if (!v)
        FATAL ("Invalid argument");
      for (size_t i = 0; i < v->get_length(); i++)
        _result = _result + (*v)[i];
    }
  }
}      
  
inline void Vector::vector_fill (Expr const& _fill)
{
  for (size_t i = 0; i < get_length(); i++)
    self[i] = _fill();
}

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

}

#endif // __rf_vector_ih__