RootEntity.h

00001 // This file may be redistributed and modified only under the terms of
00002 // the GNU Lesser General Public License (See COPYING for details).
00003 // Copyright 2000-2001 Stefanus Du Toit and Aloril.
00004 // Copyright 2001-2004 Al Riddoch.
00005 // Automatically generated using gen_cpp.py.
00006 
00007 #ifndef ATLAS_OBJECTS_ENTITY_ROOTENTITY_H
00008 #define ATLAS_OBJECTS_ENTITY_ROOTENTITY_H
00009 
00010 #include <Atlas/Objects/Root.h>
00011 #include <Atlas/Objects/SmartPtr.h>
00012 
00013 namespace Atlas { namespace Objects { namespace Entity { 
00014 
00021 class RootEntityData;
00022 typedef SmartPtr<RootEntityData> RootEntity;
00023 
00024 static const int ROOT_ENTITY_NO = 2;
00025 
00028 
00030 class RootEntityData : public RootData
00031 {
00032 protected:
00034     RootEntityData(RootEntityData *defaults = NULL) : 
00035         RootData((RootData*)defaults)
00036     {
00037         m_class_no = ROOT_ENTITY_NO;
00038     }
00040     virtual ~RootEntityData();
00041 
00042 public:
00044     virtual RootEntityData * copy() const;
00045 
00047     virtual bool instanceOf(int classNo) const;
00048 
00051     virtual int copyAttr(const std::string& name, Atlas::Message::Element & attr) const;
00053     virtual void setAttr(const std::string& name,
00054                          const Atlas::Message::Element& attr);
00056     virtual void removeAttr(const std::string& name);
00057 
00059     virtual void sendContents(Atlas::Bridge & b) const;
00060 
00062     virtual void addToMessage(Atlas::Message::MapType &) const;
00063 
00065     inline void setLoc(const std::string& val);
00067     inline void setPos(const std::vector<double>& val);
00069     inline void setPosAsList(const Atlas::Message::ListType& val);
00071     inline void setVelocity(const std::vector<double>& val);
00073     inline void setVelocityAsList(const Atlas::Message::ListType& val);
00075     inline void setContains(const std::list<std::string>& val);
00077     inline void setContainsAsList(const Atlas::Message::ListType& val);
00079     inline void setStampContains(double val);
00080 
00082     inline const std::string& getLoc() const;
00084     inline std::string& modifyLoc();
00086     inline const std::vector<double>& getPos() const;
00088     inline std::vector<double>& modifyPos();
00090     inline const Atlas::Message::ListType getPosAsList() const;
00092     inline const std::vector<double>& getVelocity() const;
00094     inline std::vector<double>& modifyVelocity();
00096     inline const Atlas::Message::ListType getVelocityAsList() const;
00098     inline const std::list<std::string>& getContains() const;
00100     inline std::list<std::string>& modifyContains();
00102     inline const Atlas::Message::ListType getContainsAsList() const;
00104     inline double getStampContains() const;
00106     inline double& modifyStampContains();
00107 
00109     inline bool isDefaultLoc() const;
00111     inline bool isDefaultPos() const;
00113     inline bool isDefaultVelocity() const;
00115     inline bool isDefaultContains() const;
00117     inline bool isDefaultStampContains() const;
00118 
00119 protected:
00121     virtual int getAttrClass(const std::string& name)const;
00123     virtual int getAttrFlag(const std::string& name)const;
00125     std::string attr_loc;
00127     std::vector<double> attr_pos;
00129     std::vector<double> attr_velocity;
00131     std::list<std::string> attr_contains;
00133     double attr_stamp_contains;
00134 
00136     void sendLoc(Atlas::Bridge&) const;
00138     void sendPos(Atlas::Bridge&) const;
00140     void sendVelocity(Atlas::Bridge&) const;
00142     void sendContains(Atlas::Bridge&) const;
00144     void sendStampContains(Atlas::Bridge&) const;
00145 
00146     virtual void iterate(int& current_class, std::string& attr) const;
00147 
00148     //freelist related things
00149 public:
00150     static RootEntityData *alloc();
00151     virtual void free();
00152 
00157     virtual RootEntityData *getDefaultObject();
00158 
00163     static RootEntityData *getDefaultObjectInstance();
00164 private:
00165     static RootEntityData *defaults_RootEntityData;
00166     static RootEntityData *begin_RootEntityData;
00167 
00168     static std::map<std::string, int> * attr_flags_RootEntityData;
00169 };
00170 
00171 //
00172 // Inlined member functions follow.
00173 //
00174 
00175 const int LOC_FLAG = 1 << 6;
00176 void RootEntityData::setLoc(const std::string& val)
00177 {
00178     attr_loc = val;
00179     m_attrFlags |= LOC_FLAG;
00180 }
00181 
00182 const int POS_FLAG = 1 << 7;
00183 void RootEntityData::setPos(const std::vector<double>& val)
00184 {
00185     attr_pos = val;
00186     m_attrFlags |= POS_FLAG;
00187 }
00188 
00189 void RootEntityData::setPosAsList(const Atlas::Message::ListType& val)
00190 {
00191     m_attrFlags |= POS_FLAG;
00192     attr_pos.resize(0);
00193     for(Atlas::Message::ListType::const_iterator I = val.begin();
00194         I != val.end();
00195         I++)
00196     {
00197         if((*I).isNum()) {
00198             attr_pos.push_back((*I).asNum());
00199         }
00200     }
00201 }
00202 
00203 const int VELOCITY_FLAG = 1 << 8;
00204 void RootEntityData::setVelocity(const std::vector<double>& val)
00205 {
00206     attr_velocity = val;
00207     m_attrFlags |= VELOCITY_FLAG;
00208 }
00209 
00210 void RootEntityData::setVelocityAsList(const Atlas::Message::ListType& val)
00211 {
00212     m_attrFlags |= VELOCITY_FLAG;
00213     attr_velocity.resize(0);
00214     for(Atlas::Message::ListType::const_iterator I = val.begin();
00215         I != val.end();
00216         I++)
00217     {
00218         if((*I).isNum()) {
00219             attr_velocity.push_back((*I).asNum());
00220         }
00221     }
00222 }
00223 
00224 const int CONTAINS_FLAG = 1 << 9;
00225 void RootEntityData::setContains(const std::list<std::string>& val)
00226 {
00227     attr_contains = val;
00228     m_attrFlags |= CONTAINS_FLAG;
00229 }
00230 
00231 void RootEntityData::setContainsAsList(const Atlas::Message::ListType& val)
00232 {
00233     m_attrFlags |= CONTAINS_FLAG;
00234     attr_contains.resize(0);
00235     for(Atlas::Message::ListType::const_iterator I = val.begin();
00236         I != val.end();
00237         I++)
00238     {
00239         if((*I).isString()) {
00240             attr_contains.push_back((*I).asString());
00241         }
00242     }
00243 }
00244 
00245 const int STAMP_CONTAINS_FLAG = 1 << 10;
00246 void RootEntityData::setStampContains(double val)
00247 {
00248     attr_stamp_contains = val;
00249     m_attrFlags |= STAMP_CONTAINS_FLAG;
00250 }
00251 
00252 const std::string& RootEntityData::getLoc() const
00253 {
00254     if(m_attrFlags & LOC_FLAG)
00255         return attr_loc;
00256     else
00257         return ((RootEntityData*)m_defaults)->attr_loc;
00258 }
00259 
00260 std::string& RootEntityData::modifyLoc()
00261 {
00262     if(!(m_attrFlags & LOC_FLAG))
00263         setLoc(((RootEntityData*)m_defaults)->attr_loc);
00264     return attr_loc;
00265 }
00266 
00267 const std::vector<double>& RootEntityData::getPos() const
00268 {
00269     if(m_attrFlags & POS_FLAG)
00270         return attr_pos;
00271     else
00272         return ((RootEntityData*)m_defaults)->attr_pos;
00273 }
00274 
00275 std::vector<double>& RootEntityData::modifyPos()
00276 {
00277     if(!(m_attrFlags & POS_FLAG))
00278         setPos(((RootEntityData*)m_defaults)->attr_pos);
00279     return attr_pos;
00280 }
00281 
00282 const Atlas::Message::ListType RootEntityData::getPosAsList() const
00283 {
00284     const std::vector<double>& lst_in = getPos();
00285     Atlas::Message::ListType lst_out;
00286     for(std::vector<double>::const_iterator I = lst_in.begin();
00287         I != lst_in.end();
00288         I++)
00289     {
00290         lst_out.push_back(*I);
00291     }
00292     return lst_out;
00293 }
00294 
00295 const std::vector<double>& RootEntityData::getVelocity() const
00296 {
00297     if(m_attrFlags & VELOCITY_FLAG)
00298         return attr_velocity;
00299     else
00300         return ((RootEntityData*)m_defaults)->attr_velocity;
00301 }
00302 
00303 std::vector<double>& RootEntityData::modifyVelocity()
00304 {
00305     if(!(m_attrFlags & VELOCITY_FLAG))
00306         setVelocity(((RootEntityData*)m_defaults)->attr_velocity);
00307     return attr_velocity;
00308 }
00309 
00310 const Atlas::Message::ListType RootEntityData::getVelocityAsList() const
00311 {
00312     const std::vector<double>& lst_in = getVelocity();
00313     Atlas::Message::ListType lst_out;
00314     for(std::vector<double>::const_iterator I = lst_in.begin();
00315         I != lst_in.end();
00316         I++)
00317     {
00318         lst_out.push_back(*I);
00319     }
00320     return lst_out;
00321 }
00322 
00323 const std::list<std::string>& RootEntityData::getContains() const
00324 {
00325     if(m_attrFlags & CONTAINS_FLAG)
00326         return attr_contains;
00327     else
00328         return ((RootEntityData*)m_defaults)->attr_contains;
00329 }
00330 
00331 std::list<std::string>& RootEntityData::modifyContains()
00332 {
00333     if(!(m_attrFlags & CONTAINS_FLAG))
00334         setContains(((RootEntityData*)m_defaults)->attr_contains);
00335     return attr_contains;
00336 }
00337 
00338 const Atlas::Message::ListType RootEntityData::getContainsAsList() const
00339 {
00340     const std::list<std::string>& lst_in = getContains();
00341     Atlas::Message::ListType lst_out;
00342     for(std::list<std::string>::const_iterator I = lst_in.begin();
00343         I != lst_in.end();
00344         I++)
00345     {
00346         lst_out.push_back(std::string(*I));
00347     }
00348     return lst_out;
00349 }
00350 
00351 double RootEntityData::getStampContains() const
00352 {
00353     if(m_attrFlags & STAMP_CONTAINS_FLAG)
00354         return attr_stamp_contains;
00355     else
00356         return ((RootEntityData*)m_defaults)->attr_stamp_contains;
00357 }
00358 
00359 double& RootEntityData::modifyStampContains()
00360 {
00361     if(!(m_attrFlags & STAMP_CONTAINS_FLAG))
00362         setStampContains(((RootEntityData*)m_defaults)->attr_stamp_contains);
00363     return attr_stamp_contains;
00364 }
00365 
00366 bool RootEntityData::isDefaultLoc() const
00367 {
00368     return (m_attrFlags & LOC_FLAG) == 0;
00369 }
00370 
00371 bool RootEntityData::isDefaultPos() const
00372 {
00373     return (m_attrFlags & POS_FLAG) == 0;
00374 }
00375 
00376 bool RootEntityData::isDefaultVelocity() const
00377 {
00378     return (m_attrFlags & VELOCITY_FLAG) == 0;
00379 }
00380 
00381 bool RootEntityData::isDefaultContains() const
00382 {
00383     return (m_attrFlags & CONTAINS_FLAG) == 0;
00384 }
00385 
00386 bool RootEntityData::isDefaultStampContains() const
00387 {
00388     return (m_attrFlags & STAMP_CONTAINS_FLAG) == 0;
00389 }
00390 
00391 
00392 } } } // namespace Atlas::Objects::Entity
00393 
00394 #endif // ATLAS_OBJECTS_ENTITY_ROOTENTITY_H

Copyright 2000-2004 the respective authors.

This document can be licensed under the terms of the GNU Free Documentation License or the GNU General Public License and may be freely distributed under the terms given by one of these licenses.