This file is indexed.

/usr/include/avogadro/primitivelist.h is in libavogadro-dev 1.1.1-0ubuntu7.

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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
/**********************************************************************
  PrimitiveList - Organized List of Primitives.

  Copyright (C) 2007 Donald Ephraim Curtis

  This file is part of the Avogadro molecular editor project.
  For more information, see <http://avogadro.openmolecules.net/>

  Avogadro is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  Avogadro is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
 **********************************************************************/

#ifndef PRIMITIVELIST_H
#define PRIMITIVELIST_H

#include <avogadro/global.h>
#include <avogadro/primitive.h>

#include <QVector>
#include <QList>

namespace Avogadro
{

  /**
   * @class PrimitiveList
   * @brief Class which set of Primitives
   * @author Donald Ephraim Curtis
   *
   * The PrimitiveList class is designed to hold a set of Primitive objects
   * and keep them organized by type allowing groups of them to be
   * retrieved in constant time.
   */
  class PrimitiveListPrivate;
  class A_EXPORT PrimitiveList
  {
    public:
      /**
       * Constructor(s)
       */
      PrimitiveList();
      PrimitiveList( const PrimitiveList &other );
      PrimitiveList( const QList<Primitive *> &other );

      PrimitiveList &operator=( const PrimitiveList &other );
      PrimitiveList &operator=(const QList<Primitive *> &other);

      /**
       * Deconstructor
       */
      ~PrimitiveList();

      /**
       * Returns a list of primitives for a given type.
       *
       * @param type the type of primitives to retrieve, one of Primitive::Type
       * @return a QList of pointers to Primitive objects
       */
      QList<Primitive *> subList( Primitive::Type type ) const;

      /**
       * Returns a list of all primitives of all types.
       *
       * @return a QList of pointers to Primitive objects
       */
      QList<Primitive *> list() const;

      /**
       * @param p the primitive to check if it is in any list
       * @return true or false depending on whether p is in this list
       */
      bool contains( const Primitive *p ) const;

      /**
       * Add a primitive to the queue.
       *
       * @param p primitive to add
       */
      void append( Primitive *p );

      /**
       * Remove a primitive from the queue.  If the parameter does not
       * exist in the queue, nothing is removed.
       *
       * @param p primitive to remove
       */
      void removeAll( Primitive *p );

      /**
       * @return The total number of primitives in this queue.
       */
      int size() const;

      /**
       * @return !size()
       */
      bool isEmpty() const;

      /**
       * @param type the type of primitives we're interested in
       * @return the number of primitives for the given type
       */
      int count( Primitive::Type type ) const;

      /**
       * effectively the same as size()
       * \sa size()
       */
      int count() const;

      /**
       * Removes every primitive from the queue.
       */
      void clear();

    private:
      PrimitiveListPrivate * const d;

    public:

      class const_iterator
      {
        public:
        QVector< QList<Primitive *> > *vl;
        QVector< QList<Primitive *> >::const_iterator vit;
        QList<Primitive *>::const_iterator lit;

        inline const_iterator(QVector< QList<Primitive *> > *p) : vl(p)
        {
          vit = vl->constBegin();
          lit = (*vit).constBegin();
          while(lit == (*vit).constEnd())
          {
            ++vit;
            if(vit != vl->constEnd())
            {
              lit = (*vit).constBegin();
            }
            else
            {
              break;
            }
          }
        }

        inline Primitive* operator*() const { return *lit; }
        inline const_iterator operator++(int) {
          const_iterator p = *this;
          ++(*this);
          return p;
        }

        inline const_iterator &operator++()
        {
          if(vit != vl->constEnd())
          {
            ++lit;
            while(lit == (*vit).constEnd())
            {
              ++vit;

              if(vit == vl->constEnd())
              {
                break;
              }
              lit = (*vit).constBegin();
            }
          }
          return *this;
        }

        inline bool operator!=(const const_iterator &o) const
        {
          return !(vit == vl->constEnd() && o.vit == vl->constEnd()) &&
              !(vit == o.vit && lit == o.lit);
        }

        inline bool operator==(const const_iterator &o) const
        { // equal if both are at the end
          return (vit == vl->constEnd() && o.vit == vl->constEnd()) ||
            (vit == o.vit && lit == o.lit);
        }
      };

      const_iterator begin() const;
      const_iterator end() const;


  };

} // namespace Avogadro

#endif // __PRIMITIVELIST_H