Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #ifndef INCLUDED_STORE_SOURCE_STORDATA_HXX
21 : #define INCLUDED_STORE_SOURCE_STORDATA_HXX
22 :
23 : #include "sal/config.h"
24 :
25 : #include "sal/types.h"
26 : #include "sal/macros.h"
27 :
28 : #include "store/types.h"
29 : #include "storbase.hxx"
30 :
31 : namespace store
32 : {
33 :
34 : /*========================================================================
35 : *
36 : * OStoreDataPageData.
37 : *
38 : *======================================================================*/
39 : #define STORE_MAGIC_DATAPAGE sal_uInt32(0x94190310)
40 :
41 : struct OStoreDataPageData : public store::OStorePageData
42 : {
43 : typedef OStorePageData base;
44 : typedef OStoreDataPageData self;
45 :
46 : typedef OStorePageDescriptor D;
47 :
48 : /** Representation.
49 : */
50 : sal_uInt8 m_pData[1];
51 :
52 : /** type.
53 : */
54 : static const sal_uInt32 theTypeId = STORE_MAGIC_DATAPAGE;
55 :
56 : /** size.
57 : */
58 : static const size_t theSize = 0;
59 : static const sal_uInt16 thePageSize = base::theSize + self::theSize;
60 : static_assert(STORE_MINIMUM_PAGESIZE >= self::thePageSize, "got to be at least equal in size");
61 :
62 : /** capacity.
63 : */
64 358 : static sal_uInt16 capacity (const D& rDescr) // @see inode::ChunkDescriptor
65 : {
66 358 : return (store::ntohs(rDescr.m_nSize) - self::thePageSize);
67 : }
68 238 : sal_uInt16 capacity() const
69 : {
70 238 : return self::capacity (base::m_aDescr);
71 : }
72 :
73 : /** usage.
74 : */
75 : sal_uInt16 usage() const
76 : {
77 : return (store::ntohs(base::m_aDescr.m_nUsed) - self::thePageSize);
78 : }
79 :
80 : /** Construction.
81 : */
82 119 : explicit OStoreDataPageData (sal_uInt16 nPageSize = self::thePageSize)
83 119 : : base (nPageSize)
84 : {
85 119 : base::m_aGuard.m_nMagic = store::htonl(self::theTypeId);
86 119 : base::m_aDescr.m_nUsed = store::htons(self::thePageSize);
87 119 : if (capacity()) memset (m_pData, 0, capacity());
88 119 : }
89 :
90 : /** guard (external representation).
91 : */
92 119 : void guard() { (void) this; /* loplugin:staticmethods */ }
93 :
94 : /** verify (external representation).
95 : */
96 0 : storeError verify() const {
97 : (void) this; // loplugin:staticmethods
98 0 : return store_E_None;
99 : }
100 : };
101 :
102 : /*========================================================================
103 : *
104 : * OStoreDataPageObject.
105 : *
106 : *======================================================================*/
107 131 : class OStoreDataPageObject : public store::OStorePageObject
108 : {
109 : typedef OStorePageObject base;
110 : typedef OStoreDataPageData page;
111 :
112 : public:
113 : /** Construction.
114 : */
115 131 : explicit OStoreDataPageObject (PageHolder const & rxPage = PageHolder())
116 131 : : OStorePageObject (rxPage)
117 131 : {}
118 :
119 : /** External representation.
120 : */
121 : virtual storeError guard (sal_uInt32 nAddr) SAL_OVERRIDE;
122 : virtual storeError verify (sal_uInt32 nAddr) const SAL_OVERRIDE;
123 : };
124 :
125 : /*========================================================================
126 : *
127 : * OStoreIndirectionPageData.
128 : *
129 : *======================================================================*/
130 : #define STORE_MAGIC_INDIRECTPAGE sal_uInt32(0x89191107)
131 :
132 : struct OStoreIndirectionPageData : public store::OStorePageData
133 : {
134 : typedef OStorePageData base;
135 : typedef OStoreIndirectionPageData self;
136 :
137 : typedef OStorePageGuard G;
138 : typedef OStorePageDescriptor D;
139 :
140 : /** Representation.
141 : */
142 : G m_aGuard;
143 : sal_uInt32 m_pData[1];
144 :
145 : /** type.
146 : */
147 : static const sal_uInt32 theTypeId = STORE_MAGIC_INDIRECTPAGE;
148 :
149 : /** size.
150 : */
151 : static const size_t theSize = sizeof(G);
152 : static const sal_uInt16 thePageSize = base::theSize + self::theSize;
153 : static_assert(STORE_MINIMUM_PAGESIZE >= self::thePageSize, "got to be at least equal in size");
154 :
155 : /** capacity.
156 : */
157 0 : static sal_uInt16 capacity (const D& rDescr)
158 : {
159 0 : return (store::ntohs(rDescr.m_nSize) - self::thePageSize);
160 : }
161 0 : sal_uInt16 capacity() const
162 : {
163 0 : return self::capacity (base::m_aDescr);
164 : }
165 :
166 : /** capacityCount.
167 : */
168 0 : static sal_uInt16 capacityCount (const D& rDescr) // @see DirectoryPageObject::scope()
169 : {
170 0 : return sal_uInt16(capacity(rDescr) / sizeof(sal_uInt32));
171 : }
172 0 : sal_uInt16 capacityCount() const
173 : {
174 0 : return sal_uInt16(capacity() / sizeof(sal_uInt32));
175 : }
176 :
177 : /** Construction.
178 : */
179 0 : explicit OStoreIndirectionPageData (sal_uInt16 nPageSize)
180 0 : : base (nPageSize)
181 : {
182 0 : base::m_aGuard.m_nMagic = store::htonl(self::theTypeId);
183 0 : base::m_aDescr.m_nUsed = store::htons(self::thePageSize);
184 0 : self::m_aGuard.m_nMagic = store::htonl(0);
185 0 : memset (m_pData, STORE_PAGE_NULL, capacity());
186 0 : }
187 :
188 : /** guard (external representation).
189 : */
190 0 : void guard()
191 : {
192 0 : sal_uInt32 nCRC32 = 0;
193 0 : nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
194 0 : nCRC32 = rtl_crc32 (nCRC32, m_pData, capacity());
195 0 : m_aGuard.m_nCRC32 = store::htonl(nCRC32);
196 0 : }
197 :
198 : /** verify (external representation).
199 : */
200 0 : storeError verify() const
201 : {
202 0 : sal_uInt32 nCRC32 = 0;
203 0 : nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
204 0 : nCRC32 = rtl_crc32 (nCRC32, m_pData, capacity());
205 0 : if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
206 0 : return store_E_InvalidChecksum;
207 : else
208 0 : return store_E_None;
209 : }
210 : };
211 :
212 : /*========================================================================
213 : *
214 : * OStoreIndirectionPageObject.
215 : *
216 : *======================================================================*/
217 0 : class OStoreIndirectionPageObject : public store::OStorePageObject
218 : {
219 : typedef OStorePageObject base;
220 : typedef OStoreIndirectionPageData page;
221 :
222 : public:
223 : /** Construction.
224 : */
225 0 : explicit OStoreIndirectionPageObject (PageHolder const & rxPage = PageHolder())
226 0 : : OStorePageObject (rxPage)
227 0 : {}
228 :
229 : /** External representation.
230 : */
231 : storeError loadOrCreate (
232 : sal_uInt32 nAddr,
233 : OStorePageBIOS & rBIOS);
234 :
235 : virtual storeError guard (sal_uInt32 nAddr) SAL_OVERRIDE;
236 : virtual storeError verify (sal_uInt32 nAddr) const SAL_OVERRIDE;
237 :
238 : /** read (indirect data page).
239 : */
240 : storeError read (
241 : sal_uInt16 nSingle,
242 : OStoreDataPageObject &rData,
243 : OStorePageBIOS &rBIOS);
244 :
245 : storeError read (
246 : sal_uInt16 nDouble,
247 : sal_uInt16 nSingle,
248 : OStoreDataPageObject &rData,
249 : OStorePageBIOS &rBIOS);
250 :
251 : storeError read (
252 : sal_uInt16 nTriple,
253 : sal_uInt16 nDouble,
254 : sal_uInt16 nSingle,
255 : OStoreDataPageObject &rData,
256 : OStorePageBIOS &rBIOS);
257 :
258 : /** write (indirect data page).
259 : */
260 : storeError write (
261 : sal_uInt16 nSingle,
262 : OStoreDataPageObject &rData,
263 : OStorePageBIOS &rBIOS);
264 :
265 : storeError write (
266 : sal_uInt16 nDouble,
267 : sal_uInt16 nSingle,
268 : OStoreDataPageObject &rData,
269 : OStorePageBIOS &rBIOS);
270 :
271 : storeError write (
272 : sal_uInt16 nTriple,
273 : sal_uInt16 nDouble,
274 : sal_uInt16 nSingle,
275 : OStoreDataPageObject &rData,
276 : OStorePageBIOS &rBIOS);
277 :
278 : /** truncate (indirect data page).
279 : */
280 : storeError truncate (
281 : sal_uInt16 nSingle,
282 : OStorePageBIOS &rBIOS);
283 :
284 : storeError truncate (
285 : sal_uInt16 nDouble,
286 : sal_uInt16 nSingle,
287 : OStorePageBIOS &rBIOS);
288 :
289 : storeError truncate (
290 : sal_uInt16 nTriple,
291 : sal_uInt16 nDouble,
292 : sal_uInt16 nSingle,
293 : OStorePageBIOS &rBIOS);
294 : };
295 :
296 : /*========================================================================
297 : *
298 : * OStorePageNameBlock.
299 : *
300 : *======================================================================*/
301 : struct OStorePageNameBlock
302 : {
303 : typedef OStorePageGuard G;
304 : typedef OStorePageKey K;
305 :
306 : /** Representation.
307 : */
308 : G m_aGuard;
309 : K m_aKey;
310 : sal_uInt32 m_nAttrib;
311 : sal_Char m_pData[STORE_MAXIMUM_NAMESIZE];
312 :
313 : /** size.
314 : */
315 : static const size_t theSize = sizeof(G) + sizeof(K) + sizeof(sal_uInt32) + sizeof(sal_Char[STORE_MAXIMUM_NAMESIZE]);
316 :
317 : /** initialize.
318 : */
319 : void initialize()
320 : {
321 : m_aGuard = G();
322 : m_aKey = K();
323 : m_nAttrib = 0;
324 : memset (m_pData, 0, sizeof(m_pData));
325 : }
326 :
327 : /** Construction.
328 : */
329 959 : OStorePageNameBlock()
330 959 : : m_aGuard(), m_aKey(), m_nAttrib (0)
331 : {
332 959 : memset (m_pData, 0, sizeof(m_pData));
333 959 : }
334 :
335 : /** guard (external representation).
336 : */
337 1357 : void guard()
338 : {
339 1357 : sal_uInt32 nCRC32 = 0;
340 1357 : nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
341 1357 : nCRC32 = rtl_crc32 (nCRC32, &m_aKey, theSize - sizeof(G));
342 1357 : m_aGuard.m_nCRC32 = store::htonl(nCRC32);
343 1357 : }
344 :
345 : /** verify (external representation).
346 : */
347 0 : storeError verify() const
348 : {
349 0 : sal_uInt32 nCRC32 = 0;
350 0 : nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
351 0 : nCRC32 = rtl_crc32 (nCRC32, &m_aKey, theSize - sizeof(G));
352 0 : if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
353 0 : return store_E_InvalidChecksum;
354 : else
355 0 : return store_E_None;
356 : }
357 : };
358 :
359 : /*========================================================================
360 : *
361 : * OStoreDirectoryDataBlock.
362 : *
363 : *======================================================================*/
364 : #define STORE_LIMIT_DATAPAGE_DIRECT 16
365 : #define STORE_LIMIT_DATAPAGE_SINGLE 8
366 : #define STORE_LIMIT_DATAPAGE_DOUBLE 1
367 : #define STORE_LIMIT_DATAPAGE_TRIPLE 1
368 :
369 : struct OStoreDirectoryDataBlock
370 : {
371 : typedef OStorePageGuard G;
372 :
373 : /** LinkDescriptor.
374 : */
375 : struct LinkDescriptor
376 : {
377 : /** Representation.
378 : */
379 : sal_uInt16 m_nIndex0;
380 : sal_uInt16 m_nIndex1;
381 : sal_uInt16 m_nIndex2;
382 : sal_uInt16 m_nIndex3;
383 :
384 : /** Construction.
385 : */
386 237 : LinkDescriptor()
387 : : m_nIndex0 ((sal_uInt16)(~0)),
388 : m_nIndex1 ((sal_uInt16)(~0)),
389 : m_nIndex2 ((sal_uInt16)(~0)),
390 237 : m_nIndex3 ((sal_uInt16)(~0))
391 237 : {}
392 : };
393 :
394 : /** LinkTable.
395 : */
396 : struct LinkTable
397 : {
398 : /** Representation.
399 : */
400 : sal_uInt32 m_pDirect[STORE_LIMIT_DATAPAGE_DIRECT];
401 : sal_uInt32 m_pSingle[STORE_LIMIT_DATAPAGE_SINGLE];
402 : sal_uInt32 m_pDouble[STORE_LIMIT_DATAPAGE_DOUBLE];
403 : sal_uInt32 m_pTriple[STORE_LIMIT_DATAPAGE_TRIPLE];
404 :
405 : /** initialize.
406 : */
407 959 : void initialize()
408 : {
409 959 : memset(m_pDirect, STORE_PAGE_NULL, sizeof(m_pDirect));
410 959 : memset(m_pSingle, STORE_PAGE_NULL, sizeof(m_pSingle));
411 959 : memset(m_pDouble, STORE_PAGE_NULL, sizeof(m_pDouble));
412 959 : memset(m_pTriple, STORE_PAGE_NULL, sizeof(m_pTriple));
413 959 : }
414 :
415 : /** Construction.
416 : */
417 959 : LinkTable()
418 : {
419 959 : initialize();
420 959 : }
421 : };
422 :
423 : /** Representation.
424 : */
425 : G m_aGuard;
426 : LinkTable m_aTable;
427 : sal_uInt32 m_nDataLen;
428 :
429 : /** size.
430 : */
431 : static const size_t theSize = sizeof(G) + sizeof(LinkTable) + sizeof(sal_uInt32);
432 :
433 : /** initialize.
434 : */
435 : void initialize()
436 : {
437 : m_aGuard = G();
438 : m_aTable.initialize();
439 : m_nDataLen = 0;
440 : }
441 :
442 : /** Construction.
443 : */
444 959 : OStoreDirectoryDataBlock()
445 959 : : m_aGuard(), m_aTable(), m_nDataLen (0)
446 959 : {}
447 :
448 : /** guard (external representation).
449 : */
450 1357 : void guard()
451 : {
452 1357 : sal_uInt32 nCRC32 = 0;
453 1357 : nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
454 1357 : nCRC32 = rtl_crc32 (nCRC32, &m_aTable, theSize - sizeof(G));
455 1357 : m_aGuard.m_nCRC32 = store::htonl(nCRC32);
456 1357 : }
457 :
458 : /** verify (external representation).
459 : */
460 0 : storeError verify() const
461 : {
462 0 : sal_uInt32 nCRC32 = 0;
463 0 : nCRC32 = rtl_crc32 (nCRC32, &m_aGuard.m_nMagic, sizeof(sal_uInt32));
464 0 : nCRC32 = rtl_crc32 (nCRC32, &m_aTable, theSize - sizeof(G));
465 0 : if (m_aGuard.m_nCRC32 != store::htonl(nCRC32))
466 0 : return store_E_InvalidChecksum;
467 : else
468 0 : return store_E_None;
469 : }
470 :
471 : /** direct.
472 : */
473 : static const sal_uInt16 directCount = ((sal_uInt16)(STORE_LIMIT_DATAPAGE_DIRECT));
474 :
475 252 : sal_uInt32 directLink (sal_uInt16 nIndex) const
476 : {
477 252 : if (nIndex < directCount)
478 252 : return store::ntohl(m_aTable.m_pDirect[nIndex]);
479 : else
480 0 : return STORE_PAGE_NULL;
481 : }
482 120 : void directLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
483 : {
484 120 : if (nIndex < directCount)
485 120 : m_aTable.m_pDirect[nIndex] = store::htonl(nAddr);
486 120 : }
487 :
488 : /** single.
489 : */
490 : static const sal_uInt16 singleCount = ((sal_uInt16)(STORE_LIMIT_DATAPAGE_SINGLE));
491 :
492 8 : sal_uInt32 singleLink (sal_uInt16 nIndex) const
493 : {
494 8 : if (nIndex < singleCount)
495 8 : return store::ntohl(m_aTable.m_pSingle[nIndex]);
496 : else
497 0 : return STORE_PAGE_NULL;
498 : }
499 8 : void singleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
500 : {
501 8 : if (nIndex < singleCount)
502 8 : m_aTable.m_pSingle[nIndex] = store::htonl(nAddr);
503 8 : }
504 :
505 : /** double.
506 : */
507 : static const sal_uInt16 doubleCount = ((sal_uInt16)(STORE_LIMIT_DATAPAGE_DOUBLE));
508 :
509 1 : sal_uInt32 doubleLink (sal_uInt16 nIndex) const
510 : {
511 1 : if (nIndex < doubleCount)
512 1 : return store::ntohl(m_aTable.m_pDouble[nIndex]);
513 : else
514 0 : return STORE_PAGE_NULL;
515 : }
516 1 : void doubleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
517 : {
518 1 : if (nIndex < doubleCount)
519 1 : m_aTable.m_pDouble[nIndex] = store::htonl(nAddr);
520 1 : }
521 :
522 : /** triple.
523 : */
524 : static const sal_uInt16 tripleCount = ((sal_uInt16)(STORE_LIMIT_DATAPAGE_TRIPLE));
525 :
526 1 : sal_uInt32 tripleLink (sal_uInt16 nIndex) const
527 : {
528 1 : if (nIndex < tripleCount)
529 1 : return store::ntohl(m_aTable.m_pTriple[nIndex]);
530 : else
531 0 : return STORE_PAGE_NULL;
532 : }
533 1 : void tripleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
534 : {
535 1 : if (nIndex < tripleCount)
536 1 : m_aTable.m_pTriple[nIndex] = store::htonl(nAddr);
537 1 : }
538 : };
539 :
540 : /*========================================================================
541 : *
542 : * OStoreDirectoryPageData.
543 : *
544 : *======================================================================*/
545 : #define STORE_MAGIC_DIRECTORYPAGE sal_uInt32(0x62190120)
546 :
547 : struct OStoreDirectoryPageData : public store::OStorePageData
548 : {
549 : typedef OStorePageData base;
550 : typedef OStoreDirectoryPageData self;
551 :
552 : typedef OStorePageDescriptor D;
553 : typedef OStorePageNameBlock NameBlock;
554 : typedef OStoreDirectoryDataBlock DataBlock;
555 :
556 : /** Representation.
557 : */
558 : NameBlock m_aNameBlock;
559 : DataBlock m_aDataBlock;
560 : sal_uInt8 m_pData[1];
561 :
562 : /** type.
563 : */
564 : static const sal_uInt32 theTypeId = STORE_MAGIC_DIRECTORYPAGE;
565 :
566 : /** size.
567 : */
568 : static const size_t theSize = NameBlock::theSize + DataBlock::theSize;
569 : static const sal_uInt16 thePageSize = base::theSize + self::theSize;
570 : static_assert(STORE_MINIMUM_PAGESIZE >= self::thePageSize, "got to be at least equal in size");
571 :
572 : /** capacity.
573 : */
574 2037 : sal_uInt16 capacity() const
575 : {
576 2037 : return (store::ntohs(base::m_aDescr.m_nSize) - self::thePageSize);
577 : }
578 :
579 : /** usage.
580 : */
581 : sal_uInt16 usage() const
582 : {
583 : return (store::ntohs(base::m_aDescr.m_nUsed) - self::thePageSize);
584 : }
585 :
586 : /** initialize.
587 : */
588 : void initialize()
589 : {
590 : base::m_aGuard.m_nMagic = store::htonl(self::theTypeId);
591 : base::m_aDescr.m_nUsed = store::htons(self::thePageSize);
592 :
593 : m_aNameBlock.initialize();
594 : m_aDataBlock.initialize();
595 :
596 : memset (m_pData, 0, capacity());
597 : }
598 :
599 : /** Construction.
600 : */
601 959 : explicit OStoreDirectoryPageData (sal_uInt16 nPageSize)
602 959 : : base (nPageSize), m_aNameBlock(), m_aDataBlock()
603 : {
604 959 : base::m_aGuard.m_nMagic = store::htonl(self::theTypeId);
605 959 : base::m_aDescr.m_nUsed = store::htons(self::thePageSize);
606 959 : memset (m_pData, 0, capacity());
607 959 : }
608 :
609 : /** guard (external representation).
610 : */
611 1357 : void guard()
612 : {
613 1357 : m_aNameBlock.guard();
614 1357 : m_aDataBlock.guard();
615 1357 : }
616 :
617 : /** verify (external representation).
618 : */
619 0 : storeError verify() const
620 : {
621 0 : storeError eErrCode = m_aNameBlock.verify();
622 0 : if (eErrCode == store_E_None)
623 0 : eErrCode = m_aDataBlock.verify();
624 0 : return eErrCode;
625 : }
626 :
627 : /** ChunkDescriptor.
628 : */
629 : struct ChunkDescriptor
630 : {
631 : /** Representation.
632 : */
633 : sal_uInt32 m_nPage;
634 : sal_uInt16 m_nOffset;
635 : sal_uInt16 m_nLength;
636 :
637 : /** Construction.
638 : */
639 530 : ChunkDescriptor (sal_uInt32 nPosition, sal_uInt16 nCapacity)
640 : {
641 530 : m_nPage = nPosition / nCapacity;
642 530 : m_nOffset = (sal_uInt16)((nPosition % nCapacity) & 0xffff);
643 530 : m_nLength = nCapacity - m_nOffset;
644 530 : }
645 : };
646 :
647 : /** ChunkScope.
648 : */
649 : enum ChunkScope
650 : {
651 : SCOPE_INTERNAL,
652 : SCOPE_EXTERNAL,
653 : SCOPE_DIRECT,
654 : SCOPE_SINGLE,
655 : SCOPE_DOUBLE,
656 : SCOPE_TRIPLE,
657 : SCOPE_UNREACHABLE,
658 : SCOPE_UNKNOWN
659 : };
660 :
661 : /** scope (internal).
662 : */
663 539 : ChunkScope scope (sal_uInt32 nPosition) const
664 : {
665 539 : sal_uInt32 nCapacity = capacity();
666 539 : if (nPosition < nCapacity)
667 418 : return SCOPE_INTERNAL;
668 : else
669 121 : return SCOPE_EXTERNAL;
670 : }
671 : };
672 :
673 : /*========================================================================
674 : *
675 : * OStoreDirectoryPageObject.
676 : *
677 : *======================================================================*/
678 2188 : class OStoreDirectoryPageObject : public store::OStorePageObject
679 : {
680 : typedef OStorePageObject base;
681 : typedef OStoreDirectoryPageData page;
682 : typedef OStoreIndirectionPageData indirect;
683 :
684 : typedef OStorePageDescriptor D;
685 :
686 : public:
687 : /** Construction.
688 : */
689 2188 : explicit OStoreDirectoryPageObject (PageHolder const & rxPage = PageHolder())
690 2188 : : OStorePageObject (rxPage)
691 2188 : {}
692 :
693 : /** External representation.
694 : */
695 : virtual storeError guard (sal_uInt32 nAddr) SAL_OVERRIDE;
696 : virtual storeError verify (sal_uInt32 nAddr) const SAL_OVERRIDE;
697 :
698 : /** attrib.
699 : */
700 2682 : sal_uInt32 attrib() const
701 : {
702 2682 : return store::ntohl(PAGE().m_aNameBlock.m_nAttrib);
703 : }
704 959 : void attrib (sal_uInt32 nAttrib)
705 : {
706 959 : PAGE().m_aNameBlock.m_nAttrib = store::htonl(nAttrib);
707 959 : touch();
708 959 : }
709 :
710 : /** key.
711 : */
712 0 : OStorePageKey key() const
713 : {
714 0 : return PAGE().m_aNameBlock.m_aKey;
715 : }
716 959 : void key (OStorePageKey const & rKey)
717 : {
718 959 : PAGE().m_aNameBlock.m_aKey = rKey;
719 959 : touch();
720 959 : }
721 :
722 : /** path.
723 : */
724 909 : sal_uInt32 path() const
725 : {
726 909 : page const & rPage = PAGE();
727 909 : const sal_Char * pszName = rPage.m_aNameBlock.m_pData;
728 909 : sal_uInt32 nPath = store::ntohl(rPage.m_aNameBlock.m_aKey.m_nHigh);
729 909 : return rtl_crc32 (nPath, pszName, rtl_str_getLength(pszName));
730 : }
731 :
732 : sal_Size getName (sal_Char * pBuffer, sal_Size nBufsize) const
733 : {
734 : sal_Char const * pszName = PAGE().m_aNameBlock.m_pData;
735 : sal_Size nLength = rtl_str_getLength(pszName);
736 : memcpy (pBuffer, pszName, nLength < nBufsize ? nLength : nBufsize);
737 : return nLength;
738 : }
739 :
740 : /** dataLength.
741 : */
742 977 : sal_uInt32 dataLength() const
743 : {
744 977 : return store::ntohl(PAGE().m_aDataBlock.m_nDataLen);
745 : }
746 526 : void dataLength (sal_uInt32 nLength)
747 : {
748 526 : PAGE().m_aDataBlock.m_nDataLen = store::htonl(nLength);
749 526 : touch();
750 526 : }
751 :
752 : /** direct.
753 : */
754 252 : sal_uInt32 directLink (sal_uInt16 nIndex) const
755 : {
756 252 : return PAGE().m_aDataBlock.directLink (nIndex);
757 : }
758 120 : void directLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
759 : {
760 120 : PAGE().m_aDataBlock.directLink (nIndex, nAddr);
761 120 : touch();
762 120 : }
763 :
764 : /** single indirect.
765 : */
766 8 : sal_uInt32 singleLink (sal_uInt16 nIndex) const
767 : {
768 8 : return PAGE().m_aDataBlock.singleLink (nIndex);
769 : }
770 8 : void singleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
771 : {
772 8 : PAGE().m_aDataBlock.singleLink (nIndex, nAddr);
773 8 : touch();
774 8 : }
775 :
776 : /** double indirect.
777 : */
778 1 : sal_uInt32 doubleLink (sal_uInt16 nIndex) const
779 : {
780 1 : return PAGE().m_aDataBlock.doubleLink (nIndex);
781 : }
782 1 : void doubleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
783 : {
784 1 : PAGE().m_aDataBlock.doubleLink (nIndex, nAddr);
785 1 : touch();
786 1 : }
787 :
788 : /** triple indirect.
789 : */
790 1 : sal_uInt32 tripleLink (sal_uInt16 nIndex) const
791 : {
792 1 : return PAGE().m_aDataBlock.tripleLink (nIndex);
793 : }
794 1 : void tripleLink (sal_uInt16 nIndex, sal_uInt32 nAddr)
795 : {
796 1 : PAGE().m_aDataBlock.tripleLink (nIndex, nAddr);
797 1 : touch();
798 1 : }
799 :
800 : /** read (external data page).
801 : */
802 : storeError read (
803 : sal_uInt32 nPage,
804 : OStoreDataPageObject &rData,
805 : OStorePageBIOS &rBIOS);
806 :
807 : /** write (external data page).
808 : */
809 : storeError write (
810 : sal_uInt32 nPage,
811 : OStoreDataPageObject &rData,
812 : OStorePageBIOS &rBIOS);
813 :
814 : /** truncate (external data page).
815 : */
816 : storeError truncate (
817 : sal_uInt32 nPage,
818 : OStorePageBIOS &rBIOS);
819 :
820 : private:
821 : /** Representation.
822 : */
823 2574 : page & PAGE()
824 : {
825 2574 : page * pImpl = static_cast<page*>(m_xPage.get());
826 : OSL_PRECOND(pImpl != 0, "OStoreDirectoryPageObject::PAGE(): Null pointer");
827 2574 : return (*pImpl);
828 : }
829 5067 : page const & PAGE() const
830 : {
831 5067 : page const * pImpl = static_cast<page const *>(m_xPage.get());
832 : OSL_PRECOND(pImpl != 0, "OStoreDirectoryPageObject::PAGE(): Null pointer");
833 5067 : return (*pImpl);
834 : }
835 :
836 : /** scope (external data page; private).
837 : */
838 : page::ChunkScope scope (
839 : sal_uInt32 nPage,
840 : page::DataBlock::LinkDescriptor &rDescr) const;
841 :
842 : /** truncate (external data page scope; private).
843 : */
844 : storeError truncate (
845 : page::ChunkScope eScope,
846 : sal_uInt16 nRemain,
847 : OStorePageBIOS &rBIOS);
848 : };
849 :
850 : /*========================================================================
851 : *
852 : * The End.
853 : *
854 : *======================================================================*/
855 :
856 : } // namespace store
857 :
858 : #endif // INCLUDED_STORE_SOURCE_STORDATA_HXX
859 :
860 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
