tpl_binNode.H

Ir a la documentación de este archivo.

# ifndef TPL_BINNODE_H
# define TPL_BINNODE_H
 
# include <iostream>
# include <ahDefs.H>
# include <ahAssert.H>

namespace Aleph {
 
 
struct Empty_Node 
{
  Empty_Node() { /* empty */ }

  Empty_Node(SentinelCtor) { /* empty */ }

  void reset() { /* empty */ }

  Empty_Node & get_data() 
  { 
    throw std::domain_error("Empty_Node has not data"); 
  }
};

# define INIT_CLASS_BINNODE(Name, height, Control_Data)       \
    template <typename Key>                                   \
class Name : public Control_Data                              \
{                                                             \
public:                                                       \
  static const size_t MaxHeight = height;                     \
  static Name * const NullPtr;                                \
  typedef Key key_type;                                       \
  typedef Key Key_Type;                                       \
                                                              \
private:                                                      \
                                                              \
  Key    key;                                                 \
  Name * lLink;                                               \
  Name * rLink;                                               \
                                                              \
public:                                                       \
                                                              \
  Key & get_key() { return key; }                             \
  const Key & get_key() const { return key; }                 \
  Name *& getL() { return lLink; }                            \
  Name *& getR() { return rLink; }                            \
  Name(const Key& k) : key(k), lLink(NullPtr), rLink(NullPtr) \
  {                                                           \
    /* Empty */                                               \
  }                                                           \
  Name(Key && k)                                              \
    : lLink(NullPtr), rLink(NullPtr)                          \
  {                                                           \
    std::swap(key, k);                                        \
  }                                                           \
  Name(const Control_Data & control_data, const Key & k) :    \
    Control_Data(control_data),                               \
    key(k), lLink(NullPtr), rLink(NullPtr)                    \
  {                                                           \
    /* Empty */                                               \
  }                                                           \
  Name(const Name & node) :                                   \
    Control_Data(node),                                       \
    key(node.key), lLink(NullPtr), rLink(NullPtr)             \
  {                                                           \
    /* Empty */                                               \
  }                                                           \
  Name(Name && node) :                                        \
    Control_Data(std::move(node)),                            \
    key(std::move(node).key), lLink(NullPtr), rLink(NullPtr)  \
  {                                                           \
    /* Empty */                                               \
  }                                                           \
  Name(const Control_Data & control_data) :                   \
    Control_Data(control_data),                               \
    lLink(NullPtr), rLink(NullPtr)                            \
  {                                                           \
    /* Empty */                                               \
  }                                                           \
  Name() : lLink(NullPtr), rLink(NullPtr)                     \
  {                                                           \
    /* Empty */                                               \
  }                                                           \
  void reset()                                                \
  {                                                           \
    Control_Data::reset();                                    \
    rLink = lLink = NullPtr;                                  \
  }                                                           \
  static Name * key_to_node(Key & __key)                      \
  {                                                           \
    Name * node_zero = 0;                                     \
    size_t offset = (size_t) &(node_zero->key);               \
    unsigned long addr = (unsigned long)(&__key);             \
    return (Name*) (addr - offset);                           \
  }

# define DECLARE_BINNODE(Name, height, Control_Data)                 \
  INIT_CLASS_BINNODE(Name, height, Control_Data)                     \
};                                                                   \
template <typename Key> Name<Key> * const Name<Key>::NullPtr = NULL; \
 INIT_CLASS_BINNODE(Name##Vtl, height, Control_Data)                 \
 virtual ~Name##Vtl() { /* empty */ }                                \
};                                                                   \
 template <typename Key> Name##Vtl<Key> *                            \
 const Name##Vtl<Key>::NullPtr = NULL

# define DECLARE_BINNODE_SENTINEL(Name, height, Control_Data)    \
INIT_CLASS_BINNODE(Name, height, Control_Data)                   \
  Name(SentinelCtor) :                                           \
    Control_Data(sentinelCtor), lLink(NullPtr), rLink(NullPtr) {}\
  static Name sentinel_node;                                     \
};                                                               \
template <typename Key>                                          \
Name<Key> Name<Key>::sentinel_node(sentinelCtor);                \
template <typename Key>                                          \
Name<Key> * const Name<Key>::NullPtr = &Name<Key>::sentinel_node;\
INIT_CLASS_BINNODE(Name##Vtl, height, Control_Data)              \
virtual ~Name##Vtl() { /* empty */ }                             \
private:                                                         \
  Name##Vtl(SentinelCtor) :                                      \
    Control_Data(sentinelCtor), lLink(NullPtr), rLink(NullPtr) {}\
  static Name##Vtl sentinel_node;                                \
};                                                               \
template <typename Key>                                          \
Name##Vtl<Key> Name##Vtl<Key>::sentinel_node(sentinelCtor);      \
template <typename Key>                                          \
Name##Vtl<Key> * const Name##Vtl<Key>::NullPtr =                 \
  &Name##Vtl<Key>::sentinel_node

# define LLINK(p) ((p)->getL())

# define RLINK(p) ((p)->getR())

# define KEY(p)   ((p)->get_key()) 

DECLARE_BINNODE(BinNode, 2048, Empty_Node);


} // end namespace Aleph
# endif