cfref.h

Go to the documentation of this file.

// Copyright 2017 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.

#ifndef SHAKA_EMBEDDED_UTIL_CF_REF_H_
#define SHAKA_EMBEDDED_UTIL_CF_REF_H_

#ifdef __APPLE__

#  include <CoreFoundation/CoreFoundation.h>

#  include <memory>
#  include <type_traits>

namespace shaka {
namespace util {

// Defines a type and a singleton to signal which overload to use.  These can
// be used with the CFRef constructors to use different reference semantics.
// CFRef(absorb_ref, GetValue())   // The ref already has an extra ref count.
// CFRef(acquire_ref, GetValue())  // Acquires the ref first.
struct absorb_ref_t {};
extern absorb_ref_t absorb_ref;
struct acquire_ref_t {};
extern acquire_ref_t acquire_ref;

template <typename T>
struct RefTypeTraits {
  static constexpr const bool AcquireWithRaw = false;

  static T Duplicate(T arg) {
    if (arg)
      CFRetain(arg);
    return arg;
  }

  static void Release(T arg) {
    if (arg)
      CFRelease(arg);
  }
};


template <typename T>
class CFRef {
 public:
  using traits = RefTypeTraits<T>;
  using value_type = T;

  CFRef() : ptr_(nullptr) {}
  CFRef(std::nullptr_t) : ptr_(nullptr) {}  // NOLINT(runtime/explicit)
  CFRef(T arg)  // NOLINT(runtime/explicit)
      : ptr_(traits::AcquireWithRaw ? traits::Duplicate(arg) : arg) {}
  CFRef(absorb_ref_t, T arg) : ptr_(arg) {}
  CFRef(acquire_ref_t, T arg) : ptr_(traits::Duplicate(arg)) {}
  CFRef(const CFRef& other) : ptr_(traits::Duplicate(other.ptr_)) {}
  CFRef(CFRef&& other) : ptr_(other.Detach()) {}
  // Careful, these assume that if U is compatible with T, that the
  // Duplicate/Release methods are compatible.
  template <typename U>
  CFRef(const CFRef<U>& other) : ptr_(traits::Duplicate(other.ptr_)) {}
  template <typename U>
  CFRef(CFRef<U>&& other) : ptr_(other.Detach()) {}
  ~CFRef() {
    Release();
  }

  CFRef& operator=(const CFRef& other) {
    Release();
    ptr_ = traits::Duplicate(other);
    return *this;
  }
  CFRef& operator=(CFRef&& other) {
    Release();
    ptr_ = other.Detach();
    return *this;
  }
  CFRef& operator=(T other) {
    Release();
    ptr_ = traits::AcquireWithRaw ? traits::Duplicate(other) : other;
    return *this;
  }

  operator T() const {
    return ptr_;
  }

  T Detach() {
    T ret = ptr_;
    ptr_ = nullptr;
    return ret;
  }

 private:
  template <typename U>
  friend class CFRef;

  void Release() {
    traits::Release(ptr_);
    ptr_ = nullptr;
  }

  T ptr_;
};

}  // namespace util
}  // namespace shaka

#endif  // __APPLE__

#endif  // SHAKA_EMBEDDED_UTIL_CF_REF_H_