src/ceph/src/test/common/ObjectContents.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 #include "ObjectContents.h"
   3 #include "include/buffer.h"
   4 #include <iostream>
   5 #include <map>
   6
   7 bool test_object_contents()
   8 {
   9   ObjectContents c, d;
  10   assert(!c.exists());
  11   c.debug(std::cerr);
  12   c.write(10, 10, 10);
  13   assert(c.exists());
  14   assert(c.size() == 20);
  15
  16   c.debug(std::cerr);
  17   bufferlist bl;
  18   for (ObjectContents::Iterator iter = c.get_iterator();
  19        iter.valid();
  20        ++iter) {
  21     bl.append(*iter);
  22   }
  23   assert(bl.length() == 20);
  24
  25   bufferlist bl2;
  26   for (unsigned i = 0; i < 8; ++i) bl2.append(bl[i]);
  27   c.write(10, 8, 4);
  28   c.debug(std::cerr);
  29   ObjectContents::Iterator iter = c.get_iterator();
  30   iter.seek_to(8);
  31   for (uint64_t i = 8;
  32        i < 12;
  33        ++i, ++iter) {
  34     bl2.append(*iter);
  35   }
  36   for (unsigned i = 12; i < 20; ++i) bl2.append(bl[i]);
  37   assert(bl2.length() == 20);
  38
  39   for (ObjectContents::Iterator iter3 = c.get_iterator();
  40        iter.valid();
  41        ++iter) {
  42     assert(bl2[iter3.get_pos()] == *iter3);
  43   }
  44
  45   assert(bl2[0] == '\0');
  46   assert(bl2[7] == '\0');
  47
  48   interval_set<uint64_t> to_clone;
  49   to_clone.insert(5, 10);
  50   d.clone_range(c, to_clone);
  51   assert(d.size() == 15);
  52
  53   c.debug(std::cerr);
  54   d.debug(std::cerr);
  55
  56   ObjectContents::Iterator iter2 = d.get_iterator();
  57   iter2.seek_to(5);
  58   for (uint64_t i = 5; i < 15; ++i, ++iter2) {
  59     std::cerr << "i is " << i << std::endl;
  60     assert(iter2.get_pos() == i);
  61     assert(*iter2 == bl2[i]);
  62   }
  63   return true;
  64 }
  65
  66
  67 unsigned int ObjectContents::Iterator::get_state(uint64_t _pos)
  68 {
  69   if (parent->seeds.count(_pos)) {
  70     return parent->seeds[_pos];
  71   }
  72   seek_to(_pos - 1);
  73   return current_state;
  74 }
  75
  76 void ObjectContents::clone_range(ObjectContents &other,
  77                                  interval_set<uint64_t> &intervals)
  78 {
  79   interval_set<uint64_t> written_to_clone;
  80   written_to_clone.intersection_of(intervals, other.written);
  81
  82   interval_set<uint64_t> zeroed = intervals;
  83   zeroed.subtract(written_to_clone);
  84
  85   written.union_of(intervals);
  86   written.subtract(zeroed);
  87
  88   for (interval_set<uint64_t>::iterator i = written_to_clone.begin();
  89        i != written_to_clone.end();
  90        ++i) {
  91     uint64_t start = i.get_start();
  92     uint64_t len = i.get_len();
  93
  94     unsigned int seed = get_iterator().get_state(start+len);
  95
  96     seeds[start+len] = seed;
  97     seeds.erase(seeds.lower_bound(start), seeds.lower_bound(start+len));
  98
  99     seeds[start] = other.get_iterator().get_state(start);
 100     seeds.insert(other.seeds.upper_bound(start),
 101                  other.seeds.lower_bound(start+len));
 102   }
 103
 104   if (intervals.range_end() > _size)
 105     _size = intervals.range_end();
 106   _exists = true;
 107   return;
 108 }
 109
 110 void ObjectContents::write(unsigned int seed,
 111                            uint64_t start,
 112                            uint64_t len)
 113 {
 114   _exists = true;
 115   unsigned int _seed = get_iterator().get_state(start+len);
 116   seeds[start+len] = _seed;
 117   seeds.erase(seeds.lower_bound(start),
 118               seeds.lower_bound(start+len));
 119   seeds[start] = seed;
 120
 121   interval_set<uint64_t> to_write;
 122   to_write.insert(start, len);
 123   written.union_of(to_write);
 124
 125   if (start + len > _size)
 126     _size = start + len;
 127   return;
 128 }