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
|
//|_ _ _. _ ._ |_ _. _ |
//| | (/_ (_| \/ (/_ | | | | (_| (_ |<
#pragma once
#include <vector>
#include "fnv.h"
extern void setting_save( const char* name, const void* src, U32 size );
extern void setting_load( const char* name, const void* dst, U32 size );
class SETTING_NODE {
public:
virtual void load() {};
virtual void save() {};
virtual FNV1A get_hash() { return {}; };
};
template <typename t>
class SETTING;
class SETTING_HOLDER : SETTING_NODE {
public:
SETTING_HOLDER() = default;
SETTING_HOLDER( SETTING_HOLDER* other ) { other->register_( this ); }
void register_( SETTING_NODE* node ) { nodes.push_back( node ); }
void save() override {
for( auto& it : nodes )
it->save();
}
void load() override {
for( auto& it : nodes )
it->load();
}
template <typename t>
SETTING<t>* find( FNV1A hash ) {
for( auto it : nodes ) {
if( it->get_hash() == hash )
return (SETTING<t>*)(it);
}
return 0;
}
private:
VECTOR<SETTING_NODE*> nodes;
};
template < typename t >
class SETTING : SETTING_NODE {
public:
SETTING( SETTING_HOLDER* owner, const char* name, t _default = t{} ) :
m_owner( owner ),
m_name( name ),
v( _default ),
m_hash( fnv1a( name ) )
{
owner->register_( this );
};
__forceinline SETTING( const SETTING<t>& other ) : v( other.v ) {}
__forceinline SETTING( const t& other ) : v( other ) {}
void save() override { setting_save( m_name, &v, sizeof( t ) ); }
void load() override { setting_load( m_name, &v, sizeof( t ) ); }
FNV1A get_hash() override { return m_hash; }
operator t&() { return v; }
t* operator&() { return &v; }
t v;
private:
SETTING_HOLDER* m_owner;
const char* m_name;
FNV1A m_hash;
};
|
