This file is indexed.

/usr/include/CGAL/Cell_attribute.h is in libcgal-dev 4.2-5ubuntu1.

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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
// Copyright (c) 2010-2011 CNRS and LIRIS' Establishments (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3 of the License,
// or (at your option) any later version.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
// Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
//
#ifndef CGAL_CELL_ATTRIBUTE_H
#define CGAL_CELL_ATTRIBUTE_H 1

#include <CGAL/Compact_container.h>

namespace CGAL {

  template < unsigned int d_, class Refs,
             class Items_, class Alloc_ >
  class Combinatorial_map_base;

  /** @file Cell_attribute.h
   * Definition of cell attribute, with or without info.
   */

  /// Info associated with a cell_attribute.
  template <typename Info>
  class Info_for_cell_attribute
  {
  public:
    /// Contructor without parameter.
    Info_for_cell_attribute()
    {}

    /// Contructor with an info in parameter.
    Info_for_cell_attribute(const Info& ainfo) : minfo(ainfo)
    {}

    /// Get the info associated with the cell_attribute.
    Info& info()
    { return minfo; }

    /// Get the info associated with the cell_attribute.
    const Info& info() const
    { return minfo; }

  protected:
    /// The info associated with the cell_attribute.
    Info minfo;
  };

  /// Cell_attribute_without_info
  template <class Refs, class Tag=Tag_true,
            class OnMerge=Null_functor, 
            class OnSplit=Null_functor>
  class Cell_attribute_without_info;

  // Cell_attribute_without_info without dart support.
  template <class Refs, class OnMerge, class OnSplit>
  class Cell_attribute_without_info<Refs, Tag_false, 
                                    OnMerge, OnSplit>
  {
    template < unsigned int d_, class Refs_,
               class Items_, class Alloc_ >
    friend class Combinatorial_map_base;
    
    template <int d, typename Refs_>
    friend struct Dart;

    template < unsigned int d_, class Refs_,
	       class Items_, class Alloc_ >
    friend class Generalized_map_base;
    
    template <int d, typename Refs_>
    friend struct GMap_dart;

    template <class T, class Alloc_>
    friend class Compact_container;

    template<typename CMap, unsigned int i, typename T>
    friend struct internal::Decrease_attribute_functor_run;

  public:
    typedef Tag_false                            Supports_cell_dart;

    typedef typename Refs::Dart_handle           Dart_handle;
    typedef typename Refs::Dart_const_handle     Dart_const_handle;
    typedef typename Refs::Alloc                 Alloc;

    typedef OnMerge On_merge;
    typedef OnSplit On_split;

    /// operator =
    /// We do nothing since we must not copy mrefcounting.
    Cell_attribute_without_info& 
    operator=(const Cell_attribute_without_info& /*acell*/)
    { return *this; }

    /// Get the dart associated with the cell.
    Dart_handle dart() { return NULL; }

    /// Get the dart associated with the cell.
    Dart_const_handle dart() const { return NULL; }

    /// Set the dart associated with the cell.
    void set_dart(Dart_handle) {}

    /// Test if the cell is valid.
    /// For cell without dart, return always true.
    bool is_valid() const
    { return true; }

  protected:
    /// Contructor without parameter.
    Cell_attribute_without_info(): mrefcounting(0)
    {}

    /// Copy contructor.
    Cell_attribute_without_info(const Cell_attribute_without_info&):
      mrefcounting(0)
    {}

    /// Increment the reference counting.
    void inc_nb_refs()
    { ++mrefcounting; }

    /// Decrement the reference counting.
    void dec_nb_refs()
    {
      CGAL_assertion( mrefcounting>0 );
      --mrefcounting; 
    }

    /// Get the reference counting.
    unsigned int get_nb_refs() const
    { return mrefcounting; }

  public:
    void * for_compact_container() const 
    { return vp; }
    void * & for_compact_container()       
    { return vp; }

  private:
    /// Reference counting: the number of darts linked to this cell.
    union
    {
      unsigned int mrefcounting;
      void        *vp;
    };
  };

  /** Definition of cell attribute.
   * Cell_attribute defines what is a a cell. This is an object allowing to
   * link to a dart of the cell (when T is true).
   * The refs class must provide the type of Combinatorial_map used.
   */
  template <class Refs, class OnMerge, class OnSplit>
  class Cell_attribute_without_info<Refs, Tag_true, 
                                    OnMerge, OnSplit>
  {
    template < unsigned int d_, class Refs_,
               class Items_, class Alloc_ >
    friend class Combinatorial_map_base;

    template <int d, typename Refs_>
    friend struct Dart;

    template < unsigned int d_, class Refs_,
	       class Items_, class Alloc_ >
    friend class Generalized_map_base;

    template <int d, typename Refs_>
    friend struct GMap_dart;

    template <class T, class Alloc_>
    friend class Compact_container;

    template<typename CMap, unsigned int i, typename T>
    friend struct internal::Decrease_attribute_functor_run;

  public:
    typedef Tag_true                             Supports_cell_dart;

    typedef typename Refs::Dart_handle           Dart_handle;
    typedef typename Refs::Dart_const_handle     Dart_const_handle;
    typedef typename Refs::Alloc                 Alloc;
    
    typedef OnMerge On_merge;
    typedef OnSplit On_split;

    /// operator =
    /// We must not copy mrefcounting.
    Cell_attribute_without_info& 
    operator=(const Cell_attribute_without_info& acell)
    {
      mdart = acell.mdart;
      return *this; 
    }

    /// Get the dart associated with the cell.
    Dart_handle dart() { return mdart; }

    /// Get the dart associated with the cell.
    Dart_const_handle dart() const { return mdart; }

    /// Set the dart associated with the cell.
    void set_dart(Dart_handle adart) { mdart = adart; }

    /// Test if the cell is valid.
    /// A cell is valid if its dart is not NULL.
    bool is_valid() const
    { return mdart!=NULL; }

  protected:
    /// Contructor without parameter.
    Cell_attribute_without_info() : mdart(NULL),
                                    mrefcounting(0)
    {}

    /// Copy contructor.
    Cell_attribute_without_info(const Cell_attribute_without_info& acell):
      mdart(acell.mdart),
      mrefcounting(0)
    {}

    /// Increment the reference counting.
    void inc_nb_refs()
    { ++mrefcounting; }

    /// Decrement the reference counting.
    void dec_nb_refs()
    {
      CGAL_assertion( mrefcounting>0 );
      --mrefcounting; 
    }

  public:
    /// Get the reference counting.
    unsigned int get_nb_refs() const
    { return mrefcounting; }

    void * for_compact_container() const
    { return mdart.for_compact_container(); }
    void * & for_compact_container()       
    { return mdart.for_compact_container(); }

  private:
    /// The dart handle associated with the cell.
    Dart_handle mdart;
   
    /// Reference counting: the number of darts linked to this cell.
    unsigned int mrefcounting;
  };

  /// Cell associated with an attribute, with or without info depending 
  /// if Info==void.
  template <class Refs, class Info_=void, class Tag_=Tag_true, 
            class OnMerge=Null_functor, 
            class OnSplit=Null_functor>
  class Cell_attribute;
  
  /// Specialization when Info==void.
  template <class Refs, class Tag_, 
            class OnMerge, class OnSplit>
  class Cell_attribute<Refs, void, Tag_, 
                       OnSplit, OnMerge> : 
    public Cell_attribute_without_info<Refs, Tag_, 
                                       OnSplit, OnMerge>
  {
    template < unsigned int d_, class Refs_,
               class Items_, class Alloc_ >
    friend class Combinatorial_map_base;
    
    template <class T, class Alloc_>
    friend class Compact_container;

  public:
    typedef Tag_                             Supports_cell_dart;
    typedef typename Refs::Dart_handle       Dart_handle;
    typedef typename Refs::Dart_const_handle Dart_const_handle;
    typedef typename Refs::Alloc             Alloc;
    typedef OnMerge                          On_merge;
    typedef OnSplit                          On_split;
  };
  

  /// Specialization when Info!=void.
  template <class Refs, class Info_, class Tag_,
            class OnMerge, class OnSplit>
  class Cell_attribute :
    public Cell_attribute_without_info<Refs, Tag_,
                                       OnMerge, OnSplit>,
    public Info_for_cell_attribute<Info_>
  {
    template < unsigned int d_, class Refs_,
               class Items_, class Alloc_ >
    friend class Combinatorial_map_base;
    
    template <class T, class Alloc_>
    friend class Compact_container;

  public:
    typedef Tag_                             Supports_cell_dart;
    typedef typename Refs::Dart_handle       Dart_handle;
    typedef typename Refs::Dart_const_handle Dart_const_handle;
    typedef typename Refs::Alloc             Alloc;
    typedef OnMerge                          On_merge;
    typedef OnSplit                          On_split;
    typedef Info_                            Info;

  protected:
    /// Default contructor.
    Cell_attribute()
    {}

    /// Contructor with an attribute in parameter.
    Cell_attribute(const Info_& ainfo) : Info_for_cell_attribute<Info_>(ainfo)
    {}
  };

} // namespace CGAL

#endif // CGAL_CELL_ATTRIBUTE_H //
// EOF //