// $Source$
// $Revision$
// $Date$
// $Author$

#ifndef __rf_symbol_ih__
#define __rf_symbol_ih__

#include "rf_symbol.hh"
#include "rf_macros.hh"

namespace rftype
{

using namespace rfrt ;

template <class C>
inline Symbol<C, FlatTerm>::Symbol () :
  Term (get_type())
{
  new (&ptr_data2) C();
}

template <class C>
template <typename CppType1>
inline Symbol<C, FlatTerm>::Symbol (CppType1 const& _arg1) :
  Term (get_type())
{
  new (&ptr_data2) C(_arg1);
}

template <class C>
template <typename CppType1, typename CppType2>
inline Symbol<C, FlatTerm>::Symbol (
    CppType1 const& _arg1, CppType2 const& _arg2
) :
  Term (get_type())
{
  new (&ptr_data2) C(_arg1, _arg2);
}

template <class C>
template <typename CppType1, typename CppType2, typename CppType3>
inline Symbol<C, FlatTerm>::Symbol (
    CppType1 const& _arg1, CppType2 const& _arg2, CppType3 const& _arg3
) :
  Term (get_type())
{
  new (&ptr_data2) C(_arg1, _arg2, _arg3);
}

template <class C>
inline C const& Symbol<C, FlatTerm>::get_object () const
{
  return *reinterpret_cast<C const*>(&int_data2);
}

template <class C>
void Symbol<C, FlatTerm>::ctor (
    Symbol<C, FlatTerm>* _to, Symbol<C, FlatTerm> const* _from
)
{
  _to->data1 = _from->data1;
  _to->int_data2 = _from->int_data2;
}

template <class C>
void Symbol<C, FlatTerm>::dtor (Symbol<C, FlatTerm>*)
{}

template <class C>
bool Symbol<C, FlatTerm>::eq (
    Symbol<C, FlatTerm> const* _s1, Symbol<C, FlatTerm> const* _s2
)
{
  return _s1->int_data2 == _s2->int_data2;
}

template <class C>
int Symbol<C, FlatTerm>::compare (
    Symbol<C, FlatTerm> const* _s1, Symbol<C, FlatTerm> const* _s2
)
{
  if (_s1->int_data2 > _s2->int_data2) return 1;
  if (_s1->int_data2 < _s2->int_data2) return -1;
  return 0;
}

template <class C>
WString Symbol<C, FlatTerm>::to_string (
    Symbol<C, FlatTerm> const* _s
)
{ 
  wchar_t s[2];
  s[0] = _s->int_data2;
  s[1] = '\0';
  return WString(s, 1);
}

template <class C>
size_t Symbol<C, FlatTerm>::get_name (
    Symbol<C, FlatTerm> const*, wchar_t const**
)
{ 
  return (size_t)-1;
}

template <class C>
short_type_funcs_t Symbol<C, FlatTerm>::funcs = {
  0,
  (void (*)(Term*, Term const*))   (Symbol<C, FlatTerm>::ctor),
  (void (*)(Term*))                (Symbol<C, FlatTerm>::dtor),
  (bool (*)(Term const*, Term const*))   (Symbol<C, FlatTerm>::eq),
  (int  (*)(Term const*, Term const*))   (Symbol<C, FlatTerm>::compare),
  null, // (uint32_t (*)(Term const*))            (Symbol<C, FlatTerm>::hash),
  (pxx::WString (*)(Term const*))  (Symbol<C, FlatTerm>::to_string),
  (size_t (*)(Term const*, wchar_t const**)) (Symbol<C, FlatTerm>::get_name)
};

template <class C>
inline unsigned Symbol<C, FlatTerm>::get_type ()
{
  return reg.get_type();
}

template <class C>
template <typename CppType>
inline size_t Symbol<C, FlatTerm>::compute_length (CppType const* _array)
{
  size_t len = 0;
  while (*_array++) len++;
  return len;
}


template <class C>
inline Symbol<C, StaticTerm>::Symbol (C* _p) :
  Term (get_type(), _p)
{}

template <class C>
inline C* Symbol<C, StaticTerm>::get_obj_ptr () const
{
  return static_cast<C*>(ptr_data2);
}

template <class C>
void Symbol<C, StaticTerm>::ctor (
    Symbol<C, StaticTerm>* _to, Symbol<C, StaticTerm> const* _from
)
{
  _to->data1 = _from->data1;
  _to->ptr_data2 = _from->ptr_data2;
}

template <class C>
void Symbol<C, StaticTerm>::dtor (Symbol<C, StaticTerm>*)
{}

template <class C>
bool Symbol<C, StaticTerm>::eq (
    Symbol<C, StaticTerm> const* _s1, Symbol<C, StaticTerm> const* _s2
)
{
  return _s1->get_obj_ptr() == _s2->get_obj_ptr();
}

template <class C>
int Symbol<C, StaticTerm>::compare (
    Symbol<C, StaticTerm> const* _s1, Symbol<C, StaticTerm> const* _s2
)
{
  if (_s1->get_obj_ptr() > _s2->get_obj_ptr()) return 1;
  if (_s1->get_obj_ptr() < _s2->get_obj_ptr()) return -1;
  return 0;
}

template <class C>
pxx::WString Symbol<C, StaticTerm>::to_string (
    Symbol<C, StaticTerm> const* _s
)
{ 
  size_t max_len = hex_ptr_len + max_int_len + 4;
  wchar_t* str = static_cast<wchar_t*>(alloca(max_len * sizeof(wchar_t)));
  C* ptr = _s->get_obj_ptr();
  int len = swprintf(str, max_len, L"<%u|%p>", get_type(), ptr);
  if (-1 == len)
    FATAL("<%u|%p> is more then %u wide characters", get_type(), ptr, max_len);
  return pxx::WString(str, len);
}

template <class C>
size_t Symbol<C, StaticTerm>::get_name (
    Symbol<C, StaticTerm> const* _s, wchar_t const** _np
)
{ 
  return (size_t)-1;
}

template <class C>
short_type_funcs_t Symbol<C, StaticTerm>::funcs = {
  0,
  (void (*)(Term*, Term const*))   (Symbol<C, StaticTerm>::ctor),
  (void (*)(Term*))                (Symbol<C, StaticTerm>::dtor),
  (bool (*)(Term const*, Term const*))   (Symbol<C, StaticTerm>::eq),
  (int  (*)(Term const*, Term const*))   (Symbol<C, StaticTerm>::compare),
  null, // (uint32_t (*)(Term const*))            (Symbol<C, StaticTerm>::hash),
  (pxx::WString (*)(Term const*))  (Symbol<C, StaticTerm>::to_string),
  (size_t (*)(Term const*, wchar_t const**)) (Symbol<C, StaticTerm>::get_name)
};

template <class C>
inline unsigned Symbol<C, StaticTerm>::get_type ()
{
  return reg.get_type();
}


template <class C>
inline Symbol<C, ObjectTerm>::Symbol () :
  Term (reg.get_type())
{
  Wrapper* w = static_cast<Wrapper*>(allocator->allocate(sizeof(Wrapper)));
  new (&(w->object)) C();
  w->ref_count = 1;
  ptr_data2 = w;
}

template <class C>
template <typename CppType1>
inline Symbol<C, ObjectTerm>::Symbol (CppType1 const& _arg1) :
  Term (reg.get_type())
{
  Wrapper* w = static_cast<Wrapper*>(allocator->allocate(sizeof(Wrapper)));
  new (&(w->object)) C(_arg1);
  w->ref_count = 1;
  ptr_data2 = w;
}

template <class C>
template <typename CppType1, typename CppType2>
inline Symbol<C, ObjectTerm>::Symbol (
    CppType1 const& _arg1, CppType2 const& _arg2
) :
  Term (reg.get_type())
{
  Wrapper* w = static_cast<Wrapper*>(allocator->allocate(sizeof(Wrapper)));
  new (&(w->object)) C(_arg1, _arg2);
  w->ref_count = 1;
  ptr_data2 = w;
}

template <class C>
template <typename CppType1, typename CppType2, typename CppType3>
inline Symbol<C, ObjectTerm>::Symbol (
    CppType1 const& _arg1, CppType2 const& _arg2, CppType3 const& _arg3
) :
  Term (reg.get_type())
{
  Wrapper* w = static_cast<Wrapper*>(allocator->allocate(sizeof(Wrapper)));
  new (&(w->object)) C(_arg1, _arg2, _arg3);
  w->ref_count = 1;
  ptr_data2 = w;
}

template <class C>
inline void Symbol<C, ObjectTerm>::replace_object ()
{
  C* p = get_obj_ptr();
  p->~C();
  new (p) C();
}

template <class C>
template<typename CppType1>
inline void Symbol<C, ObjectTerm>::replace_object (CppType1 const& _arg1)
{
  C* p = get_obj_ptr();
  p->~C();
  new (p) C(_arg1);
}

template <class C>
template<typename CppType1, typename CppType2>
inline void Symbol<C, ObjectTerm>::replace_object (
    CppType1 const& _arg1, CppType2 const& _arg2
)
{
  C* p = get_obj_ptr();
  p->~C();
  new (p) C(_arg1, _arg2);
}

template <class C>
template<typename CppType1, typename CppType2, typename CppType3>
inline void Symbol<C, ObjectTerm>::replace_object (
    CppType1 const& _arg1, CppType2 const& _arg2, CppType3 const& _arg3
)
{
  C* p = get_obj_ptr();
  p->~C();
  new (p) C(_arg1, _arg2, _arg3);
}

template <class C>
inline C const& Symbol<C, ObjectTerm>::get_object () const
{
  return static_cast<Wrapper*>(ptr_data2)->object;
}

template <class C>
inline C* Symbol<C, ObjectTerm>::get_obj_ptr () const
{
  return &static_cast<Wrapper*>(ptr_data2)->object;
}

template <class C>
void Symbol<C, ObjectTerm>::ctor (
    Symbol<C, ObjectTerm>* _to, Symbol<C, ObjectTerm> const* _from
)
{
  _to->data1 = _from->data1;
  _to->ptr_data2 = _from->ptr_data2;
  static_cast<Wrapper*>(_to->ptr_data2)->ref_count++;
}

template <class C>
void Symbol<C, ObjectTerm>::dtor (Symbol<C, ObjectTerm>* _s)
{
  Wrapper* w = static_cast<Wrapper*>(_s->ptr_data2);
  if (--(w->ref_count) == 0) {
    w->object.~C();
    allocator->deallocate(w);
  }
}

template <class C>
bool Symbol<C, ObjectTerm>::eq (
    Symbol<C, ObjectTerm> const* _s1, Symbol<C, ObjectTerm> const* _s2
)
{
  return _s1->get_obj_ptr() == _s2->get_obj_ptr();
}

template <class C>
int Symbol<C, ObjectTerm>::compare (
    Symbol<C, ObjectTerm> const* _s1, Symbol<C, ObjectTerm> const* _s2
)
{
  if (_s1->get_obj_ptr() > _s2->get_obj_ptr()) return 1;
  if (_s1->get_obj_ptr() < _s2->get_obj_ptr()) return -1;
  return 0;
}

template <class C>
pxx::WString Symbol<C, ObjectTerm>::to_string (
    Symbol<C, ObjectTerm> const* _s
)
{ 
  size_t max_len = hex_ptr_len + 15;
  wchar_t* str = static_cast<wchar_t*>(alloca(max_len * sizeof(wchar_t)));
  C* ptr = _s->get_obj_ptr();
  int len = swprintf(str, max_len, L"<Object|%p>", ptr);
  if (-1 == len)
    FATAL("<Object|%p> is more then %u wide characters", ptr, max_len);
  return pxx::WString(str, len);
}

template <class C>
short_type_funcs_t Symbol<C, ObjectTerm>::funcs = {
  0,
  (void (*)(Term*, Term const*))   (Symbol<C, ObjectTerm>::ctor),
  (void (*)(Term*))                (Symbol<C, ObjectTerm>::dtor),
  (bool (*)(Term const*, Term const*))   (Symbol<C, ObjectTerm>::eq),
  (int  (*)(Term const*, Term const*))   (Symbol<C, ObjectTerm>::compare),
  null, // (uint32_t (*)(Term const*))            (Symbol<C, ObjectTerm>::hash),
  (pxx::WString (*)(Term const*))  (Symbol<C, ObjectTerm>::to_string),
  null
};


template <class C>
inline Symbol<NamedObject<C>, ObjectTerm>::Symbol () :
  Term (reg.get_type())
{
  Wrapper* w = static_cast<Wrapper*>(allocator->allocate(sizeof(Wrapper)));
  new (&(w->object)) NamedObject<C>();
  w->ref_count = 1;
  ptr_data2 = w;
}

template <class C>
template <typename CppType1>
inline Symbol<NamedObject<C>, ObjectTerm>::Symbol (CppType1 _arg1) :
  Term (reg.get_type())
{
  Wrapper* w = static_cast<Wrapper*>(allocator->allocate(sizeof(Wrapper)));
  new (&(w->object)) NamedObject<C>(_arg1);
  w->ref_count = 1;
  ptr_data2 = w;
}

template <class C>
template <typename CppType1, typename CppType2>
inline Symbol<NamedObject<C>, ObjectTerm>::Symbol (CppType1 _arg1, CppType2 _arg2) :
  Term (reg.get_type())
{
  Wrapper* w = static_cast<Wrapper*>(allocator->allocate(sizeof(Wrapper)));
  new (&(w->object)) NamedObject<C>(_arg1, _arg2);
  w->ref_count = 1;
  ptr_data2 = w;
}

template <class C>
inline NamedObject<C> const&
Symbol<NamedObject<C>, ObjectTerm>::get_object () const
{
  return static_cast<Wrapper*>(ptr_data2)->object;
}

template <class C>
inline NamedObject<C>* Symbol<NamedObject<C>, ObjectTerm>::get_obj_ptr () const
{
  return &static_cast<Wrapper*>(ptr_data2)->object;
}

template <class C>
void Symbol<NamedObject<C>, ObjectTerm>::dtor (Symbol<NamedObject<C>, ObjectTerm>* _s)
{
  Wrapper* w = static_cast<Wrapper*>(_s->ptr_data2);
  if (--(w->ref_count) == 0) {
    w->object.~NamedObject<C>();
    allocator->deallocate(w);
  }
}

template <class C>
pxx::WString Symbol<NamedObject<C>, ObjectTerm>::to_string (
    Symbol<NamedObject<C>, ObjectTerm> const* _s
)
{ 
  NamedObject<C>* ptr = _s->get_obj_ptr();
  return ptr->name;
}

template <class C>
size_t Symbol<NamedObject<C>, ObjectTerm>::get_name (
    Symbol<NamedObject<C>, ObjectTerm> const* _s, wchar_t const** _np
)
{ 
  NamedObject<C>* ptr = _s->get_obj_ptr();
  *_np = ptr->name.get_data();
  return ptr->name.get_length();
}

template <class C>
short_type_funcs_t Symbol<NamedObject<C>, ObjectTerm>::funcs = {
  0,
  (void (*)(Term*, Term const*))   (Symbol<C, ObjectTerm>::ctor),
  (void (*)(Term*))                (Symbol<NamedObject<C>, ObjectTerm>::dtor),
  (bool (*)(Term const*, Term const*))   (Symbol<C, ObjectTerm>::eq),
  (int  (*)(Term const*, Term const*))   (Symbol<C, ObjectTerm>::compare),
  null, // (uint32_t (*)(Term const*))            (Symbol<C, ObjectTerm>::hash),
  (pxx::WString (*)(Term const*))  (Symbol<NamedObject<C>, ObjectTerm>::to_string),
  (size_t (*)(Term const*, wchar_t const**)) (Symbol<NamedObject<C>, ObjectTerm>::get_name)
};

/*
template <class C>
const TypeRegister Symbol<C, ObjectTerm>::reg(&Symbol<C, ObjectTerm>::funcs);
*/

template <class C>
inline unsigned Symbol<C, ObjectTerm>::get_type ()
{
  return reg.get_type();
}

}

#endif // __rf_symbol_ih__