simgear/hla/HLAObjectClass.hxx

   1 // Copyright (C) 2009 - 2012  Mathias Froehlich - Mathias.Froehlich@web.de
   2 //
   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.
   7 //
   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.
  12 //
  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.
  16 //
  17
  18 #ifndef HLAObjectClass_hxx
  19 #define HLAObjectClass_hxx
  20
  21 #include <string>
  22 #include <vector>
  23
  24 #include "HLADataType.hxx"
  25 #include "HLAObjectInstance.hxx"
  26 #include "HLATypes.hxx"
  27
  28 namespace simgear {
  29
  30 class RTIObjectClass;
  31 class HLAFederate;
  32
  33 class HLAObjectClass : public SGWeakReferenced {
  34 public:
  35     HLAObjectClass(const std::string& name, HLAFederate* federate);
  36     virtual ~HLAObjectClass();
  37
  38     /// Return the name of this object class
  39     const std::string& getName() const;
  40
  41     /// return the federate this class belongs to
  42     const SGWeakPtr<HLAFederate>& getFederate() const;
  43
  44     /// Return the number of attributes in this object class
  45     unsigned getNumAttributes() const;
  46
  47     /// Adds a new attribute to this object class, return the index
  48     unsigned addAttribute(const std::string& name);
  49
  50     /// Return the attribute index for the attribute with the given name
  51     unsigned getAttributeIndex(const std::string& name) const;
  52     /// Return the attribute name for the attribute with the given index
  53     std::string getAttributeName(unsigned index) const;
  54
  55     /// Return the data type of the attribute with the given index
  56     const HLADataType* getAttributeDataType(unsigned index) const;
  57     /// Sets the data type of the attribute with the given index to dataType
  58     void setAttributeDataType(unsigned index, const HLADataType* dataType);
  59
  60     /// Return the update type of the attribute with the given index
  61     HLAUpdateType getAttributeUpdateType(unsigned index) const;
  62     /// Sets the update type of the attribute with the given index to updateType
  63     void setAttributeUpdateType(unsigned index, HLAUpdateType updateType);
  64
  65     /// Return the subscription type of the attribute with the given index
  66     HLASubscriptionType getAttributeSubscriptionType(unsigned index) const;
  67     /// Sets the subscription type of the attribute with the given index to subscriptionType
  68     void setAttributeSubscriptionType(unsigned index, HLASubscriptionType subscriptionType);
  69
  70     /// Return the publication type of the attribute with the given index
  71     HLAPublicationType getAttributePublicationType(unsigned index) const;
  72     /// Sets the publication type of the attribute with the given index to publicationType
  73     void setAttributePublicationType(unsigned index, HLAPublicationType publicationType);
  74
  75     /// Return the index, path pair for the given string path pair
  76     HLADataElement::IndexPathPair getIndexPathPair(const HLADataElement::StringPathPair&) const;
  77     /// Return the index, path pair for the given string path
  78     HLADataElement::IndexPathPair getIndexPathPair(const std::string& path) const;
  79
  80     /// Get the attribute data element index for the given path, return true if successful
  81     bool getDataElementIndex(HLADataElementIndex& dataElementIndex, const std::string& path) const;
  82     HLADataElementIndex getDataElementIndex(const std::string& path) const;
  83
  84     virtual bool subscribe();
  85     virtual bool unsubscribe();
  86
  87     virtual bool publish();
  88     virtual bool unpublish();
  89
  90     // Object instance creation and destruction
  91     class InstanceCallback : public SGReferenced {
  92     public:
  93         virtual ~InstanceCallback();
  94
  95         virtual void discoverInstance(const HLAObjectClass& objectClass, HLAObjectInstance& objectInstance, const RTIData& tag);
  96         virtual void removeInstance(const HLAObjectClass& objectClass, HLAObjectInstance& objectInstance, const RTIData& tag);
  97
  98         virtual void registerInstance(const HLAObjectClass& objectClass, HLAObjectInstance& objectInstance);
  99         virtual void deleteInstance(const HLAObjectClass& objectClass, HLAObjectInstance& objectInstance);
 100     };
 101
 102     void setInstanceCallback(const SGSharedPtr<InstanceCallback>& instanceCallback)
 103     { _instanceCallback = instanceCallback; }
 104     const SGSharedPtr<InstanceCallback>& getInstanceCallback() const
 105     { return _instanceCallback; }
 106
 107     virtual void discoverInstance(HLAObjectInstance& objectInstance, const RTIData& tag);
 108     virtual void removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag);
 109     virtual void registerInstance(HLAObjectInstance& objectInstance);
 110     virtual void deleteInstance(HLAObjectInstance& objectInstance);
 111
 112     // Is called by the default registration callback if installed
 113     // Should register the already known object instances of this class.
 114     virtual void startRegistration() const;
 115     virtual void stopRegistration() const;
 116
 117     // Handles startRegistrationForObjectClass and stopRegistrationForObjectClass events
 118     class RegistrationCallback : public SGReferenced {
 119     public:
 120         virtual ~RegistrationCallback();
 121         virtual void startRegistration(HLAObjectClass& objectClass) = 0;
 122         virtual void stopRegistration(HLAObjectClass& objectClass) = 0;
 123     };
 124
 125     void setRegistrationCallback(const SGSharedPtr<RegistrationCallback>& registrationCallback)
 126     { _registrationCallback = registrationCallback; }
 127     const SGSharedPtr<RegistrationCallback>& getRegistrationCallback() const
 128     { return _registrationCallback; }
 129
 130     /// Create a new instance of this class.
 131     virtual HLAObjectInstance* createObjectInstance(const std::string& name);
 132
 133     virtual void createAttributeDataElements(HLAObjectInstance& objectInstance);
 134     virtual HLADataElement* createAttributeDataElement(HLAObjectInstance& objectInstance, unsigned index);
 135
 136 private:
 137     HLAObjectClass(const HLAObjectClass&);
 138     HLAObjectClass& operator=(const HLAObjectClass&);
 139
 140     void _setRTIObjectClass(RTIObjectClass* objectClass);
 141     void _resolveAttributeIndex(const std::string& name, unsigned index);
 142     void _clearRTIObjectClass();
 143
 144     // The internal entry points from the RTILObjectClass callback functions
 145     void _discoverInstance(RTIObjectInstance* objectInstance, const RTIData& tag);
 146     void _removeInstance(HLAObjectInstance& objectInstance, const RTIData& tag);
 147     void _registerInstance(HLAObjectInstance* objectInstance);
 148     void _deleteInstance(HLAObjectInstance& objectInstance);
 149
 150     void _startRegistration();
 151     void _stopRegistration();
 152
 153     friend class HLAObjectInstance;
 154     friend class RTIObjectClass;
 155
 156     struct Attribute {
 157         Attribute() : _subscriptionType(HLAUnsubscribed), _publicationType(HLAUnpublished), _updateType(HLAUndefinedUpdate) {}
 158         Attribute(const std::string& name) : _name(name), _subscriptionType(HLAUnsubscribed), _publicationType(HLAUnpublished), _updateType(HLAUndefinedUpdate) {}
 159         std::string _name;
 160         SGSharedPtr<const HLADataType> _dataType;
 161         HLASubscriptionType _subscriptionType;
 162         HLAPublicationType _publicationType;
 163         HLAUpdateType _updateType;
 164     };
 165     typedef std::vector<Attribute> AttributeVector;
 166     typedef std::map<std::string,unsigned> NameIndexMap;
 167
 168     /// The parent federate.
 169     SGWeakPtr<HLAFederate> _federate;
 170
 171     /// The object class name
 172     std::string _name;
 173
 174     /// The underlying rti dispatcher class
 175     SGSharedPtr<RTIObjectClass> _rtiObjectClass;
 176
 177     /// The attribute data
 178     AttributeVector _attributeVector;
 179     /// The mapping from attribute names to attribute indices
 180     NameIndexMap _nameIndexMap;
 181
 182     // Callback classes
 183     SGSharedPtr<InstanceCallback> _instanceCallback;
 184     SGSharedPtr<RegistrationCallback> _registrationCallback;
 185
 186     friend class HLAFederate;
 187 };
 188
 189 } // namespace simgear
 190
 191 #endif