torrent.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <cstdint>
#include <deque>
#include <peer.hpp>
#include <random>
#include <string>
#include <types.hpp>
#include <vector>
 
#include "bencode/bencode_value.hpp"
#include "hash.hpp"
 
namespace fur {
 
struct File {
  std::vector<std::string> filepath;
  int64_t length;
 
  // =======================================================
 
  [[nodiscard]] std::string filename() const;
};
 
struct TorrentFile {
  std::string announce_url;
  hash::hash_t info_hash{};
  std::vector<hash::hash_t> piece_hashes;
  int64_t piece_length = 0;
  int64_t length = 0;
  int64_t pieces_count = 0;
  std::string name;
 
  std::string folder_name;
  std::vector<File> files;
 
  explicit TorrentFile() = default;
 
  explicit TorrentFile(const bencode::BencodeValue& tree);
};
 
struct Subpiece {
  std::string filepath;
  int64_t file_offset;
  int64_t len;
};
 
struct Piece {
  int64_t index;
  std::vector<Subpiece> subpieces;
};
 
enum class TorrentState {
  Loading,
  Downloading,
  Paused,
  Completed,
  Stopped,
  Error,
};
 
class Torrent {
  // Unique identifier for each torrent
  TorrentID _tid;
  TorrentFile _descriptor;
 
  std::vector<peer::Peer> _peers;
  std::deque<std::atomic_int64_t> _peers_score;
  int64_t _update_interval;
 
 public:
  std::atomic<TorrentState> state;
 
  std::atomic_int64_t pieces_processed;
 
 public:
  explicit Torrent();
 
  Torrent(TorrentID tid, const TorrentFile& descriptor);
 
  void announce();
 
  void atomic_add_peer_score(int64_t peer_index);
 
  [[nodiscard]] TorrentID tid() const;
 
  [[nodiscard]] const TorrentFile& descriptor() const;
 
  [[nodiscard]] std::vector<peer::Peer> peers() const;
 
  [[nodiscard]] std::discrete_distribution<int64_t> distribution() const;
 
  [[nodiscard]] std::vector<Piece> pieces() const;
};
 
}  // namespace fur