tec_json.hpp

Go to the documentation of this file.

// Time-stamp: <Last changed 2026-02-20 15:58:13 by magnolia>
/*----------------------------------------------------------------------
------------------------------------------------------------------------
Copyright (c) 2020-2026 The Emacs Cat (https://github.com/olddeuteronomy/tec).
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
------------------------------------------------------------------------
----------------------------------------------------------------------*/
#pragma once
 
#include <string>
#include <sstream>
 
#include "tec/tec_def.hpp" // IWYU pragma: keep
#include "tec/tec_memfile.hpp"
#include "tec/tec_container.hpp"
#include "tec/tec_serialize.hpp"
#include "tec/tec_base64.hpp"
 
 
namespace tec {
 
struct Json {
 
    static constexpr char sep[]{", "};
 
    static constexpr char infix[]{": "};
 
    inline static void print_name(std::ostringstream& os, const char* name) {
        if (name) {
            os << "\"" << name << "\"" << infix;
        }
    }
 
    static std::string json(const std::string& val, const char* name = nullptr) {
        std::ostringstream os;
        print_name(os, name);
        os <<  "\"" << val << "\"";
        return os.str();
    }
 
    static std::string json(const Blob& val, const char* name = nullptr) {
        std::ostringstream os;
        print_name(os, name);
        os << "\"" << base64::encode(val.str()) << "\"";
        return os.str();
    }
 
    static std::string json_bool(const bool& val, const char* name = nullptr) {
        constexpr static char t[]{"true"};
        constexpr static char f[]{"false"};
        std::ostringstream os;
        print_name(os, name);
        os << (val ? t : f);
        return os.str();
    }
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     *                        Containers
     *
     *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    template <typename TContainer>
    static std::string json_container(const TContainer& c, const char* name) {
        std::ostringstream os;
        print_name(os, name);
        bool first{true};
        os << "[";
        for( const auto& e: c ) {
            if(first) {
                os << e;
                first = false;
            }
            else {
                os << sep << e;
            }
        }
        os << "]";
        return os.str();
    }
 
    template <typename TMap>
    static std::string json_map(const TMap& m, const char* name) {
        std::ostringstream os;
        print_name(os, name);
        bool first{true};
        os << "{";
        for (const auto& [k, v]: m) {
            if(first) {
                os << k << infix << v;
                first = false;
            }
            else {
                os << sep << k << infix << v;
 
            }
        }
        os << "}";
        return os.str();
    }
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     *                      Serializable object
     *
     *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    template <typename TObject>
    static std::string json_object(const TObject& obj, const char* name) {
        std::ostringstream os;
        print_name(os, name);
        os << "{" << obj.to_json() << "}";
        return os.str();
    }
 
    /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     *                        Generic fallback
     *
     *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
    template <typename T>
    static std::string json(const T& val, const char* name) {
        std::ostringstream os;
        if constexpr (is_serializable_v<T>) {
            return json_object(val, name);
        }
        else if constexpr (is_map_v<T>) {
            return json_map(val, name);
        }
        else if constexpr (is_container_v<T>) {
            return json_container(val, name);
        }
        else if constexpr (std::is_same_v<T, bool>) {
            return json_bool(val, name);
        }
        else {
            // Any scalar
            print_name(os, name);
            os << val;
        }
        return os.str();
    }
 
 
    template <typename T>
    std::string operator()(const T& val, const char* name) {
        return json(val, name);
    }
 
    template <typename T>
    std::string operator()(const T& val) {
        return json(val, nullptr);
    }
};
 
} // namespace tec
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*                              USAGE
*
 
struct Person: tec::Serializable {
    using json = tec::Json;
    static constexpr auto sep{tec::Json::sep};
 
    short age;
    std::string name;
    std::string surname;
 
    friend std::ostream& operator << (std::ostream& os, const Person& p) {
        os << json{}(p);
        return os;
    }
 
    std::string to_json() const override {
        std::ostringstream os;
        os
            << json{}(age, "age") << sep
            << json{}(name, "name") << sep
            << json{}(surname, "surname")
            ;
        return os.str();
    }
};
 
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/