/usr/include/opencascade/NCollection_BaseVector.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 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | // File: NCollection_BaseVector.hxx
// Created: 24.04.02 09:41:39
// Author: Alexander GRIGORIEV
// Copyright: Open Cascade 2002
#ifndef NCollection_BaseVector_HeaderFile
#define NCollection_BaseVector_HeaderFile
#include <Standard_TypeDef.hxx>
#include <stddef.h>
#if !defined No_Exception && !defined No_Standard_OutOfRange
#include <Standard_OutOfRange.hxx>
#endif
#ifdef WNT
#pragma warning(push, 1)
#pragma warning(disable:4355)
#endif
/**
* Class NCollection_BaseVector - base for generic vector
*/
class NCollection_BaseVector
{
public:
// ------------ Class MemBlock ------------
class MemBlock {
protected:
MemBlock ()
: myFirstInd(0), myLength(0), mySize(0), myData(0L) {}
MemBlock (const Standard_Integer theFirstInd,
const Standard_Integer theLength)
: myFirstInd(theFirstInd), myLength(0), mySize(theLength), myData(0L) {}
virtual ~MemBlock () {}
virtual void Reinit (const Standard_Integer,
const size_t) {}
Standard_Integer FirstIndex () const { return myFirstInd; }
size_t Size () const { return mySize; }
public:
void SetLength (const size_t theLen)
{ myLength = theLen; }
size_t Length () const { return myLength; }
void * Find (const Standard_Integer theInd,
const size_t theSize) const
{ return ((char *) myData)+theInd*theSize;}
Standard_EXPORT Standard_Integer
GetIndexV (void * theItem, const size_t theSz) const;
protected:
Standard_Integer myFirstInd;
size_t myLength;
size_t mySize;
void * myData;
friend class NCollection_BaseVector;
};
class Iterator {
protected:
Iterator () :
myICurBlock (0), myIEndBlock (0), myCurIndex (0), myEndIndex (0) {}
Iterator (const NCollection_BaseVector& theVector) { InitV (theVector); }
Iterator (const Iterator& theVector) { CopyV (theVector); }
Standard_EXPORT void InitV (const NCollection_BaseVector& theVector);
Standard_EXPORT void CopyV (const Iterator&);
Standard_Boolean MoreV () const
{ return (myICurBlock < myIEndBlock || myCurIndex < myEndIndex); }
void NextV ()
{ if (++myCurIndex >= myVector -> myData[myICurBlock].Length() &&
myICurBlock < myIEndBlock)
{ ++myICurBlock; myCurIndex = 0; } }
const MemBlock * CurBlockV () const
{ return &myVector -> myData[myICurBlock]; }
const NCollection_BaseVector * myVector; // the Master vector
size_t myICurBlock; // # of the current block
size_t myIEndBlock;
size_t myCurIndex; // Index in the current block
size_t myEndIndex;
};
protected:
// ------------ Block initializer ---------
typedef MemBlock * (* FuncPtrDataInit) (const NCollection_BaseVector&,
const Standard_Integer aCapacity,
const void * aSource,
const Standard_Integer aSize);
typedef void (* FuncPtrDataFree) (const NCollection_BaseVector&,
MemBlock *);
friend class Iterator;
// ---------- PROTECTED METHODS ----------
//! Empty constructor
NCollection_BaseVector (const size_t theSize,
const Standard_Integer theInc,
FuncPtrDataInit theDataInit,
FuncPtrDataFree theDataFree)
: myItemSize (theSize),
myIncrement (theInc),
myLength (0),
myCapacity (theInc),
myNBlocks (0),
myData (theDataInit (* this, myCapacity, NULL, 0)),
myDataInit (theDataInit),
myDataFree (theDataFree)
{
// myData = (MemBlock *) new char [myCapacity * sizeof(MemBlock)];
// for (Standard_Integer i = 0; i < myCapacity; i++)
// new (&myData[i]) MemBlock;
}
//! Copy constructor
NCollection_BaseVector (const NCollection_BaseVector& theOther,
FuncPtrDataInit theDataInit,
FuncPtrDataFree theDataFree)
: myItemSize (theOther.myItemSize),
myIncrement (theOther.myIncrement),
myLength (theOther.Length()),
myCapacity (theOther.myIncrement+theOther.Length()/theOther.myIncrement),
myNBlocks (1 + (theOther.Length() - 1)/theOther.myIncrement),
myData (theDataInit (* this, myCapacity, NULL, 0)),
myDataInit (theDataInit),
myDataFree (theDataFree) {}
//! Destructor
Standard_EXPORT ~NCollection_BaseVector ();
//! Operator =
Standard_EXPORT NCollection_BaseVector& operator =
(const NCollection_BaseVector&);
//! ExpandV: returns pointer to memory where to put the new item
Standard_EXPORT void * ExpandV (const Standard_Integer theIndex);
//! Find: locate the memory holding the desired value
inline void * Find (const Standard_Integer theIndex) const;
public:
//! Total number of items
Standard_Integer Length () const { return myLength; }
//! Empty the vector of its objects
Standard_EXPORT void Clear ();
protected:
// ---------- PRIVATE FIELDS ----------
size_t myItemSize;
Standard_Integer myIncrement;
Standard_Integer myLength;
Standard_Integer myCapacity;
Standard_Integer myNBlocks;
MemBlock * myData;
FuncPtrDataInit myDataInit;
FuncPtrDataFree myDataFree;
};
//=======================================================================
//function : Find
//purpose : locate the memory holding the desired value
//=======================================================================
inline void * NCollection_BaseVector::Find
(const Standard_Integer theIndex) const
{
#if !defined No_Exception && !defined No_Standard_OutOfRange
if (theIndex < 0 || theIndex >= myLength)
Standard_OutOfRange::Raise ("NCollection_BaseVector::Find");
#endif
const Standard_Integer aBlock = theIndex / myIncrement;
return myData[aBlock].Find (theIndex - aBlock * myIncrement, myItemSize);
}
#ifdef WNT
#pragma warning(pop)
#endif
#endif
|