include/vrvCore/DtChannelKeywordObjectManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2010 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtChannelKeywordObjectManager.h,v $ $Revision: 1.23 $ $State: Exp $
******************************************************************************/


#pragma once

#include <vrvCore/vrvCore.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>

#include <boost/unordered_map.hpp>
#include <string>
#include <vector>

namespace makVrv
{
   class DtAgentManagerInterface;
   class DtChannel;
   class DtChannelKeywordObject;
   class DtChannelConfiguration;
   class DtWindowConfiguration;
   class DtChannelManager;
   class DtDe;   
   class DtWindowConfiguration;


   class DT_DLL_VRVCORE DtChannelKeywordObjectManager : public DtVirtualBaseClass
   {
   
   public:
      // This is a map of channel keyword objects indexed by keyword name.  each channel may
      // have such a map
      typedef boost::unordered_map<std::string, DtChannelKeywordObject*> ObjectMap;
      
      // This is a map of ObjectMaps, indexed by DisplayName :: WindowName :: ChannelName
      typedef boost::unordered_map<std::string, ObjectMap> ChannelMap;   


   public:
      friend class DtChannelKeywordObjectManagerCreator;
      
      virtual ~DtChannelKeywordObjectManager();
      
      static DtChannelKeywordObjectManager& instance( DtDe& de );
      
      const ChannelMap& channelMap() const;

   protected:
   
   // Signal Slots         
      virtual void slot_channelCreated( DtChannelManager*, DtChannel* );
      
      virtual void slot_channelToBeDestroyed( const std::string& deName, 
         const std::string& winName, const std::string& channelName );
      
      virtual void slot_channelConfigurationAdded( const std::string& deName, 
         const std::string& winName, const DtChannelConfiguration& config);
       
      virtual void slot_displayConfigurationRealized( const std::string& igName, 
         const std::string& displayName );
       
      virtual void slot_displayToBeDestroyed( const std::string& displayName );
      
      virtual void slot_channelConfigurationModified( const std::string& deName, 
         const std::string& winName, const std::string& oldChannelName, 
         const DtChannelConfiguration& config);
      
      virtual void slot_windowConfigurationModified( const std::string& deName, 
         const std::string& oldWindowName, const DtWindowConfiguration& config);
         
   // Helper methods
      // we may get deName, windowName, and configuration in different ways, but once
      // we have them, call this
      virtual void processChannelConfiguration(const std::string& deName, 
         const std::string& winName, const DtChannelConfiguration& config );
         
      virtual std::string makeChannelKey( const std::string& deName, 
         const std::string& winName, const std::string& channelName );
         
      virtual std::string makeWindowKey( const std::string& deName, 
         const std::string& winName );
         
      virtual void addChannelKeywordObject( const std::string& channelKey, 
         const std::string& keyword, DtChannelKeywordObject* keywordObject );
         
      virtual void removeChannelKeywordObject( const std::string& channelKey, 
         const std::string& keyword );
         
      // Special case; can't use removeChannelKeywordObjects() because we're iterating over the
      // object map, so this one method removes them all
      virtual void removeAllChannelKeywordObjectsFromChannel( const std::string& channelKey );
      
      void addToWindowMap( const std::string& windowKey, const std::string& channelKey );
      
      void removeFromWindowMap( const std::string& windowKey, const std::string& channelKey );
      
      static std::string getChannelNameFromChannelKey( const std::string& channelKey );
      
   protected:    
      DtChannelKeywordObjectManager( DtDe& de );           
   protected:
      
      // This is a map of channel key lists indexed by window key
      // Given a deName/windowName, we can get all the channel keys for channels in that
      // window that have compasses
      
      typedef std::vector<std::string> ChannelKeyList;
      typedef boost::unordered_map<std::string, ChannelKeyList > WindowMap;

      DtDe& myDe;
      DtSignalConnectionManager myConnections;
      
      // This map provides a pointer to CompassMap given
      // a DisplayName :: WindowName :: ChannelName string.  The CompassMap
      // can then provide a pointer to a compass based on keyword
      ChannelMap myChannelMap;
      
      WindowMap myWindowMap;

   };

   class DT_DLL_VRVCORE DtChannelKeywordObjectManagerCreator : public DtVirtualBaseClass
   {

   public:
      static DtChannelKeywordObjectManagerCreator& instance( DtDe& );

      static void registerInstance( DtDe& theIG, DtChannelKeywordObjectManagerCreator* anInstance );     

      virtual DtChannelKeywordObjectManager* create( DtDe& );
   };
}