featuresDebugger.h

Go to the documentation of this file.

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


#pragma once

#include <features/featureSet.h>
#include <features/featureSetList.h>

#include <simTerrainDrawer/debugDrawerNameManager.h>

#include <vrfutil/consoleCommandManager.h>

#include <tbb/queuing_rw_mutex.h>
#include <tbb/recursive_mutex.h>

#include <boost/ptr_container/ptr_map.hpp>

#include <ostream>

class DtSubCommandManager;
class DtConsoleCommandOwner;
class DtConsoleCommandManager;

namespace MAKVRinTerra
{
   class DtSharedMemoryFeaturesDebugDrawer;

   template <typename FS>
   class DtPagingFeatureSet;

   class DT_DLL_features DtFeaturesDebugger
      : public boost::enable_shared_from_this<DtFeaturesDebugger>
      , public DtSubCommandManager
   {
   public:
      typedef boost::shared_ptr<DtFeaturesDebugger> Ptr;

      DtFeaturesDebugger(const std::string& name, DtConsoleCommandManager* manager = 0);

      virtual ~DtFeaturesDebugger();


      DtFeaturesDebugger& operator[](const std::string& key);
      const DtFeaturesDebugger& operator[](const std::string& key) const;

      virtual bool executeCommands(const std::string&);

      class DT_DLL_features Record
      {
      public:
         friend class DtFeaturesDebugger;

         typedef boost::shared_ptr<Record> Ptr;

         typedef std::vector<std::string>        CommandSequence;
         typedef CommandSequence::const_iterator CommandIterator;

         explicit Record(DtFeatureSet*, bool enable=true);

         virtual ~Record();

         virtual const DtFeatureSet& featureSet() const;
         virtual std::string name() const;

         virtual CommandIterator executeCommand(
            CommandIterator, CommandIterator, std::ostream&);
         virtual bool executeCommand(const std::string&, std::ostream&);

         virtual void executeListCommand(std::ostream&);

         virtual CommandIterator executeInfoCommand(
            CommandIterator, CommandIterator, std::ostream&);
         virtual void executeInfoCommand(std::ostream&);
         virtual bool executeInfoCommand(const std::string&, std::ostream&);

         virtual CommandIterator executeDrawCommand(
            CommandIterator, CommandIterator, std::ostream&);
         virtual bool executeDrawCommand(const std::string&, std::ostream&);

         virtual void clear();

         virtual Record& setDrawing(bool enable);

         Record& command(const std::string&);
         Record& command(const std::string&, std::ostream&);
         Record& drawCommand(const std::string&);
         Record& drawCommand(const std::string&, std::ostream&);

         virtual Record& addDrawingFeatureSet(
            DtFeatureSet*,
            const std::string& name,
            bool enable = false);

         template <typename F>
         Record& addDrawingFeatureSet(
            DtFeatureSetTemplate<F>* fs,
            const std::string& name,
            bool enable = false)
         {
            return addDrawingFeatureSet(DtFeatureSet::Wrap(fs), name, enable);
         }

         virtual Record& setMemoryType(DtDebugDrawerNameManager::MemoryType);

      protected:
         struct DrawingSet
         {
            explicit DrawingSet(DtFeatureSet* fs, bool enable);

            boost::scoped_ptr<DtFeatureSet> featureSet;
            bool enable;
         };

         typedef tbb::recursive_mutex Mutex;
         mutable Mutex mutex;

         boost::scoped_ptr<DtFeatureSet> myFeatureSet;

         typedef boost::ptr_multimap<const std::string, DrawingSet> FeatureSetMap;
         FeatureSetMap myFeatureMap;

         boost::shared_ptr<DtSharedMemoryFeaturesDebugDrawer> drawer;
         DtDebugDrawerNameManager::MemoryType myMemoryType;

      private:
         int myListIndex;
      };

      virtual Record::Ptr add(Record*);

      template <typename F>
      Record& add(DtFeatureSetTemplate<F>* fs, bool enable = true)
      {
         return *add(new Record(DtFeatureSet::Wrap(fs), enable));
      }

      bool runCommand(DtString);

      DtString helpText(const DtString&) const;

   protected:
      typedef std::vector<Record::Ptr> RecordVector;

      virtual RecordVector getMatchingRecords(
         Record::CommandIterator& i, Record::CommandIterator end) const;

      typedef tbb::queuing_rw_mutex Mutex;
      mutable Mutex myMutex;

      RecordVector myFeatureSets;
      DtConsoleCommandOwner myCommandOwner;

      typedef std::map<std::string, Ptr> SubDebuggers;
      SubDebuggers mySubDebuggers;
   };
}