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 IGNITION_RENDERING_STORAGE_HH_
#define IGNITION_RENDERING_STORAGE_HH_

#include <memory>
#include <string>
#include "ignition/rendering/config.hh"
#include "ignition/rendering/Scene.hh"
#include "ignition/rendering/Node.hh"
#include "ignition/rendering/Light.hh"
#include "ignition/rendering/Sensor.hh"
#include "ignition/rendering/Visual.hh"
#include "ignition/rendering/Geometry.hh"
#include "ignition/rendering/Material.hh"
#include "ignition/rendering/Mesh.hh"
#include "ignition/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() { }
    };

    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>;

    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