This file is indexed.

/usr/include/avogadro/primitive.h is in libavogadro-dev 1.2.0-3.

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
/**********************************************************************
  Primitive - Wrapper class around the OpenBabel classes

  Copyright (C) 2007 Donald Ephraim Curtis
  Copyright (C) 2008 Marcus D. Hanwell

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

  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 PRIMITIVE_H
#define PRIMITIVE_H

#include "config.h"

#include "global.h"

#include <QObject>
#include <QMetaType>

#include <Eigen/Core>
#include <limits> // To get the maximum size of long for FALSE_ID

namespace Avogadro {

  // Define the overflow resulting from long (-1) as the error/not found
  const unsigned long FALSE_ID = std::numeric_limits<unsigned long>::max();

  /**
   * @class Primitive primitive.h <avogadro/primitive.h>
   * @brief Base class for all primitives (Molecule, Atom, Bond, Residue, ...).
   */

  class PrimitivePrivate;
  class A_EXPORT Primitive : public QObject
  {
  Q_OBJECT
  Q_PROPERTY(Type type READ type)
  Q_ENUMS(Type)

  public:
    /**
     * This enum allows us to iterate through the various types
     * of primitives.
     */
    enum Type {
      /// Untyped Primitive
      OtherType=0,
      /// Molecule Primitive
      MoleculeType,
      /// Atom Primitive
      AtomType,
      /// Bond Primitive
      BondType,
      /// Residue Primitive
      ResidueType,
      /// Chain Primitive (i.e., a set of residues)
      ChainType,
      /// Fragment Primitve
      FragmentType,
      /// Surface Primitive
      SurfaceType,
      /// Surface Mesh Primitive
      MeshType,
      /// Cube Primitive
      CubeType,
      /// Plane Primitive
      PlaneType,
      /// Grid Primitive
      GridType,
      /// Points (i.e., non-atoms)
      PointType,
      /// Lines
      LineType,
      /// Vectors (i.e., arrows, dipole moments)
      VectorType,
      /// Non-bonded interactions (i.e., non-bond connections)
      NonbondedType,
      /// Text annoations
      TextType,
      /// End Placeholder
      LastType,
      /// First Placeholder
      FirstType=OtherType
    };

    /**
     * Default constructor.
     * @param parent the object parent
     */
    Primitive(QObject *parent = 0);

    /**
     * Constructor
     * @param type the primitive type
     * @param parent the object parent
     */
    explicit Primitive(Type type, QObject *parent=0);

    /**
     * Destructor
     */
    virtual ~Primitive();

    /**
     * Function used to push changes to a primitive to
     * the rest of the system.  At this time there is no
     * way (other than this) to generate a signal when
     * properties of a primitive change.
     *
     * In the case of the Atom primitive, this should be called
     * when changes to coordinates have been made.
     */
    void update();

    /**
     * @property Type
     * Holds the primitive type
     */

    /**
     * @return The primitive type (one of Primitive::Type)
     */
    Type type() const;

    /**
     * @return The unique id of the primitive.
     */
    unsigned long id() const { return m_id; }

    /**
     * @return The index of the primitive.
     * @note Replaces GetIdx().
     */
    unsigned long index() const { return m_index; }

  Q_SIGNALS:
    /**
     * Emitted when the primitive has been updated.
     */
    void updated();

  protected:
    /**
     * Set the id of the primitive, used to uniquely indentify the primitive.
     * @note That this should only be set by the container class.
     */
    void setId(unsigned long m_id);

    /**
     * Set the index of the primitive, starting at zero.
     * @note That this should only be set by the container class.
     */
    void setIndex(unsigned long m_index);

    PrimitivePrivate * const d_ptr;
    Primitive(PrimitivePrivate &dd, QObject *parent = 0);
    Primitive(PrimitivePrivate &dd, Type type, QObject *parent=0);

    enum Primitive::Type m_type;
    unsigned long m_id;
    unsigned long m_index;

  private:
    Q_DECLARE_PRIVATE(Primitive)
  };

} // namespace Avogadro

Q_DECLARE_METATYPE(Avogadro::Primitive*)

#endif // PRIMITIVE_H