This file is indexed.

/usr/include/coin/CoinShallowPackedVector.hpp is in coinor-libcoinutils-dev 2.9.10-1ubuntu2.

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
/* $Id: CoinShallowPackedVector.hpp 1498 2011-11-02 15:25:35Z mjs $ */
// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CoinShallowPackedVector_H
#define CoinShallowPackedVector_H

#if defined(_MSC_VER)
// Turn off compiler warning about long names
#  pragma warning(disable:4786)
#endif

#include "CoinError.hpp"
#include "CoinPackedVectorBase.hpp"

/** Shallow Sparse Vector
 
This class is for sparse vectors where the indices and 
elements are stored elsewhere.  This class only maintains
pointers to the indices and elements.  Since this class
does not own the index and element data it provides
read only access to to the data.  An CoinSparsePackedVector
must be used when the sparse vector's data will be altered.

This class stores pointers to the vectors.
It does not actually contain the vectors.

Here is a sample usage:
@verbatim
   const int ne = 4; 
   int inx[ne] =   {  1,   4,  0,   2 }; 
   double el[ne] = { 10., 40., 1., 50. }; 
 
   // Create vector and set its value 
   CoinShallowPackedVector r(ne,inx,el); 
 
   // access each index and element 
   assert( r.indices ()[0]== 1  ); 
   assert( r.elements()[0]==10. ); 
   assert( r.indices ()[1]== 4  ); 
   assert( r.elements()[1]==40. ); 
   assert( r.indices ()[2]== 0  ); 
   assert( r.elements()[2]== 1. ); 
   assert( r.indices ()[3]== 2  ); 
   assert( r.elements()[3]==50. ); 
 
   // access as a full storage vector 
   assert( r[ 0]==1. ); 
   assert( r[ 1]==10.); 
   assert( r[ 2]==50.); 
   assert( r[ 3]==0. ); 
   assert( r[ 4]==40.); 
 
   // Tests for equality and equivalence
   CoinShallowPackedVector r1; 
   r1=r; 
   assert( r==r1 ); 
   r.sort(CoinIncrElementOrdered()); 
   assert( r!=r1 ); 
 
   // Add packed vectors. 
   // Similarly for subtraction, multiplication, 
   // and division. 
   CoinPackedVector add = r + r1; 
   assert( add[0] ==  1.+ 1. ); 
   assert( add[1] == 10.+10. ); 
   assert( add[2] == 50.+50. ); 
   assert( add[3] ==  0.+ 0. ); 
   assert( add[4] == 40.+40. ); 
   assert( r.sum() == 10.+40.+1.+50. ); 
@endverbatim
*/
class CoinShallowPackedVector : public CoinPackedVectorBase {
   friend void CoinShallowPackedVectorUnitTest();

public:
  
   /**@name Get methods */
   //@{
   /// Get length of indices and elements vectors
   virtual int getNumElements() const { return nElements_; }
   /// Get indices of elements
   virtual const int * getIndices() const { return indices_; }
   /// Get element values
   virtual const double * getElements() const { return elements_; }
   //@}

   /**@name Set methods */
   //@{
   /// Reset the vector (as if were just created an empty vector)
   void clear();
   /** Assignment operator. */
   CoinShallowPackedVector& operator=(const CoinShallowPackedVector & x);
   /** Assignment operator from a CoinPackedVectorBase. */
   CoinShallowPackedVector& operator=(const CoinPackedVectorBase & x);
   /** just like the explicit constructor */
   void setVector(int size, const int * indices, const double * elements,
		  bool testForDuplicateIndex = true);
   //@}

   /**@name Methods to create, set and destroy */
   //@{
   /** Default constructor. */
   CoinShallowPackedVector(bool testForDuplicateIndex = true);
   /** Explicit Constructor.
       Set vector size, indices, and elements. Size is the length of both the
       indices and elements vectors. The indices and elements vectors are not
       copied into this class instance. The ShallowPackedVector only maintains
       the pointers to the indices and elements vectors. <br>
       The last argument specifies whether the creator of the object knows in
       advance that there are no duplicate indices.
   */
   CoinShallowPackedVector(int size,
			  const int * indices, const double * elements,
			  bool testForDuplicateIndex = true);
   /** Copy constructor from the base class. */
   CoinShallowPackedVector(const CoinPackedVectorBase &);
   /** Copy constructor. */
   CoinShallowPackedVector(const CoinShallowPackedVector &);
   /** Destructor. */
   virtual ~CoinShallowPackedVector() {}
   /// Print vector information.
   void print();
   //@}

private:
   /**@name Private member data */
   //@{
   /// Vector indices
   const int * indices_;
   ///Vector elements
   const double * elements_;
   /// Size of indices and elements vectors
   int nElements_;
   //@}
};

//#############################################################################
/** A function that tests the methods in the CoinShallowPackedVector class. The
    only reason for it not to be a member method is that this way it doesn't
    have to be compiled into the library. And that's a gain, because the
    library should be compiled with optimization on, but this method should be
    compiled with debugging. */
void
CoinShallowPackedVectorUnitTest();

#endif