sync.hpp

Go to the documentation of this file.

/******************************************************************************
 * THIS FILE IS GENERATED - ANY EDITS WILL BE OVERWRITTEN
 */
 
#pragma once
 
#include "basejob.hpp"
#include "event.hpp"
#include "csapi/definitions/timeline_batch.hpp"
#include "csapi/definitions/event_batch.hpp"
#include "csapi/definitions/state_event_batch.hpp"
 
namespace Kazv::Api {
 
class SyncJob : public BaseJob {
public:
  // Inner data structures
 
    struct RoomSummary
        {
          immer::array<std::string> mHeroes;
          std::optional<int> mJoinedMemberCount;
          std::optional<int> mInvitedMemberCount;
        
        };
 
    struct UnreadNotificationCounts
        {
          std::optional<int> highlightCount;
          std::optional<int> notificationCount;
        
        };
 
    struct JoinedRoom
        {
          std::optional<RoomSummary> summary;
          std::optional<StateEventBatch> state;
          Timeline timeline;
          std::optional<EventBatch> ephemeral;
          std::optional<EventBatch> accountData;
          std::optional<UnreadNotificationCounts> unreadNotifications;
        
        };
 
    struct InviteState
        {
          EventList events;
        
        };
 
    struct InvitedRoom
        {
          std::optional<InviteState> inviteState;
        
        };
 
    struct KnockState
        {
          EventList events;
        
        };
 
    struct KnockedRoom
        {
          std::optional<KnockState> knockState;
        
        };
 
    struct LeftRoom
        {
          std::optional<StateEventBatch> state;
          Timeline timeline;
          std::optional<EventBatch> accountData;
        
        };
 
    struct Rooms
        {
          immer::map<std::string, JoinedRoom> join;
          immer::map<std::string, InvitedRoom> invite;
          immer::map<std::string, KnockedRoom> knock;
          immer::map<std::string, LeftRoom> leave;
        
        };
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
std::string nextBatch() const;
 
    
std::optional<Rooms> rooms() const;
 
    
std::optional<EventBatch> presence() const;
 
    
std::optional<EventBatch> accountData() const;
 
    
JsonWrap toDevice() const;
 
    
JsonWrap deviceLists() const;
 
    
immer::map<std::string, int> deviceOneTimeKeysCount() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit SyncJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::optional<std::string> filter  = std::nullopt, std::optional<std::string> since  = std::nullopt, std::optional<bool> fullState  = std::nullopt, std::optional<std::string> setPresence  = std::nullopt, std::optional<int> timeout  = std::nullopt
        );
 
 
    static BaseJob::Query buildQuery(
    std::optional<std::string> filter, std::optional<std::string> since, std::optional<bool> fullState, std::optional<std::string> setPresence, std::optional<int> timeout);
 
      static BaseJob::Body buildBody(std::optional<std::string> filter, std::optional<std::string> since, std::optional<bool> fullState, std::optional<std::string> setPresence, std::optional<int> timeout);
 
        
 
        
 
      SyncJob withData(JsonWrap j) &&;
      SyncJob withData(JsonWrap j) const &;
      };
      using SyncResponse = SyncJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
      template<>
      struct adl_serializer<SyncJob::RoomSummary> {
 
  static void to_json(json& jo, const SyncJob::RoomSummary &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "m.heroes"s, pod.mHeroes);
    
    addToJsonIfNeeded(jo, "m.joined_member_count"s, pod.mJoinedMemberCount);
    
    addToJsonIfNeeded(jo, "m.invited_member_count"s, pod.mInvitedMemberCount);
  }
 
  static void from_json(const json &jo, SyncJob::RoomSummary& result)
  {
  
    if (jo.contains("m.heroes"s)) {
      result.mHeroes = jo.at("m.heroes"s);
    }
    if (jo.contains("m.joined_member_count"s)) {
      result.mJoinedMemberCount = jo.at("m.joined_member_count"s);
    }
    if (jo.contains("m.invited_member_count"s)) {
      result.mInvitedMemberCount = jo.at("m.invited_member_count"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SyncJob::UnreadNotificationCounts> {
 
  static void to_json(json& jo, const SyncJob::UnreadNotificationCounts &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "highlight_count"s, pod.highlightCount);
    
    addToJsonIfNeeded(jo, "notification_count"s, pod.notificationCount);
  }
 
  static void from_json(const json &jo, SyncJob::UnreadNotificationCounts& result)
  {
  
    if (jo.contains("highlight_count"s)) {
      result.highlightCount = jo.at("highlight_count"s);
    }
    if (jo.contains("notification_count"s)) {
      result.notificationCount = jo.at("notification_count"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SyncJob::JoinedRoom> {
 
  static void to_json(json& jo, const SyncJob::JoinedRoom &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "summary"s, pod.summary);
    
    addToJsonIfNeeded(jo, "state"s, pod.state);
    
    addToJsonIfNeeded(jo, "timeline"s, pod.timeline);
    
    addToJsonIfNeeded(jo, "ephemeral"s, pod.ephemeral);
    
    addToJsonIfNeeded(jo, "account_data"s, pod.accountData);
    
    addToJsonIfNeeded(jo, "unread_notifications"s, pod.unreadNotifications);
  }
 
  static void from_json(const json &jo, SyncJob::JoinedRoom& result)
  {
  
    if (jo.contains("summary"s)) {
      result.summary = jo.at("summary"s);
    }
    if (jo.contains("state"s)) {
      result.state = jo.at("state"s);
    }
    if (jo.contains("timeline"s)) {
      result.timeline = jo.at("timeline"s);
    }
    if (jo.contains("ephemeral"s)) {
      result.ephemeral = jo.at("ephemeral"s);
    }
    if (jo.contains("account_data"s)) {
      result.accountData = jo.at("account_data"s);
    }
    if (jo.contains("unread_notifications"s)) {
      result.unreadNotifications = jo.at("unread_notifications"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SyncJob::InviteState> {
 
  static void to_json(json& jo, const SyncJob::InviteState &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "events"s, pod.events);
  }
 
  static void from_json(const json &jo, SyncJob::InviteState& result)
  {
  
    if (jo.contains("events"s)) {
      result.events = jo.at("events"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SyncJob::InvitedRoom> {
 
  static void to_json(json& jo, const SyncJob::InvitedRoom &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "invite_state"s, pod.inviteState);
  }
 
  static void from_json(const json &jo, SyncJob::InvitedRoom& result)
  {
  
    if (jo.contains("invite_state"s)) {
      result.inviteState = jo.at("invite_state"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SyncJob::KnockState> {
 
  static void to_json(json& jo, const SyncJob::KnockState &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "events"s, pod.events);
  }
 
  static void from_json(const json &jo, SyncJob::KnockState& result)
  {
  
    if (jo.contains("events"s)) {
      result.events = jo.at("events"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SyncJob::KnockedRoom> {
 
  static void to_json(json& jo, const SyncJob::KnockedRoom &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "knock_state"s, pod.knockState);
  }
 
  static void from_json(const json &jo, SyncJob::KnockedRoom& result)
  {
  
    if (jo.contains("knock_state"s)) {
      result.knockState = jo.at("knock_state"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SyncJob::LeftRoom> {
 
  static void to_json(json& jo, const SyncJob::LeftRoom &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "state"s, pod.state);
    
    addToJsonIfNeeded(jo, "timeline"s, pod.timeline);
    
    addToJsonIfNeeded(jo, "account_data"s, pod.accountData);
  }
 
  static void from_json(const json &jo, SyncJob::LeftRoom& result)
  {
  
    if (jo.contains("state"s)) {
      result.state = jo.at("state"s);
    }
    if (jo.contains("timeline"s)) {
      result.timeline = jo.at("timeline"s);
    }
    if (jo.contains("account_data"s)) {
      result.accountData = jo.at("account_data"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<SyncJob::Rooms> {
 
  static void to_json(json& jo, const SyncJob::Rooms &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    
    addToJsonIfNeeded(jo, "join"s, pod.join);
    
    addToJsonIfNeeded(jo, "invite"s, pod.invite);
    
    addToJsonIfNeeded(jo, "knock"s, pod.knock);
    
    addToJsonIfNeeded(jo, "leave"s, pod.leave);
  }
 
  static void from_json(const json &jo, SyncJob::Rooms& result)
  {
  
    if (jo.contains("join"s)) {
      result.join = jo.at("join"s);
    }
    if (jo.contains("invite"s)) {
      result.invite = jo.at("invite"s);
    }
    if (jo.contains("knock"s)) {
      result.knock = jo.at("knock"s);
    }
    if (jo.contains("leave"s)) {
      result.leave = jo.at("leave"s);
    }
  
  }
 
};
    }
 
    namespace Kazv::Api
    {
 
} // namespace Kazv::Api