This file is indexed.

/usr/include/opencascade/NCollection_BaseSequence.hxx is in libopencascade-foundation-dev 6.5.0.dfsg-2build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
// File:        NCollection_BaseSequence.hxx
// Created:     Wed Apr 10 12:19:14 2002
// Author:      Alexander KARTOMIN (akm)
//              <a-kartomin@opencascade.com>


#ifndef NCollection_BaseSequence_HeaderFile
#define NCollection_BaseSequence_HeaderFile

#include <Standard.hxx>
#include <NCollection_BaseAllocator.hxx>

// **************************************** Class SeqNode ********************

class NCollection_SeqNode 
{
 public:
  // Methods PUBLIC
  // 
  NCollection_SeqNode (void)
    : myNext (NULL), myPrevious (NULL)                {}
  const NCollection_SeqNode * Next      () const      { return myNext; }
  const NCollection_SeqNode * Previous  () const      { return myPrevious; }
  void                      SetNext     (const NCollection_SeqNode * theNext)
                                                      { myNext = theNext; }
  void                      SetPrevious (const NCollection_SeqNode * thePrev)
                                                      { myPrevious = thePrev; }
  //~NCollection_SeqNode() {
  //  if (myNext)           myNext -> myPrevious = myPrevious;
  //  if (myPrevious)       myPrevious -> myNext = myNext;
  //}
  
 private:
  // Fields PRIVATE
  //
  const NCollection_SeqNode     * myNext;
  const NCollection_SeqNode     * myPrevious;
};

typedef void (* NCollection_DelSeqNode) 
     (NCollection_SeqNode*, Handle(NCollection_BaseAllocator)& theAl);

/**
 * Purpose:     This  is  a base  class  for  the  Sequence.  It  deals with
 *              an indexed bidirectional list of NCollection_SeqNode's.
 */              
class NCollection_BaseSequence 
{
 public:
  class Iterator
  {
  public:
    //! Empty constructor
    Iterator                    (void) : myCurrent (NULL) {}
    //! Constructor with initialisation
    Iterator                    (const NCollection_BaseSequence& theSeq,
                                 const Standard_Boolean          isStart)
      : myCurrent(isStart ? (NCollection_SeqNode *)theSeq.myFirstItem
                          : (NCollection_SeqNode *)theSeq.myLastItem) {}
    //! Initialisation
    void             Init       (const NCollection_BaseSequence& theSeq,
                                 const Standard_Boolean          isStart
                                                                = Standard_True)
    { myCurrent = isStart ? (NCollection_SeqNode *)theSeq.myFirstItem
                          : (NCollection_SeqNode *)theSeq.myLastItem; }
    //! Assignment
    Iterator& operator = (const Iterator& theOther)
    { myCurrent = theOther.myCurrent; return *this; }
    //! Previous
    void             Previous   ()
    { if (myCurrent)
        myCurrent = (NCollection_SeqNode *)myCurrent -> Previous(); }
      
  protected:
    NCollection_SeqNode * myCurrent; //!< Pointer to the current node
    friend class NCollection_BaseSequence;
  };

 public:
  // Methods PUBLIC
  // 
      Standard_Boolean   IsEmpty     () const {return (mySize == 0);}
      Standard_Integer   Length      () const {return mySize;}

 protected:
  // Methods PROTECTED
  // 
  inline          NCollection_BaseSequence ();
  Standard_EXPORT void   ClearSeq    (NCollection_DelSeqNode fDel,
                                      Handle(NCollection_BaseAllocator)& theAl);
  Standard_EXPORT void   PAppend     (NCollection_SeqNode *);
  Standard_EXPORT void   PAppend     (NCollection_BaseSequence& S);
  Standard_EXPORT void   PPrepend    (NCollection_SeqNode *);
  Standard_EXPORT void   PPrepend    (NCollection_BaseSequence& S);
  Standard_EXPORT void   PInsertAfter(Iterator& thePosition,
                                      NCollection_SeqNode *);
  Standard_EXPORT void   PInsertAfter(const Standard_Integer Index,
                                      NCollection_SeqNode *);
  Standard_EXPORT void   PInsertAfter(const Standard_Integer Index,
                                      NCollection_BaseSequence& S);
  Standard_EXPORT void   PSplit      (const Standard_Integer Index,
                                      NCollection_BaseSequence& Sub);
  Standard_EXPORT void   RemoveSeq   (Iterator& thePosition,
                                      NCollection_DelSeqNode fDel,
                                      Handle(NCollection_BaseAllocator)& theAl);
  Standard_EXPORT void   RemoveSeq   (const Standard_Integer Index,
                                      NCollection_DelSeqNode fDel,
                                      Handle(NCollection_BaseAllocator)& theAl);
  Standard_EXPORT void   RemoveSeq   (const Standard_Integer From,
                                      const Standard_Integer To,
                                      NCollection_DelSeqNode fDel,
                                      Handle(NCollection_BaseAllocator)& theAl);
  Standard_EXPORT void   PReverse    ();
  Standard_EXPORT void   PExchange   (const Standard_Integer I,
                                      const Standard_Integer J) ;
  Standard_EXPORT const NCollection_SeqNode *
                         Find        (const Standard_Integer) const;

 protected:
  // Fields PROTECTED
  //
  const NCollection_SeqNode         * myFirstItem;
  const NCollection_SeqNode         * myLastItem;
  const NCollection_SeqNode         * myCurrentItem;
  Standard_Integer                  myCurrentIndex;
  Standard_Integer                  mySize;

 private: 
  // Methods PRIVATE
  // 
  Standard_EXPORT NCollection_BaseSequence
                           (const NCollection_BaseSequence& Other);
  inline void     Nullify ();
  friend class Iterator;
};

inline NCollection_BaseSequence::NCollection_BaseSequence ()
     : myFirstItem        (NULL),
       myLastItem         (NULL),
       myCurrentItem      (NULL),
       myCurrentIndex     (0),
       mySize             (0) {}

inline void NCollection_BaseSequence::Nullify ()
{
  myFirstItem = myLastItem = myCurrentItem = NULL;
  myCurrentIndex = mySize = 0;
}

#endif