hunk.code_window:     colorScheme === 'light' ? styles.lightContainer : styles.darkContainer;
     return (
       <SafeAreaView style={[styles.container, themeContainerStyle]}>
         <StatusBar barStyle={themeStatusBarStyle} />
         <Text style={[styles.text, themeTextStyle]}>
           Color scheme: {colorScheme}
         </Text>
       </SafeAreaView>
     );
   }
  
hunk.labels: keep keep keep keep keep replace replace replace keep keep keep
hunk.after_edit:       <Text style={[styles.text, themeTextStyle]}>Color scheme: {colorScheme}</Text>
  
hunk.file_path: docs/pages/versions/v37.0.0/sdk/appearance.md
hunk.type: replace
file: // Boost.TypeErasure library
  //
  // Copyright 2011 Steven Watanabe
  //
  // Distributed under the Boost Software License Version 1.0. (See
  // accompanying file LICENSE_1_0.txt or copy at
  // http://www.boost.org/LICENSE_1_0.txt)
  //
  // $Id$
  
  #ifndef BOOST_TYPE_ERASURE_OPERATORS_HPP_INCLUDED
  #define BOOST_TYPE_ERASURE_OPERATORS_HPP_INCLUDED
  
  #include <iosfwd>
  #include <boost/utility/enable_if.hpp>
  #include <boost/type_erasure/detail/const.hpp>
  #include <boost/type_erasure/call.hpp>
  #include <boost/type_erasure/concept_interface.hpp>
  #include <boost/type_erasure/placeholder.hpp>
  #include <boost/type_erasure/concept_of.hpp>
  #include <boost/type_erasure/derived.hpp>
  #include <boost/type_erasure/rebind_any.hpp>
  #include <boost/type_erasure/param.hpp>
  #include <boost/type_erasure/check_match.hpp>
  #include <boost/type_erasure/relaxed.hpp>
  #include <boost/type_erasure/typeid_of.hpp>
  
  namespace boost {
  namespace type_erasure {
  
  template<class Concept, class Placeholder>
  class any;
  
  /** INTERNAL ONLY */
  #define BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR(name, op)                         \
      template<class T = _self>                                                       \
      struct name                                                                     \
      {                                                                               \
          static void apply(T& arg) { op arg; }                                       \
      };                                                                              \
                                                                                      \
      template<class T, class Base>                                                   \
      struct concept_interface<name<T>, Base, T,                                      \
          typename ::boost::enable_if<                                                \
              detail::should_be_non_const<T, Base>                                    \
          >::type                                                                     \
      > : Base                                                                        \
      {                                                                               \
          typedef typename ::boost::type_erasure::derived<Base>::type _derived;       \
          _derived& operator op()                                                     \
          {                                                                           \
              ::boost::type_erasure::call(name<T>(), *this);                          \
              return static_cast<_derived&>(*this);                                   \
          }                                                                           \
          typename ::boost::type_erasure::rebind_any<Base, T>::type operator op(int)  \
          {                                                                           \
              typename ::boost::type_erasure::rebind_any<Base, T>::type result(       \
                  static_cast<_derived&>(*this));                                     \
              ::boost::type_erasure::call(name<T>(), *this);                          \
              return result;                                                          \
          }                                                                           \
      };                                                                              \
                                                                                      \
      template<class T, class Base>                                                   \
      struct concept_interface<name<T>, Base, T,                                      \
          typename ::boost::enable_if<                                                \
              detail::should_be_const<T, Base>                                        \
          >::type                                                                     \
      > : Base                                                                        \
      {                                                                               \
          typedef typename ::boost::type_erasure::derived<Base>::type _derived;       \
          const _derived& operator op() const                                         \
          {                                                                           \
              ::boost::type_erasure::call(name<T>(), *this);                          \
              return static_cast<const _derived&>(*this);                             \
          }                                                                           \
          typename ::boost::type_erasure::rebind_any<Base, T>::type operator op(int) const \
          {                                                                           \
              typename ::boost::type_erasure::rebind_any<Base, T>::type result(       \
                  static_cast<const _derived&>(*this));                               \
              ::boost::type_erasure::call(name<T>(), *this);                          \
              return result;                                                          \
          }                                                                           \
      };
  
  /**
   * The @ref incrementable concept allow pre and
   * post increment on an @ref any.  The contained
   * type must provide a pre-increment operator.
   */
  BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR(incrementable, ++)
  /**
   * The @ref decrementable concept allow pre and
   * post decrement on an @ref any.  The contained
   * type must provide a pre-decrement operator.
   */
  BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR(decrementable, --)
  
  #undef BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR
  
  /** INTERNAL ONLY */
  #define BOOST_TYPE_ERASURE_UNARY_OPERATOR(name, op)                                     \
      template<class T = _self, class R = T>                                              \
      struct name                                                                         \
      {                                                                                   \
          static R apply(const T& arg) { return op arg; }                                 \
      };                                                                                  \
                                                                                          \
      template<class T, class R, class Base>                                              \
      struct concept_interface<name<T, R>, Base, T> : Base                                \
      {                                                                                   \
          typename ::boost::type_erasure::rebind_any<Base, R>::type operator op() const   \
          {                                                                               \
              return ::boost::type_erasure::call(name<T, R>(), *this);                    \
          }                                                                               \
      };
  
  /**
   * The @ref complementable concept allow use of the bitwise
   * complement operator on an @ref any.
   */
  BOOST_TYPE_ERASURE_UNARY_OPERATOR(complementable, ~)
  /**
   * The @ref negatable concept allow use of the unary
   * minus operator on an @ref any.
   */
  BOOST_TYPE_ERASURE_UNARY_OPERATOR(negatable, -)
  
  #undef BOOST_TYPE_ERASURE_UNARY_OPERATOR
  
  template<class R, class T = _self>
  struct dereferenceable
  {
      static R apply(const T& arg) { return *arg; }
  };
  
  /// \cond show_operators
  
  template<class R, class T, class Base>
  struct concept_interface<dereferenceable<R, T>, Base, T> : Base
  {
      typename ::boost::type_erasure::rebind_any<Base, R>::type operator*() const
      {
          return ::boost::type_erasure::call(dereferenceable<R, T>(), *this);
      }
  };
  
  /// \endcond
  
  /** INTERNAL ONLY */
  #define BOOST_TYPE_ERASURE_BINARY_OPERATOR(name, op)                        \
      template<class T = _self, class U = T, class R = T>                     \
      struct name                                                             \
      {                                                                       \
          static R apply(const T& lhs, const U& rhs) { return lhs op rhs; }   \
      };                                                                      \
                                                                              \
      template<class T, class U, class R, class Base>                         \
      struct concept_interface<name<T, U, R>, Base, T> : Base                 \
      {                                                                       \
          friend typename rebind_any<Base, R>::type                           \
          operator op(const typename derived<Base>::type& lhs,                \
                      typename as_param<Base, const U&>::type rhs)            \
          {                                                                   \
              return ::boost::type_erasure::call(name<T, U, R>(), lhs, rhs);  \
          }                                                                   \
      };                                                                      \
                                                                              \
      template<class T, class U, class R, class Base>                         \
      struct concept_interface<                                               \
          name<T, U, R>,                                                      \
          Base,                                                               \
          U,                                                                  \
          typename ::boost::disable_if<                                       \
              ::boost::type_erasure::is_placeholder<T> >::type                \
      > : Base                                                                \
      {                                                                       \
          friend typename rebind_any<Base, R>::type                           \
          operator op(const T& lhs,                                           \
                      const typename derived<Base>::type& rhs)                \
          {                                                                   \
              return ::boost::type_erasure::call(name<T, U, R>(), lhs, rhs);  \
          }                                                                   \
      };
  
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(addable, +)
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(subtractable, -)
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(multipliable, *)
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(dividable, /)
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(modable, %)
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(left_shiftable, <<)
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(right_shiftable, >>)
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(bitandable, &)
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(bitorable, |)
  BOOST_TYPE_ERASURE_BINARY_OPERATOR(bitxorable, ^)
  
  #undef BOOST_TYPE_ERASURE_BINARY_OPERATOR
  
  /** INTERNAL ONLY */
  #define BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(name, op)                    \
      template<class T = _self, class U = T>                                  \
      struct name                                                             \
      {                                                                       \
          static void apply(T& lhs, const U& rhs) { lhs op rhs; }             \
      };                                                                      \
                                                                              \
      template<class T, class U, class Base>                                  \
      struct concept_interface<name<T, U>, Base, T,                           \
          typename ::boost::disable_if<                                       \
              ::boost::is_same<                                               \
                  typename ::boost::type_erasure::placeholder_of<Base>::type, \
                  const T&                                                    \
              >                                                               \
          >::type                                                             \
      > : Base                                                                \
      {                                                                       \
          friend typename detail::non_const_this_param<Base>::type&           \
          operator op(typename detail::non_const_this_param<Base>::type& lhs, \
                      typename as_param<Base, const U&>::type rhs)            \
          {                                                                   \
              ::boost::type_erasure::call(name<T, U>(),lhs, rhs);             \
              return lhs;                                                     \
          }                                                                   \
      };                                                                      \
                                                                              \
      template<class T, class U, class Base>                                  \
      struct concept_interface<                                               \
          name<T, U>,                                                         \
          Base,                                                               \
          U,                                                                  \
          typename ::boost::disable_if<                                       \
              ::boost::type_erasure::is_placeholder<T> >::type                \
      > : Base                                                                \
      {                                                                       \
          friend T&                                                           \
          operator op(T& lhs, const typename derived<Base>::type& rhs)        \
          {                                                                   \
              ::boost::type_erasure::call(name<T, U>(),lhs, rhs);             \
              return lhs;                                                     \
          }                                                                   \
      };
  
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(add_assignable, +=)
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(subtract_assignable, -=)
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(multiply_assignable, *=)
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(divide_assignable, /=)
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(mod_assignable, %=)
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(left_shift_assignable, <<=)
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(right_shift_assignable, >>=)
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(bitand_assignable, &=)
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(bitor_assignable, |=)
  BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(bitxor_assignable, ^=)
  
  #undef BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR
  
  template<class T = _self, class U = T>
  struct equality_comparable
  {
      static bool apply(const T& lhs, const U& rhs) { return lhs == rhs; }
  };
  
  /// \cond show_operators
  
  template<class T, class U, class Base>
  struct concept_interface<equality_comparable<T, U>, Base, T> : Base
  {
      friend bool operator==(const typename derived<Base>::type& lhs,
                             typename as_param<Base, const U&>::type rhs)
      {
          if(::boost::type_erasure::check_match(equality_comparable<T, U>(), lhs, rhs)) {
              return ::boost::type_erasure::unchecked_call(equality_comparable<T, U>(), lhs, rhs);
          } else {
              return false;
          }
      }
      friend bool operator!=(const typename derived<Base>::type& lhs,
                             typename as_param<Base, const U&>::type rhs)
      {
          return !(lhs == rhs);
      }
  };
  
  template<class T, class U, class Base>
  struct concept_interface<
      equality_comparable<T, U>,
      Base,
      U,
      typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<T> >::type
  > : Base
  {
      friend bool operator==(const T& lhs, const typename derived<Base>::type& rhs)
      {
          return ::boost::type_erasure::call(equality_comparable<T, U>(), lhs, rhs);
      }
      friend bool operator!=(const T& lhs, const typename derived<Base>::type& rhs)
      {
          return !(lhs == rhs);
      }
  };
  
  /// \endcond
  
  template<class T = _self, class U = T>
  struct less_than_comparable
  {
      static bool apply(const T& lhs, const U& rhs) { return lhs < rhs; }
  };
  
  namespace detail {
  
  template<class F, class T, class U>
  bool less_impl(const F& f, const T& lhs, const U& rhs, ::boost::mpl::true_)
  {
      if(::boost::type_erasure::check_match(f, lhs, rhs)) {
          return ::boost::type_erasure::unchecked_call(f, lhs, rhs);
      } else {
          return ::boost::type_erasure::typeid_of(
              static_cast<const typename derived<T>::type&>(lhs)
          ).before(
              ::boost::type_erasure::typeid_of(
                  static_cast<const typename derived<U>::type&>(rhs)
              )
          ) != false;
      }
  }
  
  template<class F, class T, class U>
  bool less_impl(const F& f, const T& lhs, const U& rhs, ::boost::mpl::false_)
  {
      return ::boost::type_erasure::call(f, lhs, rhs);
  }
  
  }
  
  /// \cond show_operators
  
  template<class T, class Base>
  struct concept_interface<less_than_comparable<T, T>, Base, T> : Base
  {
      friend bool operator<(const typename derived<Base>::type& lhs,
                            typename as_param<Base, const T&>::type rhs)
      {
          return ::boost::type_erasure::detail::less_impl(
              less_than_comparable<T, T>(),
              lhs, rhs,
              ::boost::type_erasure::is_relaxed<
                  typename ::boost::type_erasure::concept_of<Base>::type>());
      }
      friend bool operator>=(const typename derived<Base>::type& lhs,
                             typename as_param<Base, const T&>::type rhs)
      {
          return !(lhs < rhs);
      }
      friend bool operator>(typename as_param<Base, const T&>::type lhs,
                            const typename derived<Base>::type& rhs)
      {
          return rhs < lhs;
      }
      friend bool operator<=(typename as_param<Base, const T&>::type lhs,
                            const typename derived<Base>::type& rhs)
      {
          return !(rhs < lhs);
      }
  };
  
  template<class T, class U, class Base>
  struct concept_interface<less_than_comparable<T, U>, Base, T> : Base
  {
      friend bool operator<(const typename derived<Base>::type& lhs,
                            typename as_param<Base, const U&>::type rhs)
      {
          return ::boost::type_erasure::call(less_than_comparable<T, U>(), lhs, rhs);
      }
      friend bool operator>=(const typename derived<Base>::type& lhs,
                             typename as_param<Base, const U&>::type rhs)
      {
          return !(lhs < rhs);
      }
      friend bool operator>(typename as_param<Base, const U&>::type lhs,
                            const typename derived<Base>::type& rhs)
      {
          return rhs < lhs;
      }
      friend bool operator<=(typename as_param<Base, const U&>::type lhs,
                            const typename derived<Base>::type& rhs)
      {
          return !(rhs < lhs);
      }
  };
  
  template<class T, class U, class Base>
  struct concept_interface<
      less_than_comparable<T, U>,
      Base,
      U,
      typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<T> >::type
  > : Base
  {
      friend bool operator<(const T& lhs, const typename derived<Base>::type& rhs)
      {
          return ::boost::type_erasure::call(less_than_comparable<T, U>(), lhs, rhs);
      }
      friend bool operator>=(const T& lhs, const typename derived<Base>::type& rhs)
      {
          return !(lhs < rhs);
      }
      friend bool operator>(const typename derived<Base>::type& lhs, const T& rhs)
      {
          return rhs < lhs;
      }
      friend bool operator<=(const typename derived<Base>::type& lhs, const T& rhs)
      {
          return !(rhs < lhs);
      }
  };
  
  /// \endcond
  
  template<class R, class T = _self, class N = std::ptrdiff_t>
  struct subscriptable
  {
      static R apply(T& arg, const N& index) { return arg[index]; }
  };
  
  /// \cond show_operators
  
  template<class R, class T, class N, class Base>
  struct concept_interface<subscriptable<R, T, N>, Base, typename ::boost::remove_const<T>::type,
      typename ::boost::enable_if<
          ::boost::type_erasure::detail::should_be_non_const<T, Base>
      >::type
  > : Base
  {
      typename ::boost::type_erasure::rebind_any<Base, R>::type operator[](
          typename ::boost::type_erasure::as_param<Base, const N&>::type index)
      {
          return ::boost::type_erasure::call(subscriptable<R, T, N>(), *this, index);
      }
  };
  
  template<class R, class T, class N, class Base>
  struct concept_interface<subscriptable<R, T, N>, Base, typename ::boost::remove_const<T>::type,
      typename ::boost::enable_if<
          ::boost::type_erasure::detail::should_be_const<T, Base>
      >::type
  > : Base
  {
      typename ::boost::type_erasure::rebind_any<Base, R>::type operator[](
          typename ::boost::type_erasure::as_param<Base, const N&>::type index) const
      {
          return ::boost::type_erasure::call(subscriptable<R, const T, N>(), *this, index);
      }
  };
  
  /// \endcond
  
  /**
   * The @ref ostreamable concept allows an @ref any to be
   * written to a @c std::ostream.
   */
  template<class Os = std::ostream, class T = _self>
  struct ostreamable
  {
      static void apply(Os& out, const T& arg) { out << arg; }
  };
  
  /// \cond show_operators
  
  template<class Base, class Os, class T>
  struct concept_interface<ostreamable<Os, T>, Base, Os> : Base
  {
      friend typename detail::non_const_this_param<Base>::type&
      operator<<(typename detail::non_const_this_param<Base>::type& lhs,
                 typename ::boost::type_erasure::as_param<Base, const T&>::type rhs)
      {
          ::boost::type_erasure::call(ostreamable<Os, T>(), lhs, rhs);
          return lhs;
      }
  };
  
  template<class Base, class Os, class T>
  struct concept_interface<
      ostreamable<Os, T>,
      Base,
      T,
      typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<Os> >::type
  > : Base
  {
      friend Os&
      operator<<(Os& lhs,
                 const typename ::boost::type_erasure::derived<Base>::type& rhs)
      {
          ::boost::type_erasure::call(ostreamable<Os, T>(), lhs, rhs);
          return lhs;
      }
  };
  
  /// \endcond
  
  /**
   * The @ref istreamable concept allows an @ref any to be
   * read from a @c std::istream.
   */
  template<class Is = std::istream, class T = _self>
  struct istreamable
  {
      static void apply(Is& out, T& arg) { out >> arg; }
  };
  
  /// \cond show_operators
  
  
  template<class Base, class Is, class T>
  struct concept_interface<istreamable<Is, T>, Base, Is> : Base
  {
      friend typename detail::non_const_this_param<Base>::type&
      operator>>(typename detail::non_const_this_param<Base>::type& lhs,
                 typename ::boost::type_erasure::as_param<Base, T&>::type rhs)
      {
          ::boost::type_erasure::call(istreamable<Is, T>(), lhs, rhs);
          return lhs;
      }
  };
  
  template<class Base, class Is, class T>
  struct concept_interface<
      istreamable<Is, T>,
      Base,
      T,
      typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<Is> >::type
  > : Base
  {
      friend Is&
      operator>>(Is& lhs,
                 typename ::boost::type_erasure::derived<Base>::type& rhs)
      {
          ::boost::type_erasure::call(istreamable<Is, T>(), lhs, rhs);
          return lhs;
      }
  };
  
  /// \endcond
  
  }
  }
  
  #endif
  