gz/rendering/Storage.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2015 Open Source Robotics Foundation
 *
 * 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.
 *
 */
#ifndef GZ_RENDERING_STORAGE_HH_
#define GZ_RENDERING_STORAGE_HH_
 
#include <memory>
#include <string>
#include "gz/rendering/config.hh"
#include "gz/rendering/Scene.hh"
#include "gz/rendering/Node.hh"
#include "gz/rendering/Light.hh"
#include "gz/rendering/Sensor.hh"
#include "gz/rendering/Visual.hh"
#include "gz/rendering/Geometry.hh"
#include "gz/rendering/Material.hh"
#include "gz/rendering/Mesh.hh"
#include "gz/rendering/Export.hh"
 
// An X11 header file defines a macro that conflicts with our function name,
// so undefine it here
#ifdef DestroyAll
#undef DestroyAll
#endif
 
namespace ignition
{
  namespace rendering
  {
    inline namespace IGNITION_RENDERING_VERSION_NAMESPACE {
    //
    template <class T>
    class IGNITION_RENDERING_VISIBLE Map
    {
      typedef std::shared_ptr<T> TPtr;
 
      typedef std::shared_ptr<const T> ConstTPtr;
 
      public: virtual ~Map() { }
 
      public: virtual unsigned int Size() const = 0;
 
      public: virtual bool ContainsKey(const std::string &_key) const = 0;
 
      public: virtual bool ContainsValue(ConstTPtr _value) const = 0;
 
      public: virtual TPtr Get(const std::string &_key) const = 0;
 
      public: virtual TPtr GetByIndex(unsigned int _index) const = 0;
 
      public: virtual bool Put(const std::string &_key, TPtr _value) = 0;
 
      public: virtual void Remove(const std::string &_key) = 0;
 
      public: virtual void Remove(TPtr _value) = 0;
 
      public: virtual void RemoveAll() = 0;
    };
 
    template <class T>
    class IGNITION_RENDERING_VISIBLE Store
    {
      typedef std::shared_ptr<T> TPtr;
 
      typedef std::shared_ptr<const T> ConstTPtr;
 
      public: virtual ~Store() { }
 
      public: virtual unsigned int Size() const = 0;
 
      public: virtual bool Contains(ConstTPtr _object) const = 0;
 
      public: virtual bool ContainsId(unsigned int _id) const = 0;
 
      public: virtual bool ContainsName(const std::string &_name) const = 0;
 
      public: virtual TPtr GetById(unsigned int _id) const = 0;
 
      public: virtual TPtr GetByName(const std::string &_name) const = 0;
 
      public: virtual TPtr GetByIndex(unsigned int _index) const = 0;
 
      public: virtual bool Add(TPtr _object) = 0;
 
      public: virtual TPtr Remove(TPtr _object) = 0;
 
      public: virtual TPtr RemoveById(unsigned int _id) = 0;
 
      public: virtual TPtr RemoveByName(const std::string &_name) = 0;
 
      public: virtual TPtr RemoveByIndex(unsigned int _index) = 0;
 
      public: virtual void RemoveAll() = 0;
 
      public: virtual void Destroy(TPtr _object) = 0;
 
      public: virtual void DestroyById(unsigned int _id) = 0;
 
      public: virtual void DestroyByName(const std::string &_name) = 0;
 
      public: virtual void DestroyByIndex(unsigned int _index) = 0;
 
      public: virtual void DestroyAll() = 0;
    };
 
    template <class T>
    class IGNITION_RENDERING_VISIBLE CompositeStore :
      public Store<T>
    {
      typedef std::shared_ptr<T> TPtr;
 
      typedef Store<T> TStore;
 
      typedef std::shared_ptr<TStore> TStorePtr;
 
      typedef std::shared_ptr<const TStore> ConstTStorePtr;
 
      public: virtual ~CompositeStore() { }
 
      public: virtual unsigned int GetStoreCount() const = 0;
 
      public: virtual bool ContainsStore(ConstTStorePtr _store) const = 0;
 
      public: virtual bool AddStore(TStorePtr _store) = 0;
 
      public: virtual TStorePtr GetStore(unsigned int _index) const = 0;
 
      public: virtual TStorePtr RemoveStore(TStorePtr _store) = 0;
 
      public: virtual TStorePtr RemoveStore(unsigned int _index) = 0;
    };
 
    template <class T, class U>
    class IGNITION_RENDERING_VISIBLE StoreWrapper :
      public Store<T>
    {
      public: virtual ~StoreWrapper() { }
    };
 
// armhf failed to build with this code. It can not be removed for the rest
// of arches to keep ABI but should be removed in major versions unreleased
// see https://github.com/ignitionrobotics/ign-rendering/pull/457
#ifndef __ARM_PCS_VFP
    template class Store<Scene>;
    template class Store<Node>;
    template class Store<Light>;
    template class Store<Sensor>;
    template class Store<Visual>;
    template class Store<Geometry>;
    template class Store<SubMesh>;
    template class Map<Material>;
    template class CompositeStore<Node>;
#endif
 
    typedef Store<Scene> SceneStore;
 
    typedef Store<Node> NodeStore;
 
    typedef Store<Light> LightStore;
 
    typedef Store<Sensor> SensorStore;
 
    typedef Store<Visual> VisualStore;
 
    typedef Store<Geometry> GeometryStore;
 
    typedef Store<SubMesh> SubMeshStore;
 
    typedef Map<Material> MaterialMap;
 
    typedef CompositeStore<Node> NodeCompositeStore;
 
    typedef std::shared_ptr<SceneStore> SceneStorePtr;
 
    typedef std::shared_ptr<NodeStore> NodeStorePtr;
 
    typedef std::shared_ptr<LightStore> LightStorePtr;
 
    typedef std::shared_ptr<SensorStore> SensorStorePtr;
 
    typedef std::shared_ptr<VisualStore> VisualStorePtr;
 
    typedef std::shared_ptr<GeometryStore> GeometryStorePtr;
 
    typedef std::shared_ptr<SubMeshStore> SubMeshStorePtr;
 
    typedef std::shared_ptr<MaterialMap> MaterialMapPtr;
 
    typedef std::shared_ptr<NodeCompositeStore> NodeCompositeStorePtr;
    }
  }
}
#endif