Project.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef PROJECT_HPP
#define PROJECT_HPP
 
#include <memory>
#include <string>
#include <vector>
 
#include <QMetaType>
#include <QObject>
#include <QString>
 
#include "ScriptDebugger.hpp"
#include "TerrainMonitor.hpp"
#include "UtCalendar.hpp"
#include "UtCallback.hpp"
#include "UtCallbackHolder.hpp"
#include "UtPath.hpp"
#include "UtReferenceTracked.hpp"
#include "UtWallClock.hpp"
#include "ViExport.hpp"
 
class UtQtXmlWriter;
class UtQtXmlReader;
 
class QAction;
class QMenu;
class UtTextDocument;
class UtTextDocumentRange;
class ViFileItem;
class WsfPProxy;
class WsfPProxyNode;
class WsfPProxyPath;
 
namespace wizard
{
class AttributeSet;
class CacheSourceProvider;
class Editor;
class ParseResults;
class ParseResultsTiny;
class ParseWorker;
class ProjectComponent;
class ProjectParseThread;
class ProjectWorkspace;
class ProxyChange;
class ProxyHash;
class RevisionStore;
class TextSource;
class TextSourceCache;
class WsfExe;
class XML_Context;

class VI_EXPORT Project : public QObject, public UtReferenceTracked
{
   Q_OBJECT
 
public:
   friend class ParseWorker;
   friend class ProjectWorkspace;
 
   typedef UtCallbackN<void()> ParseCompleteCallback;
 
   explicit Project(ProjectWorkspace* aWorkspacePtr);
   Project(const Project&) = delete;
   Project(Project&&)      = default;
   Project& operator=(const Project&) = delete;
   Project& operator=(Project&&) = default;
   ~Project() override;
 
   static Project* Instance();
 
   QString Name() const;
 
   TextSourceCache& GetSourceCache();
 
   void AddComponent(const std::string& aName, std::unique_ptr<ProjectComponent> aComponent);
 
   ProjectComponent* FindComponent(const std::string& aName);

   const UtPath& ProjectDirectory() const { return mProjectDirectory; }
   bool          SetProjectLocation(const UtPath& aProjDirPath, const UtPath& aProjFilePath);
   bool          SetProjectDirectory(const UtPath& aPath);
   bool          SetProjectFilePath(const UtPath& aPath);
   long long     GetMinimumSequenceNumber();
 
   AttributeSet* FindOptions(const WsfPProxyNode& aNode);
   AttributeSet* FindOptions(const WsfPProxyPath& aPath);
   AttributeSet* GetOptions(const WsfPProxyNode& aNode);

   std::vector<UtPath> MapSearchPath() const;
 
   RevisionStore& GetRevisionStore();

   UtCallbackListN<void(bool)> ParseUpdated;

   UtCallbackListN<void(bool)> ParseUpdatedDeferred;
 
   UtCallbackListN<void()>                MainFileListChange;
   static UtCallbackListN<void(Project*)> ProjectClosing;
   static UtCallbackListN<void(Project*)> RegisterComponents;
 
   void    GotoRange(const UtTextDocumentRange& aRange);
   Editor* GotoFile(UtTextDocument* aSourcePtr, bool aRecordLocation = false);
   Editor* GotoFile(const std::string& aFilePath, bool aRecordLocation = true);
 
   void WaitForParsing();
   void SaveAll(bool aSkipProject = true);
   void TriggerReparse();
   void InvalidateScenario(bool aInvalidateProxy = false);
   void FindIncludes(TextSource* aSourcePtr);
 
   bool SourceReloaded(TextSource* aSourcePtr);
 
   ProjectWorkspace* GetWorkspace() const { return mWorkspacePtr; }
 
   const std::string& GetMapItemsXML() const { return mMapItemsXML; }
   void               SetMapItemsXML(const std::string& aXml) { mMapItemsXML = aXml; }
 
   const std::vector<UtPath>& GetStartupFiles();
   void                       SetStartupFiles(const std::vector<UtPath>& aMainFiles);
   const std::vector<UtPath>& GetProjectDirectories() const { return mProjectDirectories; }
 
 
   bool                   AddProjectDirectory(const UtPath& aPath);
   void                   RemoveProjectDirectory(const UtPath& aPath);
   bool                   IsDirectoryInProject(const UtPath& aPath) const;
   void                   ShowSettings();
   void                   SetWorkingDirectory(const UtPath& aPath);
   WsfExe*                GetExe() const;
   void                   SetExe(WsfExe* aExePtr, bool aEmit);
   void                   SetCommandLineArgs(const QString& aArgs);
   static QString         GetDefaultCommandLineArgs();
   void                   ExeUpdated(WsfExe* aExePtr);
   void                   WaitForAllParsing();
   ParseResults*          TakeParseResults();
   bool                   IncludesFile(TextSource* aSourcePtr);
   bool                   IncludesStartupFile(TextSource* aSourcePtr);
   void                   GiveParseResults();
   void                   ProxyReady(std::unique_ptr<WsfPProxy> aProxy, std::unique_ptr<ProxyHash> aProxyHashPtr);
   void                   ExportProjectAction();
   ParseWorker*           GetParseWorker() { return mParseWorker; }
   void                   InitParseResults();
   ParseCompleteCallback* ExecuteWhenParseComplete(ParseCompleteCallback* aCallbackPtr);
   const UtPath&          WorkingDirectory() const;
   bool                   ParseIsUpToDate() const { return mParseResultsPtr != nullptr; }
   double GetLastGrammarParseTime() const noexcept { return mLastGrammarParseTime; }
   double GetLastInputParseTime() const noexcept { return mLastInputParseTime; }
   double GetLastProxyDeserializeTime() const noexcept { return mLastProxyDeserializeTime; }
   double               GetLastProxyMergeGUI_Time() const noexcept { return mLastProxyMergeGUI_Time; }
   QString              GetCommandLineArgs() const { return mCmdLineArgs; }
   ParseResults*        GetParseResults() { return mParseResultsPtr; }
   ParseResultsTiny*    TinyParseResults() { return mCurrentTinyResultsPtr; }
   ParseResults*        WaitForParseResults() const;
   void                 ToXML(XML_Context& aContext) const;
   bool                 FromXML(XML_Context& aContext);
   bool                 FromXML_StartupFile(XML_Context& aContext);
   bool                 SaveAs();
   bool                 SaveProject();
   bool                 ProjectFilePath(UtPath& aFilePath) const;
   bool                 CloseProject(bool aForce = false);
   CacheSourceProvider* SourceProvider() const { return mSourceProviderPtr; }
   WsfPProxy*           Proxy() const;
   void                 HandleProxyNodeMoved(const WsfPProxyNode&, const WsfPProxyNode&);
   void                 AddProjectDirectoryBrowse();
   void                 ShowRevisionManager();
   bool                 OpenFile(const std::string& aFilePath);
   bool                 OpenFileInTextEditor(const std::string& aFilePath);
   QString              GetCmdLineArgs() const { return mCmdLineArgs; }
   void                 OpenAction();
 
   void BuildUpContextMenu(QMenu& aMenu);
 
   void       UpdateProxyEpoch(const wizard::ProxyChange& aProxyChange);
   void       UpdateProxyEpoch();
   UtCalendar GetStartDateTime() const { return mEpoch; }
 
signals:
   void ParseUpdatedFull();
   void EventPipeRunConfigurationChanged();
   void Closed();
 
public slots:
   void ShowStartupFileDialog();
 
private:
   std::string GetXmlText() const;
   void        UndoCommand();
   void        RedoCommand();
   void        WriteStartDocument(UtQtXmlWriter& aWriter) const;
   void        WriteEndDocument(UtQtXmlWriter& aWriter) const;
   void P_CompleteGrammarParsing() noexcept;
   void P_GrammarParsingStarted() noexcept;
   void P_CompleteInputParsing() noexcept;
   void P_InputParsingStarted() noexcept;
   void P_CompleteProxyDeserialize() noexcept;
   void P_NotifyParseUpdated() noexcept;
   void P_ProxyDeserializeStarted() noexcept;
   void P_CompleteProxyMergeGUI() noexcept;
   void P_ProxyMergeGUI_Started() noexcept;
   void P_ParsingAborted() noexcept;
   void     P_CompleteAllParsing() noexcept;
   bool     RequestClose(bool aForce = false);
   QAction* GoToLocationAction(const UtTextDocumentRange& aRange);
   void     DeferUpdate(bool aFullyReparsed);
   void     FullUpdate();
   void     CleanUpFileList();
   void     Reparse();
   QString  ConstructTitle();
 
   friend class ProjectParseThread;

   UtPath              mProjectDirectory;
   std::vector<UtPath> mProjectDirectories;
   std::vector<UtPath> mStartupFiles;

   CacheSourceProvider* mSourceProviderPtr;
   ProjectWorkspace*    mWorkspacePtr;
   UtCallbackHolder     mUtCallbacks;

   bool mQuitting;
 
   UtPath      mProjectFilePath;
   std::string mLoadedXML;
   // This holds the XML configuration of the map related items
   // This is updated when the map window is closed because those
   // visual items are destroyed at that time.  Opening the map window
   // requires re-parsing this XML data
   std::string mMapItemsXML;
 
   UtCallbackListN<void()>       OneTimeParseComplete;
   UtPath                        mWorkingDirectory;
   std::string                   mExePath;
   QString                       mCmdLineArgs;
   std::unique_ptr<AttributeSet> mProxyAttributesRoot;
   RevisionStore*                mRevisionStore;
 
   using ComponentMap = std::map<std::string, std::unique_ptr<ProjectComponent>>;
   ComponentMap mComponents;

   // Parse results management --
   //    Because the parsing is done in another thread, and in multiple phases,
   //    managing the parse results isn't as simple as copying the results.
   //
   //    When parsing begins, a limited set of data is available for access,
   //     called the Tiny parse results.  When the parse phase is complete,
   //     the full parse results structure is available.
   //    The proxy data is computed in a subsequent parse phase, and
   //    added to the parse results when that phase is complete.

   ParseResults* mParseResultsPtr;

   ParseResults* mParseResultsPrivatePtr;

   ParseResultsTiny* mParseResultsTinyPtr;
 
   // Points to the latest 'tiny' parse results
   ParseResultsTiny* mCurrentTinyResultsPtr;
 
   ParseWorker* mParseWorker;
   volatile bool mParsingAllComplete;
 
   std::unique_ptr<TerrainMonitor> mTerrainMonitor{nullptr};
 
   bool       mEpochListenerSetup{false};
   UtCalendar mEpoch;

   double mLastGrammarParseTime{0.0};
   bool mGrammarParsingComplete{false};
   double mLastInputParseTime{0.0};
   bool mInputParsingComplete{false};
   bool mProxyDeserializeComplete{false};
   double mLastProxyDeserializeTime{0.0};
   bool mProxyMergeGUI_Complete{false};
   double mLastProxyMergeGUI_Time{0.0};
   UtWallClock mParseTimer;
};
} // namespace wizard
 
Q_DECLARE_METATYPE(wizard::Project*)
 
#endif