EPG.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */
 
#pragma once
 
#include "../../AddonBase.h"
#include "../../c-api/addon-instance/pvr.h"
 
//¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
// "C++" Definitions group 4 - PVR EPG
#ifdef __cplusplus
 
namespace kodi
{
namespace addon
{
 
//==============================================================================
class PVREPGTag : public DynamicCStructHdl<PVREPGTag, EPG_TAG>
{
  friend class CInstancePVRClient;
 
public:
  PVREPGTag()
  {
    m_cStructure->iSeriesNumber = EPG_TAG_INVALID_SERIES_EPISODE;
    m_cStructure->iEpisodeNumber = EPG_TAG_INVALID_SERIES_EPISODE;
    m_cStructure->iEpisodePartNumber = EPG_TAG_INVALID_SERIES_EPISODE;
  }
  PVREPGTag(const PVREPGTag& epg) : DynamicCStructHdl(epg) {}
 
 
  void SetUniqueBroadcastId(unsigned int uniqueBroadcastId)
  {
    m_cStructure->iUniqueBroadcastId = uniqueBroadcastId;
  }
 
  unsigned int GetUniqueBroadcastId() const { return m_cStructure->iUniqueBroadcastId; }
 
  void SetUniqueChannelId(unsigned int uniqueChannelId)
  {
    m_cStructure->iUniqueChannelId = uniqueChannelId;
  }
 
  unsigned int GetUniqueChannelId() const { return m_cStructure->iUniqueChannelId; }
 
  void SetTitle(const std::string& title)
  {
    ReallocAndCopyString(&m_cStructure->strTitle, title.c_str());
  }
 
  std::string GetTitle() const { return m_cStructure->strTitle ? m_cStructure->strTitle : ""; }
 
  void SetTitleExtraInfo(const std::string& titleExtraInfo)
  {
    ReallocAndCopyString(&m_cStructure->strTitleExtraInfo, titleExtraInfo.c_str());
  }
 
  std::string GetTitleExtraInfo() const
  {
    return m_cStructure->strTitleExtraInfo ? m_cStructure->strTitleExtraInfo : "";
  }
 
  void SetStartTime(time_t startTime) { m_cStructure->startTime = startTime; }
 
  time_t GetStartTime() const { return m_cStructure->startTime; }
 
  void SetEndTime(time_t endTime) { m_cStructure->endTime = endTime; }
 
  time_t GetEndTime() const { return m_cStructure->endTime; }
 
  void SetPlotOutline(const std::string& plotOutline)
  {
    ReallocAndCopyString(&m_cStructure->strPlotOutline, plotOutline.c_str());
  }
 
  std::string GetPlotOutline() const
  {
    return m_cStructure->strPlotOutline ? m_cStructure->strPlotOutline : "";
  }
 
  void SetPlot(const std::string& plot)
  {
    ReallocAndCopyString(&m_cStructure->strPlot, plot.c_str());
  }
 
  std::string GetPlot() const { return m_cStructure->strPlot ? m_cStructure->strPlot : ""; }
 
  void SetOriginalTitle(const std::string& originalTitle)
  {
    ReallocAndCopyString(&m_cStructure->strOriginalTitle, originalTitle.c_str());
  }
 
  std::string GetOriginalTitle() const
  {
    return m_cStructure->strOriginalTitle ? m_cStructure->strOriginalTitle : "";
  }
 
  void SetCast(const std::string& cast)
  {
    ReallocAndCopyString(&m_cStructure->strCast, cast.c_str());
  }
 
  std::string GetCast() const { return m_cStructure->strCast ? m_cStructure->strCast : ""; }
 
  void SetDirector(const std::string& director)
  {
    ReallocAndCopyString(&m_cStructure->strDirector, director.c_str());
  }
 
  std::string GetDirector() const
  {
    return m_cStructure->strDirector ? m_cStructure->strDirector : "";
  }
 
  void SetWriter(const std::string& writer)
  {
    ReallocAndCopyString(&m_cStructure->strWriter, writer.c_str());
  }
 
  std::string GetWriter() const { return m_cStructure->strWriter ? m_cStructure->strWriter : ""; }
 
  void SetYear(int year) { m_cStructure->iYear = year; }
 
  int GetYear() const { return m_cStructure->iYear; }
 
  void SetIMDBNumber(const std::string& IMDBNumber)
  {
    ReallocAndCopyString(&m_cStructure->strIMDBNumber, IMDBNumber.c_str());
  }
 
  std::string GetIMDBNumber() const
  {
    return m_cStructure->strIMDBNumber ? m_cStructure->strIMDBNumber : "";
  }
 
  void SetIconPath(const std::string& iconPath)
  {
    ReallocAndCopyString(&m_cStructure->strIconPath, iconPath.c_str());
  }
 
  std::string GetIconPath() const
  {
    return m_cStructure->strIconPath ? m_cStructure->strIconPath : "";
  }
 
  void SetGenreType(int genreType) { m_cStructure->iGenreType = genreType; }
 
  int GetGenreType() const { return m_cStructure->iGenreType; }
 
  void SetGenreSubType(int genreSubType) { m_cStructure->iGenreSubType = genreSubType; }
 
  int GetGenreSubType() const { return m_cStructure->iGenreSubType; }
 
  void SetGenreDescription(const std::string& genreDescription)
  {
    ReallocAndCopyString(&m_cStructure->strGenreDescription, genreDescription.c_str());
  }
 
  std::string GetGenreDescription() const
  {
    return m_cStructure->strGenreDescription ? m_cStructure->strGenreDescription : "";
  }
 
  void SetFirstAired(const std::string& firstAired)
  {
    ReallocAndCopyString(&m_cStructure->strFirstAired, firstAired.c_str());
  }
 
  std::string GetFirstAired() const
  {
    return m_cStructure->strFirstAired ? m_cStructure->strFirstAired : "";
  }
 
  void SetParentalRating(unsigned int parentalRating)
  {
    m_cStructure->iParentalRating = parentalRating;
  }
 
  unsigned int GetParentalRating() const { return m_cStructure->iParentalRating; }
 
  void SetParentalRatingCode(const std::string& parentalRatingCode)
  {
    ReallocAndCopyString(&m_cStructure->strParentalRatingCode, parentalRatingCode.c_str());
  }
 
  std::string GetParentalRatingCode() const
  {
    return m_cStructure->strParentalRatingCode ? m_cStructure->strParentalRatingCode : "";
  }
 
  void SetParentalRatingIcon(const std::string& parentalRatingIcon)
  {
    ReallocAndCopyString(&m_cStructure->strParentalRatingIcon, parentalRatingIcon.c_str());
  }
 
  std::string GetParentalRatingIcon() const
  {
    return m_cStructure->strParentalRatingIcon ? m_cStructure->strParentalRatingIcon : "";
  }
 
  void SetParentalRatingSource(const std::string& parentalRatingSource)
  {
    //m_parentalRatingSource = parentalRatingSource;
    ReallocAndCopyString(&m_cStructure->strParentalRatingSource, parentalRatingSource.c_str());
  }
 
  std::string GetParentalRatingSource() const
  {
    return m_cStructure->strParentalRatingSource ? m_cStructure->strParentalRatingSource : "";
  }
 
  void SetStarRating(int starRating) { m_cStructure->iStarRating = starRating; }
 
  int GetStarRating() const { return m_cStructure->iStarRating; }
 
  void SetSeriesNumber(int seriesNumber) { m_cStructure->iSeriesNumber = seriesNumber; }
 
  int GetSeriesNumber() const { return m_cStructure->iSeriesNumber; }
 
  void SetEpisodeNumber(int episodeNumber) { m_cStructure->iEpisodeNumber = episodeNumber; }
 
  int GetEpisodeNumber() const { return m_cStructure->iEpisodeNumber; }
 
  void SetEpisodePartNumber(int episodePartNumber)
  {
    m_cStructure->iEpisodePartNumber = episodePartNumber;
  }
 
  int GetEpisodePartNumber() const { return m_cStructure->iEpisodePartNumber; }
 
  void SetEpisodeName(const std::string& episodeName)
  {
    ReallocAndCopyString(&m_cStructure->strEpisodeName, episodeName.c_str());
  }
 
  std::string GetEpisodeName() const
  {
    return m_cStructure->strEpisodeName ? m_cStructure->strEpisodeName : "";
  }
 
  void SetFlags(unsigned int flags) { m_cStructure->iFlags = flags; }
 
  unsigned int GetFlags() const { return m_cStructure->iFlags; }
 
  void SetSeriesLink(const std::string& seriesLink)
  {
    ReallocAndCopyString(&m_cStructure->strSeriesLink, seriesLink.c_str());
  }
 
  std::string GetSeriesLink() const
  {
    return m_cStructure->strSeriesLink ? m_cStructure->strSeriesLink : "";
  }
 
 
  static void AllocResources(const EPG_TAG* source, EPG_TAG* target)
  {
    target->strTitle = AllocAndCopyString(source->strTitle);
    target->strTitleExtraInfo = AllocAndCopyString(source->strTitleExtraInfo);
    target->strPlotOutline = AllocAndCopyString(source->strPlotOutline);
    target->strPlot = AllocAndCopyString(source->strPlot);
    target->strOriginalTitle = AllocAndCopyString(source->strOriginalTitle);
    target->strCast = AllocAndCopyString(source->strCast);
    target->strDirector = AllocAndCopyString(source->strDirector);
    target->strWriter = AllocAndCopyString(source->strWriter);
    target->strIMDBNumber = AllocAndCopyString(source->strIMDBNumber);
    target->strIconPath = AllocAndCopyString(source->strIconPath);
    target->strGenreDescription = AllocAndCopyString(source->strGenreDescription);
    target->strParentalRatingCode = AllocAndCopyString(source->strParentalRatingCode);
    target->strParentalRatingIcon = AllocAndCopyString(source->strParentalRatingIcon);
    target->strParentalRatingSource = AllocAndCopyString(source->strParentalRatingSource);
    target->strEpisodeName = AllocAndCopyString(source->strEpisodeName);
    target->strSeriesLink = AllocAndCopyString(source->strSeriesLink);
    target->strFirstAired = AllocAndCopyString(source->strFirstAired);
  }
 
  static void FreeResources(EPG_TAG* target)
  {
    FreeString(target->strTitle);
    FreeString(target->strTitleExtraInfo);
    FreeString(target->strPlotOutline);
    FreeString(target->strPlot);
    FreeString(target->strOriginalTitle);
    FreeString(target->strCast);
    FreeString(target->strDirector);
    FreeString(target->strWriter);
    FreeString(target->strIMDBNumber);
    FreeString(target->strIconPath);
    FreeString(target->strGenreDescription);
    FreeString(target->strParentalRatingCode);
    FreeString(target->strParentalRatingIcon);
    FreeString(target->strParentalRatingSource);
    FreeString(target->strEpisodeName);
    FreeString(target->strSeriesLink);
    FreeString(target->strFirstAired);
  }
 
private:
  PVREPGTag(const EPG_TAG* epg) : DynamicCStructHdl(epg) {}
  PVREPGTag(EPG_TAG* epg) : DynamicCStructHdl(epg) {}
};
//------------------------------------------------------------------------------
 
//==============================================================================
class PVREPGTagsResultSet
{
public:
  PVREPGTagsResultSet() = delete;
  PVREPGTagsResultSet(const AddonInstance_PVR* instance, PVR_HANDLE handle)
    : m_instance(instance), m_handle(handle)
  {
  }
 
  void Add(const kodi::addon::PVREPGTag& tag)
  {
    m_instance->toKodi->TransferEpgEntry(m_instance->toKodi->kodiInstance, m_handle, tag);
  }
 
 
private:
  const AddonInstance_PVR* m_instance = nullptr;
  const PVR_HANDLE m_handle;
};
//------------------------------------------------------------------------------
 
} /* namespace addon */
} /* namespace kodi */
 
#endif /* __cplusplus */