otrav.h

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef BASE_OTRAV_H
#define BASE_OTRAV_H

#include "fastlib/base/common.h"
#include "fastlib/base/debug.h"
#include "fastlib/base/cc.h"
#include "fastlib/base/ccmem.h"

#include <typeinfo>

#define OT_CUSTOM_PRINT_OBJ(x, name) \
    if (true) { \
      ot__visitor->Name(name, x); \
      ot__visitor->Obj(x); \
    } else NOP // require semicolon

#define OT_OBJ(x) \
    OT_CUSTOM_PRINT_OBJ(x, #x)

#define OT_ENUM_VAL(val) \
   case val: \
    if (ot__visitor->IS_PRINTER) { \
      const char *ot__temp = #val; \
      ot__visitor->Obj(ot__temp); \
      break; \
    } // fall-through to default inside OT_ENUM_EXPERT

//    if (ot__visitor->IS_PRINTER && ot__enum == val) {
//      const char *ot__temp = #val;
//      ot__visitor->Obj(ot__temp);
//    } else // for series of OT_ENUM_VAL, use in OT_ENUM_EXPERT

#define OT_ENUM_EXPERT(x, T, print_code) \
    if (true) { \
      ot__visitor->Name(#x, x); \
      switch (x) { \
        print_code \
       default: \
        ot__visitor->Enum(x); \
      } \
    } else NOP // require semicolon

#define OT_ENUM(x) \
    OT_ENUM_EXPERT(x, int, )

#define OT_ARRAY_IMPL(x, len, iter_var, loop_code, func, args...) \
    if (true) { \
      ot__visitor->Name(#x, x); \
      index_t ot__len = len; \
      if (ot__visitor->Pre##func(x, ot__len, ## args)) { \
        for (index_t iter_var = 0; iter_var < ot__len; ++iter_var) { \
          ot__visitor->ElemOf(x); \
          loop_code; \
        } \
        ot__visitor->Name(#x, x); \
        ot__visitor->Post##func(x, ot__len, ## args); \
      } \
    } else NOP // require semicolon

#define OT_STATIC_ARRAY_EXPERT(x, iter_var, elem_code) \
    OT_ARRAY_IMPL(x, sizeof(x) / sizeof(*x), \
        iter_var, elem_code, StaticArray)

#define OT_STATIC_ARRAY(x) \
    OT_STATIC_ARRAY_EXPERT(x, ot__iter, OT_OBJ((x)[ot__iter]))

#define OT_PTR_EXPERT(x, nullable, deref_code) \
    OT_ARRAY_IMPL(x, 1, ot__iter, deref_code, \
        Array, nullable, false, true)

#define OT_PTR(x) \
    OT_PTR_EXPERT(x, true, OT_OBJ(*(x)))

#define OT_ARRAY_EXPERT(x, len, nullable, iter_var, elem_code) \
    OT_ARRAY_IMPL(x, len, iter_var, elem_code, \
        Array, nullable, false, false)

#define OT_ARRAY(x, len) \
    OT_ARRAY_EXPERT(x, len, true, ot__iter, OT_OBJ((x)[ot__iter]))

#define OT_ALLOC_EXPERT(x, len, nullable, iter_var, elem_code) \
    OT_ARRAY_IMPL(x, len, iter_var, elem_code, \
        Array, nullable, true, false)

#define OT_ALLOC(x, len) \
    OT_ALLOC_EXPERT(x, len, true, ot__iter, OT_OBJ((x)[ot__iter]))

#define OT_STR_EXPERT(x, nullable, alloc) \
    if (true) { \
      ot__visitor->Name(#x, x); \
      ot__visitor->Str(x, nullable, alloc); \
    } else NOP // require semicolon

#define OT_STR(x) \
    OT_STR_EXPERT(x, true, true)



#define OT_CONSTRUCTOR(C) \
   public: \
    C() { \
      ot__private::Unstructor ot__unstructor(this); \
      OT__DefaultConstruct(this); \
    } \
   private:

#define OT_DESTRUCTOR(C) \
   public: \
    ~C() { \
      DEBUG_DESTRUCT_OK(this); \
      ot__private::Destructor<false> ot__destructor(this); \
    } \
   private:

#define OT_COPY_CONSTRUCTOR(C) \
   public: \
    C(const C &src) { \
      ot__private::Copier<false> ot__copier(this, &src); \
    } \
    ASSIGN_VIA_RECURSION_SAFE_COPY_CONSTRUCTION(C) \
   private:

#define OT_DEPRECATED_COPY_CONSTRUCTOR(C) \
   public: \
    COMPILER_DEPRECATED \
    C(const C &src) { \
      ot__private::Copier<false> ot__copier(this, &src); \
    } \
    ASSIGN_VIA_RECURSION_SAFE_COPY_CONSTRUCTION(C) \
   private:



#define OT_RENEW_METHOD(C) \
   public: \
    void Renew() { \
      this->~C(); \
      new(this) C(); \
    } \
   private:

#define OT_COPY_METHOD(C) \
   public: \
    void InitCopy(const C &src) { \
      ot::InitCopy(this, src); \
    } \
    COMPILER_DEPRECATED \
    void Copy(const C &src) { \
      ot::InitCopy(this, src); \
    } \
   private:

#define OT_PRINT_METHOD(C) \
   public: \
    template<typename TPrintFormat> \
    const char *Print(const char *name, FILE *stream = stdout) { \
      return ot::Print<TPrintFormat>(*this, name, stream); \
    } \
    const char *Print(const char *name, FILE *stream = stdout) { \
      return Print<ot::StandardFormat>(name, stream); \
    } \
   private:



#define OT_FREEZE_METHODS(C) \
   public: \
    size_t FrozenSize() { \
      return ot::FrozenSize(*this); \
    } \
    size_t Freeze(char *block) { \
      return ot::Freeze(block, *this); \
    } \
    void InitThaw(char *block) { \
      ot::InitThaw(this, block); \
    } \
   private:

#define OT_SERIALIZE_METHODS(C) \
   public: \
    size_t SerialSize() { \
      return ot::SerialSize(*this); \
    } \
    size_t Serialize(FILE *stream) { \
      return ot::Serialize(*this, stream); \
    } \
    size_t InitDeserialize(FILE *stream) { \
      return ot::InitDeserialize(this, stream); \
    } \
   private:



#define OT_BECOME_NON_ALIAS(C) \
   public: \
    friend void OT__BecomeNonAlias(C *ot__obj) { \
      ot__obj->OT__BecomeNonAlias_(); \
      DEBUG_ASSERT_MSG(!OT__IsAlias(ot__obj), \
          "OT_BECOME_NON_ALIAS left OT_IS_ALIAS true for %s.", \
          typeid(C).name()); \
    } \
   private: \
    void OT__BecomeNonAlias_()

#define OT_BECOME_ALIAS(C) \
   public: \
    friend bool OT__Aliasable(const C *ot__obj) { \
      return true; \
    } \
    friend void OT__BecomeAlias(C *ot__obj) { \
      ot__obj->OT__BecomeAlias_(); \
      DEBUG_ASSERT_MSG(OT__IsAlias(ot__obj), \
          "OT_BECOME_ALIAS left OT_IS_ALIAS false for %s.", \
          typeid(C).name()); \
    } \
   private: \
    void OT__BecomeAlias_()

#define OT_IS_ALIAS(C) \
   public: \
    friend bool OT__IsAlias(C *ot__obj) { \
      return ot__obj->OT__IsAlias_(); \
    } \
   private: \
    bool OT__IsAlias_()

#define OT_ALIAS_METHODS(C) \
   public: \
    void InitAlias(const C &src) { \
      DEBUG_INIT_OK(this); \
      mem::Copy(this, &src); \
      ot__private::Aliaser ot__aliaser(this); \
    } \
    void InitSteal(C *src) { \
      DEBUG_INIT_OK(this); \
      DEBUG_WARN_MSG_IF(OT__IsAlias(src), \
          "Stealing from an alias %s.", typeid(C).name()); \
      mem::Copy(this, src); \
      ot__private::Aliaser ot__aliaser(src); \
    } \
    bool IsAlias() { \
      return OT__IsAlias(this); \
    } \
   private:



#define OT_DEFAULT_CONSTRUCT(C) \
   public: \
    friend void OT__DefaultConstruct(C *ot__obj) { \
      ot__obj->OT__DefaultConstruct_(); \
    } \
   private: \
    void OT__DefaultConstruct_()

#define OT_DEBUG_INIT_OK(C) \
   public: \
    friend bool OT__DebugInitOK(C *ot__obj) { \
      return ot__obj->OT__DebugInitOK_(); \
    } \
   private: \
    bool OT__DebugInitOK_()

#define DEBUG_INIT_OK(x) \
    DEBUG_ASSERT_MSG(OT__DebugInitOK(x), \
        "Reinitialization of %s; missing Renew()?", \
        typeid(*x).name());

#define OT_DEBUG_MODIFY_OK(C) \
   public: \
    friend bool OT__DebugModifyOK(C *ot__obj) { \
      return ot__obj->OT__DebugModifyOK_(); \
    } \
   private: \
    bool OT__DebugModifyOK_()

#define DEBUG_MODIFY_OK(x) \
    DEBUG_ASSERT_MSG(OT__DebugModifyOK(x), \
        "Modification of alias/locked %s; missing Init?", \
        typeid(*x).name());

#define OT_DEBUG_DESTRUCT_OK(x) \
   public: \
    friend bool OT__DebugDestructOK(C *ot__obj) { \
      return ot__obj->OT__DebugDestructOK_(); \
    } \
   private: \
    bool OT__DebugDestructOK_()

#define DEBUG_DESTRUCT_OK(x) \
    DEBUG_ASSERT_MSG(OT__DebugDestructOK(x), \
        "Premature destruction of %s; missing Init?", \
        typeid(*x).name());



#define OT_REFILL_TRANSIENTS(C) \
   public: \
    friend void OT__RefillTransients(C *ot__obj) { \
      OT__BecomeNonAlias(ot__obj); \
      ot__obj->OT__RefillTransients_(); \
    } \
   private: \
    void OT__RefillTransients_()

#define OT_TRANSIENTS(C) \
   public: \
    template<typename TVisitor> \
    friend void OT__TraverseTransients(C *ot__obj, TVisitor *ot__visitor) { \
      ot__obj->OT__TraverseTransients_(ot__visitor); \
    } \
   private: \
    template<typename TVisitor> \
    void OT__TraverseTransients_(TVisitor *ot__visitor)



#define OBJECT_TRAVERSAL_ONLY(C) \
   public: \
    template<typename TVisitor> \
    friend bool OT__PreTraverse(C *ot__dest, const C *ot__src, \
                                index_t ot__len, TVisitor *ot__visitor) { \
      return ot__visitor->PreTraverse(ot__dest, ot__src, ot__len); \
    } \
    template<typename TVisitor> \
    friend void OT__TraverseObject(C *ot__obj, TVisitor *ot__visitor) { \
      ot__obj->OT__TraverseObject_(ot__visitor); \
    } \
   private: \
    template<typename TVisitor> \
    void OT__TraverseObject_(TVisitor *ot__visitor)

#define OBJECT_TRAVERSAL_CORE(C) \
    OT_RENEW_METHOD(C) \
    OT_COPY_METHOD(C) \
    OT_PRINT_METHOD(C) \
    OBJECT_TRAVERSAL_ONLY(C)

#define OBJECT_TRAVERSAL(C) \
    OT_CONSTRUCTOR(C) \
    OT_DESTRUCTOR(C) \
    OT_COPY_CONSTRUCTOR(C) \
    OBJECT_TRAVERSAL_CORE(C)

#define OBJECT_TRAVERSAL_NO_COPIES(C) \
    OT_CONSTRUCTOR(C) \
    OT_DESTRUCTOR(C) \
    FORBID_ACCIDENTAL_COPIES(C) \
    OBJECT_TRAVERSAL_CORE(C)

#define OBJECT_TRAVERSAL_DEPRECATED_COPIES(C) \
    OT_CONSTRUCTOR(C) \
    OT_DESTRUCTOR(C) \
    OT_DEPRECATED_COPY_CONSTRUCTOR(C) \
    OBJECT_TRAVERSAL_CORE(C)

#define OBJECT_TRAVERSAL_SHALLOW(C) \
   public: \
    C() { \
      mem::DebugPoison(this); \
    } \
    ~C() { \
      DEBUG_DESTRUCT_OK(this); \
      mem::DebugPoison(this); \
    } \
    friend bool OT__Shallow(const C *ot__obj) { \
      return true; \
    } \
   private: \
    OT_IS_ALIAS(C) { return false; } \
    OT_DEFAULT_CONSTRUCT(C) {} \
    OT_REFILL_TRANSIENTS(C) {} \
    OT_TRANSIENTS(C) {} \
    OBJECT_TRAVERSAL_CORE(C)



#define OT_CUSTOM_PRINT(C) \
   private: \
    template<typename TPrintFormat> \
    void OT__TraverseObject_(ot__private::Printer<TPrintFormat> *ot__visitor)

#define OT_CUSTOM_DESTRUCT(C) \
   private: \
    template<bool t_semi> \
    void OT__TraverseObject_(ot__private::Destructor<t_semi> *ot__visitor)



#define NEED_OTRAV_IMPL
#include "fastlib/base/otrav_impl.h"
#undef NEED_OTRAV_IMPL



namespace ot {
  template<typename TPrintFormat, typename T>
  const char *Print(const T &obj, const char *name, FILE *stream = stdout) {
    ot__private::Printer<TPrintFormat> ot__printer(obj, name, stream);
    return name;
  }
  template<typename TPrintFormat, typename T>
  void Print(const T &obj, FILE *stream = stdout) {
    ot__private::Printer<TPrintFormat> ot__printer(obj, "_", stream);
  }

  template<typename T>
  const char *Print(const T &obj, const char *name, FILE *stream = stdout) {
    return Print<ot::StandardFormat>(obj, name, stream);
  }
  template<typename T>
  void Print(const T &obj, FILE *stream = stdout) {
    Print<ot::StandardFormat>(obj, stream);
  }



  template<typename T>
  inline void InitCopy(T *dest, const T &src) {
    DEBUG_INIT_OK(dest);
    ot__private::Copier<false> ot__copier(dest, &src);
  }



  template<typename T>
  inline size_t FrozenSize(const T &obj) {
    ot__private::Freezer<true> ot__freezer(NULL, obj);
    return ot__freezer.size();
  }

  template<typename T>
  inline size_t Freeze(char *block, const T &src) {
    ot__private::Freezer<false> ot__freezer(block, src);
    return ot__freezer.size();
  }

  template<typename T>
  inline void InitThaw(T *dest, const char *block) {
    DEBUG_INIT_OK(dest);
    ot__private::Copier<true> 
        ot__copier(dest, reinterpret_cast<const T *>(block));
  }



  template<typename T>
  inline T *SemiCopy(char *block, const T *orig) {
    DEBUG_WARN_MSG_IF(block == reinterpret_cast<const char *>(orig),
        "In-place SemiCopy may leak memory; probably incorrect.");
    ot__private::Relocator<false, true> ot__relocator(block, orig);
    return reinterpret_cast<T *>(block);
  }
  template<typename T>
  inline T *SemiCopy(char *block, const char *orig) {
    return SemiCopy(block, reinterpret_cast<const T *>(orig));
  }

  template<typename T>
  inline void SemiFreeze(char *block, const T *orig) {
    DEBUG_WARN_MSG_IF(block == reinterpret_cast<const char *>(orig),
        "In-place SemiFreeze may leak memory; use SemiFreezeDestruct.");
    ot__private::Relocator<true, false> ot__relocator(block, orig);
  }
  template<typename T>
  void SemiFreeze(char *block, const char *orig) {
    SemiFreeze(block, reinterpret_cast<const T *>(orig));
  }

  template<typename T>
  inline T *SemiThaw(char *block) {
    return SemiCopy(block, reinterpret_cast<const T *>(NULL));
  }

  template<typename T>
  inline void SemiDestruct(T *obj) {
    ot__private::Destructor<true> ot__destructor(obj);
  }
  template<typename T>
  inline void SemiDestruct(char *block) {
    SemiDestruct(reinterpret_cast<T *>(block));
  }

  template<typename T>
  inline char *SemiFreezeDestruct(T *obj) {
    ot__private::Relocator<true, true>
        ot__relocator(reinterpret_cast<char *>(obj), obj);
    return reinterpret_cast<char *>(obj);
  }
  template<typename T>
  inline char *SemiFreezeDestruct(char *block) {
    return SemiFreezeDestruct(reinterpret_cast<T *>(block));
  }



  template<typename T>
  inline size_t SerialSize(const T &obj) {
    ot__private::Serializer<true> ot__serializer(obj, NULL);
    return ot__serializer.size();
  }

  template<typename T>
  inline size_t Serialize(const T &obj, FILE *stream) {
    ot__private::Serializer<false> ot__serializer(obj, stream);
    return ot__serializer.size();
  }

  template<typename T>
  inline size_t InitDeserialize(T *dest, FILE *stream) {
    DEBUG_INIT_OK(dest);
    ot__private::Deserializer ot__deserializer(dest, stream);
    return ot__deserializer.size();
  }



  template<typename T>
  inline T *Construct(T *array, size_t elems = 1) {
    if (OT__ShallowOrPtr(array)) {
      return mem::DebugPoison(array, elems);
    } else {
      return mem::Construct(array, elems);
    }
  }

  template<typename T>
  inline T *Destruct(T *array, size_t elems = 1) {
    if (OT__ShallowOrPtr(array)) {
      return mem::DebugPoison(array, elems);
    } else {
      return mem::Destruct(array, elems);
    }
  }

  template<typename T>
  inline T *CopyConstruct(T *dest, const T *src, size_t elems = 1) {
    ot__private::Copier<false> ot__copier(dest, src, elems);
    return dest;
  }

  template<typename T>
  inline T *RepeatConstruct(T *array, const T &init, size_t elems) {
    for (size_t i = 0; i < elems; ++i) {
      ot__private::Copier<false> ot__copier(array + i, &init);
    }
    return array;
  }


  template<typename T>
  COMPILER_DEPRECATED
  void Copy(const T &src, T *dest) {
    InitCopy(dest, src);
  }

  template<typename T>
  COMPILER_DEPRECATED
  size_t PointerFrozenSize(const T &obj) {
    return FrozenSize(obj);
  }

  template<typename T>
  COMPILER_DEPRECATED
  void PointerFreeze(const T &obj, char *block) {
    Freeze(block, obj);
  }

  template<typename T>
  COMPILER_DEPRECATED
  void PointerRefreeze(const T *src, char *dest) {
    SemiFreeze(dest, src);
  }

  template<typename T>
  COMPILER_DEPRECATED
  T *PointerThaw(char *block) {
    return SemiThaw<T>(block);
  }

  template<typename T>
  COMPILER_DEPRECATED
  void PointerRelocate(const char *old_loc, char *new_loc) {
    /*
     * TODO: Perhaps detect if Shallow, doing nothing, or try function
     * FixTransients, which by default deallocates them and
     * reallocates them and can be redefined to blank.  Carefully
     * consider Swap behavior in cachearray_impl.h.
     */
    // leaks memory for allocated transients
    SemiCopy<T>(new_loc, old_loc);
  }
};


#define OT_MY_OBJECT OT_OBJ
#define OT_MY_ARRAY OT_STATIC_ARRAY
#define OT_MALLOC_ARRAY OT_ALLOC
#define OT_PTR_NULLABLE OT_PTR

#define OT_FIX OT_REFILL_TRANSIENTS

#define OT_DEF OBJECT_TRAVERSAL
#define OT_DEF_BASIC OBJECT_TRAVERSAL

#endif /* BASE_OTRAV_H */