DtDynamicTerrainFeature.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2016 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 


#pragma once

#include <vrvUtil/vrvUtil.h>
#include <vrvUtil/DtDisconnectable.h>
#include <vrvUtil/DtDynamicTerrainChange.h>

#include <boost/function.hpp>
#include <boost/signals2.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/optional.hpp>

#include <tbb/spin_rw_mutex.h>

#include <map>

class DtString;

namespace makVrv
{
   class DtDynamicTerrainGeometry;
   class DtDynamicTerrainChange;
   class DtDynamicTerrainWorld;
   class DtDynamicTerrainIndex;
   class DtDynamicTerrainChanges;


   class DT_DLL_VRVUTIL DtDynamicTerrainFeature
      : public DtDisconnectable
      , public boost::enable_shared_from_this<DtDynamicTerrainFeature>
         
   {
   public:
      class Link;
      class RequestInfo;

      class DT_DLL_VRVUTIL RequestHandle
      {
      public:
         RequestHandle();

         void removeTerrainChange();

         void releaseOwnership();

      private:
         friend class DtDynamicTerrainWorld;
         friend class DtDynamicTerrainFeature;

         explicit RequestHandle(
            const boost::shared_ptr<DtDynamicTerrainFeature::RequestInfo>&);

         boost::weak_ptr<DtDynamicTerrainFeature::RequestInfo> myRequest;
      };

      static unsigned long long GetObjectCount();

      DtDynamicTerrainFeature();

      virtual ~DtDynamicTerrainFeature();

      virtual bool matches(const DtDynamicTerrainChange&, bool useOriginalGeometry = false) const = 0;
      virtual bool matches(const DtDynamicTerrainGeometry&, bool useOriginalGeometry = false) const = 0;

      virtual const DtDynamicTerrainGeometry* geometry() const = 0;

      virtual const DtDynamicTerrainGeometry* originalGeometry() const;

      virtual boost::optional<DtString> featureAttribute(const DtString& key) const;

      virtual bool isInDefaultState() const = 0;

      virtual bool lastStateWasDefaultState() const = 0;

      virtual void changeState(const DtDynamicTerrainChanges& history) = 0;



      typedef boost::function<void (const DtDynamicTerrainFeature&)> Callback;

      typedef
         boost::function<void (const DtDynamicTerrainFeature&, const DtDynamicTerrainChanges&)>
         ChangeCallback;

      virtual boost::signals2::connection connectToChangeSignal(const ChangeCallback& callback) const;

      virtual boost::signals2::connection connectToPageOutSignal(const Callback& callback) const;




      virtual DtString description() const = 0;

      virtual const DtDynamicTerrainFeature* parentFeature() const;

      virtual void iterateCommands(
         const boost::function<void (const DtDynamicTerrainChange&)>&) const;

      void changed();

      bool pageOut();

      void changes(const boost::function<void (const DtDynamicTerrainChanges&)>& callback) const;

      RequestHandle addChangeRequest(DtDynamicTerrainChange* change);
      RequestHandle addChangeRequest(double time, DtDynamicTerrainChange* change);

   protected:

      void indexDoubleAscending(const DtString& key);
      void indexDoubleDescending(const DtString& key);
      void indexIntAscending(const DtString& key);
      void indexIntDescending(const DtString& key);
      void indexStringAscending(const DtString& key);
      void indexStringDescending(const DtString& key);

      void setupIndex(const DtString& key, DtDynamicTerrainIndex* index);

   private:
      friend class Link;

      typedef boost::signals2::signal<void (const DtDynamicTerrainFeature&)> Signal;

      typedef boost::signals2::signal<
         void (const DtDynamicTerrainFeature&, const DtDynamicTerrainChanges&)
      > ChangeSignal;

      typedef std::map<RequestInfo*, boost::shared_ptr<Link> > LinkInfoMap;

      // functions for creating and breaking the links
      bool makeLinkToRequest(const boost::shared_ptr<Link>& link);
      void breakLinkToRequest(LinkInfoMap::iterator);

      mutable ChangeSignal myChangeSignal;  // implements connectToChangeSignal
      mutable Signal myPageOutSignal; // implements connectToRemoveSignal


      typedef tbb::spin_rw_mutex Mutex;
      mutable Mutex myMutex;

      // Container which holds links to all the requests that match the feature.
      LinkInfoMap myLinkMap;

      typedef std::map<DtString, DtDynamicTerrainIndex*> IndexMap;
      IndexMap myIndices;
   };

   class DT_DLL_VRVUTIL DtDynamicTerrainIndex
   {
   public:
      typedef boost::function<void (const DtDynamicTerrainChange&)> IterateRequestCallback;

      virtual ~DtDynamicTerrainIndex();

      virtual void iterateRequests(const IterateRequestCallback& callback) const = 0;

      virtual const DtDynamicTerrainChange* firstChange() const = 0;

      virtual bool addValue(
         const boost::shared_ptr<DtDynamicTerrainFeature::Link>& link,
         const DtString& key) = 0;
   };

   class DT_DLL_VRVUTIL DtDynamicTerrainChanges
   {
   public:
      typedef boost::function<void (const DtDynamicTerrainChange&)> IterateRequestCallback;

      virtual ~DtDynamicTerrainChanges();

      virtual void iterateRequests(const IterateRequestCallback& callback) const = 0;

      virtual const DtDynamicTerrainIndex* indexFor(const DtString& key) const = 0;
   };

   // Represents the link between a change request and a feature that is made when the feature
   // determines that the request applies to it. The objects are managed by shared pointers
   // and live two separate containers, one in the request info and one in the feature info.
   // The feature holds them in a map from the time of the request to the link, so that the
   // map implements the time line. The request holds the links in an unordered list since it
   // does not care anything about the order of changes to the various features it has applied to.
   class DT_DLL_VRVUTIL DtDynamicTerrainFeature::Link : public DtDisconnectable
   {
   public:
      static unsigned long long GetObjectCount();

      // Create link between a feature and a request.
      // This will create the object and insert it into the feature and request.
      // Neither parameter can be null.
      static bool Create(
         const boost::shared_ptr<DtDynamicTerrainFeature>& featureInfo,
         const boost::shared_ptr<RequestInfo>& reqInfo);

      virtual ~Link();

      RequestInfo& request() { return *myRequestInfo; }
      DtDynamicTerrainFeature& feature() { return *myFeatureInfo; }

   private:
      Link(
         const boost::shared_ptr<DtDynamicTerrainFeature>& featureInfo,
         const boost::shared_ptr<RequestInfo>& reqInfo);

      const boost::shared_ptr<RequestInfo> myRequestInfo;
      const boost::shared_ptr<DtDynamicTerrainFeature> myFeatureInfo;
   };

   // Bookkeeping info for an individual change request.
   // Holds the list of links that this change request applies to.
   class DT_DLL_VRVUTIL DtDynamicTerrainFeature::RequestInfo
      : public DtDisconnectable
   {
   public:
      friend class Link;

      static unsigned long long GetObjectCount();

      // takes ownership of command
      explicit RequestInfo(DtDynamicTerrainChange* command);

      virtual ~RequestInfo();

      const DtDynamicTerrainChange& command() const;

      // called by DtDynamicTerrainWorld::RequestHandle to remove the request
      void pageOut();

   private:
      typedef std::list<boost::shared_ptr<Link> > LinkList;

      // functions for creating and breaking the links
      void makeLinkToFeature(const boost::shared_ptr<Link>& link);
      void breakLinkToFeature(LinkList::iterator i);

      // command of this request
      boost::scoped_ptr<DtDynamicTerrainChange> myCommand;

      // mutex only protects myLinksToFeatures, all other members not changed after initial setup
      typedef tbb::spin_mutex Mutex;
      mutable Mutex myMutex;
      // list of links to the features we've linked to
      LinkList myLinksToFeatures;
   };
}