1 // This file may be redistributed and modified only under the terms of
2 // the GNU Lesser General Public License (See COPYING for details).
3 // Copyright 2000-2001 Aloril.
4 // Copyright 2001-2005 Alistair Riddoch.
5 // Automatically generated using gen_cpp.py.
6
7 #include <Atlas/Objects/objectFactory.h>
8 #include <Atlas/Objects/Entity.h>
9 #include <Atlas/Objects/Anonymous.h>
10 #include <Atlas/Objects/Operation.h>
11
12 #include <Atlas/Objects/Generic.h>
13
14 namespace Atlas { namespace Objects {
15
16 int enumMax = 42;
17
18 using Atlas::Message::Element;
19 using Atlas::Message::ListType;
20 using Atlas::Message::MapType;
21
~NoSuchFactoryException()22 NoSuchFactoryException::~NoSuchFactoryException()
23 {
24 }
25
generic_factory(const std::string & name,int no)26 SmartPtr<RootData> generic_factory(const std::string & name, int no)
27 {
28 Operation::Generic obj;
29 obj->setType(name, no);
30 return obj;
31 }
32
anonymous_factory(const std::string & name,int no)33 SmartPtr<RootData> anonymous_factory(const std::string & name, int no)
34 {
35 Entity::Anonymous obj;
36 obj->setType(name, no);
37 return obj;
38 }
39
40 std::map<const std::string, Root> objectDefinitions;
41
42 class AddFactories {
43 public:
44 AddFactories();
45 } addThemHere;
46
AddFactories()47 AddFactories::AddFactories()
48 {
49 Factories * objectFactory = Factories::instance();
50
51 objectFactory->addFactory("root", &factory<RootData>, ROOT_NO);
52
53 objectFactory->addFactory("root_entity", &factory<Entity::RootEntityData>, Entity::ROOT_ENTITY_NO);
54
55 objectFactory->addFactory("admin_entity", &factory<Entity::AdminEntityData>, Entity::ADMIN_ENTITY_NO);
56
57 objectFactory->addFactory("account", &factory<Entity::AccountData>, Entity::ACCOUNT_NO);
58
59 objectFactory->addFactory("player", &factory<Entity::PlayerData>, Entity::PLAYER_NO);
60
61 objectFactory->addFactory("admin", &factory<Entity::AdminData>, Entity::ADMIN_NO);
62
63 objectFactory->addFactory("game", &factory<Entity::GameData>, Entity::GAME_NO);
64
65 objectFactory->addFactory("game_entity", &factory<Entity::GameEntityData>, Entity::GAME_ENTITY_NO);
66
67 objectFactory->addFactory("root_operation", &factory<Operation::RootOperationData>, Operation::ROOT_OPERATION_NO);
68
69 objectFactory->addFactory("action", &factory<Operation::ActionData>, Operation::ACTION_NO);
70
71 objectFactory->addFactory("create", &factory<Operation::CreateData>, Operation::CREATE_NO);
72
73 objectFactory->addFactory("combine", &factory<Operation::CombineData>, Operation::COMBINE_NO);
74
75 objectFactory->addFactory("divide", &factory<Operation::DivideData>, Operation::DIVIDE_NO);
76
77 objectFactory->addFactory("communicate", &factory<Operation::CommunicateData>, Operation::COMMUNICATE_NO);
78
79 objectFactory->addFactory("talk", &factory<Operation::TalkData>, Operation::TALK_NO);
80
81 objectFactory->addFactory("delete", &factory<Operation::DeleteData>, Operation::DELETE_NO);
82
83 objectFactory->addFactory("set", &factory<Operation::SetData>, Operation::SET_NO);
84
85 objectFactory->addFactory("affect", &factory<Operation::AffectData>, Operation::AFFECT_NO);
86
87 objectFactory->addFactory("move", &factory<Operation::MoveData>, Operation::MOVE_NO);
88
89 objectFactory->addFactory("wield", &factory<Operation::WieldData>, Operation::WIELD_NO);
90
91 objectFactory->addFactory("get", &factory<Operation::GetData>, Operation::GET_NO);
92
93 objectFactory->addFactory("perceive", &factory<Operation::PerceiveData>, Operation::PERCEIVE_NO);
94
95 objectFactory->addFactory("look", &factory<Operation::LookData>, Operation::LOOK_NO);
96
97 objectFactory->addFactory("listen", &factory<Operation::ListenData>, Operation::LISTEN_NO);
98
99 objectFactory->addFactory("sniff", &factory<Operation::SniffData>, Operation::SNIFF_NO);
100
101 objectFactory->addFactory("touch", &factory<Operation::TouchData>, Operation::TOUCH_NO);
102
103 objectFactory->addFactory("login", &factory<Operation::LoginData>, Operation::LOGIN_NO);
104
105 objectFactory->addFactory("logout", &factory<Operation::LogoutData>, Operation::LOGOUT_NO);
106
107 objectFactory->addFactory("imaginary", &factory<Operation::ImaginaryData>, Operation::IMAGINARY_NO);
108
109 objectFactory->addFactory("use", &factory<Operation::UseData>, Operation::USE_NO);
110
111 objectFactory->addFactory("info", &factory<Operation::InfoData>, Operation::INFO_NO);
112
113 objectFactory->addFactory("perception", &factory<Operation::PerceptionData>, Operation::PERCEPTION_NO);
114
115 objectFactory->addFactory("sight", &factory<Operation::SightData>, Operation::SIGHT_NO);
116
117 objectFactory->addFactory("appearance", &factory<Operation::AppearanceData>, Operation::APPEARANCE_NO);
118
119 objectFactory->addFactory("disappearance", &factory<Operation::DisappearanceData>, Operation::DISAPPEARANCE_NO);
120
121 objectFactory->addFactory("sound", &factory<Operation::SoundData>, Operation::SOUND_NO);
122
123 objectFactory->addFactory("smell", &factory<Operation::SmellData>, Operation::SMELL_NO);
124
125 objectFactory->addFactory("feel", &factory<Operation::FeelData>, Operation::FEEL_NO);
126
127 objectFactory->addFactory("error", &factory<Operation::ErrorData>, Operation::ERROR_NO);
128
129 objectFactory->addFactory("anonymous", &factory<Entity::AnonymousData>, Entity::ANONYMOUS_NO);
130
131 objectFactory->addFactory("generic", &factory<Operation::GenericData>, Operation::GENERIC_NO);
132 }
133
Factories()134 Factories::Factories()
135 {
136 }
137
Factories(const Factories & other)138 Factories::Factories(const Factories & other) : m_factories(other.m_factories)
139 {
140 }
141
hasFactory(const std::string & name)142 bool Factories::hasFactory(const std::string& name)
143 {
144 FactoryMap::const_iterator I = m_factories.find(name);
145 return I != m_factories.end();
146 }
147
createObject(const std::string & name)148 Root Factories::createObject(const std::string& name)
149 {
150 FactoryMap::const_iterator I = m_factories.find(name);
151 if (I == m_factories.end()) {
152 return Root(0);
153 } else {
154 return (*I).second.first(name, (*I).second.second);
155 }
156 }
157
createObject(const MapType & msg_map)158 Root Factories::createObject(const MapType & msg_map)
159 {
160 Root obj(0);
161
162 // is this instance of entity or operation?
163 MapType::const_iterator I = msg_map.find(Atlas::Objects::OBJTYPE_ATTR);
164 MapType::const_iterator Iend = msg_map.end();
165 bool is_instance = false;
166 if(I != Iend && I->second.isString()) {
167 const std::string & objtype = I->second.String();
168 if(objtype == "op" || objtype == "obj" || objtype == "object") {
169 // get parent
170 I = msg_map.find(Atlas::Objects::PARENTS_ATTR);
171 if(I != Iend && I->second.isList()) {
172 const ListType & parents_lst = I->second.List();
173 if(parents_lst.size()>=1 && parents_lst.front().isString()) {
174 const std::string & parent = parents_lst.front().String();
175 // objtype and parent ok, try to create it:
176 FactoryMap::const_iterator I = m_factories.find(parent);
177 if (I != m_factories.end()) {
178 obj = I->second.first(parent, I->second.second);
179 } else {
180 if (objtype == "op") {
181 obj = Atlas::Objects::Operation::Generic();
182 } else {
183 obj = Atlas::Objects::Entity::Anonymous();
184 }
185 }
186 is_instance = true;
187 // FIXME We might want to do something different here.
188 } // parent list ok?
189 } // has parent attr?
190 } // has known objtype
191 } // has objtype attr
192 if (!is_instance) {
193 // Should we really use factory? Why not just instantiate by hand?
194 obj = Atlas::Objects::Entity::Anonymous();
195 } // not instance
196 for (I = msg_map.begin(); I != Iend; I++) {
197 obj->setAttr(I->first, I->second);
198 }
199 return obj;
200 }
201
getKeys()202 std::list<std::string> Factories::getKeys()
203 {
204 std::list<std::string> keys;
205 for (FactoryMap::const_iterator I = m_factories.begin();
206 I != m_factories.end(); I++) {
207 keys.push_back(I->first);
208 }
209 return keys;
210 }
211
addFactory(const std::string & name,FactoryMethod method,int classno)212 void Factories::addFactory(const std::string& name, FactoryMethod method, int classno)
213 {
214 m_factories[name] = std::make_pair(method, classno);
215 }
216
addFactory(const std::string & name,FactoryMethod method)217 int Factories::addFactory(const std::string& name, FactoryMethod method)
218 {
219 int classno = ++enumMax;
220 m_factories[name] = std::make_pair(method, classno);
221 return classno;
222 }
223
instance()224 Factories * Factories::instance()
225 {
226 if (m_instance == 0) {
227 m_instance = new Factories;
228 }
229 return m_instance;
230 }
231
232 Factories * Factories::m_instance = 0;
233 } } // namespace Atlas::Objects
234