DtOsgEarthFeatureDataBroker.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2011 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile:  $ $Revision:  $ $State:  $
******************************************************************************/


#pragma once
#include <vrvOsg/vrvOsg.h>
#include <osg/observer_ptr>
#include <osg/ref_ptr>

#include <osgEarth/Map>
#include <boost/unordered_map.hpp>

#include <set>
#include <string>

// Forward declarations
namespace osg {
   class Node;
}
namespace osgEarth {
   class MapNode;
   class ModelLayer;
}

namespace makVrv
{
   class DT_DLL_VRVOSG DtOsgEarthFeatureDataBroker : public osg::Referenced
   {
   public:
      // Callback to invoke when new data merges into the scene graph.
      struct DT_DLL_VRVOSG Callback : public osg::Referenced
      {
         virtual void onLayerLoaded(osgEarth::MapNode*    mapNode,
                                    osgEarth::ModelLayer* layer) =0;

         virtual void onDataLoaded(osgEarth::Map*        map,
                                   osgEarth::ModelLayer* layer,
                                   osg::Node*            newData) =0;
      };

   public:
      // Constructs a broker for the specified map node.
      DtOsgEarthFeatureDataBroker(osgEarth::MapNode* mapNode, DtDe& de);

      // Install a callback.
      void addCallback(const std::string& registrant, Callback* cb);

      // Whether to run state sharing optimization after invoking
      // all the callbacks. Default = true.
      void setOptimizeStateSharing(bool value);
      bool getOptimizeStateSharing() const;

   public: // internal functions

      // Adds a model layer to the broker. You normally do not need to
      // call this directly; the object will discover model layers in the
      // Map model automatically.
      void addModelLayer(osgEarth::ModelLayer* layer);

      // Internal function that's called after a new map layer is
      // loaded in the MapNode.
      void notifyNewLayer(osgEarth::ModelLayer* layer);

      // Internal function that's called after new data for the model
      // layer merges into the scene graph. This is called internally;
      // there is no need to call it yourself.
      void notifyNewData(osgEarth::ModelLayer* layer, osg::Node* data);

   protected:
      virtual ~DtOsgEarthFeatureDataBroker();

      bool readFeatureNameRegistrationFile( const std::string& path, 
         const std::string& filename );

   protected:
      static std::string getFeatureNameFromModelLayer( 
         const osgEarth::ModelLayer& layer );

   protected:
      static const char* theFeatureDataBrokerRegistrantToFeatureList;

   protected:

      typedef osg::ref_ptr<osgEarth::NodeOperation> NodeOperationRefPtr;
      osg::observer_ptr<osgEarth::MapNode> myMapNode;
      osg::ref_ptr<osgEarth::MapCallback> myMapCallback;
      std::set<NodeOperationRefPtr> myOperations;
      DtDe& myDe;
      bool myShareState;

      typedef osg::ref_ptr<Callback> CallbackRefPtr;
      typedef boost::unordered_multimap<std::string, CallbackRefPtr> 
         FeatureDataCallbackMap;
      typedef std::pair<FeatureDataCallbackMap::iterator,
         FeatureDataCallbackMap::iterator> RangeIterFeatureDataCallbacks;
      typedef std::pair<FeatureDataCallbackMap::const_iterator,
         FeatureDataCallbackMap::const_iterator> 
         ConstRangeIterFeatureDataCallbacks;

      FeatureDataCallbackMap myFeatureDataCallbacks;

      typedef boost::unordered_map<std::string, std::vector<std::string> > 
         RegistrantToFeaturesMap;

      typedef boost::unordered_map<std::string, 
         std::vector<std::string> >::iterator RegistrantToFeaturesMapIter;

      RegistrantToFeaturesMap myRegistrantToFeaturesMap;


   };
}