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