This file is indexed.

/usr/include/Eris-1.3/Eris/ViewEntity.h is in liberis-1.3-dev 1.3.19-5ubuntu2.

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
#ifndef ERIS_VIEW_ENTITY_H_
#define ERIS_VIEW_ENTITY_H_

#include <Eris/Entity.h>

namespace Eris {

/**
 * @brief An entity which is bound to an Eris::View.
 * This subclass of Eris::Entity is intimately bound to a View.
 * As Atlas messages are received from the server these will be routed into
 * an instance of this class.
 *
 * In your client this is the class you would want to work with for any
 * entities which represents entities that are on the server. If you however
 * are working with entities that aren't represented on the server (the
 * typical example would be if you're allowing client side authoring where
 * you want to create entities locally) you would instead want to implement
 * a new class which inherits Eris::Entity.
 */
class ViewEntity : public Entity {
friend class EntityRouter;
public:

	/**
	 * @brief Ctor.
	 * @param id The id of the entity.
	 * @param ty Type info for the entity.
	 * @param view The view to which the entity belongs.
	 */
	ViewEntity(const std::string& id, TypeInfo* ty, View* view);

	virtual ~ViewEntity();

    virtual void shutdown();

    /**
     * @brief Gets the view to which this entity belongs, if any.
     * @return The view to which this entity belongs, or null if
     * this entity isn't connected to any view.
     */
    virtual View* getView() const;

protected:

    /**
     * @brief The View which owns this Entity.
     */
    View* m_view;

    /**
     * @brief A router instance which routes messages from the view
     * into this entity.
     */
    EntityRouter* m_router;

    virtual void onTalk(const Atlas::Objects::Operation::RootOperation& talk);

    virtual void onSoundAction(
    		const Atlas::Objects::Operation::RootOperation& op);

    virtual void onVisibilityChanged(bool vis);

    virtual void onTaskAdded(Task* task);

    virtual void removeFromMovementPrediction();

    virtual void addToMovementPredition();

    virtual Entity* getEntity(const std::string& id);

    virtual TypeService* getTypeService() const;

    /**
     * @brief Listen to task progress rates updates and send to the view.
     * @param task The task which is changed.
     */
    void task_ProgressRateChanged(Task* task);


};

inline View* ViewEntity::getView() const
{
    return m_view;
}
}

#endif /* VIEWENTITY_H_ */