libzypp  17.36.1
ValueTransform.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
11 #ifndef ZYPP_BASE_VALUETRANSFORM_H
12 #define ZYPP_BASE_VALUETRANSFORM_H
13 
14 #include <iosfwd>
15 
16 #include <zypp/base/Iterator.h>
17 
19 namespace zypp
20 {
22  namespace base
23  {
34  template<class Tp, class TUnaryFunction>
36  {
37  using RawType = Tp;
38  using Transformator = TUnaryFunction;
39 #if __cplusplus < 201703L
40  using TransformedType = std::result_of_t<Transformator (RawType)>; // yast in 15.[23] uses c++11
41 #else
42  using TransformedType = std::invoke_result_t<Transformator, RawType>;
43 #endif
44 
45  public:
47  {}
48 
49  explicit ValueTransform( RawType raw_r )
50  : _raw( std::move(raw_r) )
51  {}
52 
53  ValueTransform( RawType raw_r, Transformator transform_r )
54  : _raw( std::move(raw_r) ), _transform( std::move(transform_r) )
55  {}
56 
57  public:
59  const RawType & raw() const
60  { return _raw; }
61 
64  { return _raw; }
65 
66  public:
69  { return _transform( _raw ); }
70 
72  TransformedType transformed( const RawType & raw_r ) const
73  { return _transform( raw_r ); }
74 
76  const Transformator & transformator() const
77  { return _transform; }
78 
79  private:
82  };
83 
94  template<class TContainer, class TUnaryFunction>
96  {
97  using Container = TContainer;
98  using Transformator = TUnaryFunction;
99  using size_type = typename Container::size_type;
100  using RawType = typename Container::value_type;
101 #if __cplusplus < 201703L
102  using TransformedType = std::result_of_t<Transformator (RawType)>; // yast in 15.[23] uses c++11
103 #else
104  using TransformedType = std::invoke_result_t<Transformator, RawType>;
105 #endif
106  public:
108  {}
109 
110  explicit ContainerTransform( Container raw_r )
111  : _raw( std::move(raw_r) )
112  {}
113 
115  : _raw( std::move(raw_r) ), _transform( std::move(transform_r) )
116  {}
117 
118  public:
119  bool empty() const
120  { return _raw.empty(); }
121 
122  size_type size() const
123  { return _raw.size(); }
124 
125  using RawConstIterator = typename Container::const_iterator;
126 
128  { return _raw.begin(); }
129 
131  { return _raw.end(); }
132 
134  const Container & raw() const
135  { return _raw; }
136 
139  { return _raw; }
140 
141  public:
142  using TransformedConstIterator = transform_iterator<Transformator, typename Container::const_iterator>;
143 
145  { return make_transform_iterator( _raw.begin(), _transform ); }
146 
148  { return make_transform_iterator( _raw.end(), _transform ); }
149 
152  { return Container( transformedBegin(), transformedEnd() ); }
153 
155  TransformedType transformed( const RawType & raw_r ) const
156  { return _transform( raw_r ); }
157 
159  TransformedType transformed( const RawConstIterator & rawIter_r ) const
160  { return _transform( *rawIter_r ); }
161 
163  const Transformator & transformator() const
164  { return _transform; }
165 
166  private:
169  };
170 
171  } // namespace base
173 } // namespace zypp
175 #endif // ZYPP_BASE_VALUETRANSFORM_H
TransformedType transformed(const RawType &raw_r) const
Return a transformed copy of an arbitrary RawType.
RawConstIterator rawBegin() const
Definition: Arch.h:363
const Transformator & transformator() const
Return the transformator.
Helper managing raw values with transformed representation.
Helper managing a container of raw values with transformed representation.
ValueTransform(RawType raw_r, Transformator transform_r)
const Container & raw() const
Get the raw value.
ContainerTransform(Container raw_r, Transformator transform_r)
Container transformed() const
Return copy with transformed variables (expensive)
TransformedType transformed() const
Return a transformed copy of the raw value.
TransformedType transformed(const RawType &raw_r) const
Return a transformed copy of an arbitrary RawType.
ValueTransform(RawType raw_r)
RawConstIterator rawEnd() const
const RawType & raw() const
Get the raw value.
std::result_of_t< Transformator(RawType)> TransformedType
TransformedConstIterator transformedBegin() const
typename result_of< T >::type result_of_t
Definition: TypeTraits.h:51
transform_iterator< Transformator, typename Container::const_iterator > TransformedConstIterator
TransformedConstIterator transformedEnd() const
RawType & raw()
Set the raw value.
ContainerTransform(Container raw_r)
Functor replacing repository variables.
Easy-to use interface to the ZYPP dependency resolver.
Definition: Application.cc:19
SolvableIdType size_type
Definition: PoolMember.h:126
TransformedType transformed(const RawConstIterator &rawIter_r) const
Return a transformed copy of a RawConstIterator raw value.
Url manipulation class.
Definition: Url.h:92
const Transformator & transformator() const
Return the transformator.
Container & raw()
Set the raw value.