config_obj.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef CONFIG_OBJ_H
#define CONFIG_OBJ_H
 
#include <buffers.h>
#include <nbstring.h>
#include <string.h>
#include <utils.h>
#include <limits.h>
#include <float.h>
 
void ShowTree();
 
enum ConfigTestResult
{
    eUnchanged,
    eOk,
    eBad
};
 
 
 
const uint32_t fConfigValueLeaf = 0x01;    
const uint32_t fConfigReadOnly = 0x02;     
const uint32_t fConfigModified = 0x04;     
const uint32_t fConfigHidden = 0x08;       
const uint32_t fConfigNoSave = 0x10;       
const uint32_t fConfigNoObscure = 0x20;    
const uint32_t fConfigNeedReboot = 0x40;   
const uint32_t fConfigNoReload = 0x80;     
const uint32_t fConfigDetached = 0x100;     
const uint32_t fConfigIsDefault= 0x200;     
const uint32_t fMaskDoingSave  = 0x40000000;
/* Config Mask Values */
const uint32_t PermitFlashFromStorage = (0x80000000);
 
class config_leaf;
class config_obj;
class ParsedJsonDataSet;
class RootParseStateInfo;
class ConfigNotificationObject;
 
 
class notify_list
{
    volatile uint32_t bits;
   public:
    // The following functions are all guaranteed to be atomic
    void set(const notify_list & nl) volatile;
    void set(int set_num) volatile;
    void clr(int clr_num) volatile;
    notify_list() {bits=0;}
    notify_list(const notify_list &l) {bits=l.bits;}
    // The following functions return 0 if no bits are set.
    uint32_t gethigh() volatile;
    inline uint32_t get_high_and_clear() volatile {uint32_t h = gethigh(); clr(h); return h;}
    inline bool AnySet() volatile const { return (bits!=0);};
    inline uint32_t getmask()volatile {return bits; };
};
 
 
 
 
typedef void(LeafCallBack)(config_leaf *p, void *pextra);
 
/*
 * Configuration leaf class.
 * Used to manage the configuration tree, internal use only.
 */
class config_leaf
{
    // We explicitly *do not allow* copy construction, as the only likely usage
    //  would be passing to variadic functions *which will not know this is non-POD*
    config_leaf(config_leaf &rhs) = delete;
   protected:
    config_leaf *FindChild(const char *&cp);
    void RootParse(RootParseStateInfo &rpsi);
    static void FixTree(config_leaf* root);
 
 
    virtual void RemoveFromRootList();
   public:
    virtual void RawFdPrintTree(int fd, int n, bool pretty, uint32_t mask, bool braw_values,bool valonly) = 0;
 
    inline void FdPrintValTree(int fd, int n, bool pretty, uint32_t inhibit_mask = fConfigHidden, bool bRawValue = false)
    {
        RawFdPrintTree(fd,n,pretty,inhibit_mask,bRawValue,true);
    }
    inline void FdPrintTree(int fd, int n, bool pretty, uint32_t inhibit_mask = fConfigHidden, bool bRawValue = false)
    {
        RawFdPrintTree(fd,n,pretty,inhibit_mask,bRawValue,false);
    }
 
    virtual void FdPrintSchema(int fd, config_leaf *pl, int n, bool pretty, uint32_t inhibit_mask = fConfigHidden);
    void SchemaOptions(int fd, int indent, bool pretty);
    void ForEachLeaf(LeafCallBack *pc, void *pextra, bool siblings = false);
    bool FlatParseBuffer(fifo_buffer_storage &rxbuf, uint32_t permissions, const char *where);
    bool ParseBuffer(fifo_buffer_storage &rxbuf, uint32_t permissions, const char *where);
    bool ParseBlob(uint8_t *pdata, int len, uint32_t permissions);
    bool FlatParseBlob(uint8_t *pdata, int len, uint32_t permissions);
    bool ParseFd(int fd, uint32_t permissions, config_leaf * pParseRoot = NULL);
    config_obj *FindParent() { return pParent; };
    static config_leaf *FindConfigLeaf(const unsigned char *name, config_leaf *pBranch = NULL);
 
    void AddNotification(ConfigNotificationObject & noteobj);
 
 
    //Call if a config object is not static
    void FixNonStaticObject();
 
    void RemoveFromConfigTree();
 
    const char *pName;
    const char *pDescription;
    config_leaf *pNextSibling;
    config_obj *pParent;
    config_leaf *pChildren;
    config_leaf *pGList;
    notify_list  NotifyListMask;
 
 
    static config_leaf *pRootList;
    static config_leaf *pDetachList;
 
    uint32_t m_Flags;
    void DoSchemaLine(int fd, const char *name, const char *value, int indent, bool pretty, bool quoted = true);
    void DoSchemaLine(int fd, const char *name, int value, int indent, bool pretty, bool quoted = true);
    void DoSchemaLine(int fd, const char *name, double value, int indent, bool pretty, bool quoted = true);
 
   public:
    bool NameMatch(const char *cp);
    virtual const char *GetSortNameValue() { return pName; };
    virtual void GetDescriptionValue(NBString &s) { s = pDescription; };
    virtual void GetNameValue(NBString &s) { s = pName; };
    virtual void GetTextValue(NBString &s) { s = pName; };
    virtual void GetRawValue(NBString &s) { return GetTextValue(s); };
    virtual void GetTypeValue(NBString &s) { s = "unknown"; };
    virtual void ExtendedSchema(int fd, int indent, bool pretty){};
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) { return eOk; };
    // This is named so error messages make sense to user
    // Old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp) = 0;
 
    void ClearModified();
 
    bool MatchId(ParsedJsonDataSet &pjs);
 
    virtual bool CheckGroupValues() {return true;}
    virtual void CommitTestedValue(uint32_t permission_mask){};
 
    virtual ~config_leaf();
 
    config_leaf(bool bDetached=false)
    {
        pNextSibling = NULL;
        pChildren = NULL;
        m_Flags = fConfigIsDefault;
        pParent = NULL;
        if (bDetached)
        {
           pGList=pDetachList;
           pDetachList=this;
           m_Flags|=fConfigDetached;
        }
        else
        {
            pGList = pRootList;
            pRootList = this;
        }
    }
    config_leaf(config_leaf &&l);
 
    static void DiagShow();
    static void FixTree();
    void FindUnknownParent();
 
    void ShowOne();
 
    int compare(config_leaf *pl)
    {
        if (pl == NULL) return -1;
        return strcmp(GetSortNameValue(), pl->GetSortNameValue());
    };
 
    void GetFullName(NBString &s);
    void GetBranchName(NBString &s, config_leaf *branchRoot);
    void RenderToFd(int fd, bool pretty = false, uint32_t mask = fConfigHidden, bool bRawValue = false);
    void RenderSchemaToFd(int fd, bool pretty = false, uint32_t mask = fConfigHidden);
    uint32_t GetFlags() { return m_Flags; }
    uint32_t GetFlags(uint32_t mask) { return m_Flags & mask; }
    void SetFlag(uint32_t flag) { m_Flags |= flag; };
    void SetBranchFlag(uint32_t flag, bool upNotDown = false);
    void ClrFlag(uint32_t flag) { m_Flags &= (~flag); };
    void ClrBranchFlag(uint32_t flag, bool upNotDown = false);
    void ReloadFromFlash();
    void AssignmentNotify();
 
    void LogParseError(NBString & err);
    inline void LogParseError(const char * err) {NBString s(err); LogParseError(s); };
 
 
    friend void HtmlLeafRender(int fd, config_leaf *pl, int eMode, int len, const char *extra);
    friend ConfigNotificationObject;
};
 
class config_obj : public config_leaf
{
   protected:
    config_obj(bool bDetached=false):config_leaf(bDetached){}
    config_obj *pMasterObjectLink;
    static config_obj *pObjList;
 
    virtual void RemoveFromRootList();
   public:
    virtual void RawFdPrintTree(int fd, int n, bool pretty, uint32_t mask, bool braw_values,bool valonly) override;
    void InstallUnderMe(config_leaf &ltoadd);
    void RemoveFromChildren(config_leaf &ltoremove);
 
    config_obj(config_obj &owner, const char *name, const char *desc)
    {
        pName = name;
        pDescription = desc;
        pChildren = NULL;
        pMasterObjectLink = pObjList;
        pObjList = this;
        pParent = &owner;
    }
    config_obj(config_obj &&o);
 
    config_obj(const char *name, const char *desc)
    {
        pName = name;
        pDescription = desc;
        pChildren = NULL;
        pParent = NULL;
        pMasterObjectLink = pObjList;
        pObjList = this;
    }
 
 
 
    bool DoIContain(config_leaf *pl);
 
    /*
     * These two functions, along with GetTextValue(), can be used to create a custom object
     * class, including the responsibility for the JSON serialization.
     *
     * GetTextValue():  Must return a string with the object encoded in it in JSON format
     *
     * TestNewValue():  Takes a parsed JSON object and extracts the values from that tree.
     *                  This is where parameters can be tested for validity, and if not valid,
     *                  the entire set is marked as invalid.
     *
     * CommitTestedValue(): Commit the values extracted by TestNewValue()
     *
     * This enables functionality such as parsing a set of values to determine if the SET is
     * valid, rather than just an individual value.
     */
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override;
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp) override
    {
        startp = this;
        return sizeof(*this);
    };
 
    virtual void GetTextValue(NBString &s) override;
 
    virtual void GetTypeValue(NBString &s) override { s = "object"; };
 
    friend class config_leaf;
};
 
/*
 * Configuration Root object class
 */
class root_obj : public config_obj
{
   public:
    root_obj()
    { pName = "Config";
      pDescription = "Root of config tree";
    }
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp) override
    {
        startp = this;
        return sizeof(*this);
    };
};
 
class detached_root_obj : public config_obj
{
   public:
    detached_root_obj():config_obj(true)
    { pName = "detached";
      pDescription = "Root of detached tree";
    }
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp) override
    {
        startp = this;
        return sizeof(*this);
    };
};
 
 
 
 
extern root_obj root;
extern detached_root_obj detached;
 
class config_value : public config_leaf
{
   public:
    virtual void GetTextValue(NBString &s) override = 0;
 
   protected:
    config_value(config_obj &owner, const char *name, const char *desc)
    {
        pName = name;
        pDescription = desc;
        owner.InstallUnderMe(*this);
        pChildren = NULL;
        m_Flags |= fConfigValueLeaf;
    }
 
    config_value(const char *name, const char *desc)
    {
        pName = name;
        pDescription = desc;
        pParent = NULL;
        pChildren = NULL;
        m_Flags |= fConfigValueLeaf;
    }
 
    config_value(config_value &&v);
    virtual int FdPrintValue(int fd, bool raw);
 
public:
    virtual void RawFdPrintTree(int fd, int n, bool pretty, uint32_t mask, bool braw_values,bool valonly) override;
};
 
class config_uint : public config_value
{
   protected:
    uint32_t val;
    uint32_t pend_val;
 
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    virtual void GetTextValue(NBString &s) override { s.siprintf("%u", val); };
 
    config_uint(config_obj &owner, uint32_t def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_uint(uint32_t def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_uint(config_uint &&u);
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override { val = pend_val; }
 
    // Assignment operators
 
    operator uint32_t() const { return val; };
 
    config_uint &operator=(const uint32_t i)
    {
        pend_val = val = i;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_uint &operator=(const config_uint &ci)
    {
        pend_val = val = ci.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    // This is named so error messages make sense to user. Old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp) override
    {
        startp = this;
        return sizeof(*this);
    };
 
    virtual void GetTypeValue(NBString &s) override { s = "integer"; };
};
 
class config_hex_uint : public config_uint
{
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs);
 
protected:
    virtual int FdPrintValue(int fd, bool raw) override;
public:
    config_hex_uint(config_obj &owner, uint32_t def_val, const char *name, const char *desc = NULL) : config_uint(owner,def_val, name, desc){}
 
    config_hex_uint(uint32_t def_val, const char *name, const char *desc = NULL) : config_uint(def_val,name, desc){}
 
    virtual void GetTextValue(NBString &s) override { s.siprintf("\"0x%X\"", val); };
    virtual void GetTypeValue(NBString &s) override { s = "string"; };
 
};
 
 
 
class config_int : public config_value
{
   protected:
    int val;
    int pend_val;
 
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    virtual void GetTextValue(NBString &s) override { s.siprintf("%d", val); };
 
    config_int(config_obj &owner, int def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_int(int def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_int(config_int &&i);
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
 
    virtual void CommitTestedValue(uint32_t permission_mask) override { val = pend_val; }
 
    // Assignment operators
 
    operator int() const { return val; };
 
    config_int &operator=(const int i)
    {
        pend_val = val = i;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_int &operator=(const config_int &ci)
    {
        pend_val = val = ci.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp) override
    {
        startp = this;
        return sizeof(*this);
    };
 
    virtual void GetTypeValue(NBString &s) override { s = "integer"; };
};
 
class config_double : public config_value
{
    protected:
    double val;
    double pend_val;
 
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    virtual void GetTextValue(NBString &s) override { s.sprintf("%g", val); };
 
    config_double(config_obj &owner, double def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_double(double def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_double(config_double &&d);
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override { val = pend_val; }
 
    // Assignment operators
 
    operator int() const { return val; };
 
    operator float() const { return val; };
 
    operator double() const { return val; };
 
    config_double &operator=(const double d)
    {
        pend_val = val = d;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_double &operator=(const config_double &ci)
    {
        pend_val = val = ci.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    // This is named so error messages make sense to user. old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp) override
    {
        startp = this;
        return sizeof(*this);
    };
 
    virtual void GetTypeValue(NBString &s) override { s = "string"; };
};
 
/*
 * Class used for system status reports, for internal use only
 */
class config_report : public config_value
{
   protected:
    const char *m_value;
 
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    config_report(config_obj &owner, const char *value, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        m_Flags = fConfigReadOnly | fConfigNoSave;
        m_value = value;
    }
    config_report(const char *value, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        m_Flags = fConfigReadOnly | fConfigNoSave;
        m_value = value;
    }
 
    config_report(config_report &&r);
 
    virtual void GetTextValue(NBString &s) override;
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override;
    // This is named so error messages make sense to user
    // Old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp) override
    {
        startp = this;
        return sizeof(*this);
    };
    virtual void GetTypeValue(NBString &s) override { s = "string"; };
 
    const char *c_str() { return m_value; };
    void ModifyValue(const char *nv) { m_value = nv; };
};
 
class config_bool : public config_value
{
   protected:
    bool val;
    bool pend_val;
 
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    virtual void GetTextValue(NBString &s) override
    {
        if (val)
            s = "true";
        else
            s = "false";
    };
 
    config_bool(config_obj &owner, bool def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_bool(bool def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        val = def_val;
        pend_val = val;
    }
    config_bool(config_bool &&b);
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override { val = pend_val; }
 
    // Assignemt operators
 
    operator bool() const { return val; };
 
    config_bool &operator=(const bool v)
    {
        pend_val = val = v;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_bool &operator=(const config_bool &cb)
    {
        pend_val = val = cb.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_bool &operator=(const int i)
    {
        pend_val = val = (i != 0);
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp)
    {
        startp = this;
        return sizeof(*this);
    };
 
    virtual void GetTypeValue(NBString &s) override { s = "boolean"; };
};
 
class config_string : public config_value
{
   protected:
    NBString val;
    NBString pend_val;
    NBString enum_list;
 
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    virtual void GetTextValue(NBString &s) override;
//    {
//        s = "\"";
//        s += val;
//        s += "\"";
//    };
 
    config_string(config_string &&s);
 
    const char * GetPendValue() {return pend_val.c_str();};
 
    config_string(config_obj &owner, NBString def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_string(NBString def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        pName = name;
        val = def_val;
        pend_val = val;
    }
 
    config_string(config_obj &owner, const char *def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_string(const char *def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override { val = pend_val; }
 
    void SetEnumList(NBString s) { enum_list = s; };
 
    // Assignment Operators
 
    operator NBString() const { return val; };
 
    config_string &operator=(const char *p)
    {
        pend_val = val = p;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_string &operator=(const NBString &s)
    {
        pend_val = val = s;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_string &operator=(const config_string &ci)
    {
        pend_val = val = ci.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp) override
    {
        startp = this;
        return sizeof(*this);
    };
 
    inline const char *c_str() const { return val.c_str(); };
 
    inline size_t length() const { return val.length(); };
 
    inline const char &operator[](size_t pos) const { return val[pos]; };
 
    virtual void GetTypeValue(NBString &s) override { s = "string"; };
 
    virtual void ExtendedSchema(int fd, int indent, bool pretty);
 
    /* *
     * @brief Perform a string interpolation and place the finished interpolation
     *  in the Destination string
     *
     * @param dest  Destination string
     *
     * @returns Whether the interpolation was successful
     */
    bool Interpolate(NBString &dest)
    {
        return val.Interpolate(dest);
    }
 
    friend class config_pass;
    friend class config_localname;
    friend class config_chooser;
    friend class config_localname;
};
 
class config_pass : public config_string
{
    protected:
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    config_pass(config_obj &owner, NBString def_val, const char *name, const char *desc = NULL)
        : config_string(owner, def_val, name, desc){};
 
    config_pass(NBString def_val, const char *name, const char *desc = NULL) : config_string(def_val, name, desc){};
 
    config_pass(config_obj &owner, const char *def_val, const char *name, const char *desc = NULL)
        : config_string(owner, def_val, name, desc){};
 
    config_pass(const char *def_val, const char *name, const char *desc = NULL) : config_string(def_val, name, desc){};
 
    config_pass(config_pass &&s);
 
    virtual void GetTextValue(NBString &s) override;
 
    virtual void GetRawValue(NBString &s) override;
 
    virtual void CommitTestedValue(uint32_t permission_mask) override;
 
    // Add help pop-ups for web page display
    virtual void ExtendedSchema(int fd, int indent, bool pretty)
    {
        config_string::ExtendedSchema(fd, indent, pretty);
        DoSchemaLine(fd, "format", "password", indent, pretty);
    };
 
    operator NBString() const { return val; };
 
    config_pass &operator=(const char *p)
    {
        pend_val = val = p;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_pass &operator=(const NBString &s)
    {
        pend_val = val = s;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_pass &operator=(const config_string &ci)
    {
        pend_val = val = ci.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_pass &operator=(const config_pass &ci)
    {
        pend_val = val = ci.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
};
 
 
class I4Record;
class config_IPADDR4 : public config_value
{
    IPADDR4 val;
    IPADDR4 pend_val;
 
    protected:
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    virtual void GetTextValue(NBString &s) override { s.siprintf("\"%hI\"", val); };
 
    config_IPADDR4(config_obj &owner, IPADDR4 def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_IPADDR4(IPADDR4 def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_IPADDR4(config_IPADDR4 &&I);
 
    config_IPADDR4(config_obj &owner, const char *def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        IPADDR4 i4;
        i4.SetFromAscii(def_val);
        val = i4;
        pend_val = val;
    }
 
    config_IPADDR4(const char *def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        IPADDR4 i4;
        i4.SetFromAscii(def_val);
        val = i4;
        pend_val = val;
    }
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override { val = pend_val; }
 
    // Assignment operators
 
    operator IPADDR4() const { return val; };
 
    inline bool IsNull() const { return val.IsNull(); };
 
    inline bool NotNull() const { return !(val.IsNull()); };
 
    inline void SetNull()
    {
        val.SetNull();
        pend_val = val;
    };
 
    config_IPADDR4 &operator=(const IPADDR4 &i4)
    {
        pend_val = val = i4;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_IPADDR4 &operator=(const config_IPADDR4 &ci)
    {
        pend_val = val = ci.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp)
    {
        startp = this;
        return sizeof(*this);
    };
 
    virtual void GetTypeValue(NBString &s) override { s = "string"; };
 
    // Add web page help
    virtual void ExtendedSchema(int fd, int indent, bool pretty) { DoSchemaLine(fd, "format", "ipv4", indent, pretty); };
    friend I4Record;
};
 
#ifdef IPV6
class config_IPADDR : public config_value
{
    IPADDR val;
    IPADDR pend_val;
 
    protected:
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    virtual void GetTextValue(NBString &s) override { s.siprintf("\"%I\"", val); };
 
    config_IPADDR(config_obj &owner, IPADDR def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_IPADDR(config_IPADDR &&I);
 
    config_IPADDR(IPADDR def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_IPADDR(config_obj &owner, const char *def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        IPADDR i6;
        i6.SetFromAscii(def_val);
        val = i6;
        pend_val = val;
    }
 
    config_IPADDR(const char *def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        IPADDR i6;
        i6.SetFromAscii(def_val);
        val = i6;
        pend_val = val;
    }
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override { val = pend_val; }
 
    operator IPADDR() const { return val; };
 
    bool IsNull() const { return val.IsNull(); }
 
    bool NotNull() const { return !(val.IsNull()); }
 
    void SetNull()
    {
        val.SetNull();
        pend_val = val;
    }
 
    config_IPADDR &operator=(const IPADDR &i6)
    {
        pend_val = val = i6;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_IPADDR &operator=(const config_IPADDR &ci)
    {
        pend_val = val = ci.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp)
    {
        startp = this;
        return sizeof(*this);
    };
 
    virtual void GetTypeValue(NBString &s) override { s = "string"; };
 
    // Add web page help
    virtual void ExtendedSchema(int fd, int indent, bool pretty) { DoSchemaLine(fd, "format", "ipv6", indent, pretty); };
};
#else
#define config_IPADDR config_IPADDR4
#endif
 
class config_MACADR : public config_value
{
    MACADR val;
    MACADR pend_val;
 
    protected:
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    virtual void GetTextValue(NBString &s) override
    {
        s.siprintf("\"%02X:%02X:%02X:%02X:%02X:%02X\"", val.phywadr[0] >> 8, val.phywadr[0] & 0xFF, val.phywadr[1] >> 8,
                   val.phywadr[1] & 0xFF, val.phywadr[2] >> 8, val.phywadr[2] & 0xFF);
    };
 
    config_MACADR(config_obj &owner, MACADR def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_MACADR(config_MACADR &&m);
 
    config_MACADR(MACADR def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        val = def_val;
        pend_val = val;
    }
 
    config_MACADR(config_obj &owner, const char *def_val, const char *name, const char *desc = NULL) : config_value(owner, name, desc)
    {
        MACADR ma;
        ma = AsciiToMac(def_val);
 
        val = ma;
        pend_val = val;
    }
 
    config_MACADR(const char *def_val, const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        MACADR ma;
        ma = AsciiToMac(def_val);
        val = ma;
        pend_val = val;
    }
 
    // Assignment Operators
 
    operator MACADR() const { return val; };
 
    config_MACADR &operator=(const config_MACADR &ci)
    {
        pend_val = val = ci.val;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_MACADR &operator=(const MACADR &ci)
    {
        pend_val = val = ci;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    MACADR operator+(uint32_t rhs)
    { return val + rhs; }
 
    MACADR operator-(uint32_t rhs)
    { return val - rhs; }
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp)
    {
        startp = this;
        return sizeof(*this);
    };
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override { val = pend_val; }
 
    virtual void GetTypeValue(NBString &s) override { s = "string"; };
};
 
// This is named so error messages make sense to user, old name was GetExtent
#define ConfigEndMarker                                \
    virtual int Missing_ConfigEndMarker(void *&startp) override \
    {                                                  \
        startp = this;                                 \
        return sizeof(*this);                          \
    };
 
class config_chooser : public config_obj
{
    config_string value{"", "Value"};
    config_string choices{"", "Choices"};
    ConfigEndMarker;
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
 
   public:
    config_chooser(config_obj &owner, const char *name, const char *in_value, const char *in_choices, const char *desc = NULL)
        : config_obj(owner, name, desc)
    {
        value = in_value;                                     // Current choice
        choices = in_choices;                                 // List of choices
        choices.m_Flags |= fConfigReadOnly | fConfigNoSave;   // Confiuration flags
        value.SetEnumList(choices);                           // Create enum list from string containing all choices
    };
 
    config_chooser(config_chooser &&c);
 
    const char * GetPendValue() {return value.pend_val.c_str();};
 
 
    config_chooser(const char *name, const char *in_value, const char *in_choices, const char *desc = NULL) : config_obj(name, desc)
    {
        value = in_value;
        choices = in_choices;
        choices.m_Flags |= fConfigReadOnly | fConfigNoSave;
        value.SetEnumList(choices);
    };
 
    bool IsSelected(const char *choice) { return (choice == value); };
 
    bool IsSelected(const NBString &s) { return (s == value); };
 
    bool IsInChoices(const char *str, size_t strLen)
    {
        const char *sChoices = choices.c_str();
        size_t listLen = choices.length();
        size_t index = 0;
 
        if (str == nullptr) { return false; }
        if (listLen == 0) { return false; }
 
        while (index < listLen)
        {
            size_t curVarStart = index;
            size_t curVarLength;
 
            // determine the length of the current element in the list of choices
            while (sChoices[index] != 0 && sChoices[index] != ',')
            {
                // index until the end of the current element in the list of choices
                index++;
            }
            curVarLength = index - curVarStart;
 
            if (strncmp(str, &sChoices[curVarStart], (curVarLength > strLen) ? curVarLength : strLen) == 0)
            {
                return true;   // found a match
            }
            index++;   // increment past ','
        }
 
        return false;
    }
 
    bool IsInChoices(const NBString &str, size_t strLen)
    {
        const char *sStr = str.c_str();
        const char *sChoices = choices.c_str();
        size_t length = choices.length();
        size_t index = 0;
 
        if (sStr == nullptr) { return false; }
        if (length == 0) { return false; }
 
        while (index < length)
        {
            size_t curVarStart = index;
            size_t curVarLength;
 
            // determine the length of the current element in the list of choices
            while (sChoices[index] != 0 && sChoices[index] != ',')
            {
                // index until the end of the current element in the list of choices
                index++;
            }
            curVarLength = index - curVarStart;
 
            if (strncmp(sStr, &sChoices[curVarStart], curVarLength > strLen ? curVarLength : strLen) == 0)
            {
                return true;   // found a match
            }
            index++;   // increment past ','
        }
 
        return false;
    }
 
    const config_string &GetChoices() { return choices; }
 
    const config_string &SetChoices(const char *in_choices)
    {
        choices = in_choices;
        value.SetEnumList(choices);
 
        return choices;
    }
 
     /* @brief Set the list of choices
     *
     * @param in_choices The list of option choices
     *
     * @returns A config_string object containing the list of choices
     */
    const config_string &SetChoices(const NBString &in_choices)
    {
        choices = in_choices;
        value.SetEnumList(choices);
 
        return choices;
    }
 
 
    operator NBString() const { return (NBString)value; };
 
    config_chooser &operator=(const char *p)
    {
        value = p;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_chooser &operator=(const NBString &s)
    {
        value = s;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    config_chooser &operator=(const config_chooser &ci)
    {
        value = ci.value;
        if (GetFlags(fConfigIsDefault))
            ClrBranchFlag(fConfigIsDefault, true);
        return *this;
    };
 
    virtual void GetTypeValue(NBString &s) override { s = "object"; };
};
 
class config_int_limit : public config_int
{
   protected:
    int min_val; // should be INT_MIN by default
    int max_val; // should be INT_MAX by default
 
   public:
    config_int_limit(config_obj &owner, int def_val, int minv=INT_MIN,int maxv=INT_MAX,const char *name = NULL, const char *desc = NULL) : config_int(owner,def_val, name, desc)
    {
        min_val=minv;
        max_val=maxv;
    }
 
    config_int_limit(int def_val, int minv=INT_MIN,int maxv=INT_MAX,const char *name = NULL, const char *desc = NULL) : config_int(def_val,name, desc)
    {
        min_val=minv;
        max_val=maxv;
    }
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void ExtendedSchema(int fd, int indent, bool pretty) override;
 
    config_int_limit &operator=(const int i)
    {
        if(i>=min_val && max_val<=i)
        {
            pend_val = val = i;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_int_limit &operator=(const config_int &ci)
    {
        int test_v=ci;
        if((test_v>=min_val) && (test_v<=max_val))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_int_limit &operator=(const config_int_limit &cil)
    {
        int test_v=cil;
        if((test_v>=min_val) && (test_v<=max_val))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
};
 
class config_uint_limit : public config_uint
{
   protected:
    uint32_t min_val; // should be 0 by default
    uint32_t max_val; // should be UINT_MAX by default
 
   public:
    config_uint_limit(config_obj &owner, uint32_t def_val, uint32_t minv=0,uint32_t maxv=UINT_MAX,const char *name = NULL, const char *desc = NULL) : config_uint(owner,def_val, name, desc)
    {
        min_val=minv;
        max_val=maxv;
    }
 
    config_uint_limit(uint32_t def_val, uint32_t minv=0,uint32_t maxv=UINT_MAX,const char *name = NULL, const char *desc = NULL) : config_uint(def_val,name, desc)
    {
        min_val=minv;
        max_val=maxv;
    }
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void ExtendedSchema(int fd, int indent, bool pretty) override;
 
    config_uint_limit &operator=(const uint32_t i)
    {
        if(i>=min_val && max_val<=i)
        {
            pend_val = val = i;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_uint_limit &operator=(const config_uint &ci)
    {
        uint32_t test_v=ci;
        if((test_v>=min_val) && (test_v<=max_val))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_uint_limit &operator=(const config_uint_limit &cil)
    {
        uint32_t test_v=cil;
        if((test_v>=min_val) && (test_v<=max_val))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
};
 
 
 
class config_double_limit : public config_double
{
   protected:
    double min_val; // should be -DBL_MAX by default
    double max_val; // should be DBL_MAX by default
    double step; // allowable increments in the HTML GUI (precision to round to, not strictly enforced)
 
   public:
    config_double_limit(config_obj &owner, double def_val, double minv=-DBL_MAX,double maxv=DBL_MAX,double stepv=0.01, const char *name = NULL, const char *desc = NULL) : config_double(owner,def_val, name, desc)
    {
        min_val=minv;
        max_val=maxv;
        step=stepv;
    }
 
    config_double_limit(double def_val, double minv=-DBL_MAX,double maxv=DBL_MAX,double stepv=0.01, const char *name = NULL, const char *desc = NULL) : config_double(def_val,name, desc)
    {
        min_val=minv;
        max_val=maxv;
        step=stepv;
    }
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void ExtendedSchema(int fd, int indent, bool pretty) override;
 
    config_double_limit &operator=(const double i)
    {
        if(i>=min_val && max_val<=i)
        {
            pend_val = val = i;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_double_limit &operator=(const config_double &ci)
    {
        double test_v=ci;
        if((test_v>=min_val) && (test_v<=max_val))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_double_limit &operator=(const config_double_limit &cil)
    {
        double test_v=cil;
        if((test_v>=min_val) && (test_v<=max_val))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
 
    virtual void GetTypeValue(NBString &s) override { s = "number"; };
};
 
class config_string_limit : public config_string
{
   protected:
    size_t min_len; // should be 0 by default
    size_t max_len; // should be 0 by default
 
   public:
    config_string_limit(config_obj &owner, NBString def_val, size_t minl=0,size_t maxl=0,const char *name = NULL, const char *desc = NULL) : config_string(owner,def_val, name, desc)
    {
        min_len=minl;
        max_len=maxl;
    }
 
    config_string_limit(NBString def_val, size_t minl=0,size_t maxl=0,const char *name = NULL, const char *desc = NULL) : config_string(def_val,name, desc)
    {
        min_len=minl;
        max_len=maxl;
    }
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void ExtendedSchema(int fd, int indent, bool pretty) override;
 
    config_string_limit &operator=(const NBString i)
    {
        if(i.length()>=min_len && max_len<=i.length())
        {
            pend_val = val = i;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_string_limit &operator=(const config_string &ci)
    {
        NBString test_v=ci;
        if((test_v.length()>=min_len) && (test_v.length()<=max_len))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_string_limit &operator=(const config_string_limit &cil)
    {
        NBString test_v=cil;
        if((test_v.length()>=min_len) && (test_v.length()<=max_len))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
};
 
class config_pass_limit : public config_pass
{
   protected:
    size_t min_len; // should be 0 by default
    size_t max_len; // should be 0 by default
 
   public:
    config_pass_limit(config_obj &owner, NBString def_val, size_t minl=0,size_t maxl=0,const char *name = NULL, const char *desc = NULL) : config_pass(owner,def_val, name, desc)
    {
        min_len=minl;
        max_len=maxl;
    }
 
    config_pass_limit(NBString def_val, size_t minl=0,size_t maxl=0,const char *name = NULL, const char *desc = NULL) : config_pass(def_val,name, desc)
    {
        min_len=minl;
        max_len=maxl;
    }
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void ExtendedSchema(int fd, int indent, bool pretty) override;
 
    config_pass_limit &operator=(const NBString i)
    {
        if(i.length()>=min_len && max_len<=i.length())
        {
            pend_val = val = i;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_pass_limit &operator=(const config_pass &ci)
    {
        NBString test_v=ci;
        if((test_v.length()>=min_len) && (test_v.length()<=max_len))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
    config_pass_limit &operator=(const config_pass_limit &cil)
    {
        NBString test_v=cil;
        if((test_v.length()>=min_len) && (test_v.length()<=max_len))
        {
            pend_val = val = test_v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
        }
        return *this;
    };
 
};
 
class reboot_obj : public config_bool
{
    virtual const char *GetSortNameValue() { return "ZZZc"; };
 
   public:
    reboot_obj() : config_bool(root, false, "Reboot", "Cause system reboot on save"){};
    void clear()
    {
        val = false;
        pend_val = false;
    };
 
    // This is named so error messages make sense to user, old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp)
    {
        startp = this;
        return sizeof(*this);
    };
};
 
class version_obj : public config_int
{
    bool bNeverSet;
    virtual const char *GetSortNameValue() { return "ZZZb"; };
 
   public:
    version_obj() : config_int(root, 0, "Version", "Version serial number") { bNeverSet = true; };
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs);
    void inc()
    {
        val++;
        pend_val = val;
    };
    // This is named so error messages make sense to user
    // Old name was GetExtent
    virtual int Missing_ConfigEndMarker(void *&startp)
    {
        startp = this;
        return sizeof(*this);
    };
};
 
class empty_config_obj : public config_obj
{
    ConfigEndMarker;
 
   public:
    empty_config_obj(const char *name, const char *desc = NULL) : config_obj(name, desc){};
    empty_config_obj(config_obj &owner, const char *name, const char *desc = NULL) : config_obj(owner, name, desc){};
    empty_config_obj(empty_config_obj &&e);
};
 
 
 
// This class is intended for recovery applications or for devices supporting multiple
//  application profiles to preserve unused config tree branches across configuration
//  updates
//  Ex:
//      Application A has a config object at 'AppData.AppA', and Application B
//      has a config object at 'AppData.AppB'. Normally, if Application A were
//      to update any configuration (whether Application or System related), this
//      would wipe out any AppB configuration as it is not known of by Application A.
//      Using a config_preserver_obj, any configuration tree data below it's registration
//      will be persisted across updates unless explicitly wiped.
class config_preserver_obj : public config_obj
{
    ConfigEndMarker;
    ParsedJsonDataSet &pendingTreeData;
    ParsedJsonDataSet &treeData;
 
   public:
    config_preserver_obj(const char *name, const char *desc = NULL);
    config_preserver_obj(config_obj &owner, const char *name, const char *desc = NULL);
    config_preserver_obj(config_preserver_obj &&po);
 
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) override;
    virtual void CommitTestedValue(uint32_t permission_mask) override;
    virtual void GetTextValue(NBString &s) override;
    virtual void GetRawValue(NBString &s) override;
};
 
extern const char *AppName;
extern const char PlatformName[];
 
class SysRecord : public config_obj
{
   public:
    config_report system_platform{PlatformName, "Platform", "Hardware Platform"};
    config_report system_app{AppName, "Application", "Application name"};
    ConfigEndMarker;
 
    SysRecord(const char *name, const char *desc = NULL) : config_obj(name, desc){};
    SysRecord(config_obj &owner, const char *name, const char *desc = NULL) : config_obj(owner, name, desc){};
    SysRecord(SysRecord &&sr);
};
 
extern SysRecord sys;
extern empty_config_obj netif;
 
extern reboot_obj rebooter;
extern version_obj config_cur_version;
 
extern const int plat_def_baud;
extern const int plat_def_delay;
extern const int plat_def_quiet;
extern const int plat_def_watchdog_enabled;
 
#include <plat_cfg_types.h>
#ifdef PRESERVE_APP_DATA
extern config_preserver_obj appdata;
#else
extern empty_config_obj appdata;
#endif
 
void SaveConfigToStorage();
 
class MonitorRecord : public config_obj
{
   public:
    config_int Baud{plat_def_baud, "BootBaud"};
    config_uart Uart{plat_def_com, "BootUart"};
    config_int BootDelay{plat_def_delay, "BootDelay"};
    config_bool Quiet{plat_def_quiet, "BootQuiet"};
    config_chooser sercfg_action{"SerialConfig", "DuringBoot", "DuringBoot,AlwaysEnabled,PauseAfterBoot,Disabled"};
    config_string abortbootcmd{"A", "Abort"};
    config_pass system_user{"", "User"};
    config_pass system_pass{"", "Password"};
    ConfigEndMarker;
 
    MonitorRecord(const char *name) : config_obj(name, "Boot monitor record")
    {
        sercfg_action.SetFlag(fConfigNeedReboot);
        Baud.SetFlag(fConfigNeedReboot);
        Uart.SetFlag(fConfigNeedReboot);
    };
    MonitorRecord(config_obj &owner, const char *name) : config_obj(owner, name, "Boot Monitor Record")
    {
        sercfg_action.SetFlag(fConfigNeedReboot);
        Baud.SetFlag(fConfigNeedReboot);
        Uart.SetFlag(fConfigNeedReboot);
    };
    MonitorRecord(MonitorRecord &&mr);
};
extern MonitorRecord monitor_config;
 
void OverrideConfig();
 
 
 
 
#endif