jsonobjectdescriptions.h

Go to the documentation of this file.

/********************************************************************************************
 * Twitch Broadcasting SDK
 *
 * This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
 * may not be copied or used except in accordance with the terms of that agreement
 * Copyright (c) 2012-2016 Twitch Interactive, Inc.
 *********************************************************************************************/

#pragma once

#include "twitchsdk/core/json/jsonserialization.h"

namespace ttv
{
    namespace json
    {
        namespace description
        {
            struct UserInfo;                    
            struct ChannelInfo;                 
            struct StreamInfo;                  
            struct BroadcasterType;             
            struct PreviewImages;               
            struct BroadcastPlatform;           
            struct StreamType;                  
        }
    }
}


struct ttv::json::description::UserInfo
{
    template <typename UserInfoType>
    static auto BindFields(UserInfoType& info)
    {
        return std::make_tuple
        (
            make_field<RequiredField>("_id", info.userId),
            make_field<RequiredField>("name", info.userName),
            make_field("display_name", info.displayName),
            make_field("bio", info.bio),
            make_field("logo", info.logoImageUrl),
            make_field<DateSchema, OptionalField>("created_at", info.createdTimestamp)
         );
    }
};


struct ttv::json::description::ChannelInfo
{
    template <typename ChannelInfoType>
    static auto BindFields(ChannelInfoType& channelInfo)
    {
        using namespace ttv::json;
        
        return std::make_tuple
        (
            make_field<RequiredField>("_id", channelInfo.channelId),
            make_field<OptionalField>("broadcaster_language", channelInfo.broadcasterLanguage),
            make_field<OptionalField>("broadcaster_type", channelInfo.broadcasterType),
            make_field<DateSchema, OptionalField>("created_at", channelInfo.createdAtTimestamp),
            make_field<OptionalField>("description", channelInfo.description),
            make_field<OptionalField>("display_name", channelInfo.displayName),
            make_field<OptionalField>("followers", channelInfo.numFollowers),
            make_field<OptionalField>("game", channelInfo.game),
            make_field<OptionalField>("language", channelInfo.language),
            make_field<OptionalField>("logo", channelInfo.logoImageUrl),
            make_field<OptionalField>("mature", channelInfo.mature),
            make_field<OptionalField>("name", channelInfo.name),
            make_field<OptionalField>("partner", channelInfo.partner),
            make_field<OptionalField>("profile_banner", channelInfo.profileBannerImageUrl),
            make_field<ColorSchema, OptionalField>("profile_banner_background_color", channelInfo.profileBannerBackgroundColor),
            make_field<OptionalField>("status", channelInfo.status),
            make_field<DateSchema, OptionalField>("updated_at", channelInfo.updatedAtTimestamp),
            make_field<OptionalField>("url", channelInfo.channelUrl),
            make_field<OptionalField>("video_banner", channelInfo.videoBannerImageUrl),
            make_field<OptionalField>("views", channelInfo.numViews)
        );
    }
};


struct ttv::json::description::BroadcasterType
{
    static auto EnumMap()
    {
        using namespace ttv::json;
        
        return std::make_tuple
        (
            make_enum_mapping("partner", ttv::BroadcasterType::Partner),
            make_enum_mapping("affiliate", ttv::BroadcasterType::Affiliate),
            make_enum_mapping("", ttv::BroadcasterType::None)
        );
    }
    
    static auto GetFallbackValue()
    {
        return ttv::BroadcasterType::Unknown;
    }
};


struct ttv::json::description::StreamInfo
{
    template <typename StreamInfoType>
    static auto BindFields(StreamInfoType& streamInfo)
    {
        using namespace ttv::json;
        
        return std::make_tuple
        (
            make_field<RequiredField>("_id", streamInfo.streamId),
            make_field<OptionalField>("average_fps", streamInfo.averageFPS),
            make_field<OptionalField>("broadcast_platform", streamInfo.broadcastPlatform),
            make_field<OptionalField>("channel", streamInfo.channelInfo),
            make_field<OptionalField>("community_ids", streamInfo.communityIds),
            make_field<DateSchema, OptionalField>("created_at", streamInfo.createdAtTimestamp),
            make_field<OptionalField>("delay", streamInfo.delay),
            make_field<OptionalField>("game", streamInfo.game),
            make_field<OptionalField>("is_playlist", streamInfo.isPlaylist),
            make_field<OptionalField>("delay", streamInfo.delay),
            make_field<OptionalField>("preview", streamInfo.previewImages),
            make_field<OptionalField>("stream_type", streamInfo.streamType),
            make_field<OptionalField>("video_height", streamInfo.videoHeight),
            make_field<OptionalField>("viewers", streamInfo.viewerCount)
        );
    }
};


struct ttv::json::description::PreviewImages
{
    template <typename PreviewImagesType>
    static auto BindFields(PreviewImagesType& images)
    {
        using namespace ttv::json;

        return std::make_tuple
        (
            make_field<RequiredField>("large", images.largeUrl),
            make_field<OptionalField>("medium", images.mediumUrl),
            make_field<OptionalField>("small", images.smallUrl),
            make_field<OptionalField>("template", images.templateUrl)
        );
    }
};


struct ttv::json::description::BroadcastPlatform
{
    static auto EnumMap()
    {
        using namespace ttv::json;
        
        return std::make_tuple
        (
            make_enum_mapping("watch_party", ttv::BroadcastPlatform::WatchParty),
            make_enum_mapping("premiere", ttv::BroadcastPlatform::Premiere),
            make_enum_mapping("rerun", ttv::BroadcastPlatform::Rerun),
            make_enum_mapping("playlist", ttv::BroadcastPlatform::Playlist),
            make_enum_mapping("mobile", ttv::BroadcastPlatform::Mobile),
            make_enum_mapping("xbox", ttv::BroadcastPlatform::Xbox),
            make_enum_mapping("ps4", ttv::BroadcastPlatform::PS4),
            make_enum_mapping("live", ttv::BroadcastPlatform::Live)
        );
    }
    
    static auto GetFallbackValue()
    {
        return ttv::BroadcastPlatform::Unknown;
    }
};


struct ttv::json::description::StreamType
{
    static auto EnumMap()
    {
        using namespace ttv::json;
        
        return std::make_tuple
        (
            make_enum_mapping("watch_party", ttv::StreamType::WatchParty),
            make_enum_mapping("premiere", ttv::StreamType::Premiere),
            make_enum_mapping("rerun", ttv::StreamType::Rerun),
            make_enum_mapping("playlist", ttv::StreamType::Playlist),
            make_enum_mapping("live", ttv::StreamType::Live)
        );
    }
    
    static auto GetFallbackValue()
    {
        return ttv::StreamType::Unknown;
    }
};


template <>
struct ttv::json::DefaultSchemaProvider<ttv::UserInfo>
{
    using Type = ObjectSchema<ttv::json::description::UserInfo>;
};


template <>
struct ttv::json::DefaultSchemaProvider<ttv::ChannelInfo>
{
    using Type = ObjectSchema<ttv::json::description::ChannelInfo>;
};


template<>
struct ttv::json::DefaultSchemaProvider<ttv::BroadcasterType>
{
    using Type = EnumSchema<ttv::json::description::BroadcasterType>;
};


template <>
struct ttv::json::DefaultSchemaProvider<ttv::PreviewImages>
{
    using Type = ObjectSchema<ttv::json::description::PreviewImages>;
};


template <>
struct ttv::json::DefaultSchemaProvider<ttv::StreamInfo>
{
    using Type = ObjectSchema<ttv::json::description::StreamInfo>;
};


template<>
struct ttv::json::DefaultSchemaProvider<ttv::BroadcastPlatform>
{
    using Type = EnumSchema<ttv::json::description::BroadcastPlatform>;
};


template<>
struct ttv::json::DefaultSchemaProvider<ttv::StreamType>
{
    using Type = EnumSchema<ttv::json::description::StreamType>;
};