ConfigurationTree.h

#ifndef _ots_ConfigurationTree_h_
#define _ots_ConfigurationTree_h_
 
#include "otsdaq/TableCore/TableView.h"
 
namespace ots
{
class ConfigurationManager;
class TableBase;
 
template<typename T>
struct identity
{
    typedef T type;
};
 
class ConfigurationTree
{
    friend class ConfigurationGUISupervisor;
    friend class Iterator;
    friend class ARTDAQTableBase;
 
    // clang-format off
  public:
    ConfigurationTree();
    ConfigurationTree(const ConfigurationManager* const& configMgr,
                      const TableBase* const&            table);
    ~ConfigurationTree(void);
 
    ConfigurationTree(ConfigurationTree const& a) = default;
 
    ConfigurationTree& operator=(const ConfigurationTree& a)
    {
        __COUT__ << "OPERATOR= COPY CONSTRUCTOR ConfigManager: " << configMgr_
                 << " configuration: " << table_ << std::endl;
        // Note: Members of the ConfigurationTree are declared constant.
        //  (Refer to comments at top of class declaration for solutions)
        //  So this operator cannot work.. SO I am going to crash just in case it is
        // called by mistake
        __COUT__ << "OPERATOR= COPY CONSTRUCTOR CANNOT BE USED - ConfigurationTree is a "
                    "const class. SO YOUR CODE IS WRONG! You should probably instantiate "
                    "and initialize another ConfigurationTree, rather than assigning to "
                    "an existing ConfigurationTree. Crashing now."
                 << std::endl;
        __COUT__ << "OPERATOR= COPY CONSTRUCTOR CANNOT BE USED - ConfigurationTree is a "
                    "const class. SO YOUR CODE IS WRONG! You should probably instantiate "
                    "and initialize another ConfigurationTree, rather than assigning to "
                    "an existing ConfigurationTree. Crashing now."
                 << std::endl;
        __COUT__ << "OPERATOR= COPY CONSTRUCTOR CANNOT BE USED - ConfigurationTree is a "
                    "const class. SO YOUR CODE IS WRONG! You should probably instantiate "
                    "and initialize another ConfigurationTree, rather than assigning to "
                    "an existing ConfigurationTree. Crashing now."
                 << std::endl;
        __COUT__ << "OPERATOR= COPY CONSTRUCTOR CANNOT BE USED - ConfigurationTree is a "
                    "const class. SO YOUR CODE IS WRONG! You should probably instantiate "
                    "and initialize another ConfigurationTree, rather than assigning to "
                    "an existing ConfigurationTree. Crashing now."
                 << std::endl;
        __COUT__ << "OPERATOR= COPY CONSTRUCTOR CANNOT BE USED - ConfigurationTree is a "
                    "const class. SO YOUR CODE IS WRONG! You should probably instantiate "
                    "and initialize another ConfigurationTree, rather than assigning to "
                    "an existing ConfigurationTree. Crashing now."
                 << std::endl;
        __COUT__ << "OPERATOR= COPY CONSTRUCTOR CANNOT BE USED - ConfigurationTree is a "
                    "const class. SO YOUR CODE IS WRONG! You should probably instantiate "
                    "and initialize another ConfigurationTree, rather than assigning to "
                    "an existing ConfigurationTree. Crashing now."
                 << std::endl;
 
        StringMacros::stackTrace();
        exit(0);
 
        // copy to const members is not allowed.. but would look like this:
 
        configMgr_ = a.configMgr_;
        table_     = a.table_;
        // groupId_     = a.groupId_;
        // linkColName_ = a.linkColName_;
        // childLinkIndex_ = a.childLinkIndex_;
        // row_         = a.row_;
        // col_         = a.col_;
        tableView_ = a.tableView_;
        __COUT__ << "OPERATOR COPY CONSTRUCTOR" << std::endl;
        return *this;
    }; //end operator=
 
    static const std::string DISCONNECTED_VALUE;
    static const std::string VALUE_TYPE_DISCONNECTED;
    static const std::string VALUE_TYPE_NODE;
 
    static const std::string NODE_TYPE_GROUP_TABLE;
    static const std::string NODE_TYPE_TABLE;
    static const std::string NODE_TYPE_GROUP_LINK;
    static const std::string NODE_TYPE_UID_LINK;
    static const std::string NODE_TYPE_VALUE;
    static const std::string NODE_TYPE_UID;
    static const std::string NODE_TYPE_ROOT;
 
    static const std::string ROOT_NAME;
 
    template<typename T>
    struct BitMap
    {
        BitMap() : isDefault_(true), zero_(T()) {}
 
        friend ConfigurationTree;  
        const T& get(unsigned int row, unsigned int col) const
        {
            return isDefault_ ? zero_ : bitmap_[row][col];
        }
        unsigned int numberOfRows() const { return bitmap_.size(); }
        unsigned int numberOfColumns(unsigned int row) const
        {
            return bitmap_[row].size();
        }
        void print(std::ostream& out = std::cout) const;
 
      private:
        std::vector<std::vector<T>> bitmap_;
        bool                        isDefault_;  
        T                           zero_;
    };
 
    //==============================================================================
    template<class T>
    void                                        getValue                    (T& value) const;  
    void                                        getValue                    (std::string& value) const;
    template<class T>
    void                                        getValueAsBitMap            (ConfigurationTree::BitMap<T>& value) const;
    void                                        getValueAsBitMap            (ConfigurationTree::BitMap<std::string>& value) const; 
 
    //==============================================================================
    template<class T>
    T                                           getValue                    (void) const;  
    template<class T>
    T                                           getValueWithDefault         (const T& defaultValue) const;  
    std::string                                 getValue                    (void) const;
    std::string                                 getValueWithDefault         (const std::string& defaultValue) const;
    template<class T>
    ConfigurationTree::BitMap<T>                getValueAsBitMap            (void) const;
    ConfigurationTree::BitMap<std::string>      getValueAsBitMap            (void) const; 
 
  private:
    template<typename T>
    T                                           handleValidateValueForColumn(
        const TableView*                configView,
        std::string                     value,
        unsigned int                    col,
        ots::identity<T>) const;  
    std::string                                 handleValidateValueForColumn(
        const TableView*                configView,
        std::string                     value,
        unsigned int                    col,
        ots::identity<std::string>) const;
 
  public:
    ConfigurationTree                           getNode                     (const std::string& nodeName, bool doNotThrowOnBrokenUIDLinks = false) const;
    std::map<std::string, ConfigurationTree>    getNodes                    (const std::string& nodeString) const;
    ConfigurationTree                           getBackNode                 (std::string nodeName, unsigned int backSteps = 1) const;
    ConfigurationTree                           getForwardNode              (std::string  nodeName, unsigned int forwardSteps = 1) const;
 
    const ConfigurationManager*                 getConfigurationManager     (void) const { return configMgr_; }
    const std::string&                          getTableName                (void) const;
    const std::string&                          getParentTableName          (void) const;
    const std::string&                          getParentRecordName         (void) const;
    const std::string&                          getParentLinkColumnName     (void) const;
    std::string                                 getParentLinkID             (void) const;
    std::string                                 getParentLinkIndex          (void) const;
    const std::string&                          getFieldTableName           (void) const;
    const TableVersion&                         getTableVersion             (void) const;
    const time_t&                               getTableCreationTime        (void) const;
    std::vector<std::vector<std::string>>       getChildrenNamesByPriority  (bool onlyStatusTrue = false) const;
    std::vector<std::string>                    getChildrenNames            (bool byPriority = false, bool onlyStatusTrue = false) const;
    std::vector<std::vector<std::pair<
        std::string, ConfigurationTree>>>       getChildrenByPriority       (std::map<std::string /*relative-path*/,
                                                                                std::string /*value*/> filterMap    = std::map<std::string /*relative-path*/, std::string /*value*/>(),
                                                                                bool onlyStatusTrue                 = false) const;
    std::vector<std::pair<std::string,
        ConfigurationTree>>                     getChildren                 (std::map<std::string /*relative-path*/,
                                                                                std::string /*value*/> filterMap    = std::map<std::string /*relative-path*/, std::string /*value*/>(),
                                                                                bool byPriority                     = false,
                                                                                bool onlyStatusTrue                 = false) const;
    std::map<std::string, ConfigurationTree>    getChildrenMap              (std::map<std::string /*relative-path*/,
                                                                                std::string /*value*/> filterMap    = std::map<std::string /*relative-path*/, std::string /*value*/>(),
                                                                                bool onlyStatusTrue                 = false) const;
    bool                                        passFilterMap               (const std::string& childName, std::map<std::string /*relative-path*/, std::string /*value*/> filterMap) const;
    std::string                                 getEscapedValue             (void) const;
    const std::string&                          getValueAsString            (bool returnLinkTableValue = false) const;
    const std::string&                          getUIDAsString              (void) const;
    const std::string&                          getComment                  (void) const;
    bool                                        hasComment                  (void) const;
    const std::string&                          getAuthor                   (void) const;
    const std::string&                          getValueDataType            (void) const;
    const std::string&                          getValueType                (void) const;
    const std::string&                          getValueName                (void) const;
    const std::string&                          getDefaultValue             (void) const;
    inline const std::string&                   getFieldName                (void) const { return getValueName(); } 
    std::string                                 getNodeType                 (void) const;
    const unsigned int&                         getNodeRow                  (void) const;
    const std::string&                          getDisconnectedTableName    (void) const;
    const std::string&                          getDisconnectedLinkID       (void) const;
    const std::string&                          getChildLinkIndex           (void) const;
    std::vector<std::string>                    getFixedChoices             (void) const;
    std::set<std::string>                       getSetOfGroupIDs            (void) const;
 
  public:
    bool                                        isDefaultValue              (void) const;
    inline bool                                 isRootNode                  (void) const { return (!isLinkNode() && !table_); }
    inline bool                                 isTableNode                 (void) const { return (table_ && row_ == TableView::INVALID && col_ == TableView::INVALID); }
    bool                                        isValueNode                 (void) const;
    bool                                        isValueBoolType             (void) const;
    bool                                        isValueNumberDataType       (void) const;
    bool                                        isDisconnected              (void) const;
    bool                                        isLinkNode                  (void) const;
    bool                                        isGroupLinkNode             (void) const;
    bool                                        isUIDLinkNode               (void) const;
    bool                                        isGroupIDNode               (void) const;
    bool                                        isUIDNode                   (void) const;
    bool                                        isStatusNode                (void) const;
    bool                                        isEnabled                   (void) const; 
    inline bool                                 status                      (void) const { return isEnabled(); } 
 
    void                                        print                       (const unsigned int& depth = -1, std::ostream& out = std::cout) const;
    std::string                                 nodeDump                    (bool forcePrintout = false) const;  
 
    friend std::ostream&                        operator<<					(
        std::ostream& out, const ConfigurationTree& t)
    {
        out << t.getValueAsString();
        return out;
    }
 
    const TableViewColumnInfo&                  getColumnInfo               (void) const;
 
  protected:
    const unsigned int&                         getRow                      (void) const;
    const unsigned int&                         getColumn                   (void) const;
    const unsigned int&                         getFieldRow                 (void) const;
    const unsigned int&                         getFieldColumn              (void) const;
 
 
    struct RecordField
    {
        RecordField(const std::string&         table,
                    const std::string&         /*uid*/,
                    const std::string&         columnName,
                    const std::string&         relativePath,
                    const TableViewColumnInfo* columnInfo)
            : tableName_(table)
            , columnName_(columnName)
            , relativePath_(relativePath)
            , columnInfo_(columnInfo)
        {
        }
 
        std::string tableName_, columnName_, relativePath_;
        // relativePath_ is relative to record uid node, not including columnName_
 
        const TableViewColumnInfo* columnInfo_;
    };
    std::vector<ConfigurationTree::RecordField> getCommonFields             (
        const std::vector<std::string /*relative-path*/>& recordList,
        const std::vector<std::string /*relative-path*/>& fieldAcceptList,
        const std::vector<std::string /*relative-path*/>& fieldRejectList,
        unsigned int                                      depth = -1,
        bool autoSelectFilterFields                             = false) const;
    std::set<std::string /*unique-value*/>      getUniqueValuesForField     (
        const std::vector<std::string /*relative-path*/>& recordList,
        const std::string&                                fieldName,
        std::string*                                      fieldGroupIDChildLinkIndex = 0) const;
 
  private:
    ConfigurationTree(const ConfigurationManager* const& configMgr,
                      const TableBase* const&            config,
                      const std::string&                 groupId,
                      const TableBase* const&            linkParentConfig,
                      const std::string&                 linkColName,
                      const std::string&                 linkColValue,
                      const unsigned int                 linkBackRow,
                      const unsigned int                 linkBackCol,
                      const std::string&                 disconnectedTargetName,
                      const std::string&                 disconnectedLinkID,
                      const std::string&                 childLinkIndex,
                      const unsigned int                 row = TableView::INVALID,
                      const unsigned int                 col = TableView::INVALID);
 
    static ConfigurationTree                    recurse                     (const ConfigurationTree& t, const std::string& childPath, bool doNotThrowOnBrokenUIDLinks, const std::string& originalNodeString);
    ConfigurationTree                           recursiveGetNode            (const std::string& nodeName, bool doNotThrowOnBrokenUIDLinks, const std::string& originalNodeString) const;
    static void                                 recursivePrint              (const ConfigurationTree& t, unsigned int depth, std::ostream& out, std::string space);
 
    void                                        recursiveGetCommonFields    (
                                                                                std::vector<ConfigurationTree::RecordField>&      fieldCandidateList,
                                                                                std::vector<int>&                                 fieldCount,
                                                                                const std::vector<std::string /*relative-path*/>& fieldAcceptList,
                                                                                const std::vector<std::string /*relative-path*/>& fieldRejectList,
                                                                                unsigned int                                      depth,
                                                                                const std::string&                                relativePathBase,
                                                                                bool                                              inFirstRecord) const;
    ConfigurationTree                           getValueAsTreeNode          (void) const;
 
    const ConfigurationManager*             configMgr_;         
    const TableBase*                        table_;             
    const std::string                       groupId_;           
    const TableBase*                        linkParentTable_;  
    const std::string                       linkColName_;       
    const std::string                       linkColValue_;      
    const unsigned int                      linkBackRow_;       
    const unsigned int                      linkBackCol_;       
    const std::string                       disconnectedTargetName_;    
    const std::string                       disconnectedLinkID_;        
    const std::string                       childLinkIndex_;            
    const unsigned int                      row_;                       
    const unsigned int                      col_;                       
    const TableView*                        tableView_;
 
    static time_t                           LAST_NODE_DUMP_TIME;
};
 
#include "otsdaq/ConfigurationInterface/ConfigurationTree.icc"  //define template functions
 
//==============================================================================
template<typename T>
inline void ConfigurationTree::BitMap<T>::print(std::ostream& out) const
{
    if(!bitmap_.size())
    {
        out << "Bitmap print of empty bitmap.";
        return;
    }
 
    out << "Bitmap print of size " << bitmap_.size() << " x " << bitmap_[0].size() << __E__;
    out << " r x c : ";
    for(unsigned int c = 0; c < bitmap_[0].size(); ++c)
        out << std::right << std::setw(15) << c << ' ';
    out << "\n-------+-";
    for(unsigned int c = 0; c < bitmap_[0].size(); ++c)
        out << "---------------+";
    for(unsigned int r = 0; r < bitmap_.size(); ++r)
    {
        out << "\n" << std::right << std::setw(6) << r << " : ";
        if(sizeof(T) == 1) //force 8-bit to number display
            for(unsigned int c = 0; c < bitmap_[r].size(); ++c)
                out << std::right << std::setw(15) << std::fixed << std::setprecision(3) << (uint16_t)get(r,c) << ' ';
        else
            for(unsigned int c = 0; c < bitmap_[r].size(); ++c)
                out << std::right << std::setw(15) << std::fixed << std::setprecision(3) << get(r,c) << ' ';
    }
    out << "\n=======+=";
    for(unsigned int c = 0; c < bitmap_[0].size(); ++c)
        out << "===============+";
 
    out << "\n";
} //end print()
 
//==============================================================================
template<>
inline void ConfigurationTree::BitMap<std::string>::print(std::ostream& out) const
{
    if(!bitmap_.size())
    {
        out << "Bitmap print of empty bitmap.";
        return;
    }
 
    out << "Bitmap print of size " << bitmap_.size() << " x " << bitmap_[0].size() << __E__;
    out << " r x c : ";
    for(unsigned int c = 0; c < bitmap_[0].size(); ++c)
        out << std::right << std::setw(15) << c << ' ';
    out << "\n-------+-";
    for(unsigned int c = 0; c < bitmap_[0].size(); ++c)
        out << "---------------+";
    for(unsigned int r = 0; r < bitmap_.size(); ++r)
    {
        out << "\n" << std::right << std::setw(6) << r << " : ";
        for(unsigned int c = 0; c < bitmap_[r].size(); ++c)
            out << std::right << std::setw(15) << get(r,c) << ' ';
    }
    out << "\n=======+=";
    for(unsigned int c = 0; c < bitmap_[0].size(); ++c)
        out << "===============+";
 
    out << "\n";
} //end print() T=std:string
 
// clang-format on
}  // namespace ots
 
#endif