← Back to branch summary

~ubuntu-branches/ubuntu/saucy/rheolef/saucy

« back to all changes in this revision

Viewing changes to skit/plib2/polymorphic_map.icc

  • Committer: Bazaar Package Importer
  • Author(s): Pierre Saramito
  • Date: 2011-03-23 11:14:26 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20110323111426-cjvhey7lxt6077ty
Tags: 5.93-1
* New upstream release (minor changes):
  - some extra warning message deleted in heap_allocator
  - graphic output with mayavi2 fixed
  - add doc refman in .info and .pdf format

Show diffs side-by-side

added added

removed removed

Lines of Context:
skit/plib2/polymorphic_map.icc
27
27
// ----------------------------------------------------------------------------
28
28
/// @break for debug purpose
29
29
template <class T, class V>
30
 
oparstream&
31
 
polymorphic_map_rep<T,V,N>::put (oparstream& ops) const
 
30
odiststream&
 
31
polymorphic_map_rep<T,V,N>::put (odiststream& ops) const
32
32
{
33
33
  size_type my_proc = communicator().rank();
34
34
  std::ostream& os = ops.os();
35
35
  os << "polymorphic_map{"<<my_proc<<"}.size="<< _ptr.size() << std::endl;
36
36
  for (typename map_type::const_iterator iter = _ptr.begin(), last = _ptr.end(); iter != last; iter++) {
37
 
    const std::pair<size_type, polymorphic_pair_type<T,V,N> >& par_idx_value = *iter;
38
 
    size_type par_idx = par_idx_value.first;
39
 
    size_type k_var = par_idx_value.second.variant();
 
37
    const std::pair<size_type, polymorphic_pair_type<T,V,N> >& dis_idx_value = *iter;
 
38
    size_type dis_idx = dis_idx_value.first;
 
39
    size_type k_var = dis_idx_value.second.variant();
40
40
    const T* ptr_value = 0;
41
41
    switch (k_var) {
42
42
#define _RHEOLEF_case(z,k,unused)                                                       \
43
43
      case k : {                                                                        \
44
44
        typedef typename map##k##_type::iterator iterator;                              \
45
 
        iterator iter = to_iterator<map##k##_type>(par_idx_value.second.raw_pointer()); \
 
45
        iterator iter = to_iterator<map##k##_type>(dis_idx_value.second.raw_pointer()); \
46
46
        const T##k& value = (*iter).second;                                             \
47
 
        os << "polymorphic_map{"<<my_proc<<"}["<<par_idx<<"] = " << value << std::endl;         \
 
47
        os << "polymorphic_map{"<<my_proc<<"}["<<dis_idx<<"] = " << value << std::endl;         \
48
48
        break;                                                                          \
49
49
      }
50
50
      BOOST_PP_REPEAT(N, _RHEOLEF_case, ~)
51
51
#undef _RHEOLEF_case
52
52
      default :{
53
 
        error_macro ("unexpected type #"<<k_var<<" variant of "<<typeid_name_macro(T));
 
53
        error_macro ("unexpected type #"<<k_var<<" variant of "<<typename_macro(T));
54
54
      }
55
55
    }
56
56
  }
75
75
template <class T, class V>
76
76
template <class U>
77
77
void
78
 
polymorphic_map_rep<T,V,N>::insert (const std::pair<size_type, U>& par_idx_value)
 
78
polymorphic_map_rep<T,V,N>::insert (const std::pair<size_type, U>& dis_idx_value)
79
79
{
80
 
  size_type par_idx = par_idx_value.first;
81
 
  size_type k_var = par_idx_value.second.variant();
82
 
  const T& value  = par_idx_value.second; // hope that "const U" converts to "const T&"...
83
 
  warning_macro ("insert[k="<<k_var<<"]: {"<<par_idx_value.first <<"; "<<value << "}...");
84
 
  // TODO: when there is another par_idx element in _ptr, delete it
 
80
  size_type dis_idx = dis_idx_value.first;
 
81
  size_type k_var = dis_idx_value.second.variant();
 
82
  const T& value  = dis_idx_value.second; // hope that "const U" converts to "const T&"...
 
83
  // TODO: when there is another dis_idx element in _ptr, delete it
85
84
  // assume that the location is empty: insert 
86
85
  switch (k_var) {
87
86
#define _RHEOLEF_case(z,k,unused)                                                       \
89
88
        typedef typename map##k##_type::iterator iterator;                              \
90
89
        const T##k* ptr_k = dynamic_cast<const T##k*>(&value);                          \
91
90
         std::pair<iterator,bool> status                                                \
92
 
         = _data._stack_##k.insert (std::pair<size_type,T##k>(par_idx,*ptr_k));         \
 
91
         = _data._stack_##k.insert (std::pair<size_type,T##k>(dis_idx,*ptr_k));         \
93
92
        _data._counter[k]++;                                                            \
94
93
        _data._size++;                                                                  \
95
94
        check_macro (status.second, "insert failed");                                   \
96
95
        iterator iter = status.first;                                                   \
97
 
        _ptr.insert (std::make_pair(par_idx,                                            \
 
96
        _ptr.insert (std::make_pair(dis_idx,                                            \
98
97
                        polymorphic_pair_type<T,V,N>(k, to_pointer<map##k##_type>(iter))));\
99
98
        break;                                                                          \
100
99
      }
101
100
      BOOST_PP_REPEAT(N, _RHEOLEF_case, ~)
102
101
#undef _RHEOLEF_case
103
102
      default :{
104
 
        error_macro ("unexpected type #"<<k_var<<" variant of "<<typeid_name_macro(T));
 
103
        error_macro ("unexpected type #"<<k_var<<" variant of "<<typename_macro(T));
105
104
      }
106
105
  }
107
 
  warning_macro ("insert[k="<<k_var<<"]: {"<<par_idx_value.first <<"; "<<value << "} done");
108
 
}
109
 
#ifdef TODO
110
 
 
111
 
#endif // TODO
 
106
}
 
107
template <class T, class V>
 
108
typename polymorphic_map_rep<T,V,N>::const_iterator
 
109
polymorphic_map_rep<T,V,N>::find (size_type dis_i) const
 
110
{
 
111
    typename map_type::const_iterator raw_iter = _ptr.find (dis_i);
 
112
    return const_iterator (raw_iter);
 
113
}
 
114
template <class T, class V>
 
115
typename polymorphic_map_rep<T,V,N>::const_iterator
 
116
polymorphic_map_rep<T,V,N>::begin () const
 
117
{
 
118
    return const_iterator (_ptr.begin());
 
119
}
 
120
template <class T, class V>
 
121
typename polymorphic_map_rep<T,V,N>::const_iterator
 
122
polymorphic_map_rep<T,V,N>::end () const
 
123
{
 
124
    return const_iterator (_ptr.end());
 
125
}