rollUpManager.h

Go to the documentation of this file.

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


#pragma once

#include "simulationObjectEditorImpl/simulationObjectEditorImplDefines.h"
#include "vrfutil/rwKeywordValuePairsReader.h"
#include <vrfutil/assembliesReaderWriter.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrfExtProtocol/objectType.h>

#include <boost/function.hpp>
#include <set>

class DtFilename;
class DtRwPropertiesMap;
class DtReaderWriter;
class DtComponentSystemDefinition;

namespace makVrv
{
   class DtDe;
}

class DT_DLL_simulationObjectEditorimpl DtRollUpManager : public makVrv::DtVirtualBaseClass
{
public:

   DtRollUpManager(makVrv::DtDe&);

   virtual ~DtRollUpManager();

   virtual bool loadDataFiles(const DtFilename&);

   virtual bool loadAdditionalDataFiles(const DtFilename&);

   static DtRollUpManager& instance(makVrv::DtDe&);

   static void registerInstance(makVrv::DtDe&, DtRollUpManager*);

   virtual std::map<std::string, std::string> ammunition() const;
   virtual std::map<std::string, std::string> equipment() const;
   virtual std::map<std::string, std::string> variables() const;
   virtual std::map<std::string, std::string> weapons() const;
   virtual std::map<std::string, std::string> assemblies() const;

   virtual std::map<std::string, std::string> combinedAmmunition() const;
   virtual std::map<std::string, std::string> combinedEquipment() const;
   virtual std::map<std::string, std::string> combinedWeapons() const;
   virtual std::map<std::string, std::string> combinedAssemblies() const;
   virtual std::map<std::string, std::string> combinedVariables() const;

   virtual DtAssembliesReaderWriter::RootNodeContainer combinedAssembliesRootNodes() const;

   virtual DtAssembliesReaderWriter::RootNodeContainer combinedAmmunitionNodes() const;
   virtual DtAssembliesReaderWriter::RootNodeContainer combinedEquipmentNodes() const;
   virtual DtAssembliesReaderWriter::RootNodeContainer combinedWeaponsNodes() const;

   const DtAssembliesReaderWriter& assembliesReaderWriter() const
   {
      return myAssembliesReaderWriter;
   }

   DtAssembliesReaderWriter& assembliesReaderWriter()
   {
      return myAssembliesReaderWriter;
   }

   DtRollUpManager* additionalData()
   {
      return myAdditionalData;
   }

   const DtRollUpManager* additionalData() const
   {
      return myAdditionalData;
   }

   const DtRwKeywordValuePairsReader& keywordValuePairs() const
   {
      return myKeywordValuePairsReaderWriter;
   }

   typedef boost::function<void (const DtRwPropertiesMap*, const DtObjectType&, const DtAssembliesReaderWriter::RwRootNode&,
      const std::set<DtString>& validElements)> RollUpFunction;

   virtual void rollUpAndReselect(std::vector<DtObjectType>);

   virtual void rollUp(std::vector<DtObjectType>, bool reselect = false);

   virtual void rollUp(const DtObjectType&);

   virtual std::set<DtString> resetRollUpVariables(const DtObjectType&, const DtRwPropertiesMap* assemblies, const DtAssembliesReaderWriter::RwRootNode* = 0);

   virtual void resetRollUpVariables(const DtObjectType&, const DtAssembliesReaderWriter::RwRootNode&, std::set<DtString>&, const DtAssembliesReaderWriter::RwRootNode* = 0);

   virtual void resetRollUpVariable(const DtObjectType&, const std::string&, std::set<DtString>&, const DtAssembliesReaderWriter::RwRootNode* = 0);

   virtual void addMappedElementsFromAssembly(const DtObjectType&, DtRwPropertiesMap*, int, const DtAssembliesReaderWriter::RwRootNode&);

   virtual void addSystemsFromAssembly(const DtObjectType&, int, const DtAssembliesReaderWriter::RwRootNode&);
   virtual void addSystem(const DtObjectType&, const DtFilename& systemFilename,
      const DtComponentSystemDefinition*, int, const DtAssembliesReaderWriter::RwRootNode&);

   virtual void addRollUpFunction(const std::string& function, RollUpFunction);

   virtual const std::set<DtString>& availableVariables();

   virtual const std::set<DtString>& availableSystems();

   virtual void resetSystems(const DtObjectType&);

   virtual void rollUpAll();

   virtual bool hasRollUpItems() const;

   virtual void clear();

   virtual void combinedRollUpRules(DtAssembliesReaderWriter::RwRootNode&) const;

   virtual DtAssembliesReaderWriter::RwRootNode* rootNodeFor(const std::string&) const;
   virtual DtAssembliesReaderWriter::RwRootNode* rootNodeFor(const std::string& type, const std::string&) const;
   virtual DtAssembliesReaderWriter::RwRootNode* rootNodeFor(const DtAssembliesReaderWriter&, const std::string& type, const std::string&) const;
   virtual DtAssembliesReaderWriter::RwRootNode* assemblyNodeFor(const std::string&) const;

protected:
   virtual void collect(const DtRwPropertiesMap*, const DtObjectType&, const DtAssembliesReaderWriter::RwRootNode& itemsToCollect,
      const std::set<DtString>& validElements);

   typedef boost::function<void (double, double, DtReaderWriter*)> CollectionFunction;

   virtual void sum(double count, double value, DtReaderWriter*);
   virtual void sumFunction(const DtRwPropertiesMap*, const DtObjectType&, const DtAssembliesReaderWriter::RwRootNode& itemsToSum,
      const std::set<DtString>& validElements);

   virtual void minimum(double count, double value, DtReaderWriter*);
   virtual void minimumFunction(const DtRwPropertiesMap*, const DtObjectType&, const DtAssembliesReaderWriter::RwRootNode& itemsToSum,
      const std::set<DtString>& validElements);

   virtual void maximum(double count, double value, DtReaderWriter*);
   virtual void maximumFunction(const DtRwPropertiesMap*, const DtObjectType&, const DtAssembliesReaderWriter::RwRootNode& itemsToSum,
      const std::set<DtString>& validElements);
   virtual void ignoreFunction(const DtRwPropertiesMap*, const DtObjectType&, const DtAssembliesReaderWriter::RwRootNode& itemsToSum,
      const std::set<DtString>& validElements);

   virtual void averageFunction(const DtRwPropertiesMap*, const DtObjectType&, const DtAssembliesReaderWriter::RwRootNode& itemsToSum,
      const std::set<DtString>& validElements);
   virtual void calculateAverage(const DtRwPropertiesMap*, const DtObjectType&,
      const std::string& propertyToAverage, const DtAssembliesReaderWriter::RwRootNode& itemsToSum, const std::set<DtString>& validElements);

   virtual void singleValueRollUp(const DtRwPropertiesMap*, const DtObjectType&, const DtAssembliesReaderWriter::RwRootNode&, 
      const std::set<DtString>& validElements, CollectionFunction func);

   virtual void extractVariables(DtReaderWriter*, std::set<DtString>& vars) const;

   virtual std::string valueForVariable(const DtAssembliesReaderWriter::RwRootNode& variables, const std::string& keyword) const;

   virtual std::map<std::string, std::string> combine(const std::map<std::string, std::string>& base,
      const std::map<std::string, std::string>& takeFrom) const;

   virtual bool ignoreVariable(DtReaderWriter*, const DtAssembliesReaderWriter::RwRootNode*) const;

private:
   DtRollUpManager(const DtRollUpManager&);
   DtRollUpManager& operator=(const DtRollUpManager&);

protected:
   makVrv::DtDe& myDe;
   DtAssembliesReaderWriter myAssembliesReaderWriter;

   typedef std::map<std::string, RollUpFunction> RollUpFunctions;
   RollUpFunctions myRollUpFunctions;

   bool myNeedsAvailableVariablesCheck;
   std::set<DtString> myAvailableVariables;
   std::set<DtString> myAvailableSystems;

   DtRollUpManager* myAdditionalData;
   DtRwKeywordValuePairsReader myKeywordValuePairsReaderWriter;
};