This file is indexed.

/usr/include/Wt/WAbstractProxyModel is in libwt-dev 3.3.4+dfsg-6ubuntu1.

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
// This may look like C code, but it's really -*- C++ -*-
/*
 * Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
 *
 * See the LICENSE file for terms of use.
 */
#ifndef WABSTRACT_PROXY_MODEL_H_
#define WABSTRACT_PROXY_MODEL_H_

#include <Wt/WAbstractItemModel>

namespace Wt {

/*! \class WAbstractProxyModel Wt/WAbstractProxyModel Wt/WAbstractProxyModel
 *  \brief An abstract proxy model for %Wt's item models.
 *
 * A proxy model does not store data, but presents data from a source
 * model in another way. It may provide filtering, sorting, or other
 * computed changes to the source model. A proxy model may be a fully
 * functional model, that also allows modification of the underlying
 * model.
 *
 * This abstract proxy model may be used as a starting point for
 * implementing a custom proxy model, when WSortFilterProxyModel is
 * not adequate. It implements data access and manipulation using the
 * a virtual mapping method (mapToSource()) to access and manipulate
 * the underlying sourceModel().
 *
 * \ingroup modelview
 */
class WT_API WAbstractProxyModel : public WAbstractItemModel
{
public:
  /*! \brief Constructor.
   */
  WAbstractProxyModel(WObject *parent = 0);

  /*! \brief Maps a source model index to the proxy model.
   *
   * This method returns a model index in the proxy model that
   * corresponds to the model index \p sourceIndex in the source
   * model. This method must only be implemented for source model
   * indexes that are mapped and thus are the result of mapToSource().
   *
   * \sa mapToSource()
   */
  virtual WModelIndex mapFromSource(const WModelIndex& sourceIndex) const = 0;

  /*! \brief Maps a proxy model index to the source model.
   *
   * This method returns a model index in the source model that
   * corresponds to the proxy model index \p proxyIndex.
   *
   * \sa mapFromSource()
   */
  virtual WModelIndex mapToSource(const WModelIndex& proxyIndex) const = 0;

  /*! \brief Sets the source model.
   *
   * The source model provides the actual data for the proxy
   * model.
   *
   * Ownership of the source model is <i>not</i> transferred.
   *
   * Note that the source model's signals are not forwarded to
   * the proxy model by default, but some specializations,
   * like WBatchEditProxyModel and WSortFilterProxyModel do.
   * If you want to reimplement data() with no changes to row
   * or column indices, consider the use of WIdentityProxyModel.
   */
  virtual void setSourceModel(WAbstractItemModel *sourceModel);

  /*! \brief Returns the source model.
   *
   * \sa setSourceModel()
   */
  WAbstractItemModel *sourceModel() const { return sourceModel_; }

  using WAbstractItemModel::setData;
  using WAbstractItemModel::data;
  using WAbstractItemModel::setHeaderData;

  /*! \brief Returns the data at a specific model index.
   *
   * The default proxy implementation translates the index to the source model, and
   * calls sourceModel()->data() with this index.
   */
  virtual boost::any data(const WModelIndex& index, int role = DisplayRole) const;

  /*! \brief Returns the row or column header data.
   *
   * The default proxy implementation constructs a dummy
   * WModelIndex with the row set to 0 and column set to \c section
   * if the orientation is Wt::Horizontal, or with the
   * row set to \c section and the column set to 0 if the orientation
   * is Wt::Vertical.
   *
   * The resulting section that is forwarded to sourceModel()->headerData()
   * depends on how the WModelIndex is transformed with mapToSource().
   */
  virtual boost::any headerData(int section, Orientation orientation = Horizontal, int role = DisplayRole) const;

  /*! \brief Sets the data at the given model index.
   *
   * The default proxy implementation calls sourceModel()->setData(mapToSource(index), value, role)
   */
  virtual bool setData(const WModelIndex& index, const boost::any& value,
		       int role = EditRole);

  /*! \brief Sets the data at the given model index.
   *
   * The default proxy implementation calls sourceModel()->setData(mapToSource(index), values)
   */
  virtual bool setItemData(const WModelIndex& index, const DataMap& values);

  /*! \brief Returns the flags for an item.
   *
   * The default proxy implementation calls sourceModel()->flags(mapToSource(index))
   */
  virtual WFlags<ItemFlag> flags(const WModelIndex& index) const;

  /*! \brief Returns the flags for a header.
   *
   * The default proxy implementation constructs a dummy
   * WModelIndex with the row set to 0 and column set to \c section
   * if the orientation is Wt::Horizontal, or with the
   * row set to \c section and the column set to 0 if the orientation
   * is Wt::Vertical.
   *
   * The resulting section that is forwarded to sourceModel()->headerFlags()
   * depends on how the WModelIndex is transformed with mapToSource().
   */
  virtual WFlags<HeaderFlag> headerFlags(int section, Orientation orientation = Horizontal) const;

  /*! \brief Inserts one or more columns.
   *
   * The default proxy implementation calls sourceModel()->insertColumns(column, count, parent)
   */
  virtual bool insertColumns(int column, int count,
			     const WModelIndex& parent = WModelIndex());

  /*! \brief Removes columns.
   *
   * The default proxy implementation calls sourceModel()->removeColumns(column, count, parent)
   */
  virtual bool removeColumns(int column, int count,
			     const WModelIndex& parent = WModelIndex());

  /*! \brief Returns a mime-type for dragging a set of indexes.
   *
   * The default proxy implementation calls sourceModel()->mimeType()
   */
  virtual std::string mimeType() const;

  /*! \brief Returns a list of mime-types that could be accepted for a
   *         drop event.
   *
   * The default proxy implementation calls sourceModel()->acceptDropMimeTypes()
   */
  virtual std::vector<std::string> acceptDropMimeTypes() const;

  /*! \brief Handles a drop event.
   *
   * The default proxy implementation maps the given row and parent
   * to the row and parent in the source model, and forwards the
   * dropEvent call to the source model.
   */
  virtual void dropEvent(const WDropEvent& e, DropAction action,
			 int row, int column, const WModelIndex& parent);

  /*! \brief Converts a model index to a raw pointer that remains valid
   *         while the model's layout is changed.
   *
   * The default proxy implementation calls sourceModel()->toRawIndex(mapToSource(index))
   */
  virtual void *toRawIndex(const WModelIndex& index) const;

  /*! \brief Converts a raw pointer to a model index.
   *
   * The default proxy implementation calls mapFromSource(sourceModel()->fromRawIndex(rawIndex))
   */
  virtual WModelIndex fromRawIndex(void *rawIndex) const;

protected:
  /*! \brief Create a source model index.
   *
   * This is a utility function that allows you to create indexes in
   * the source model. In this way, you can reuse the internal pointers of
   * the source model in proxy model indexes, and convert a proxy model index
   * back to the source model index using this method.
   */
  WModelIndex createSourceIndex(int row, int column, void *ptr) const;

  /*! \brief A base class for an item modeling a source index parent.
   *
   * Many mplementations of a proxy model will need to maintain a data
   * structure per source model indexes, where they relate source rows or
   * columns to proxy rows or columns, per hierarchical parent.
   *
   * It may be convenient to start from this item class as a base
   * class so that shiftModelIndexes() can be used to update this data
   * structure when the source model adds or removes rows.
   *
   * You will typically use your derived class of this item as the
   * internal pointer for proxy model indexes: a proxy model index
   * will have an item as internal pointer whose sourceIndex_ corresponds
   * to the source equivalent of the proxy model index parent.
   *
   * \sa createIndex()
   */
  struct WT_API BaseItem {
    /*! \brief The source model index.
     *
     * The source model index for this item.
     */
    WModelIndex sourceIndex_;

    /*! \brief Create a BaseItem.
     */
    BaseItem(const WModelIndex& sourceIndex) : sourceIndex_(sourceIndex) { }
    virtual ~BaseItem();
  };

  /*! \brief A map for items.
   *
   * \sa BaseItem
   */
#ifndef WT_TARGET_JAVA
  typedef std::map<WModelIndex, BaseItem *> ItemMap;
#else
  typedef std::treemap<WModelIndex, BaseItem *> ItemMap;
#endif // WT_TARGET_JAVA

  /*! \brief Utility methods to shift items in an item map.
   *
   * You can use this method to adjust an item map after the source
   * model has inserted or removed rows. When removing rows (count < 0),
   * items may possibly be removed and deleted.
   */
  void shiftModelIndexes(const WModelIndex& sourceParent, int start, int count,
			 ItemMap& items);

private:
  WAbstractItemModel     *sourceModel_;
};

}

#endif // WABSTRACT_PROXY_MODEL_H_