JsonCdl.hpp

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX INC 2026. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX INC. 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 INC.
******************************************************************************/
#ifndef LOGGING_JSON_CDL_H
#define LOGGING_JSON_CDL_H
 
#include "types.h"
#include "core/clockwerkerrors.h"
#include "utils/json.h"
#include "utils/stringutils.hpp"
#include "core/CartesianVector.hpp"
#include "dynamics/Quaternion.h"
 
namespace clockwerk {

enum cdl_types_e : uint8 {
    INT32_TP,           
    FPOINT_TP,          
    CARTESIANVECTOR3_TP,
    QUATERNION_TP       
};

template <uint32 NUM_CDLS, uint32 MAX_JSON_KEY_LEN, uint32 MAX_JSON_FIELD_LEN>
class JsonCdl {
public:    
    JsonCdl() {}
    ~JsonCdl() {}

    int16 registerCdl(const char* name, cdl_types_e cdl_type, uint8 cdl_size, void* data_ptr);

    int16 parseCdlFile(const char* file_data, uint32 file_len);
 
    // Counting statistics for CDLs
    uint32 num_loaded_correct = 0;
    uint32 num_missing = 0;
    uint32 num_errors = 0;
    uint32 num_failed_registries = 0;
 
protected:
    struct _cdl_info_t {
        char key[MAX_JSON_KEY_LEN];     
        cdl_types_e type;               
        uint8 size;                     
        void* ptr;                      
    };

    int16 _loadSingleCdl(const _cdl_info_t* cdl_info_ptr, const char* file_data, jsmntok_t* json_ptr, uint8 num_tok);
 
    // Internal tracking variables and arrays
    uint32 _storage_index = 0;
    _cdl_info_t _cdls[NUM_CDLS];                
};
 
template <uint32 NUM_CDLS, uint32 MAX_JSON_KEY_LEN, uint32 MAX_JSON_FIELD_LEN>
int16 JsonCdl<NUM_CDLS, MAX_JSON_KEY_LEN, MAX_JSON_FIELD_LEN>::registerCdl(const char* name, cdl_types_e cdl_type, uint8 cdl_size, void* data_ptr) {
    // If we're full, return error
    if(_storage_index == NUM_CDLS) {
        num_failed_registries++;
        return ERROR_QUEUE_FULL;
    }
    if(name == nullptr || data_ptr == nullptr) {
        num_failed_registries++;
        return ERROR_NULLPTR;
    }
    if(cdl_size <= 0) {
        num_failed_registries++;
        return ERROR_DIMENSIONS;
    }
 
    // Otherwise add CDL and return
    strcpy(_cdls[_storage_index].key, name);
    _cdls[_storage_index].type = cdl_type;
    _cdls[_storage_index].size = cdl_size;
    _cdls[_storage_index].ptr = data_ptr;
    _storage_index++;
 
    return NO_ERROR;
}
 
template <uint32 NUM_CDLS, uint32 MAX_JSON_KEY_LEN, uint32 MAX_JSON_FIELD_LEN>
int16 JsonCdl<NUM_CDLS, MAX_JSON_KEY_LEN, MAX_JSON_FIELD_LEN>::parseCdlFile(const char* file_data, uint32 file_len) {
    // Verify we have valid file data
    if(file_data == nullptr) {
        return ERROR_NULLPTR;
    }
 
    // Init our json object and parse into tokens
    jsmn_parser parser;
    jsmntok_t tokens[2*NUM_CDLS + 1];
    jsmn_init(&parser);
    int32 num_tokens = jsmn_parse(&parser, file_data, file_len, tokens, 2*NUM_CDLS + 1);
    if (num_tokens < 1) {
        return ERROR_INVALID_RANGE;
    }
 
    // Now loop through CDL parameters and load
    for(uint32 i = 0; i < _storage_index; i++) {
        _loadSingleCdl(&_cdls[i], file_data, tokens, num_tokens);
    }
 
    return NO_ERROR;
}
 
template <uint32 NUM_CDLS, uint32 MAX_JSON_KEY_LEN, uint32 MAX_JSON_FIELD_LEN>
int16 JsonCdl<NUM_CDLS, MAX_JSON_KEY_LEN, MAX_JSON_FIELD_LEN>::_loadSingleCdl(const _cdl_info_t* cdl_info_ptr, const char* file_data, jsmntok_t* json_ptr, uint8 num_tok) {
    if(cdl_info_ptr == nullptr || file_data == nullptr || json_ptr == nullptr) {
        return ERROR_NULLPTR;
    }
 
    // Loop through tokens starting from i=1 (index 0 is all json info) and stepping
    // in increments of 2 because tokens are key/value/key/value/key/value/...
    uint32 val_len = 0;
    uint32 key_len;
    jsmntok_t val;
    char value[MAX_JSON_FIELD_LEN];
    bool found = false;
    for(int32 i = 1; i < num_tok; i+=2) {
        if(json_ptr[i].type == JSMN_STRING) {
            key_len = json_ptr[i].end - json_ptr[i].start;
            const char* key = file_data + json_ptr[i].start;
            val = json_ptr[i + 1];
            val_len = val.end - val.start;
            if(val_len > MAX_JSON_FIELD_LEN) {
                return ERROR_DIMENSIONS;
            }
            snprintf(value, sizeof(value), "%.*s", val_len, file_data + val.start); // Note null terminator automatic
 
            if(key_len == strlen(cdl_info_ptr->key) && strncmp(cdl_info_ptr->key, key, key_len) == 0) {
                found = true;
                if(cdl_info_ptr->type == cdl_types_e::INT32_TP) {
                    // Write as if we have an array no matter what -- doesn't matter
                    int32* write_ptr = static_cast<int32*>(cdl_info_ptr->ptr);
                    int16 err = clockwerk::setArrayFromString(value, write_ptr, cdl_info_ptr->size);
                    if(err > 0) {
                        num_errors++;
                    } else {
                        num_loaded_correct++;
                    }
                    break;
 
                } else if(cdl_info_ptr->type == cdl_types_e::FPOINT_TP) {
                    // Write as if we have an array no matter what -- doesn't matter
                    floating_point* write_ptr = static_cast<floating_point*>(cdl_info_ptr->ptr);
                    int16 err = clockwerk::setArrayFromString(value, write_ptr, cdl_info_ptr->size);
                    if(err > 0) {
                        num_errors++;
                    } else {
                        num_loaded_correct++;
                    }
                    break;
 
                } else if(cdl_info_ptr->type == cdl_types_e::CARTESIANVECTOR3_TP) {
                    clockwerk::CartesianVector<3>* converted_ptr = static_cast<clockwerk::CartesianVector<3>*>(cdl_info_ptr->ptr);
 
                    int16 err = converted_ptr->fromStr(value);
                    if(err) {
                        num_errors++;
                    } else {
                        num_loaded_correct++;
                    }
                    break;
 
                } else { // Must be quaternion
                    clockwerk::Quaternion* converted_ptr = static_cast<clockwerk::Quaternion*>(cdl_info_ptr->ptr);
 
                    int16 err = converted_ptr->fromStr(value);
                    if(err) {
                        num_errors++;
                    } else {
                        num_loaded_correct++;
                    }
                    break;
                } 
            }
        }
    }
 
    if(!found) {
        num_missing++;
        return WARNING_NO_MATCH;
    }
 
    return NO_ERROR;
}
 
}
 
#endif