code_twain/sane/gb_json.h

#pragma once

#if defined(WIN32) || defined(_WIN64)
#include <Windows.h>
#endif

// #include "cJSON.h"
#include "../../code_device/hgsane/cJSON.h"
#include <vector>
#include <string>
#include <map>

namespace gb
{
    class refer
    {
        volatile long ref_;

    protected:
        refer();
        virtual ~refer();

    public:
        long add_ref(void);
        long release(void);
    };


    class json : public refer
    {
        cJSON	*obj_;
        cJSON   *cur_child_;
        cJSON   walk_head_;
        bool    is_array_;

        cJSON* find_sibling(cJSON* first, const char* name, cJSON*** addr);
        cJSON* find_child(cJSON *parent, std::vector<std::string>& path, bool create, cJSON*** addr = NULL);
        cJSON* find(const char* path, bool create = false, cJSON*** addr = NULL);

    protected:
        ~json();

    public:
        json(char* json_txt = 0);

        static std::string to_string(cJSON* root, bool formatted);
        static std::string get_value_as_string(cJSON* root, bool integer = false);
        static void free_node_data(cJSON* node);
        static cJSON* create_element(bool is_array = false);
        static cJSON* create_element_with_name(const char* name);

    public:
        bool attach_text(char* json_txt);
        bool attach_cjson(cJSON* cjson);
        bool create_empty(bool array = false);
        void clear(void);
        std::string to_string(bool formatted);

        // can be path: child/value ...
        bool get_value(const char* key, bool& val);
        bool get_value(const char* key, int& val);
        bool get_value(const char* key, double& val);
        bool get_value(const char* key, std::string& val);
        bool get_value(const char* key, json*& val);		// caller shoud call "delete" to free the returned object !!!
        bool get_value_as_string(const char* key, std::string& val, bool integer);
        bool get_as_array(const char* key, std::vector<std::string>& val);

        bool first_child(std::string& val, std::string* name = NULL);
        bool next_child(std::string& val, std::string* name = NULL);

        bool set_value(const char* key, bool val);
        bool set_value(const char* key, int val);
        bool set_value(const char* key, double val);
        bool set_value(const char* key, std::string val);
        bool set_value(const char* key, const char* val);
        bool set_value(const char* key, json* obj);

        bool change_key(const char* old_key, const char* new_key);
        bool remove(const char* key);
    };

    class base64
    {
        char	base64_ind_[128];
        char	base64_char_[80];
        char    padding_char_;

        bool is_valid_base64_table(const char* table);
        bool initialize_base64_table(const char* table);

    public:
        base64();
        ~base64();

    public:
        bool set_base64_table(const char* table = NULL);
        std::string encode(const char* data, size_t bytes, unsigned int line_bytes = -1, bool need_padding = true);
        std::string decode(const char* data, size_t bytes);
    };

    class sane_config_schm : public refer
    {
        std::string     scheme_name_;
        std::wstring    file_;
        json* jsn_;
        json* bkp_;
        json* def_val_;
        bool    in_setting_;
        std::map<int, std::string>  id_name_;       // (id, default-val)

        void clear();
        std::string to_hex_letter(const char* data, size_t bytes);
        std::string from_hex_letter(const char* data, size_t bytes);
        std::string default_value(const char* name);

    protected:
        ~sane_config_schm();

    public:
        sane_config_schm();

        static std::string opt_data_appendix_;
        static bool hex(unsigned char ch, unsigned char* val);
        static bool hex_char(const char* data, unsigned char* val);
        static bool is_option_data(std::string& name);  // reset baase option name into 'name' if name was option data, and return true

    public:
        bool load_from_file(const wchar_t* file);
        bool load_from_mem(const char* mem);
        bool save_to(const wchar_t* file);
        void set_default_value(int sn, const char* name, const char* val, size_t bytes);
        bool first_config(std::string& name, std::string& val);
        bool next_config(std::string& name, std::string& val);
        void begin_setting(bool restore = false);
        void config_changed(const char* name, const char* val, size_t bytes, bool extra = false);
        void config_changed(int sn, const char* val, size_t bytes, bool extra = false);
        void remove_config(const char* name);
        void end_setting(bool cancel);
        int id_from_name(const char* name);
        std::string to_text_stream(void);
        std::string get_version(void);
        std::string get_scheme_name(void);
        void set_scheme_name(const char* name);
        void update(bool(__stdcall* is_float)(int, void*), void* param, const char*(__stdcall* t2n)(const char*), std::string* discard = NULL);
    };
}