hunk.code_window: The properties of this component extend from `View`; however, you should not attempt to set `backgroundColor` or `borderRadius` with the `style` property. This will not work and is against the App Store Guidelines. Instead, you should use the `buttonStyle` property to choose one of the predefined color styles and the `cornerRadius` property to change the border radius of the button.
   #### `AppleAuthentication.AppleAuthenticationButtonProps`
   - **onPress (_function_)** - The method to call when the user presses the button. You should call [`AppleAuthentication.signInAsync`](#appleauthenticationsigninasyncoptions) in here.
   - **buttonType (_[AppleAuthenticationButtonType](#appleauthenticationappleauthenticationbuttontype)_)** - The type of button text to display ("Sign In with Apple" vs. "Continue with Apple").
   - **buttonStyle (_[AppleAuthenticationButtonStyle](#appleauthenticationappleauthenticationbuttonstyle)_)** - The Apple-defined color scheme to use to display the button.
  
hunk.labels: keep keep add keep keep keep keep keep
hunk.after_edit: Make sure to attach height and width via the `style` props as without these styles, the button will not appear on the screen. 
  
hunk.file_path: docs/pages/versions/v35.0.0/sdk/apple-authentication.md
hunk.type: add
file: /////////////////////////////////////////////////////////////////////////////
  //
  // (C) Copyright Ion Gaztanaga  2014-2014
  //
  // 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)
  //
  // See http://www.boost.org/libs/intrusive for documentation.
  //
  /////////////////////////////////////////////////////////////////////////////
  
  #ifndef BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
  #define BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
  
  #ifndef BOOST_CONFIG_HPP
  #  include <boost/config.hpp>
  #endif
  
  #if defined(BOOST_HAS_PRAGMA_ONCE)
  #  pragma once
  #endif
  
  #include <boost/intrusive/detail/config_begin.hpp>
  #include <boost/intrusive/detail/iterator.hpp>
  #include <boost/intrusive/detail/mpl.hpp>
  
  namespace boost {
  namespace intrusive {
  
  template<class It>
  class reverse_iterator
  {
     public:
     typedef typename boost::intrusive::iterator_traits<It>::pointer             pointer;
     typedef typename boost::intrusive::iterator_traits<It>::reference           reference;
     typedef typename boost::intrusive::iterator_traits<It>::difference_type     difference_type;
     typedef typename boost::intrusive::iterator_traits<It>::iterator_category   iterator_category;
     typedef typename boost::intrusive::iterator_traits<It>::value_type          value_type;
  
  
     typedef It iterator_type;
  
     reverse_iterator()
        : m_current()  //Value initialization to achieve "null iterators" (N3644)
     {}
  
     explicit reverse_iterator(It r)
        : m_current(r)
     {}
  
     reverse_iterator(const reverse_iterator& r)
        : m_current(r.base())
     {}
  
     template<class OtherIt>
     reverse_iterator( const reverse_iterator<OtherIt>& r
                     , typename boost::intrusive::detail::enable_if_convertible<OtherIt, It>::type* =0
                     )
        : m_current(r.base())
     {}
  
     reverse_iterator & operator=( const reverse_iterator& r)
     {  m_current = r.base();   return *this;  }
  
     template<class OtherIt>
     typename boost::intrusive::detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
           operator=( const reverse_iterator<OtherIt>& r)
     {  m_current = r.base();   return *this;  }
  
     It base() const
     {  return m_current;  }
  
     reference operator*() const
     {
        It temp(m_current);
        --temp;
        reference r = *temp;
        return r;
     }
  
     pointer operator->() const
     {
        It temp(m_current);
        --temp;
        return iterator_arrow_result(temp);
     }
  
     reference operator[](difference_type off) const
     {
        return this->m_current[-off - 1];
     }
  
     reverse_iterator& operator++()
     {
        --m_current;
        return *this;
     }
  
     reverse_iterator operator++(int)
     {
        reverse_iterator temp((*this));
        --m_current;
        return temp;
     }
  
     reverse_iterator& operator--()
     {
        ++m_current;
        return *this;
     }
  
     reverse_iterator operator--(int)
     {
        reverse_iterator temp((*this));
        ++m_current;
        return temp;
     }
  
     friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
     {  return l.m_current == r.m_current;  }
  
     friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
     {  return l.m_current != r.m_current;  }
  
     friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
     {  return l.m_current > r.m_current;  }
  
     friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
     {  return l.m_current >= r.m_current;  }
  
     friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
     {  return l.m_current < r.m_current;  }
  
     friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
     {  return l.m_current <= r.m_current;  }
  
     reverse_iterator& operator+=(difference_type off)
     {  m_current -= off; return *this;  }
  
     reverse_iterator& operator-=(difference_type off)
     {  m_current += off; return *this;  }
  
     friend reverse_iterator operator+(reverse_iterator l, difference_type off)
     {  return (l += off);  }
  
     friend reverse_iterator operator+(difference_type off, reverse_iterator r)
     {  return (r += off);   }
  
     friend reverse_iterator operator-(reverse_iterator l, difference_type off)
     {  return (l-= off);  }
  
     friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
     {  return r.m_current - l.m_current;  }
  
     private:
     It m_current;   // the wrapped iterator
  };
  
  } //namespace intrusive {
  } //namespace boost {
  
  #include <boost/intrusive/detail/config_end.hpp>
  
  #endif //BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP
  