Ton

1
/*
2
    This file is part of TON Blockchain Library.
3

4
    TON Blockchain Library is free software: you can redistribute it and/or modify
5
    it under the terms of the GNU Lesser General Public License as published by
6
    the Free Software Foundation, either version 2 of the License, or
7
    (at your option) any later version.
8

9
    TON Blockchain Library is distributed in the hope that it will be useful,
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
    GNU Lesser General Public License for more details.
13

14
    You should have received a copy of the GNU Lesser General Public License
15
    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
16

17
    Copyright 2017-2020 Telegram Systems LLP
18
*/
19

20
#include "FileSyncState.h"
21
namespace td {
22
std::pair<FileSyncState::Reader, FileSyncState::Writer> FileSyncState::create() {
23
  auto self = std::make_shared<Self>();
24
  return {Reader(self), Writer(self)};
25
}
26

27
FileSyncState::Reader::Reader(std::shared_ptr<Self> self) : self(std::move(self)) {
28
}
29
bool FileSyncState::Reader::set_requested_sync_size(size_t size) const {
30
  if (self->requested_synced_size.load(std::memory_order_relaxed) == size) {
31
    return false;
32
  }
33
  self->requested_synced_size.store(size, std::memory_order_release);
34
  return true;
35
}
36

37
size_t FileSyncState::Reader::synced_size() const {
38
  return self->synced_size;
39
}
40
size_t FileSyncState::Reader::flushed_size() const {
41
  return self->flushed_size;
42
}
43

44
FileSyncState::Writer::Writer(std::shared_ptr<Self> self) : self(std::move(self)) {
45
}
46

47
size_t FileSyncState::Writer::get_requested_synced_size() {
48
  return self->requested_synced_size.load(std::memory_order_acquire);
49
}
50

51
bool FileSyncState::Writer::set_synced_size(size_t size) {
52
  if (self->synced_size.load(std::memory_order_relaxed) == size) {
53
    return false;
54
  }
55
  self->synced_size.store(size, std::memory_order_release);
56
  return true;
57
}
58

59
bool FileSyncState::Writer::set_flushed_size(size_t size) {
60
  if (self->flushed_size.load(std::memory_order_relaxed) == size) {
61
    return false;
62
  }
63
  self->flushed_size.store(size, std::memory_order_release);
64
  return true;
65
}
66

67
}  // namespace td
68