ydb/DbVal.hh at master · PerNilsson360/ydb · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#ifndef _DB_VALUE_HH_
#define _DB_VALUE_HH_

#include <stdexcept>
#include <sstream>
#include <iostream>
#include <list>

template <class T> struct Dtor
{
    void operator () (const T* n) {
        delete n;
    }
};

class Bool;
class Singelton;
class String;
class Int64;
class Ref;
class Composite;

class DbVal
{
public:
    virtual bool operator < (const DbVal& val) const = 0;
    virtual bool operator > (const Bool& val) const;
    virtual bool operator > (const Singelton& val) const;
    virtual bool operator > (const String& val) const;
    virtual bool operator > (const Int64& val) const;
    virtual bool operator > (const Ref& val) const;
    virtual bool operator > (const Composite& val) const;
    virtual void put(std::ostream& os) const = 0;
private:
};

class Bool : public DbVal
{
public:
    Bool(bool b) : _b(b) {}
    bool operator < (const DbVal& val) const {
        return val > *this;
    }
    bool operator > (const Bool& val) const {
        return _b > val._b;
    }
    void put(std::ostream& os) const {
        os << _b;
    }
private:
    bool _b;
};

class Singelton : public DbVal
{
public:
    bool operator < (const DbVal& val) const {
        return val > *this;
    }
    bool operator > (const Singelton& val) const {
        return false;
    }
    void put(std::ostream& os) const {
        os << "Singelton";
    }
};

class String : public DbVal
{
public:
    String(const std::string& s) : _s(s) {}
    bool operator < (const DbVal& val) const {
        return val > *this;
    }
    bool operator > (const String& val) const {
        return _s > val._s;
    }
    void put(std::ostream& os) const {
        os << _s;
    }
private:
    std::string _s;
};

class Int64 : public DbVal
{
public:
    Int64(int64_t i) : _i(i) {}
    bool operator < (const DbVal& val) const {
        return val > *this;
    }
    bool operator > (const Int64& val) const {
        return _i > val._i;
    }
    void put(std::ostream& os) const {
        os << _i;
    }
private:
    int64_t _i;
};

class Ref : public DbVal
{
public:
private:
};

class Composite : public DbVal
{
public:
private:
};

inline std::ostream&
operator<<(std::ostream& os, const DbVal& v)
{
    v.put(os);
    return os;
}

inline
bool
operator == (const DbVal& l, const DbVal& r)
{
    return !(l < r) && !(r < l);
}

struct DbValEq
{
    DbValEq(const DbVal* r) : _r(r) {}
    bool operator() (const DbVal* l) const { return *l == *_r; }
    const DbVal* _r;
};

struct DbValGt
{
    DbValGt(const DbVal* r) : _r(r) {}
    bool operator() (const DbVal* l) const { return (*_r < *l); }
    const DbVal* _r;
};

typedef std::list<const DbVal*> Vals;

#endif