This file is indexed.

/usr/include/glbinding/FunctionCall.h is in libglbinding-dev 2.1.1-1.

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
#pragma once

#include <vector>
#include <string>
#include <chrono>

#include <glbinding/glbinding_api.h>


namespace glbinding
{


class AbstractFunction;
class AbstractValue;

/**
 * @brief
 *   A FunctionCall represents a function call of an OpenGL API function, including the parameter and return values.
 */
struct GLBINDING_API FunctionCall
{
public:
    /**
     * @brief
     *   Constructor
     *
     * @param[in] _function
     *   The Function of this call.
     *
     * This FunctionCall is initialized with empty parameters and return values with the current time.
     */
    FunctionCall(const AbstractFunction * _function);

    /**
     * @brief
     *   Destructor
     */
    virtual ~FunctionCall();

    /**
     * @brief
     *   Move Constructor
     *
     * @param[in] other
     *   The FunctionCall to move the memory from.
     */
    FunctionCall(FunctionCall && other);

    /**
     * @brief
     *   Deleted assigment operator; no memory management for dynamically allocated memory implemented.
     */
    FunctionCall & operator=(const FunctionCall &) = delete;


    /**
     * @brief
     *   Move assignment
     *
     * @param[in] other
     *   The other FunctionCall to move memory from.
     *
     * @return
     *   This FunctionCall.
     */
    FunctionCall & operator=(FunctionCall && other);

    /**
     * @brief
     *   Converts this FunctionCall to a string usable to put into a log.
     *
     * @return
     *   A string representing the contents of this FunctionCall.
     */
    std::string toString() const;

public:
    const AbstractFunction * function; ///< The function of this call
    std::chrono::system_clock::time_point timestamp; ///< The time of the call

    std::vector<AbstractValue *> parameters; ///< The list of parameter values; doesn't have to be filled.
    AbstractValue * returnValue; ///< The return value; doesn't have to be filled.
};


} // namespace glbinding