////////////////////////////////////////////////////////////////////////////////
/*! @file NodePtr.h   A clever pointer to a node of RANet.
- Part of RANet - Research Assistant Net Library (based on ANSI C++).
- Copyright(C) 1994-2013, Viktor E. Bursian, St.Petersburg, Russia.
                     Viktor.Bursian@mail.ioffe.ru
*///////////////////////////////////////////////////////////////////////////////
#ifndef NodePtr_H
#define NodePtr_H
#include "NodeLocation.h"
#include <QMutex>
namespace RA {
//------------------------------------------------------------------------------

ANNOUNCE_CLASS(sNodePtr)

//template  sPtr< node_class >

//----------------------------------------------------------------- sNodePtr ---
/*! Encapsulated pointer to a node.

It can point either to a node in memory or to a node stored in file.
Operators * and -> do what is expected for pointers.
However, if the pointer points to a stored node, the node will be
automatically loaded and the pointer transforms itself so that it
points now to the loaded copy of the node.
Also, there may be a case when a node can be accessed through
different branches of the net.  In this case, ...
*/
class RANet_EXPORT  sNodePtr
{
  public:
    virtual                   ~sNodePtr ();
                              sNodePtr ();

    explicit                  sNodePtr (psNode);
                              sNodePtr (rcsNodePtr);
    rsNodePtr                 operator = (rcsNodePtr);

    bool                      IsNULL () const;
    void                      SetToNULL ();
    bool                      operator == (rcsNodePtr) const;

    //!@todo{Net} добавить вариант, возвращающий pcsNode?
    psNode                    operator -> ();
    //!@todo{Net} изменить возвращаемый на rcsNode?
    rsNode                    operator * ();

  public:
    sNodePtr                  operator >> (rcsAttrName  attr_name);
    sNodePtr                  operator >> (integer  attr_name)
                                {return operator>>(sAttrName(attr_name));}
    sNodePtr                  operator >> (rcsString  attr_name)
                                {return operator>>(sAttrName(attr_name));}
    sNodePtr                  operator >> (literal  attr_name)
                                {return operator>>(sAttrName(attr_name));}

    rsNodePtr                 operator << (sAttribute);
    rsNodePtr                 operator << (sNodePtr value_of_a_nameless_attr);

    sNodePtr                  operator >= (sAttribute);
    sNodePtr                  operator >= (rcsAttrName  attr_name);
    sNodePtr                  operator >= (integer  attr_name)
                                {
                                  return operator>=(sAttrName(attr_name));
                                }
    sNodePtr                  operator >= (rcsString  attr_name)
                                {
                                  return operator>=(sAttrName(attr_name));
                                }
    sNodePtr                  operator >= (literal  attr_name)
                                {
                                  return operator>=(sAttrName(attr_name));
                                }

    void                      operator |= (sAttribute);
    void                      operator |= (rcsAttrName  attr_name);
    void                      operator |= (integer  attr_name)
                                { operator|=(sAttrName(attr_name));}
    void                      operator |= (rcsString  attr_name)
                                { operator|=(sAttrName(attr_name));}
    void                      operator |= (literal  attr_name)
                                { operator|=(sAttrName(attr_name));}
    void                      DelAttr (sAttrName);     //not Nameless
    void                      DelAttr (integer  attr_name)
                                { DelAttr(sAttrName(attr_name)); }
    void                      DelAttr (rcsString  attr_name)
                                { DelAttr(sAttrName(attr_name)); }
    void                      DelAttr (literal  attr_name)
                                { DelAttr(sAttrName(attr_name)); }
    void                      DelAttr (sNodePtr  value_ptr);//Nameless only
    void                      DeleteAllAttributes ();
//    rsNodePtr                 operator |= (sNodePtr  model);

    pcsNodeLocation           NodeLocation ();
    bool                      NodeIsRecentlyEdited ()
                                { return NodeIsRecentlyEditedFlag; }
    void                      AcknowledgeThatNodeIsRecentlyEdited ()
                                { NodeIsRecentlyEditedFlag=false; }

  protected:


  private:
    explicit                  sNodePtr (psNodeLocation);
    void                      Clear ();
    void                      GetNode ();

  private://fields
    QMutex                    Mutex;
    bool                      InMemory;
    union{
        psNode                    TheNodePtr;         //if InMemory
        psNodeLocation            TheNodeLocationPtr; //if ! InMemory
    };
    bool                      NodeIsRecentlyEditedFlag;


  #ifdef RANET_DEBUG
  public:
    static long int           Counter;
  #endif

  friend class sNode;
  friend class sAttribute;


//                              sNodePtr (rsObjectStream);
//    virtual void              Store (rsObjectStream);
//    bool                      Strip (); //returns true if any of
//                                        //unstripable nodes down the net
//                                        //have to be saved (i.e. are Edited)
//    void                      StripCareless ();
//    bool                      Stripped () const
//                                /*! @todo{NetIO} NullNodePtr??? */
//                                { return ! InMemory; };
//    void                      PurgeAttributes ();
//    void                      Preallocate (sNodePtr        Host
//                                          ,sAttrName  AN);

//  protected:
//    bool                      IsHosting () const
//                                { return Hosting; };

//  private:
//    void                      SetHostingFlag ()
//                                { Hosting=true; };
//    void                      SetKeepFromSwitchingFlag()
//                                { KeepFromSwitching=true; };

//  protected://fields

//  private://fields
//    bool                      Hosting;
//    bool                      KeepFromSwitching;

//  friend class sAttribute;
};

//--------------------------------------------------------- sPtr<node_class> ---

template <class node_class>
struct  sPtr : public sNodePtr
{
                              sPtr ()
                                  :sNodePtr()
                                {}
    explicit                  sPtr (node_class *  new_node)
                                  :sNodePtr(new_node)
                                { Check(); }
                              sPtr (rcsNodePtr  other)
                                  :sNodePtr(other)
                                { Check(); }
                              sPtr (const sPtr &  other)
                                  :sNodePtr(other)
                                { Check(); }
    sPtr &                    operator = (const sPtr &  other)
                                {
                                  return (sPtr &)(sNodePtr::operator=(other));
                                }
    sPtr &                    operator = (rcsNodePtr other)
                                {
                                  return this->operator=(sPtr(other));
                                }
    node_class *              operator -> ()
                                {
                                  return (node_class *)(sNodePtr::operator->());
                                }
    node_class &              operator * ()
                                {
                                  return (node_class &)(sNodePtr::operator*());
                                }
    bool                      IsCorrect () const
                                { return ! IsNULL(); }
  private:
    void                      Check ()
                                {
                                  if( ! IsNULL()
                                      && ! dynamic_cast< node_class * >
                                                   (sNodePtr::operator ->()) )
                                    SetToNULL();
                                }
};

//------------------------------------------------------------------------------
} //namespace RA
#endif