Multiscale Universal Interface  2.0
A Concurrent Framework for Coupling Heterogeneous Solvers
virtual_container.h
Go to the documentation of this file.
1 /*****************************************************************************
2 * Multiscale Universal Interface Code Coupling Library *
3 * *
4 * Copyright (C) 2019 Y. H. Tang, S. Kudo, X. Bian, Z. Li, G. E. Karniadakis *
5 * *
6 * This software is jointly licensed under the Apache License, Version 2.0 *
7 * and the GNU General Public License version 3, you may use it according *
8 * to either. *
9 * *
10 * ** Apache License, version 2.0 ** *
11 * *
12 * Licensed under the Apache License, Version 2.0 (the "License"); *
13 * you may not use this file except in compliance with the License. *
14 * You may obtain a copy of the License at *
15 * *
16 * http://www.apache.org/licenses/LICENSE-2.0 *
17 * *
18 * Unless required by applicable law or agreed to in writing, software *
19 * distributed under the License is distributed on an "AS IS" BASIS, *
20 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
21 * See the License for the specific language governing permissions and *
22 * limitations under the License. *
23 * *
24 * ** GNU General Public License, version 3 ** *
25 * *
26 * This program is free software: you can redistribute it and/or modify *
27 * it under the terms of the GNU General Public License as published by *
28 * the Free Software Foundation, either version 3 of the License, or *
29 * (at your option) any later version. *
30 * *
31 * This program is distributed in the hope that it will be useful, *
32 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
33 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
34 * GNU General Public License for more details. *
35 * *
36 * You should have received a copy of the GNU General Public License *
37 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
38 *****************************************************************************/
39 
50 #ifndef VIRTUAL_CONTAINER_H_
51 #define VIRTUAL_CONTAINER_H_
52 
53 #include "../general/util.h"
54 
55 namespace mui {
56 
57 template<typename V, typename ARRAY>
58 struct index_iterator: public std::iterator<std::forward_iterator_tag,V>
59 {
60  typedef std::iterator<std::forward_iterator_tag,V> iterator;
61 
62  typedef typename iterator::iterator_category iterator_category;
63  typedef typename iterator::value_type value_type;
64  typedef typename iterator::difference_type difference_type;
65  typedef typename iterator::pointer pointer;
66  typedef typename iterator::reference reference;
67 
68  index_iterator( ARRAY& array, std::size_t index=0 ): array_(array), index_(index) {}
69  index_iterator() = default;
70  index_iterator( const index_iterator& ) = default;
71  index_iterator& operator=( const index_iterator& ) = default;
72 
73  value_type operator*() const { return array_[index_]; }
74  reference operator*() { return array_[index_]; }
75  const pointer operator->() const { return &(array_[index_]); }
76  pointer operator->() { return &(array_[index_]); }
77 
78 
80  ++index_;
81  return *this;
82  }
84  index_iterator prev = *this;
85  operator++();
86  return prev;
87  }
88  bool operator==( const index_iterator& rhs ) const { return index_ == rhs.index_; }
89  bool operator!=( const index_iterator& rhs ) const { return index_ != rhs.index_; }
90 private:
91  ARRAY& array_;
92  std::size_t index_;
93 };
94 
95 
96 template < typename TYPE, typename CONFIG>
98 public:
99  using elem_type = std::pair<typename CONFIG::point_type,TYPE>;
100  using container_type = std::vector<elem_type>;
102 
103  inline virtual_container( const container_type &container, std::vector<size_t> map ) :
104  container_(container), map_(std::move(map)) {
105  }
106  virtual_container( const container_type &container, const std::vector<bool> &pred ) :
107  container_(container) {
108  for( size_t i = 0 ; i < pred.size() ; i++ ) if (pred[i]) map_.push_back(i);
109  }
110 
111  // operator [] does no bound check
112  inline const elem_type& operator [] ( size_t i ) const {
113  return container_[ map_[i] ];
114  }
115 
116  // at performs bound check
117  inline const elem_type& at ( size_t i ) const {
118  if ( i >= map_.size() ) typename CONFIG::EXCEPTION(std::out_of_range("MUI Error [virtual_container.h]: Out of range."));
119  return container_[ map_[i] ];
120  }
121 
122  inline iterator begin() const {
123  iterator iter(*this);
124  return iter;
125  }
126  inline iterator cbegin() const { return begin(); }
127 
128  inline iterator end()const{
129  iterator iter(*this,size());
130  return iter;
131  }
132  inline iterator cend() const { return end(); }
133 
134  inline size_t size() const { return map_.size(); }
135 protected:
137  std::vector<size_t> map_;
138 
139 };
140 
141 template < typename TYPE, typename CONFIG>
142 virtual_container<TYPE,CONFIG> make_vc( const std::vector<typename CONFIG::point_type,TYPE> &container,
143  const std::vector<size_t> &map )
144 {
145  return virtual_container<TYPE,CONFIG>(container,map);
146 }
147 
148 template < typename TYPE, typename CONFIG>
149 virtual_container<TYPE,CONFIG> make_vc( const std::vector<std::pair<typename CONFIG::point_type,TYPE> > &container,
150  const std::vector<bool> &pred )
151 {
152  return virtual_container<TYPE,CONFIG>(container,pred);
153 }
154 
155 }
156 
157 #endif /* VIRTUAL_CONTAINER_H_ */
Definition: virtual_container.h:97
virtual_container(const container_type &container, const std::vector< bool > &pred)
Definition: virtual_container.h:106
iterator begin() const
Definition: virtual_container.h:122
std::vector< elem_type > container_type
Definition: virtual_container.h:100
std::pair< typename CONFIG::point_type, TYPE > elem_type
Definition: virtual_container.h:99
iterator end() const
Definition: virtual_container.h:128
const elem_type & at(size_t i) const
Definition: virtual_container.h:117
const elem_type & operator[](size_t i) const
Definition: virtual_container.h:112
iterator cend() const
Definition: virtual_container.h:132
iterator cbegin() const
Definition: virtual_container.h:126
index_iterator< const elem_type, const virtual_container > iterator
Definition: virtual_container.h:101
container_type const & container_
Definition: virtual_container.h:136
virtual_container(const container_type &container, std::vector< size_t > map)
Definition: virtual_container.h:103
size_t size() const
Definition: virtual_container.h:134
std::vector< size_t > map_
Definition: virtual_container.h:137
Definition: comm.h:54
virtual_container< TYPE, CONFIG > make_vc(const std::vector< typename CONFIG::point_type, TYPE > &container, const std::vector< size_t > &map)
Definition: virtual_container.h:142
Definition: virtual_container.h:59
iterator::difference_type difference_type
Definition: virtual_container.h:64
iterator::reference reference
Definition: virtual_container.h:66
iterator::iterator_category iterator_category
Definition: virtual_container.h:62
bool operator!=(const index_iterator &rhs) const
Definition: virtual_container.h:89
iterator::value_type value_type
Definition: virtual_container.h:63
index_iterator operator++(int)
Definition: virtual_container.h:83
value_type operator*() const
Definition: virtual_container.h:73
reference operator*()
Definition: virtual_container.h:74
index_iterator(ARRAY &array, std::size_t index=0)
Definition: virtual_container.h:68
bool operator==(const index_iterator &rhs) const
Definition: virtual_container.h:88
index_iterator & operator=(const index_iterator &)=default
index_iterator & operator++()
Definition: virtual_container.h:79
const pointer operator->() const
Definition: virtual_container.h:75
pointer operator->()
Definition: virtual_container.h:76
index_iterator(const index_iterator &)=default
std::iterator< std::forward_iterator_tag, V > iterator
Definition: virtual_container.h:60
index_iterator()=default
iterator::pointer pointer
Definition: virtual_container.h:65