ConfigurationWriter.h

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, LLC.
******************************************************************************/
#ifndef CPP_APP_CONFIGURATION_WRITER_H
#define CPP_APP_CONFIGURATION_WRITER_H
 
#include "utils/AutoDoc.h"
#include "ImNode.h"
#include "Connection.h"
 
namespace modelspace {
    /** @brief Write out script from UX to execute using set toolchain. Base class for override. */
    class ConfigurationWriter {
    public:
        ConfigurationWriter() {}
        virtual ~ConfigurationWriter() {}
 
        /// @brief  Set the file for write and redirect
        ///         output to that file
        /// @param filename The filename to write to
        /// @return 0 on success, 1 on failure
        /// @note   Calling this function will cause the ConfigurationWriter class
        ///         to begin writing its data to the provided file
        void file(const std::string &filename) {_filename = filename;}
        std::string file() {return _filename;}
 
        /// @brief Add a node to the ConfigurationWriter for tracking
        /// @param target The node to add to tracking
        /// @note Will ignore node if its unique ID is already tracked
        void watchNode(ImNode* target);
 
        /// @brief Remove a node from the ConfigurationWriter for tracking
        /// @param target The node to remove from tracking
        /// @note Will ignore node if its unique ID is not tracked
        void unwatchNode(ImNode* target);
 
        /// @brief Write watched node data to file
        void write();
    protected:
        /// @brief Set the sequence of nodes for creation and write paired connections
        virtual void _setNodeConnectionSequence() {}
 
        /// @brief Decompose all relevant strings from the provided node and connection information
        virtual void _decomposeNodeInformation() {}
 
        /// @brief Write the start of the file
        virtual void _writeOutputStart() {}
 
        /// @brief Write the creation of a single node, given by node
        /// @param node The node to write to file
        virtual void _writeDataValue(ImNode* node) {}
 
        /// @brief Write the connection of one "Connection" to another
        /// @param upstream The data output connection (typically, but not always an output) to connect
        /// @param downstream The data input connection (typically, but not always an input) to connect
        virtual void _writeDataConnection(Connection* upstream, Connection* downstream) {}
 
        /// @brief Write all logged data to file
        virtual void _writeLogData() {}
 
        /// @brief Write the end of the file output
        virtual void _writeOutputEnd() {}
 
        // Autodoc framework, which we repurpose here for writing to file
        AutoDoc* _autodoc_ptr;
 
        // Vector in which to store watched nodes
        std::vector<ImNode*> _watched_nodes;
 
        // Vector in which to store sequenced nodes
        std::vector<ImNode*> _sequenced_nodes;
 
        // Vector of sequenced connections
        std::vector<std::pair<Connection*, Connection*>> _paired_connections;
 
        // String to record our filename
        std::string _filename = "gui_config_file.py";
    };
}
 
#endif