Base.hh

/*
 * Copyright 2011 Nate Koenig & Andrew Howard
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/

/* Desc: Base class shared by all classes in Gazebo.
 * Author: Nate Koenig
 * Date: 09 Sept. 2008
 */

#ifndef GAZEBO_PHYSICS_BASE_HH
#define GAZEBO_PHYSICS_BASE_HH

#include <boost/enable_shared_from_this.hpp>

#include <string>

#include "sdf/sdf.h"
#include "common/CommonTypes.hh"
#include "physics/PhysicsTypes.hh"

namespace gazebo
{
    namespace physics
  {

    static std::string EntityTypename[] = { 
      "common", 
      "entity", 
      "model", 
      "link", 
      "collision",
      "light",
      "visual",
      "joint",
      "ball",
      "hinge2",
      "hinge",
      "slider",
      "universal",
      "shape",
      "box",
      "cylinder",
      "heightmap",  
      "map", 
      "multiray", 
      "ray", 
      "plane",
      "sphere", 
      "trimesh"
    };

    class Base : public boost::enable_shared_from_this<Base>
    {
      public: enum EntityType{
                BASE            = 0x00000000,
                ENTITY          = 0x00000001,
                MODEL           = 0x00000002,
                LINK            = 0x00000004,
                COLLISION       = 0x00000010,
                LIGHT           = 0x00000020,
                VISUAL          = 0x00000040,

                JOINT           = 0x10000000,
                BALL_JOINT      = 0x10000001,
                HINGE2_JOINT    = 0x10000002,
                HINGE_JOINT     = 0x10000004,
                SLIDER_JOINT    = 0x10000010,
                SCREW_JOINT     = 0x10000020,
                UNIVERSAL_JOINT = 0x10000040,

                SHAPE           = 0x20000000,
                BOX_SHAPE       = 0x20000001,
                CYLINDER_SHAPE  = 0x20000002,
                HEIGHTMAP_SHAPE = 0x20000004,
                MAP_SHAPE       = 0x20000010,
                MULTIRAY_SHAPE  = 0x20000020,
                RAY_SHAPE       = 0x20000040,
                PLANE_SHAPE     = 0x20000100,
                SPHERE_SHAPE    = 0x20000200,
                TRIMESH_SHAPE   = 0x20000400
              };

      public: Base(BasePtr parent);
  
      public: virtual ~Base();
  
      public: virtual void Load( sdf::ElementPtr &_sdf );

      public: virtual void Fini();

      public: virtual void Init() {}
      public: virtual void Reset();
      public: virtual void Update() {}

      public: virtual void UpdateParameters( sdf::ElementPtr &_sdf );

      public: virtual void SetName(const std::string &name);
    
      public: std::string GetName() const;
  
      public: unsigned int GetId() const;
  
      public: void SetSaveable(bool v);
  
      public: bool GetSaveable() const;
  
      public: int GetParentId() const;
    
      public: void SetParent(BasePtr parent);
    
      public: BasePtr GetParent() const;
  
      public: void AddChild(BasePtr child);
  
      public: virtual void RemoveChild(unsigned int id);
  
      public: void RemoveChildren();

      public: unsigned int GetChildCount() const;

      public: BasePtr GetById(unsigned int _id) const;

      public: BasePtr GetByName(const std::string &name);
  
      public: BasePtr GetChild(unsigned int i) const;
  
      public: BasePtr GetChild(const std::string &name );

      public: void RemoveChild( const std::string &_name);
  
      public: void AddType( EntityType _type );
  
      public: bool HasType(const EntityType &_t) const;
  
      public: unsigned int GetType() const;
  
      public: std::string GetScopedName() const;
  
      public: std::string GetCompleteScopedName() const;
  
      public: void Print(std::string prefix);
  
      public: bool GetShowInGui() const;
  
      public: void SetShowInGui(bool v);
  
      //         the gui
      public: virtual bool SetSelected( bool s );
    
      public: bool IsSelected() const;
  
      public: bool operator==(const Base &ent) const;
  
      public: void SetWorld(const WorldPtr &_newWorld);
    
      public: const WorldPtr &GetWorld() const;

      public: virtual const sdf::ElementPtr &GetSDF();

      protected: sdf::ElementPtr sdf;

      protected: BasePtr parent;
 
      protected: Base_V children;
      protected: Base_V::iterator childrenEnd;

      protected: WorldPtr world;

      private: bool saveable;
 
      private: unsigned int id;
    
      private: static unsigned int idCounter;
   
      private: unsigned int type;
  
      private: bool selected;
    };
  }

}
#endif