hunk.code_window:   state = {
       scannerIsVisible: false,
     };
     _hasOpenedUrl: boolean;
     _isMounted: boolean;
     componentWillMount() {
       this._hasOpenedUrl = false;
  
hunk.labels: keep keep keep keep keep replace replace replace replace replace keep
hunk.after_edit:   _hasOpenedUrl = false;
     _isMounted = false;
  
hunk.file_path: home/screens/QRCodeScreen.android.js
hunk.type: replace
file: //
  //=======================================================================
  // Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
  // Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
  //
  // 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)
  //=======================================================================
  //
  #ifndef BOOST_GRAPH_MATRIX2GRAPH_HPP
  #define BOOST_GRAPH_MATRIX2GRAPH_HPP
  
  #include <utility>
  #include <boost/config.hpp>
  #include <boost/operators.hpp>
  #include <boost/pending/detail/int_iterator.hpp>
  #include <boost/graph/graph_traits.hpp>
  
  namespace boost {
  
    template <class Iter, class Vertex>
    class matrix_adj_iterator;
  
    template <class Iter, class Vertex>
    class matrix_incidence_iterator;
  
  }
  
  #define BOOST_GRAPH_ADAPT_MATRIX_TO_GRAPH(Matrix)  \
  namespace boost { \
    template <> \
    struct graph_traits< Matrix > { \
      typedef Matrix::OneD::const_iterator Iter; \
      typedef Matrix::size_type V; \
      typedef V vertex_descriptor; \
      typedef Iter E; \
      typedef E edge_descriptor; \
      typedef boost::matrix_incidence_iterator<Iter, V> out_edge_iterator; \
      typedef boost::matrix_adj_iterator<Iter, V> adjacency_iterator; \
      typedef Matrix::size_type size_type; \
      typedef boost::int_iterator<size_type> vertex_iterator; \
      \
      friend std::pair<vertex_iterator, vertex_iterator> \
      vertices(const Matrix& g) { \
        typedef vertex_iterator VIter; \
        return std::make_pair(VIter(0), VIter(g.nrows())); \
      } \
      \
      friend std::pair<out_edge_iterator, out_edge_iterator> \
      out_edges(V v, const Matrix& g) { \
        typedef out_edge_iterator IncIter; \
        return std::make_pair(IncIter(g[v].begin()), \
                              IncIter(g[v].end())); \
      } \
      friend std::pair<adjacency_iterator, adjacency_iterator> \
      adjacent_vertices(V v, const Matrix& g) { \
        typedef adjacency_iterator AdjIter; \
        return std::make_pair(AdjIter(g[v].begin()), \
                              AdjIter(g[v].end())); \
      } \
      friend vertex_descriptor \
      source(E e, const Matrix& g) {  \
        return e.row();  \
      } \
      friend vertex_descriptor \
      target(E e, const Matrix& g) { \
        return e.column();  \
      } \
      friend size_type \
      num_vertices(const Matrix& g) { \
        return g.nrows();  \
      } \
      friend size_type \
      num_edges(const Matrix& g) { \
        return g.nnz(); \
      } \
      friend size_type \
      out_degree(V i, const Matrix& g) { \
        return g[i].nnz(); \
      } \
    }; \
  }
  
  namespace boost {
  
    template <class Iter, class Vertex>
    class matrix_adj_iterator
      : public std::iterator<std::input_iterator_tag, Vertex >
    {
      typedef matrix_adj_iterator self;
    public:
      matrix_adj_iterator() { }
      matrix_adj_iterator(Iter i) : _iter(i) { }
      matrix_adj_iterator(const self& x) : _iter(x._iter) { }
      self& operator=(const self& x) { _iter = x._iter; return *this; }
      Vertex operator*() { return _iter.column(); }
      self& operator++() { ++_iter; return *this; }
      self operator++(int) { self t = *this; ++_iter; return t; }
      bool operator==(const self& x) const { return _iter == x._iter; }
      bool operator!=(const self& x) const { return _iter != x._iter; }
    protected:
      Iter _iter;
    };
  
    template <class Iter, class Vertex>
    class matrix_incidence_iterator
      : public std::iterator<std::input_iterator_tag, Iter >
    {
      typedef matrix_incidence_iterator self;
    public:
      matrix_incidence_iterator() { }
      matrix_incidence_iterator(Iter i) : _iter(i) { }
      matrix_incidence_iterator(const self& x) : _iter(x._iter) { }
      self& operator=(const self& x) { _iter = x._iter; return *this; }
      Iter operator*() { return _iter; }
      self& operator++() { ++_iter; return *this; }
      self operator++(int) { self t = *this; ++_iter; return t; }
      bool operator==(const self& x) const { return _iter == x._iter; }
      bool operator!=(const self& x) const { return _iter != x._iter; }
    protected:
      Iter _iter;
    };
    
  } /* namespace boost */
  
  #endif /* BOOST_GRAPH_MATRIX2GRAPH_HPP*/
  