manifest.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/manifest.h"

#include "src/js/manifest.h"

namespace shaka {

class InitDataOverride::Impl {
 public:
  const std::string initDataType{};
  const shaka::optional<std::string> keyId{};

  Impl() {}
  Impl(js::InitDataOverride&& internal)
    : initDataType(std::move(internal.initDataType)),
      keyId(std::move(internal.keyId)) {}
};

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

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

const std::string& InitDataOverride::init_data_type() const {
  return impl_->initDataType;
}

shaka::optional<std::string> InitDataOverride::key_id() const {
  return impl_->keyId;
}


js::InitDataOverride InitDataOverride::GetInternal() const {
  js::InitDataOverride ret;
  ret.initDataType = impl_->initDataType;
  ret.keyId = impl_->keyId;
  return ret;
}


class DrmInfo::Impl {
 public:
  const std::string keySystem{};
  const std::string licenseServerUri{};
  const bool distinctiveIdentifierRequired{};
  const bool persistentStateRequired{};
  const std::string audioRobustness{};
  const std::string videoRobustness{};
  const std::vector<shaka::InitDataOverride> initData{};
  const std::vector<std::string> keyIds{};

  Impl() {}
  Impl(js::DrmInfo&& internal)
    : keySystem(std::move(internal.keySystem)),
      licenseServerUri(std::move(internal.licenseServerUri)),
      distinctiveIdentifierRequired(std::move(internal.distinctiveIdentifierRequired)),
      persistentStateRequired(std::move(internal.persistentStateRequired)),
      audioRobustness(std::move(internal.audioRobustness)),
      videoRobustness(std::move(internal.videoRobustness)),
      initData(std::make_move_iterator(internal.initData.begin()), std::make_move_iterator(internal.initData.end())),
      keyIds(std::make_move_iterator(internal.keyIds.begin()), std::make_move_iterator(internal.keyIds.end())) {}
};

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

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

const std::string& DrmInfo::key_system() const {
  return impl_->keySystem;
}

const std::string& DrmInfo::license_server_uri() const {
  return impl_->licenseServerUri;
}

bool DrmInfo::distinctive_identifier_required() const {
  return impl_->distinctiveIdentifierRequired;
}

bool DrmInfo::persistent_state_required() const {
  return impl_->persistentStateRequired;
}

const std::string& DrmInfo::audio_robustness() const {
  return impl_->audioRobustness;
}

const std::string& DrmInfo::video_robustness() const {
  return impl_->videoRobustness;
}

const std::vector<shaka::InitDataOverride>& DrmInfo::init_data() const {
  return impl_->initData;
}

const std::vector<std::string>& DrmInfo::key_ids() const {
  return impl_->keyIds;
}


js::DrmInfo DrmInfo::GetInternal() const {
  js::DrmInfo ret;
  ret.keySystem = impl_->keySystem;
  ret.licenseServerUri = impl_->licenseServerUri;
  ret.distinctiveIdentifierRequired = impl_->distinctiveIdentifierRequired;
  ret.persistentStateRequired = impl_->persistentStateRequired;
  ret.audioRobustness = impl_->audioRobustness;
  ret.videoRobustness = impl_->videoRobustness;
  for (const auto& item : impl_->initData) {
    ret.initData.emplace_back(item.GetInternal());
  }
  ret.keyIds = impl_->keyIds;
  return ret;
}



} // namespace shaka