#ifndef __rf_channel_ih__
#define __rf_channel_ih__

#include "rf_channel.hh"
#include "rf_object.ih"
#include "rf_expr.ih"

#include <typeinfo>

namespace rftype
{

inline Channel::Channel (FILE* _fp /* = null */) :
  fp (_fp)
{
  was_opened = (fp != null) ? true : false;
}

inline Channel::Channel (Channel const& _channel) :
  Object (),
  fp (_channel.fp)
{}

inline Channel::~Channel ()
{
  if (!was_opened) close();
}

inline Channel& Channel::operator = (Channel const& _channel)
{
  if (this != &_channel) {
    this->~Channel();
    new(this) Channel(_channel);
  }
  return self;
}

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

//
// FIXME: Return proper hash value
inline uint32_t Channel::hash () const
{
  return 0;
}

inline bool Channel::operator == (Object const& _obj) const
{
  try {
    Channel const& ch = dynamic_cast<Channel const&>(_obj);
    return fp == ch.fp;
  } catch (std::bad_cast&) {
    return false;
  }
}

inline bool Channel::open (char const* _fname, char const* _mode)
{
  if (fp != null) fclose(fp);
  fp = fopen(_fname, _mode);
  return fp != null ? true : false;
}

inline void Channel::close ()
{
  if (fp != null) fclose(fp);
  fp = null;
}

inline bool Channel::eof()
{
  return (feof(fp));
}


inline FILE* Channel::get_fp () const
{
  return fp;
}

inline pxx::WString Channel::to_string () const
{ 
  size_t max_len = hex_ptr_len + max_int_len + 15;
  char str[max_len];
  int len =
      snprintf(str, max_len, "<Channel|%p|%d>", this, fp ? fileno(fp) : -1);
  if (-1 == len) {
    FATAL("<Channel|%p|%d> is more than %u characters",
          this, fp ? fileno(fp) : -1, max_len);
  }
  wchar_t wstr[len];
  len = strtowstr(wstr, str, len);
  return pxx::WString(wstr, len);
}

}

#endif // __rf_channel_ih__