1 // Copyright (C) 2009 - 2011 Mathias Froehlich - Mathias.Froehlich@web.de
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Library General Public
5 // License as published by the Free Software Foundation; either
6 // version 2 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Library General Public License for more details.
13 // You should have received a copy of the GNU General Public License
14 // along with this program; if not, write to the Free Software
15 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 #ifndef HLAFederate_hxx
19 #define HLAFederate_hxx
23 #include "HLAObjectInstance.hxx"
24 #include "HLAObjectClass.hxx"
25 #include "HLAInteractionClass.hxx"
33 class HLAFederate : public SGWeakReferenced {
36 virtual ~HLAFederate();
44 /// The rti version backend to connect
45 Version getVersion() const;
46 bool setVersion(HLAFederate::Version version);
48 /// The rti backends connect arguments, depends on the version
49 const std::list<std::string>& getConnectArguments() const;
50 bool setConnectArguments(const std::list<std::string>& connectArguments);
52 /// If true try to create on join and try to destroy on resign
53 bool getCreateFederationExecution() const;
54 bool setCreateFederationExecution(bool createFederationExecution);
56 /// The federation execution name to use on create, join and destroy
57 const std::string& getFederationExecutionName() const;
58 bool setFederationExecutionName(const std::string& federationExecutionName);
60 /// The federation object model name to use on create and possibly join
61 const std::string& getFederationObjectModel() const;
62 bool setFederationObjectModel(const std::string& federationObjectModel);
64 /// The federate type used on join
65 const std::string& getFederateType() const;
66 bool setFederateType(const std::string& federateType);
68 /// The federate name possibly used on join
69 const std::string& getFederateName() const;
70 bool setFederateName(const std::string& federateName);
73 bool connect(Version version, const std::list<std::string>& stringList);
77 /// Create a federation execution
78 /// Semantically this methods should be static,
79 /// but the nonstatic case could reuse the connection to the server
80 bool createFederationExecution(const std::string& federation, const std::string& objectModel);
81 bool destroyFederationExecution(const std::string& federation);
82 bool createFederationExecution();
83 bool destroyFederationExecution();
85 /// Join with federateType the federation execution
86 bool join(const std::string& federateType, const std::string& federation);
90 /// Try to create and join the federation execution.
91 bool createJoinFederationExecution();
92 bool resignDestroyFederationExecution();
97 /// If set to true, time constrained mode is entered on init
98 bool getTimeConstrained() const;
99 bool setTimeConstrained(bool timeConstrained);
101 /// If set to true, time advance is constrained by the local system clock
102 bool getTimeConstrainedByLocalClock() const;
103 bool setTimeConstrainedByLocalClock(bool timeConstrainedByLocalClock);
105 /// If set to true, time regulation mode is entered on init
106 bool getTimeRegulating() const;
107 bool setTimeRegulating(bool timeRegulating);
109 /// If set to a non zero value, this federate leads the federations
110 /// locical time advance by this amount of time.
111 const SGTimeStamp& getLeadTime() const;
112 bool setLeadTime(const SGTimeStamp& leadTime);
114 /// The time increment for use in the default update method.
115 const SGTimeStamp& getTimeIncrement() const;
116 bool setTimeIncrement(const SGTimeStamp& timeIncrement);
118 /// Actually enable time constrained mode.
119 /// This method blocks until time constrained mode is enabled.
120 bool enableTimeConstrained();
121 /// Actually disable time constrained mode.
122 bool disableTimeConstrained();
124 /// Actually enable time constrained by local clock mode.
125 bool enableTimeConstrainedByLocalClock();
127 /// Actually enable time regulation mode.
128 /// This method blocks until time regulation mode is enabled.
129 bool enableTimeRegulation(const SGTimeStamp& lookahead);
130 bool enableTimeRegulation();
131 /// Actually disable time regulation mode.
132 bool disableTimeRegulation();
133 /// Actually modify the lookahead time.
134 bool modifyLookahead(const SGTimeStamp& lookahead);
136 /// Advance the logical time by the given time increment.
137 /// Depending on the time constrained mode, this might
138 /// block until the time advance is granted.
139 bool timeAdvanceBy(const SGTimeStamp& timeIncrement);
140 /// Advance the logical time to the given time.
141 /// Depending on the time constrained mode, this might
142 /// block until the time advance is granted.
143 bool timeAdvance(const SGTimeStamp& timeStamp);
144 /// Advance the logical time as far as time advances are available.
145 /// This call should not block and advance the logical time
146 /// as far as currently possible.
147 bool timeAdvanceAvailable();
149 /// Get the current federates time
150 bool queryFederateTime(SGTimeStamp& timeStamp);
151 /// Get the current federates lookahead
152 bool queryLookahead(SGTimeStamp& timeStamp);
154 /// Process one messsage
155 bool processMessage();
156 /// Process one message but do not wait longer than the relative timeout.
157 bool processMessage(const SGTimeStamp& timeout);
158 /// Process messages until the federate can proceed with the
159 /// next simulation step. That is flush all pending messages and
160 /// depending on the time constrained mode process messages until
161 /// a pending time advance is granted.
162 bool processMessages();
165 bool tick(const double& minimum, const double& maximum);
167 class ObjectModelFactory {
169 virtual ~ObjectModelFactory()
172 virtual HLAObjectClass* createObjectClass(const std::string& name, HLAFederate& federate)
173 { return new HLAObjectClass(name, federate); }
174 virtual bool subscribeObjectClass(const std::string& objectClassName, const std::string& sharing)
175 { return sharing.find("Subscribe") != std::string::npos; }
176 virtual bool publishObjectClass(const std::string& objectClassName, const std::string& sharing)
177 { return sharing.find("Publish") != std::string::npos; }
178 virtual bool subscribeAttribute(const std::string& objectClassName, const std::string& attributeName, const std::string& sharing)
179 { return sharing.find("Subscribe") != std::string::npos; }
180 virtual bool publishAttribute(const std::string& objectClassName, const std::string& attributeName, const std::string& sharing)
181 { return sharing.find("Publish") != std::string::npos; }
185 /// Read an omt xml file
186 bool readObjectModelTemplate(const std::string& objectModel,
187 ObjectModelFactory& objectModelFactory);
189 /// Get the object class of a given name
190 HLAObjectClass* getObjectClass(const std::string& name);
191 const HLAObjectClass* getObjectClass(const std::string& name) const;
193 /// Get the interaction class of a given name
194 HLAInteractionClass* getInteractionClass(const std::string& name);
195 const HLAInteractionClass* getInteractionClass(const std::string& name) const;
197 /// Tells the main exec loop to continue or not.
198 void setDone(bool done);
199 bool getDone() const;
201 virtual bool readObjectModel();
203 virtual bool subscribe();
204 virtual bool publish();
207 virtual bool update();
208 virtual bool shutdown();
213 HLAFederate(const HLAFederate&);
214 HLAFederate& operator=(const HLAFederate&);
216 /// The underlying interface to the rti implementation
217 SGSharedPtr<RTIFederate> _rtiFederate;
219 /// Parameters required to connect to an rti
221 std::list<std::string> _connectArguments;
223 /// Parameters for the federation execution
224 std::string _federationExecutionName;
225 std::string _federationObjectModel;
226 bool _createFederationExecution;
228 /// Parameters for the federate
229 std::string _federateType;
230 std::string _federateName;
232 /// Time management related parameters
233 /// If true, the federate is expected to enter time constrained mode
234 bool _timeConstrained;
235 /// If true, the federate is expected to enter time regulating mode
236 bool _timeRegulating;
237 /// The amount of time this federate leads the others.
238 SGTimeStamp _leadTime;
239 /// The regular time increment we do on calling update()
240 SGTimeStamp _timeIncrement;
241 /// The reference system time at initialization time.
242 /// Is used to implement being time constrained on the
243 /// local system time.
244 bool _timeConstrainedByLocalClock;
245 SGTimeStamp _localClockOffset;
247 /// If true the exec method returns.
250 typedef std::map<std::string, SGSharedPtr<HLAObjectClass> > ObjectClassMap;
251 ObjectClassMap _objectClassMap;
253 typedef std::map<std::string, SGSharedPtr<HLAInteractionClass> > InteractionClassMap;
254 InteractionClassMap _interactionClassMap;
256 friend class HLAInteractionClass;
257 friend class HLAObjectClass;
260 } // namespace simgear