space_hierarchy.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"
 
namespace Kazv::Api {
 
class GetSpaceHierarchyJob : public BaseJob {
public:
  // Inner data structures
 
    struct StrippedChildStateEvent :
      Event
        {
          std::int_fast64_t originServerTs;
        
        };
 
    struct ChildRoomsChunk
        {
          int numJoinedMembers;
          std::string roomId;
          bool worldReadable;
          bool guestCanJoin;
          immer::array<StrippedChildStateEvent> childrenState;
          std::optional<std::string> canonicalAlias;
          std::optional<std::string> name;
          std::optional<std::string> topic;
          std::optional<std::string> avatarUrl;
          std::optional<std::string> joinRule;
          std::optional<std::string> roomType;
        
        };
 
 
 
class JobResponse : public Response
{
 
public:
  JobResponse(Response r);
  bool success() const;
 
    // Result properties
        
        
 
    
immer::array<ChildRoomsChunk> rooms() const;
 
    
std::optional<std::string> nextBatch() const;
 
};
          static constexpr auto needsAuth() {
          return true
            ;
              }
 
 
// Construction/destruction
 
    explicit GetSpaceHierarchyJob(std::string serverUrl
    , std::string _accessToken
      ,
        std::string roomId , std::optional<bool> suggestedOnly  = std::nullopt, std::optional<int> limit  = std::nullopt, std::optional<int> maxDepth  = std::nullopt, std::optional<std::string> from  = std::nullopt
        );
 
 
    static BaseJob::Query buildQuery(
    std::optional<bool> suggestedOnly, std::optional<int> limit, std::optional<int> maxDepth, std::optional<std::string> from);
 
      static BaseJob::Body buildBody(std::string roomId, std::optional<bool> suggestedOnly, std::optional<int> limit, std::optional<int> maxDepth, std::optional<std::string> from);
 
        
 
        
 
      GetSpaceHierarchyJob withData(JsonWrap j) &&;
      GetSpaceHierarchyJob withData(JsonWrap j) const &;
      };
      using GetSpaceHierarchyResponse = GetSpaceHierarchyJob::JobResponse;
      } 
      namespace nlohmann
      {
      using namespace Kazv;
      using namespace Kazv::Api;
      template<>
      struct adl_serializer<GetSpaceHierarchyJob::StrippedChildStateEvent> {
 
  static void to_json(json& jo, const GetSpaceHierarchyJob::StrippedChildStateEvent &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
    jo = static_cast<const Event &>(pod);
    //nlohmann::to_json(jo, static_cast<const Event &>(pod));
  
    jo["origin_server_ts"s] = pod.originServerTs;
    
  }
 
  static void from_json(const json &jo, GetSpaceHierarchyJob::StrippedChildStateEvent& result)
  {
    static_cast<Event &>(result) = jo;
    //nlohmann::from_json(jo, static_cast<const Event &>(result));
    if (jo.contains("origin_server_ts"s)) {
      result.originServerTs = jo.at("origin_server_ts"s);
    }
  
  }
 
};
      template<>
      struct adl_serializer<GetSpaceHierarchyJob::ChildRoomsChunk> {
 
  static void to_json(json& jo, const GetSpaceHierarchyJob::ChildRoomsChunk &pod)
  {
  if (! jo.is_object()) { jo = json::object(); }
  
  
    jo["num_joined_members"s] = pod.numJoinedMembers;
    
    jo["room_id"s] = pod.roomId;
    
    jo["world_readable"s] = pod.worldReadable;
    
    jo["guest_can_join"s] = pod.guestCanJoin;
    
    jo["children_state"s] = pod.childrenState;
    
    
    addToJsonIfNeeded(jo, "canonical_alias"s, pod.canonicalAlias);
    
    addToJsonIfNeeded(jo, "name"s, pod.name);
    
    addToJsonIfNeeded(jo, "topic"s, pod.topic);
    
    addToJsonIfNeeded(jo, "avatar_url"s, pod.avatarUrl);
    
    addToJsonIfNeeded(jo, "join_rule"s, pod.joinRule);
    
    addToJsonIfNeeded(jo, "room_type"s, pod.roomType);
  }
 
  static void from_json(const json &jo, GetSpaceHierarchyJob::ChildRoomsChunk& result)
  {
  
    if (jo.contains("num_joined_members"s)) {
      result.numJoinedMembers = jo.at("num_joined_members"s);
    }
    if (jo.contains("room_id"s)) {
      result.roomId = jo.at("room_id"s);
    }
    if (jo.contains("world_readable"s)) {
      result.worldReadable = jo.at("world_readable"s);
    }
    if (jo.contains("guest_can_join"s)) {
      result.guestCanJoin = jo.at("guest_can_join"s);
    }
    if (jo.contains("children_state"s)) {
      result.childrenState = jo.at("children_state"s);
    }
    if (jo.contains("canonical_alias"s)) {
      result.canonicalAlias = jo.at("canonical_alias"s);
    }
    if (jo.contains("name"s)) {
      result.name = jo.at("name"s);
    }
    if (jo.contains("topic"s)) {
      result.topic = jo.at("topic"s);
    }
    if (jo.contains("avatar_url"s)) {
      result.avatarUrl = jo.at("avatar_url"s);
    }
    if (jo.contains("join_rule"s)) {
      result.joinRule = jo.at("join_rule"s);
    }
    if (jo.contains("room_type"s)) {
      result.roomType = jo.at("room_type"s);
    }
  
  }
 
};
    }
 
    namespace Kazv::Api
    {
 
} // namespace Kazv::Api