GraphTreeObject.h

Go to the documentation of this file.

/******************************************************************************
* 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.
******************************************************************************/
/*
Graph tree header file
 
Author: Alex Reynolds
*/
#ifndef DATA_MANAGEMENT_GRAPH_TREE_H
#define DATA_MANAGEMENT_GRAPH_TREE_H
 
#include "configuration.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <array>
#if CLOCKWERK_ALLOW_VECTOR
#include <vector>
#endif
#if CLOCKWERK_ALLOW_STD_STRING
#include <string>
#endif
 
#include "core/clockwerkerrors.h"
 
#define DELIMETER "."
#define DEFAULT_NAME ""
 
namespace clockwerk {

    enum graph_tree_types_e : int8 {
        BASE_GRAPH_TREE = 0,
        DATAIO = 1,
        TASK = 2,
        EXECUTIVE = 3,
        FRAME = 4,
        BODY = 5,
        NODE = 6
    };

    class GraphTreeObject {
    public:
        GraphTreeObject(const char* gt_nme = "", GraphTreeObject** storage_array=nullptr, uint32 storage_size=0);

        virtual ~GraphTreeObject() {}

        GraphTreeObject* parent() {return _parent;}
        GraphTreeObject** children() {return _children_ptr;}
        GraphTreeObject* childAtIndex(uint8 i) const {return (_children_ptr && i < _max_num_children) ? _children_ptr[i] : nullptr;}

        int16 parent(GraphTreeObject* new_parent);

        int16 parent(GraphTreeObject& new_parent);

        uint8 nChildren() const {return _num_children;}
        uint16 nDescendants() const {return _num_descendants;}
        uint8 capacity() const { return _max_num_children; }

        const char* name() const {return _name;}
        int16 name(const char* new_name);

        uint8 rank() {return _rank;}

        int8 type() {return _graph_tree_type;}

        bool loggable() {return _loggable;}

        GraphTreeObject* getRootDataPointer();

        virtual int16 str(char* output, size_t size) const {return ERROR_BUFFER_NOT_IMPLEMENTED;}

        virtual int16 fromStr(const char* val) {return ERROR_CANNOT_CONVERT_STRING;}

#if CLOCKWERK_ALLOW_STD_STRING
        std::string address();
 
#if CLOCKWERK_ALLOW_VECTOR
        std::vector<std::string> search(const std::string &address);

        GraphTreeObject* getByAddress(const std::string &address);

        virtual int16 header(void* logger) {return WARN_NOT_LOGGABLE;}
 
        virtual std::vector<std::string> header_info() const {return std::vector<std::string>();}

        virtual int16 log(void* logger) {return WARN_NOT_LOGGABLE;}
#endif
#endif
 
#if CLOCKWERK_ALLOW_VECTOR
        void findLoggable(std::vector<GraphTreeObject*> &matches);
#endif
    protected:
        int16 _setStorage(GraphTreeObject** storage_array, uint8 storage_size);

        void _recalculateDescendants();

        void _recalculateRank();

#if CLOCKWERK_ALLOW_VECTOR
#if CLOCKWERK_ALLOW_STD_STRING
        std::vector<std::string> _decomposeAddress(std::string address);

        void _findMatches(const std::vector<std::string> &subaddresses, uint32 num_subaddresses,
                          uint32 index, bool match_found, std::vector<GraphTreeObject*> &matches);

        std::vector<GraphTreeObject*> _searchNodes(const std::string &address);
#endif
#endif

        int16 _addChild(GraphTreeObject* child);

        int16 _removeChild(GraphTreeObject* child);

        GraphTreeObject* _parent = nullptr;

        GraphTreeObject** _children_ptr = nullptr;      // Pointer to children array
        uint32 _max_num_children = 0;                   // Max number of allowable children

        uint16 _num_descendants = 0;

        char _name[MAXIMUM_NAME_CHARS] = "";

        uint8 _num_children = 0;

        uint8 _rank = 0;

        int8 _graph_tree_type = BASE_GRAPH_TREE;
        
        bool _loggable = false;

        uint32 _index = 0;
    };
 
}
 
#endif