-
Notifications
You must be signed in to change notification settings - Fork 47
/
SpawnArgs.h
104 lines (77 loc) · 3.11 KB
/
SpawnArgs.h
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
#pragma once
#include "AttachmentData.h"
#include <vector>
#include "KeyValue.h"
#include <memory>
namespace entity {
/**
* \brief Implementation of the class Entity.
*
* A SpawnArgs basically just keeps track of all the spawnargs and delivers
* them on request, taking the inheritance tree (EntityClasses) into account.
* The actual rendering and entity behaviour is handled by the EntityNode.
*
* It's possible to attach observers to this entity to get notified upon
* key/value changes.
*/
class SpawnArgs: public Entity
{
IEntityClassPtr _eclass;
typedef std::shared_ptr<KeyValue> KeyValuePtr;
// A key value pair using a dynamically allocated value
typedef std::pair<std::string, KeyValuePtr> KeyValuePair;
// The unsorted list of KeyValue pairs
typedef std::vector<KeyValuePair> KeyValues;
KeyValues _keyValues;
typedef std::set<Observer*> Observers;
Observers _observers;
undo::ObservedUndoable<KeyValues> _undo;
bool _instanced;
bool _observerMutex;
bool _isContainer;
// Store attachment information
AttachmentData _attachments;
public:
// Constructor, pass the according entity class
SpawnArgs(const IEntityClassPtr& eclass);
// Copy constructor
SpawnArgs(const SpawnArgs& other);
void importState(const KeyValues& keyValues);
/* Entity implementation */
void attachObserver(Observer* observer) override;
void detachObserver(Observer* observer) override;
void connectUndoSystem();
void disconnectUndoSystem();
IEntityClassPtr getEntityClass() const override;
void forEachKeyValue(KeyValueVisitFunc func,
bool includeInherited) const override;
void forEachEntityKeyValue(const EntityKeyValueVisitFunctor& visitor) override;
void setKeyValue(const std::string& key, const std::string& value) override;
std::string getKeyValue(const std::string& key) const override;
bool isInherited(const std::string& key) const override;
void forEachAttachment(AttachmentFunc func) const override;
bool isWorldspawn() const override;
bool isContainer() const override;
void setIsContainer(bool isContainer);
bool isModel() const override;
// Returns the actual pointer to a KeyValue (or NULL if not found),
// not just the string like getKeyValue() does.
// Only returns non-NULL for non-inherited keyvalues.
EntityKeyValuePtr getEntityKeyValue(const std::string& key);
bool isOfType(const std::string& className) override;
private:
// Parse attachment information from def_attach and related keys (which are
// most likely on the entity class, not the entity itself)
void parseAttachments();
// Notification functions
void notifyInsert(const std::string& key, KeyValue& value);
void notifyChange(const std::string& k, const std::string& v);
void notifyErase(const std::string& key, KeyValue& value);
void insert(const std::string& key, const KeyValuePtr& keyValue);
void insert(const std::string& key, const std::string& value);
void erase(const KeyValues::iterator& i);
void erase(const std::string& key);
KeyValues::iterator find(const std::string& key);
KeyValues::const_iterator find(const std::string& key) const;
};
} // namespace entity