player_externs.cc

Go to the documentation of this file.

// Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// AUTO-GENERATED: DO NOT EDIT

#include "shaka/player_externs.h"

#include "src/js/player_externs.h"

namespace shaka {

class BufferedRange::Impl {
 public:
  const double start{};
  const double end{};

  Impl() {}
  Impl(js::BufferedRange&& internal)
    : start(std::move(internal.start)),
      end(std::move(internal.end)) {}
};

BufferedRange::BufferedRange() : impl_(new Impl) {}
BufferedRange::BufferedRange(js::BufferedRange&& internal) : impl_(new Impl{std::move(internal)}) {}
BufferedRange::BufferedRange(const BufferedRange&) = default;
BufferedRange::BufferedRange(BufferedRange&&) = default;
BufferedRange::~BufferedRange() {}

BufferedRange& BufferedRange::operator=(const BufferedRange&) = default;
BufferedRange& BufferedRange::operator=(BufferedRange&&) = default;

double BufferedRange::start() const {
  return impl_->start;
}

double BufferedRange::end() const {
  return impl_->end;
}


js::BufferedRange BufferedRange::GetInternal() const {
  js::BufferedRange ret;
  ret.start = impl_->start;
  ret.end = impl_->end;
  return ret;
}


class BufferedInfo::Impl {
 public:
  const std::vector<shaka::BufferedRange> total{};
  const std::vector<shaka::BufferedRange> audio{};
  const std::vector<shaka::BufferedRange> video{};
  const std::vector<shaka::BufferedRange> text{};

  Impl() {}
  Impl(js::BufferedInfo&& internal)
    : total(std::make_move_iterator(internal.total.begin()), std::make_move_iterator(internal.total.end())),
      audio(std::make_move_iterator(internal.audio.begin()), std::make_move_iterator(internal.audio.end())),
      video(std::make_move_iterator(internal.video.begin()), std::make_move_iterator(internal.video.end())),
      text(std::make_move_iterator(internal.text.begin()), std::make_move_iterator(internal.text.end())) {}
};

BufferedInfo::BufferedInfo() : impl_(new Impl) {}
BufferedInfo::BufferedInfo(js::BufferedInfo&& internal) : impl_(new Impl{std::move(internal)}) {}
BufferedInfo::BufferedInfo(const BufferedInfo&) = default;
BufferedInfo::BufferedInfo(BufferedInfo&&) = default;
BufferedInfo::~BufferedInfo() {}

BufferedInfo& BufferedInfo::operator=(const BufferedInfo&) = default;
BufferedInfo& BufferedInfo::operator=(BufferedInfo&&) = default;

const std::vector<shaka::BufferedRange>& BufferedInfo::total() const {
  return impl_->total;
}

const std::vector<shaka::BufferedRange>& BufferedInfo::audio() const {
  return impl_->audio;
}

const std::vector<shaka::BufferedRange>& BufferedInfo::video() const {
  return impl_->video;
}

const std::vector<shaka::BufferedRange>& BufferedInfo::text() const {
  return impl_->text;
}


js::BufferedInfo BufferedInfo::GetInternal() const {
  js::BufferedInfo ret;
  for (const auto& item : impl_->total) {
    ret.total.emplace_back(item.GetInternal());
  }
  for (const auto& item : impl_->audio) {
    ret.audio.emplace_back(item.GetInternal());
  }
  for (const auto& item : impl_->video) {
    ret.video.emplace_back(item.GetInternal());
  }
  for (const auto& item : impl_->text) {
    ret.text.emplace_back(item.GetInternal());
  }
  return ret;
}


class LanguageRole::Impl {
 public:
  const std::string language{};
  const std::string role{};

  Impl() {}
  Impl(js::LanguageRole&& internal)
    : language(std::move(internal.language)),
      role(std::move(internal.role)) {}
};

LanguageRole::LanguageRole() : impl_(new Impl) {}
LanguageRole::LanguageRole(js::LanguageRole&& internal) : impl_(new Impl{std::move(internal)}) {}
LanguageRole::LanguageRole(const LanguageRole&) = default;
LanguageRole::LanguageRole(LanguageRole&&) = default;
LanguageRole::~LanguageRole() {}

LanguageRole& LanguageRole::operator=(const LanguageRole&) = default;
LanguageRole& LanguageRole::operator=(LanguageRole&&) = default;

const std::string& LanguageRole::language() const {
  return impl_->language;
}

const std::string& LanguageRole::role() const {
  return impl_->role;
}


js::LanguageRole LanguageRole::GetInternal() const {
  js::LanguageRole ret;
  ret.language = impl_->language;
  ret.role = impl_->role;
  return ret;
}



} // namespace shaka