mdl_state.h

Go to the documentation of this file.

#pragma once
 
#include <float.h>
#include <stddef.h>
#include <stdint.h>
 
#if !defined(__STDC_IEC_559__) && !defined(__STDC_IEC_60559_BFP__) && !defined(__clang__) &&       \
  !defined(__GNUC__)
#error "mdl state v3 requires IEC 60559 binary floating-point"
#endif
 
static_assert(sizeof(double) == 8U, "mdl state v3 requires binary64 double");
static_assert(FLT_RADIX == 2, "mdl state v3 requires radix-2 floating-point");
typedef enum : int16_t {
  k_mdl_binary64_mantissa_bits = 53,    
  k_mdl_binary64_max_exponent  = 1024,  
  k_mdl_binary64_min_exponent  = -1021, 
} mdl_binary64_parameter_t;
 
static_assert(DBL_MANT_DIG == k_mdl_binary64_mantissa_bits,
              "mdl state requires 53-bit binary64 precision");
static_assert(DBL_MAX_EXP == k_mdl_binary64_max_exponent,
              "mdl state requires binary64 exponent range");
static_assert(DBL_MIN_EXP == k_mdl_binary64_min_exponent,
              "mdl state requires binary64 exponent range");
 
#include "mdl_config.h"
#include "mdl_extract.h"
#include "mdl_net.h"
#include "mdl_storage.h"
#include "ra8_err.h"

typedef enum : uint16_t {
  k_mdl_state_version_v1 = 1,    
  k_mdl_state_version_v2 = 2,    
  k_mdl_state_version_v3 = 3,    
  k_mdl_state_version    = 4,    
  k_mdl_chapter_id_max   = 128,  
  k_mdl_title_max        = 192,  
  k_mdl_summary_max      = 1024, 
  k_mdl_person_max       = 128,  
  k_mdl_language_max     = 16,   
  k_mdl_relpath_max      = 200,  
  k_mdl_cfgpath_max      = 512,  
  k_mdl_max_chapters     = 512,  
} mdl_state_limit_t;

typedef enum : uint8_t {
  k_mdl_state_read_ltr = 0, 
  k_mdl_state_read_rtl = 1, 
} mdl_state_reading_direction_t;

typedef enum : uint32_t {
  k_mdl_max_page_recs = 8192U, 
} mdl_state_pool_t;

typedef struct {
  char     chapter_id[k_mdl_chapter_id_max]; 
  char     source_url[k_mdl_url_max];        
  char     title[k_mdl_title_max];           
  double   number;                           
  bool     number_known;                     
  uint16_t page_count;                       
  uint16_t pages_done;                       
  bool     complete;                         
  int64_t  fetched_at;                       
} mdl_chapter_rec_t;

typedef struct {
  uint64_t url_hash;                    
  uint64_t content_hash;                
  char     rel_path[k_mdl_relpath_max]; 
  char     etag[k_mdl_etag_max];        
  char     last_modified[k_mdl_last_mod_max];
  int64_t  fetched_at;      
  uint16_t response_status; 
} mdl_page_rec_t;

typedef struct {
  uint16_t version;                        
  char     series_url[k_mdl_url_max];      
  char     series_title[k_mdl_title_max];  
  char     site_name[k_mdl_name_max];      
  char     site_host[k_mdl_host_max];      
  char     config_path[k_mdl_cfgpath_max]; 
  char     summary[k_mdl_summary_max];     
  char     writer[k_mdl_person_max];       
  char     artist[k_mdl_person_max];       
  char     cover_url[k_mdl_url_max];       
  char     cover_path[k_mdl_relpath_max];  
  char     language[k_mdl_language_max];   
  mdl_state_reading_direction_t reading_direction;
  uint16_t chapter_count;
  uint32_t page_rec_count;
  mdl_chapter_rec_t chapters[k_mdl_max_chapters];
  mdl_page_rec_t pages[k_mdl_max_page_recs];
} mdl_state_t;

void mdl_state_init(mdl_state_t* st);

void mdl_state_set_series(mdl_state_t* st,
                          const char*  url,
                          const char*  title,
                          const char*  site_name,
                          const char*  site_host,
                          const char*  config_path);

bool mdl_state_set_series_metadata(mdl_state_t*                  st,
                                   const char*                   summary,
                                   const char*                   writer,
                                   const char*                   artist,
                                   const char*                   cover_url,
                                   const char*                   cover_path,
                                   const char*                   language,
                                   mdl_state_reading_direction_t direction);

ra8_err_t mdl_state_load(mdl_storage_t* storage, const char* path, mdl_state_t* st);

[[nodiscard]] ra8_err_t
mdl_state_load_authenticated(mdl_storage_t* storage, const char* path, mdl_state_t* st);

ra8_err_t mdl_state_save(mdl_storage_t*     storage,
                         const char*        path,
                         const mdl_state_t* st,
                         bool*              out_published);

[[nodiscard]] ra8_err_t mdl_state_probe(mdl_storage_t* storage, const char* path, bool* out_exists);

mdl_chapter_rec_t* mdl_state_find_chapter(mdl_state_t* st, const char* id);

mdl_chapter_rec_t*
mdl_state_add_chapter(mdl_state_t* st, const char* id, const char* url, long number);

mdl_chapter_rec_t* mdl_state_add_chapter_numbered(mdl_state_t* st,
                                                  const char*  id,
                                                  const char*  url,
                                                  double       number,
                                                  bool         number_known);

bool mdl_state_set_chapter_metadata(mdl_chapter_rec_t* chapter,
                                    const char*        title,
                                    double             number,
                                    bool               number_known);

bool mdl_state_chapter_complete(const mdl_state_t* st, const char* id);

uint16_t mdl_state_chapter_pages(const mdl_state_t* st, const char* id);

const mdl_page_rec_t* mdl_state_find_page(const mdl_state_t* st, uint64_t url_hash);

bool mdl_state_add_page(mdl_state_t* st,
                        uint64_t     url_hash,
                        uint64_t     content_hash,
                        const char*  rel_path,
                        const char*  etag,
                        const char*  last_modified,
                        int64_t      fetched_at,
                        uint16_t     response_status);

bool mdl_state_note_page_response(mdl_state_t* st,
                                  uint64_t     url_hash,
                                  int64_t      fetched_at,
                                  uint16_t     response_status);

void mdl_state_coverage(const mdl_state_t* st, char* buf, size_t cap);