ParentChildSiblingInfo.h

Go to the documentation of this file.

// created by Bobby Philip 05092001
#ifndef _PARENTCHILDSIBLINGINFO_H_
#define _PARENTCHILDSIBLINGINFO_H_

#include <limits.h>
#include "GenericDataBase.h"
#include "ReferenceCounting.h"
#include "GenericDataBase.h"
#include "GridCollection.h"

#ifndef OV_USE_OLD_STL_HEADERS
#include <list>
OV_USINGNAMESPACE(std);
#else
#include <list.h>
#endif

#include "ListOfParentChildSiblingInfo.h"
#include <BoxArray.H>

// forward declarations
class ChildInfo;
class ParentInfo;
class SiblingInfo;

class ParentChildSiblingInfoData: public ReferenceCounting
{
 private:

  list<ParentInfo*>  ParentList;  

  list<ChildInfo*>   ChildList;   

  list<SiblingInfo*> SiblingList; 

  aString className;

  inline virtual ReferenceCounting& operator=( const ReferenceCounting &x )
    { return operator=((ParentChildSiblingInfoData &) x);}

  inline virtual void reference( const ReferenceCounting &x )
    { reference((ParentChildSiblingInfoData &) x); }

  inline virtual ReferenceCounting *virtualConstructor( const CopyType ct = DEEP ) const
    { return new ParentChildSiblingInfoData(*this, ct); }
  
 public:

  ParentChildSiblingInfoData();

  ParentChildSiblingInfoData( const ParentChildSiblingInfoData &x,
                              const CopyType ct = DEEP );

  ~ParentChildSiblingInfoData();

  ParentChildSiblingInfoData &operator=( const ParentChildSiblingInfoData &x );

  inline virtual aString getClassName( void ) const { return className; }

  void reference( const ParentChildSiblingInfoData &x );

  virtual void breakReference(void);

  virtual void consistencyCheck( void ) const;

  virtual Integer get( const GenericDataBase & db, const aString &name );

  virtual Integer put( const GenericDataBase & db, const aString &name ) const;

  inline const list<ParentInfo* > &getParents (void) const { return ParentList; }

  inline const list<ChildInfo*  > &getChildren(void) const { return ChildList;  }

  inline const list<SiblingInfo*> &getSiblings(void) const { return SiblingList;}

  void addParent ( ParentInfo * );

  void addChild  ( ChildInfo  * );

  void addSibling( SiblingInfo *);

  friend ostream& operator<<(ostream& s, const ParentChildSiblingInfoData &pcsInfoData );

};

class ParentChildSiblingInfo: public ReferenceCounting
{
 private:

  aString className;

  inline virtual ReferenceCounting& operator=( const ReferenceCounting &x )
    { return operator=((ParentChildSiblingInfo &) x);}

  inline virtual void reference( const ReferenceCounting &x )
    { reference((ParentChildSiblingInfo &) x); }

  inline virtual ReferenceCounting *virtualConstructor( const CopyType ct = DEEP ) const
    { return new ParentChildSiblingInfo(*this, ct); }

  static bool gridsOverlap( const MappedGrid &, const MappedGrid &, const IntegerArray &refinementRatio, Box & );

  static bool isSibling( const MappedGrid &, const MappedGrid &, Box & );

  static bool isSibling( const Box &, const Box &, const IntegerArray &, const int, Box & );

  bool addIfPeriodicSibling( const MappedGrid &,
                             const MappedGrid &, 
                             const MappedGrid &,
                             const IntegerArray &,
                             const int );
  void addParent(  const int, 
                   const Box & );

  void addChild( const int, 
                 const Box & );
  void addSibling( const int siblingGridIndex,
                   const Box &ghostBox,
                   const Box &siblingBox );


 public:
  // public member data
  typedef ParentChildSiblingInfoData RCData;   // following conventions in Overture
  RCData *rcData;

  ParentChildSiblingInfo();
  ParentChildSiblingInfo( const ParentChildSiblingInfo &x,
                          const CopyType ct = DEEP );
  ~ParentChildSiblingInfo();

  ParentChildSiblingInfo &operator=( const ParentChildSiblingInfo &x );

  inline virtual aString getClassName( void ) const { return className; }

  void reference( const ParentChildSiblingInfo &x );

  void reference( ParentChildSiblingInfoData &x );

  virtual void breakReference( void );

  virtual void consistencyCheck( void ) const;

  virtual Integer get( const GenericDataBase & db, const aString &name );

  virtual Integer put( const GenericDataBase & db, const aString &name ) const;

  inline const list<ParentInfo*>  &getParents (void) const { assert( rcData != NULL ); return rcData->getParents(); }

  inline const list<ChildInfo*>   &getChildren(void) const { assert( rcData != NULL ); return rcData->getChildren();}

  inline const list<SiblingInfo*> &getSiblings(void) const { assert( rcData != NULL ); return rcData->getSiblings();}

  static void buildParentChildSiblingInfoObjects( const GridCollection &gc, 
                                                  ListOfParentChildSiblingInfo &listOfPCSInfo );

  static bool isValidBoxForType( const Box &box, const IndexType &iType );

  static void getGhostRegionBoxes( const MappedGrid &, const Range &, const IndexType &, BoxList & ,
                                   bool excludePhysicalBoundaries = false );

  int getParentBoxes( intSerialArray &, BoxList &, const IndexType &, const int );

  int getChildBoxes ( intSerialArray &, BoxList &, const IndexType &, const int );

  int getSiblingBoxes ( intSerialArray &, BoxList &, BoxList &, const IndexType &, const int );

  int getParentGhostBoxes ( intSerialArray &, BoxList &, const Range &, const GridCollection &, const int, const IndexType &, const bool = FALSE );

  int getSiblingGhostBoxes( intSerialArray &, BoxList &, BoxList &, const Range &, const GridCollection &, const int, const IndexType &  );

  // writes a description of pcsInfo to output stream s
  friend ostream& operator<<(ostream& s, const ParentChildSiblingInfo &pcsInfo );
};

#endif  //_PARENTCHILDSIBLINGINFO_H_