~vbursian/research-assistant/intervers

////////////////////////////////////////////////////////////////////////////////
/*! @file NodePtr.cpp   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
*///////////////////////////////////////////////////////////////////////////////
#include "NodePtr.h"
#include "NetExceptions.h"
#include "Attribute.h"
#include "Nodes.h"
#include "Net.h"
#include "FolderNode.h"
#include <QMutexLocker>
namespace RA {
//------------------------------------------------------------------------------

#ifdef RANET_DEBUG
long int                      sNodePtr::Counter(0);
#endif

//----------------------------------------------------------------- sNodePtr ---

sNodePtr::~sNodePtr ()
{
  IF_DEBUG(--Counter;)
  Clear();
}


sNodePtr::sNodePtr ()
    :InMemory(true)
    ,TheNodePtr(NULL)
    ,NodeIsRecentlyEditedFlag(false)
//    ,Hosting(false)
//    ,KeepFromSwitching(false)
{
  IF_DEBUG(++Counter;)
}


/*!

@todo{Net} этот нехороший конструктор используется:
- В attr(...) - спрятать в конструкторы sAttribute?
- В sDB_SQL_Net::GetNode - можно реализовать через
  protected: sNodePtr sNet::Convert(psNode) const //backdoor
- При конструировании сети, когда добавляется безымянный атрибут, и нужно
  сохранить указатель на его значение для дальнейшего конструирования.
  Ранее для этого (но не только для этого) использовался метод MakeSubcluster.
  Можно сделать NewSubfolder(sString docket=sString()), возвращающий указатель
  на созданный узел, в отличие от операторов |=. Однако нет уверенности, что
  не потребуется то же самое для других типов узлов.  Может подмена операции
  new для узлов?

*/
sNodePtr::sNodePtr (psNode  node)
    :InMemory(true)
    ,TheNodePtr(NULL)
    ,NodeIsRecentlyEditedFlag(false)
//    ,Hosting(false)
//    ,KeepFromSwitching(false)
{
  IF_DEBUG(++Counter;)
  if( node ){
    TheNodePtr=node;
    TheNodePtr->RegisterPointer(this);
  }
}


/*!

@note The created sNodePtr instance takes ownership of @c location.
*/
sNodePtr::sNodePtr(psNodeLocation  location)
    :InMemory(false)
    ,TheNodeLocationPtr(location)
    ,NodeIsRecentlyEditedFlag(false)
//    ,Hosting(false)
//    ,KeepFromSwitching(false)
{
  IF_DEBUG(++Counter;)
}


sNodePtr::sNodePtr (rcsNodePtr  other)
    :InMemory(other.InMemory)
    ,TheNodePtr(NULL)
    ,NodeIsRecentlyEditedFlag(false)
//    ,Hosting(false)
//    ,KeepFromSwitching(false)
{
  IF_DEBUG(++Counter;)
  if( InMemory ){
    if( other.TheNodePtr ){
      TheNodePtr=other.TheNodePtr;
      TheNodePtr->RegisterPointer(this);
    };
  }else{
    ASSERT( other.TheNodeLocationPtr );
    TheNodeLocationPtr= other.TheNodeLocationPtr->Replica();
    ASSERT( TheNodeLocationPtr );
  };
}


rsNodePtr  sNodePtr::operator = (rcsNodePtr  other)
{
  Clear();
  InMemory=other.InMemory;
  if( InMemory ){
    if( other.TheNodePtr ){
      TheNodePtr=other.TheNodePtr;
      TheNodePtr->RegisterPointer(this);
    };
  }else{
    ASSERT( other.TheNodeLocationPtr );
    TheNodeLocationPtr= other.TheNodeLocationPtr->Replica();
    ASSERT( TheNodeLocationPtr );
  }
  return *this;
}


bool  sNodePtr::IsNULL() const
{
  return ( InMemory  &&  ! TheNodePtr );
}


void  sNodePtr::SetToNULL ()
{
  Clear();
}

bool  sNodePtr::operator == (rcsNodePtr  other) const
{
  bool                        Equal = false;
  bool                        ThisIsNULL = IsNULL();
  bool                        OtherIsNULL = other.IsNULL();
  if( ThisIsNULL && OtherIsNULL ){
    Equal = true;
  }else if( ThisIsNULL || OtherIsNULL ){
    Equal = false;
  }else if( InMemory ){
    ASSERT( TheNodePtr );
    if( other.InMemory ){
      ASSERT( other.TheNodePtr );
      Equal = TheNodePtr==other.TheNodePtr;
    }else{
      ASSERT( other.TheNodeLocationPtr );
      if( ! TheNodePtr->TheLocation )//*this is not yet allocated (newborn)
        Equal = false;
      else
        Equal = ( *(TheNodePtr->TheLocation) == other.TheNodeLocationPtr );
    };
  }else{// this->InMemory == false
    ASSERT( TheNodeLocationPtr );
    if( other.InMemory ){
      ASSERT( other.TheNodePtr );
      if( ! other.TheNodePtr->TheLocation )//*other is not yet allocated
        Equal = false;
      else
        Equal = ( *TheNodeLocationPtr == other.TheNodePtr->TheLocation );
    }else{
      ASSERT( other.TheNodeLocationPtr );
      Equal = ( *(TheNodeLocationPtr) == other.TheNodeLocationPtr );
    };
  };
  return Equal;
}


psNode  sNodePtr::operator -> ()
{
  GetNode();
  return TheNodePtr;
}


rsNode  sNodePtr::operator * ()
{
  GetNode();
  return *TheNodePtr;
}


/*! Gets a value of a named attribute of the node,
    "pointed" by this instance of sNodePtr.

*/
sNodePtr  sNodePtr::operator >> (rcsAttrName  attr_name)
{
  if( attr_name.Type() == sAttrName::cNameless )
    throw xNetInvalidOp("operator >> (nameless)",__FILE__,__LINE__);
  sNodePtr                    Result;
  if( ! IsNULL() ){
    GetNode();
    Result = TheNodePtr->GetAttr(attr_name);
  }
  return Result;
}


rsNodePtr  sNodePtr::operator << (sAttribute  attr)
{
  try{
    GetNode();
    TheNodePtr->SetAttr(attr);
  }catch( rxGetNullNode ){
    throw xNetInvalidOp("operator << for NULL ptr",__FILE__,__LINE__);
  }
  return *this;
}


rsNodePtr  sNodePtr::operator << (sNodePtr value_of_a_nameless_attr)
{
  try{
    GetNode();
    sAttribute                A (sAttrName(),value_of_a_nameless_attr);
    TheNodePtr->SetAttr(A);
  }catch( rxGetNullNode ){
    throw xNetInvalidOp("operator << for NULL ptr",__FILE__,__LINE__);
  }
  return *this;
}


/*! Ascribes the attribute,
    returns the pointer to the value of the ascribed attribute.
*/
sNodePtr  sNodePtr::operator >= (sAttribute  attr)
{
  try{
    GetNode();
    return TheNodePtr->AscribeAttr(attr);
  }catch( rxGetNullNode ){
    throw xNetInvalidOp("operator >= for NULL ptr",__FILE__,__LINE__);
  }
}


sNodePtr  sNodePtr::operator >= (rcsAttrName  attr_name)
{
  return operator>=(sAttribute( attr_name ,sNodePtr(new sFolderNode()) ));
}


void  sNodePtr::operator |= (sAttribute  attr)
{
  try{
    GetNode();
    TheNodePtr->AscribeAttr(attr);
  }catch( rxGetNullNode ){
    throw xNetInvalidOp("operator |= for NULL ptr",__FILE__,__LINE__);
  }
//  return *this;
}


void  sNodePtr::operator |= (rcsAttrName  attr_name)
{
  try{
    GetNode();
    sAttribute                A (attr_name,sNodePtr(new sFolderNode()) );
    TheNodePtr->AscribeAttr(A);
  }catch( rxGetNullNode ){
    throw xNetInvalidOp("operator |= for NULL ptr",__FILE__,__LINE__);
  }
//  return *this;
}


void  sNodePtr::DelAttr (sAttrName  attr_name)
{
  if( ! IsNULL() )
    operator->()->DelAttr(attr_name);
}


void  sNodePtr::DelAttr (sNodePtr  value_ptr)
{
  if( ! IsNULL() )
    operator->()->DelAttr(value_ptr);
}


void  sNodePtr::DeleteAllAttributes ()
{
  if( ! IsNULL() )
    operator->()->DeleteAllAttributes();
}


//rsNodePtr  sNodePtr::operator |= (sNodePtr  /*model*/)
//{
//  //!@patch not implemented yet
//  return *this;
//}


pcsNodeLocation  sNodePtr::NodeLocation ()
{
  QMutexLocker                Locker(&Mutex);
  if( ! InMemory )
    return TheNodeLocationPtr;
  else if( TheNodePtr )
    return TheNodePtr->TheLocation;
  return NULL;
}


void  sNodePtr::Clear ()
{
  QMutexLocker                Locker(&Mutex);
  if( ! InMemory ){
    ASSERT( TheNodeLocationPtr );
    delete TheNodeLocationPtr;  TheNodeLocationPtr=NULL;
  }else if( TheNodePtr ){
    TheNodePtr->UnregisterPointer(this);
    //!@todo{Net} delete node if not in register and doesn't have other ptrs?
  };
  InMemory=true;
  TheNodePtr=NULL;
  NodeIsRecentlyEditedFlag=false;
//  /*! @todo{Net!!!} ???Hosting=false;  ???KeepFromSwitching=false; */
}


void sNodePtr::GetNode ()
{
  //!@todo{NetIO} !!! rewrite to catch xNetIO !!!
  QMutexLocker                Locker(&Mutex);
  if( ! InMemory ){
    TheNodePtr = TheNodeLocationPtr->Net->GetNode(TheNodeLocationPtr)
                 .TheNodePtr;
    InMemory=true;
    if( TheNodePtr )
      TheNodePtr->RegisterPointer(this);
  };
  if( ! TheNodePtr ){
    throw xGetNullNode(*this);
  };
}




////sNodePtr::sNodePtr (rsObjectStream S)     //++FileStream
////    :InMemory(true)
////    ,TheNodePtr(NULL)
////    ,Next(NULL)
////    ,Hosting(false)
////    ,KeepFromSwitching(false)
////    ,NodeIsRecentlyEditedFlag(false)
////{
////  IF_DEBUG(++Counter;)
////  sNodeLocation::eIOPrefix    LocationIOPrefix;
////  sNodeLocation::eType        LocationType;
////  tNodeUID                    NodeUID;
////  sString                     LocationPath;
////  sString                     LocationDefaultSuffix;
////  tStreamPos                  LocationOffset;
////  psStorable                  V;

////  //! @todo{NetIO} CurrentIOLocation PATCH
////  ASSERT( sNode::CurrentIOLocation->Type == sNodeLocation::InStreamFile );
////  LocationOffset=S.GetReadingPosition();
////  S.READ_INTO(LocationIOPrefix);
////  if( LocationIOPrefix == sNodeLocation::NoNode ){
////  }else if( LocationIOPrefix == sNodeLocation::RightHere ){
////    sNode::CurrentIOLocation->NodeUID=NoID;
////    S>>LocationDefaultSuffix;
////    V=S.GetObject();
////    Next=this;
////    TheNodePtr=dynamic_cast<psNode>(V);
////    if( ! TheNodePtr )
////      throw xNet();  //! @todo{Net} something in place of xNet?  "not a node"
////    TheNodePtr->PtrRing=this;
////    TheNodePtr->NumberOfPointers++;
////    ASSERT( TheNodePtr->NumberOfPointers == 1 );
////    TheNodePtr->Location.Type=sNodeLocation::InStreamFile;
////    TheNodePtr->Location.NodeUID=NoID;
////    //problem:  NodePtr->Location.Path=rsFileStream(S).Fname;
////    TheNodePtr->Location.DefaultSuffix=LocationDefaultSuffix;
////    TheNodePtr->Location.Offset=LocationOffset;
////  }else{
////    S.READ_INTO(LocationType);
////    S.READ_INTO(NodeUID);
////    S>>LocationPath;
////    S>>LocationDefaultSuffix;
////    S.READ_INTO(LocationOffset);
////    InMemory=false;
////    TheNodeLocationPtr= new sNodeLocation(LocationType,NodeUID
////                                      ,LocationPath,LocationDefaultSuffix
////                                      ,LocationOffset);
////  };
////};


////void  sNodePtr::Store (rsObjectStream S)
////{
////  sNodeLocation::eIOPrefix    NoNodePrefix=sNodeLocation::NoNode;
////  sNodeLocation::eIOPrefix    RightHerePrefix=sNodeLocation::RightHere;
////  sNodeLocation::eIOPrefix    SeparatePrefix=sNodeLocation::Separate;
////  if( InMemory ){
////    if( ! TheNodePtr ){
////      S.WRITE_FROM(NoNodePrefix);
////    }else if( TheNodePtr == NullNodePtr.TheNodePtr ){
////      S.WRITE_FROM(NoNodePrefix);
////    }else{
////      if( TheNodePtr->Location.NodeUID == NoID ){
////        S.WRITE_FROM(RightHerePrefix);
////        S<<(TheNodePtr->Location.DefaultSuffix);
////        S.PutObject((psStorable)TheNodePtr);
////      }else{
////        S.WRITE_FROM(SeparatePrefix);
////        S.WRITE_FROM(TheNodePtr->Location.Type);
////        S.WRITE_FROM(TheNodePtr->Location.NodeUID);
////        S<<(TheNodePtr->Location.Path);
////        S<<(TheNodePtr->Location.DefaultSuffix);
////        S.WRITE_FROM(TheNodePtr->Location.Offset);
////      };
////    };
////  }else{
////    ASSERT( TheNodeLocationPtr );
////    S.WRITE_FROM(SeparatePrefix);
////    S.WRITE_FROM(TheNodeLocationPtr->Type);
////    S.WRITE_FROM(TheNodeLocationPtr->NodeUID);
////    S<<(TheNodeLocationPtr->Path);
////    S<<(TheNodeLocationPtr->DefaultSuffix);
////    S.WRITE_FROM(TheNodeLocationPtr->Offset);
////  };
////};


//bool  sNodePtr::Strip ()                 //returns true if any of
//                                         //unstripable nodes down the net
//                                         //have to be saved (i.e. are Edited)
//{
//  bool                        edited = false;
//  if( InMemory && ! IsNULL() ){
//    /*/////////DEBUG
//    tNodeUID    DEBUG_ID=NodePtr->Location.NodeUID;
//    sLongString DEBUG_LP=NodePtr->Location.Path+NodePtr->Location.DefaultSuffix;
//    bool        DEBUG_EDITED=NodePtr->Edited;
//    int         DEBUG_NUMOFHOSTS=NodePtr->NumberOfHosts;
//    int         DEBUG_NUMOFPTRS=NodePtr->NumberOfPointers;
//    */
////    sNet::Manager->Allocate(NodePtr);//! @todo{NetIO} obsolete allocation?
//    if( TheNodePtr->Location.NodeUID == NoID ){
//      TheNodePtr->Strip(); //may set up NodePtr->Edited flag
//      edited=TheNodePtr->EditedFlag;
//    }else{
//      psNode                  PNode=TheNodePtr;
//      PNode->DisconnectAllPtrs();
//      PNode->Strip(); //may set up PNode->Edited flag
//      ASSERT( PNode->NumberOfPointers == 0 );
//      PNode->Save();
//      edited=PNode->LocationEdited;
//      ASSERT( ! PNode->EditedFlag );
//      ASSERT( PNode->NumberOfPointers == 0 );
//      PNode->PurgeAttributes();
//      ASSERT( PNode->NumberOfPointers == 0 );
//      delete PNode;
//      /*------- а было так ------------
//      while( Next != this ){
//        Next->StripCareless();
//      };
//      NodePtr->Save();
//      NodePtr->Strip(); //may set up NodePtr->Edited flag
//      NodePtr->Save();
//      edited=NodePtr->LocationEdited;
//      ASSERT( ! NodePtr->Edited );
//      ASSERT( NodePtr->NumberOfPointers == 1 );
//      psNodeLocation              NL = new sNodeLocation(NodePtr->Location);
//      NodePtr->PurgeAttributes();
//      NodePtr->NumberOfPointers--;
//      delete NodePtr;
//      InMemory=false;
//      NodeLocationPtr=NL;
//      -------------------------------*/
//    };
//  };
//  return edited;
//};


//void  sNodePtr::StripCareless ()
//{
//  ASSERT( InMemory );
//  ASSERT( TheNodePtr->Location.NodeUID != NoID );
//  psNodeLocation              NL = new sNodeLocation(TheNodePtr->Location);
//  Clear();
//  InMemory=false;
//  TheNodeLocationPtr=NL;
//};


//void  sNodePtr::PurgeAttributes ()
//{
//  if( InMemory && ! IsNULL() ){
//    if( TheNodePtr->Location.NodeUID == NoID ){
//      TheNodePtr->PurgeAttributes();
//    };
//  };
//};


//void  sNodePtr::Preallocate (sNodePtr Host ,sAttrName  AN)
//{
//  if( InMemory && ! IsNULL() ){
//    if( TheNodePtr->Location.NodeUID == NoID ){
//      /*/////////DEBUG
//      tNodeUID    DEBUG_ID=NodePtr->Location.NodeUID;
//      sLongString DEBUG_LP=NodePtr->Location.Path+NodePtr->Location.DefaultSuffix;
//      bool        DEBUG_EDITED=NodePtr->Edited;
//      int         DEBUG_NUMOFHOSTS=NodePtr->NumberOfHosts;
//      int         DEBUG_NUMOFPTRS=NodePtr->NumberOfPointers;
//      */
//      TheNodePtr->Preallocate(Host,AN);
//    };
//  };
//};

//------------------------------------------------------------------------------
} //namespace RA