var.h

#ifndef WREPORT_VAR_H
#define WREPORT_VAR_H
 
#include <wreport/error.h>
#include <wreport/fwd.h>
#include <wreport/varinfo.h>
#include <cstdio>
#include <string>
#include <memory>
 
struct lua_State;
 
namespace wreport {
 
class Var
{
protected:
    Varinfo m_info;
 
    bool m_isset;
 
    union {
        int32_t i;
        char* c;
    } m_value;
 
    Var* m_attrs;
 
    void allocate();
 
    void copy_value(const Var& var);
    void move_value(Var& var);
    void assign_i_checked(int32_t val);
    void assign_d_checked(double val);
    void assign_b_checked(uint8_t* val, unsigned size);
    void assign_c_checked(const char* val, unsigned size);
 
public:
    Var(Varinfo info);
 
    Var(Varinfo info, int val);
 
    Var(Varinfo info, double val);
 
    Var(Varinfo info, const char* val);
 
    Var(Varinfo info, const std::string& val);
 
    Var(Varinfo info, const Var& var);
 
    Var(const Var& var);
 
    Var(Var&& var);
 
    ~Var();
 
    Var& operator=(const Var& var);
 
    Var& operator=(Var&& var);
 
    bool operator==(const Var& var) const;
    bool operator!=(const Var& var) const { return !operator==(var); }
 
    bool value_equals(const Var& var) const;
 
    Varcode code() const throw () { return m_info->code; }
 
    Varinfo info() const throw () { return m_info; }
 
    bool isset() const throw () { return m_isset; }
 
 
    int enqi() const;
 
    double enqd() const;
 
    const char* enqc() const;
 
    std::string enqs() const;
 
    template<typename T>
    T enq() const
    {
        throw error_unimplemented("getting value of unsupported type");
    }
 
    template<typename T>
    T enq(T default_value) const
    {
        if (!isset()) return default_value;
        return enq<T>();
    }
 
    void seti(int val);
 
    void setd(double val);
 
    void setc(const char* val);
 
    void sets(const std::string& val);
 
    void setf(const char* val);
 
    void setc_truncate(const char* val);
 
    void setval(const Var& src);
 
    void setattrs(const Var& src);
 
    void set(int val) { seti(val); }
    void set(double val) { setd(val); }
    void set(const char* val) { setc(val); }
    void set(const std::string& val) { setc(val.c_str()); }
    void set(const Var& var) { setval(var); setattrs(var); }
 
    void unset();
 
    void clear_attrs();
 
    const Var* enqa(Varcode code) const;
 
    void seta(const Var& attr);
 
    void seta(Var&& attr);
 
    void seta(std::unique_ptr<Var>&& attr);
 
    void unseta(Varcode code);
 
    const Var* next_attr() const;
 
    std::string format(const char* ifundef="") const;
 
    void format(FILE* out, const char* ifundef="") const;
 
    void print(FILE* out) const;
 
    void print(std::ostream& out) const;
 
    void print_without_attrs(FILE* out, const char* end="\n") const;
 
    void print_without_attrs(std::ostream& out) const;
 
    unsigned diff(const Var& var) const;
 
 
    void lua_push(struct lua_State* L);
 
    void lua_push(struct lua_State* L) const;
 
    static Var* lua_check(struct lua_State* L, int idx);
 
    static const Var* lua_const_check(struct lua_State* L, int idx);
};
 
template<> inline int Var::enq() const { return enqi(); }
template<> inline float Var::enq() const { return (float)enqd(); }
template<> inline double Var::enq() const { return enqd(); }
template<> inline const char* Var::enq() const { return enqc(); }
template<> inline std::string Var::enq() const { return enqs(); }
 
}
#endif