X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=simgear%2Fhla%2FHLAFederate.hxx;h=0775a566ca04d49e8c3467568f4151e4f6506555;hb=5708ec5a89ff21868068a67815cd2771b96c11c4;hp=5af83396fe6c75cd0eb5ccbcb4a1daa56026063f;hpb=29faf13afda0032b7f70bdde6092158c067c5da4;p=simgear.git diff --git a/simgear/hla/HLAFederate.hxx b/simgear/hla/HLAFederate.hxx index 5af83396..0775a566 100644 --- a/simgear/hla/HLAFederate.hxx +++ b/simgear/hla/HLAFederate.hxx @@ -1,4 +1,4 @@ -// Copyright (C) 2009 - 2010 Mathias Froehlich - Mathias.Froehlich@web.de +// Copyright (C) 2009 - 2011 Mathias Froehlich - Mathias.Froehlich@web.de // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Library General Public @@ -32,49 +32,136 @@ class RTIFederate; class HLAFederate : public SGWeakReferenced { public: + HLAFederate(); + virtual ~HLAFederate(); + enum Version { RTI13, RTI1516, RTI1516E }; - HLAFederate(); - virtual ~HLAFederate(); + /// The rti version backend to connect + Version getVersion() const; + bool setVersion(HLAFederate::Version version); + + /// The rti backends connect arguments, depends on the version + const std::list& getConnectArguments() const; + bool setConnectArguments(const std::list& connectArguments); + + /// If true try to create on join and try to destroy on resign + bool getCreateFederationExecution() const; + bool setCreateFederationExecution(bool createFederationExecution); + + /// The federation execution name to use on create, join and destroy + const std::string& getFederationExecutionName() const; + bool setFederationExecutionName(const std::string& federationExecutionName); + + /// The federation object model name to use on create and possibly join + const std::string& getFederationObjectModel() const; + bool setFederationObjectModel(const std::string& federationObjectModel); + + /// The federate type used on join + const std::string& getFederateType() const; + bool setFederateType(const std::string& federateType); + + /// The federate name possibly used on join + const std::string& getFederateName() const; + bool setFederateName(const std::string& federateName); /// connect to an rti bool connect(Version version, const std::list& stringList); + bool connect(); bool disconnect(); - /// Get the name of the joined federate/federation - std::string getFederateType() const; - std::string getFederationName() const; - /// Create a federation execution /// Semantically this methods should be static, /// but the nonstatic case could reuse the connection to the server - /// FIXME: cannot determine from the return value if we created the execution bool createFederationExecution(const std::string& federation, const std::string& objectModel); bool destroyFederationExecution(const std::string& federation); + bool createFederationExecution(); + bool destroyFederationExecution(); /// Join with federateType the federation execution bool join(const std::string& federateType, const std::string& federation); + bool join(); bool resign(); + + /// Try to create and join the federation execution. + bool createJoinFederationExecution(); + bool resignDestroyFederationExecution(); + + + /// Time management + + /// If set to true, time constrained mode is entered on init + bool getTimeConstrained() const; + bool setTimeConstrained(bool timeConstrained); + + /// If set to true, time advance is constrained by the local system clock + bool getTimeConstrainedByLocalClock() const; + bool setTimeConstrainedByLocalClock(bool timeConstrainedByLocalClock); + /// If set to true, time regulation mode is entered on init + bool getTimeRegulating() const; + bool setTimeRegulating(bool timeRegulating); + + /// If set to a non zero value, this federate leads the federations + /// locical time advance by this amount of time. + const SGTimeStamp& getLeadTime() const; + bool setLeadTime(const SGTimeStamp& leadTime); + + /// The time increment for use in the default update method. + const SGTimeStamp& getTimeIncrement() const; + bool setTimeIncrement(const SGTimeStamp& timeIncrement); + + /// Actually enable time constrained mode. + /// This method blocks until time constrained mode is enabled. bool enableTimeConstrained(); + /// Actually disable time constrained mode. bool disableTimeConstrained(); + /// Actually enable time constrained by local clock mode. + bool enableTimeConstrainedByLocalClock(); + + /// Actually enable time regulation mode. + /// This method blocks until time regulation mode is enabled. bool enableTimeRegulation(const SGTimeStamp& lookahead); + bool enableTimeRegulation(); + /// Actually disable time regulation mode. bool disableTimeRegulation(); + /// Actually modify the lookahead time. + bool modifyLookahead(const SGTimeStamp& lookahead); - bool timeAdvanceRequestBy(const SGTimeStamp& dt); - bool timeAdvanceRequest(const SGTimeStamp& dt); + /// Advance the logical time by the given time increment. + /// Depending on the time constrained mode, this might + /// block until the time advance is granted. + bool timeAdvanceBy(const SGTimeStamp& timeIncrement); + /// Advance the logical time to the given time. + /// Depending on the time constrained mode, this might + /// block until the time advance is granted. + bool timeAdvance(const SGTimeStamp& timeStamp); + /// Advance the logical time as far as time advances are available. + /// This call should not block and advance the logical time + /// as far as currently possible. + bool timeAdvanceAvailable(); + /// Get the current federates time bool queryFederateTime(SGTimeStamp& timeStamp); - bool modifyLookahead(const SGTimeStamp& timeStamp); + /// Get the current federates lookahead bool queryLookahead(SGTimeStamp& timeStamp); - /// Process messages - bool tick(); + /// Process one messsage + bool processMessage(); + /// Process one message but do not wait longer than the relative timeout. + bool processMessage(const SGTimeStamp& timeout); + /// Process messages until the federate can proceed with the + /// next simulation step. That is flush all pending messages and + /// depending on the time constrained mode process messages until + /// a pending time advance is granted. + bool processMessages(); + + /// Legacy tick call bool tick(const double& minimum, const double& maximum); class ObjectModelFactory { @@ -105,9 +192,59 @@ public: HLAInteractionClass* getInteractionClass(const std::string& name); const HLAInteractionClass* getInteractionClass(const std::string& name) const; + /// Tells the main exec loop to continue or not. + void setDone(bool done); + bool getDone() const; + + virtual bool readObjectModel(); + + virtual bool subscribe(); + virtual bool publish(); + + virtual bool init(); + virtual bool update(); + virtual bool shutdown(); + + virtual bool exec(); + private: + HLAFederate(const HLAFederate&); + HLAFederate& operator=(const HLAFederate&); + + /// The underlying interface to the rti implementation SGSharedPtr _rtiFederate; + /// Parameters required to connect to an rti + Version _version; + std::list _connectArguments; + + /// Parameters for the federation execution + std::string _federationExecutionName; + std::string _federationObjectModel; + bool _createFederationExecution; + + /// Parameters for the federate + std::string _federateType; + std::string _federateName; + + /// Time management related parameters + /// If true, the federate is expected to enter time constrained mode + bool _timeConstrained; + /// If true, the federate is expected to enter time regulating mode + bool _timeRegulating; + /// The amount of time this federate leads the others. + SGTimeStamp _leadTime; + /// The regular time increment we do on calling update() + SGTimeStamp _timeIncrement; + /// The reference system time at initialization time. + /// Is used to implement being time constrained on the + /// local system time. + bool _timeConstrainedByLocalClock; + SGTimeStamp _localClockOffset; + + /// If true the exec method returns. + bool _done; + typedef std::map > ObjectClassMap; ObjectClassMap _objectClassMap;