diff options
Diffstat (limited to 'src/tests/cache.cpp')
-rw-r--r-- | src/tests/cache.cpp | 289 |
1 files changed, 0 insertions, 289 deletions
diff --git a/src/tests/cache.cpp b/src/tests/cache.cpp deleted file mode 100644 index 4751559..0000000 --- a/src/tests/cache.cpp +++ /dev/null | |||
@@ -1,289 +0,0 @@ | |||
1 | #include "bu/myriadcache.h" | ||
2 | #include "bu/uuid.h" | ||
3 | #include "bu/string.h" | ||
4 | #include "bu/sio.h" | ||
5 | |||
6 | class Something : public Bu::CacheObject<Bu::Uuid, Something> | ||
7 | { | ||
8 | friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s ); | ||
9 | friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s ); | ||
10 | public: | ||
11 | Something() | ||
12 | { | ||
13 | } | ||
14 | |||
15 | Something( const Bu::String &sName ) : | ||
16 | uId( Bu::Uuid::generate() ), | ||
17 | sName( sName ) | ||
18 | { | ||
19 | } | ||
20 | |||
21 | virtual ~Something() | ||
22 | { | ||
23 | } | ||
24 | |||
25 | virtual Bu::Uuid getKey() const | ||
26 | { | ||
27 | return uId; | ||
28 | } | ||
29 | |||
30 | Bu::String getName() const | ||
31 | { | ||
32 | return sName; | ||
33 | } | ||
34 | |||
35 | void setName( const Bu::String &sNewName ) | ||
36 | { | ||
37 | sName = sNewName; | ||
38 | changed(); | ||
39 | } | ||
40 | |||
41 | virtual Bu::String toString() const=0; | ||
42 | |||
43 | private: | ||
44 | Bu::Uuid uId; | ||
45 | Bu::String sName; | ||
46 | }; | ||
47 | |||
48 | class SubSomethingA : public Something | ||
49 | { | ||
50 | friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingA &s ); | ||
51 | friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingA &s ); | ||
52 | public: | ||
53 | SubSomethingA() | ||
54 | { | ||
55 | } | ||
56 | |||
57 | SubSomethingA( const Bu::String &sName, int iNumber ) : | ||
58 | Something( sName ), | ||
59 | iNumber( iNumber ) | ||
60 | { | ||
61 | } | ||
62 | |||
63 | virtual Bu::String toString() const | ||
64 | { | ||
65 | return Bu::String("[typeA] %1 (%2)").arg( getName() ).arg( iNumber ); | ||
66 | } | ||
67 | |||
68 | private: | ||
69 | int iNumber; | ||
70 | }; | ||
71 | |||
72 | class SubSomethingB : public Something | ||
73 | { | ||
74 | friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingB &s ); | ||
75 | friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingB &s ); | ||
76 | public: | ||
77 | SubSomethingB() | ||
78 | { | ||
79 | } | ||
80 | |||
81 | SubSomethingB( const Bu::String &sName, const Bu::String &sString ) : | ||
82 | Something( sName ), | ||
83 | sString( sString ) | ||
84 | { | ||
85 | } | ||
86 | |||
87 | virtual Bu::String toString() const | ||
88 | { | ||
89 | return Bu::String("[typeB] %1 (%2)").arg( getName() ).arg( sString ); | ||
90 | } | ||
91 | |||
92 | private: | ||
93 | Bu::String sString; | ||
94 | }; | ||
95 | |||
96 | Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s ) | ||
97 | { | ||
98 | return ar >> s.uId >> s.sName; | ||
99 | } | ||
100 | |||
101 | Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s ) | ||
102 | { | ||
103 | return ar << s.uId << s.sName; | ||
104 | } | ||
105 | |||
106 | Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingA &s ) | ||
107 | { | ||
108 | return ar >> (Something &)s >> s.iNumber; | ||
109 | } | ||
110 | |||
111 | Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingA &s ) | ||
112 | { | ||
113 | return ar << (Something &)s << s.iNumber; | ||
114 | } | ||
115 | |||
116 | Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, SubSomethingB &s ) | ||
117 | { | ||
118 | return ar >> (Something &)s >> s.sString; | ||
119 | } | ||
120 | |||
121 | Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const SubSomethingB &s ) | ||
122 | { | ||
123 | return ar << (Something &)s << s.sString; | ||
124 | } | ||
125 | |||
126 | namespace Bu | ||
127 | { | ||
128 | template<> | ||
129 | void _cacheObjectSave<const Something>( Bu::Stream &s, const Something *pObject ) | ||
130 | { | ||
131 | Bu::Archive ar( s, Bu::Archive::save ); | ||
132 | if( typeid(*pObject) == typeid(SubSomethingA) ) | ||
133 | { | ||
134 | ar << (uint8_t)1 << (SubSomethingA &)*pObject; | ||
135 | } | ||
136 | else if( typeid(*pObject) == typeid(SubSomethingB) ) | ||
137 | { | ||
138 | ar << (uint8_t)2 << (SubSomethingB &)*pObject; | ||
139 | } | ||
140 | else | ||
141 | { | ||
142 | Bu::println("Not a recognized type!"); | ||
143 | throw Bu::ExceptionBase("Not recognized type!"); | ||
144 | } | ||
145 | } | ||
146 | |||
147 | template<> | ||
148 | Something *_cacheObjectLoad<Bu::Uuid, Something>( Bu::CacheObject<Bu::Uuid, Something>::Initializer &initObj, const Bu::Uuid &rKey, Bu::Stream &s ) | ||
149 | { | ||
150 | Bu::Archive ar( s, Bu::Archive::load ); | ||
151 | uint8_t uType; | ||
152 | ar >> uType; | ||
153 | switch( uType ) | ||
154 | { | ||
155 | case 1: | ||
156 | { | ||
157 | SubSomethingA *ret = initObj(new SubSomethingA()); | ||
158 | ar >> *ret; | ||
159 | return ret; | ||
160 | } | ||
161 | break; | ||
162 | |||
163 | case 2: | ||
164 | { | ||
165 | SubSomethingB *ret = initObj(new SubSomethingB()); | ||
166 | ar >> *ret; | ||
167 | return ret; | ||
168 | } | ||
169 | break; | ||
170 | |||
171 | default: | ||
172 | throw Bu::ExceptionBase("Flagrant error! Invalid type!"); | ||
173 | } | ||
174 | |||
175 | return NULL; | ||
176 | } | ||
177 | } | ||
178 | |||
179 | typedef Bu::CachePtr<Bu::Uuid, Something> SomethingPtr; | ||
180 | typedef Bu::CachePtr<Bu::Uuid, SubSomethingA, Something> SomethingAPtr; | ||
181 | typedef Bu::CachePtr<Bu::Uuid, SubSomethingB, Something> SomethingBPtr; | ||
182 | typedef Bu::MyriadCache<Bu::Uuid, Something> SomethingCache; | ||
183 | |||
184 | int main( int, char *[] ) | ||
185 | { | ||
186 | Bu::File fStore("test.myr", Bu::File::Create|Bu::File::ReadWrite); | ||
187 | SomethingCache c( fStore ); | ||
188 | |||
189 | SomethingPtr ptr; | ||
190 | if( time(NULL)%2 ) | ||
191 | ptr = c.insert( new SubSomethingA("Hello", 55) ).cast<Something>(); | ||
192 | else | ||
193 | ptr = c.insert( new SubSomethingB("Goodbye", "Things") ).cast<Something>(); | ||
194 | |||
195 | Bu::println("Something[%1]: %2"). | ||
196 | arg( ptr.getKey() ). | ||
197 | arg( ptr->getName() ); | ||
198 | |||
199 | SomethingCache::KeyList lKeys = c.getKeys(); | ||
200 | Bu::println("Count: %1").arg( lKeys.getSize() ); | ||
201 | for( SomethingCache::KeyList::iterator i = lKeys.begin(); i; i++ ) | ||
202 | { | ||
203 | Bu::println(" - %1: '%2'").arg( *i ).arg( c.get( *i )->toString() ); | ||
204 | } | ||
205 | Bu::println("Count: %1").arg( c.getSize() ); | ||
206 | |||
207 | SomethingPtr p2 = c.get( ptr.getKey() ); | ||
208 | Bu::println("%1 == %2").arg( p2->getName() ).arg( ptr->getName() ); | ||
209 | SomethingPtr p3 = ptr.cast<Something>(); | ||
210 | Bu::println("%1: %2").arg( p3.getKey() ).arg( p3->getName() ); | ||
211 | |||
212 | return 0; | ||
213 | } | ||
214 | |||
215 | /* | ||
216 | int main( int argc, char *argv[] ) | ||
217 | { | ||
218 | Bu::File fStore("test.myr", Bu::File::Create|Bu::File::ReadWrite); | ||
219 | SomethingCache c( fStore ); | ||
220 | |||
221 | for( int j = 1; j < argc; j++ ) | ||
222 | { | ||
223 | SomethingPtr ptr = c.insert( new Something(argv[j]) ); | ||
224 | |||
225 | Bu::println("Something[%1]: %2"). | ||
226 | arg( ptr.getKey() ). | ||
227 | arg( ptr->getName() ); | ||
228 | } | ||
229 | |||
230 | SomethingCache::KeyList lKeys = c.getKeys(); | ||
231 | Bu::println("Count: %1").arg( lKeys.getSize() ); | ||
232 | int j = 0; | ||
233 | for( SomethingCache::KeyList::iterator i = lKeys.begin(); i; i++ ) | ||
234 | { | ||
235 | Bu::println(" - %1: '%2'").arg( *i ).arg( c.get( *i )->getName() ); | ||
236 | if( ((j++)%2) ) | ||
237 | c.erase( *i ); | ||
238 | } | ||
239 | Bu::println("Count: %1").arg( c.getSize() ); | ||
240 | |||
241 | c._debug(); | ||
242 | |||
243 | SomethingPtr p2; | ||
244 | SomethingPtr p1( c.get( lKeys.first() ) ); | ||
245 | |||
246 | c._debug(); | ||
247 | |||
248 | { | ||
249 | SomethingPtr p2( p1 ); | ||
250 | c._debug(); | ||
251 | } | ||
252 | |||
253 | c._debug(); | ||
254 | |||
255 | p2 = p1; | ||
256 | |||
257 | c._debug(); | ||
258 | |||
259 | p1.unbind(); | ||
260 | |||
261 | c._debug(); | ||
262 | |||
263 | Bu::println("Name: %1").arg( p1->getName() ); | ||
264 | |||
265 | p1.unbind(); | ||
266 | p1.lock(); | ||
267 | p1.unlock(); | ||
268 | |||
269 | c._debug(); | ||
270 | |||
271 | SomethingPtr p3 = c.getLazy( lKeys.first() ); | ||
272 | |||
273 | c._debug(); | ||
274 | |||
275 | { | ||
276 | SomethingPtr::Locker l( p3 ); | ||
277 | |||
278 | Bu::println("Name again: %1").arg( p3->getName() ); | ||
279 | |||
280 | p3->setName( p3->getName() + " - again" ); | ||
281 | } | ||
282 | |||
283 | c.sync(); | ||
284 | |||
285 | c._debug(); | ||
286 | |||
287 | return 0; | ||
288 | } | ||
289 | */ | ||