├── CMakeLists.txt
├── LICENSE
├── README.md
├── include
    └── generators
    │   ├── gen_factory.h
    │   ├── gen_iterator.h
    │   ├── generator.h
    │   ├── msft_gen_mod.h
    │   └── type_generator.h
├── test
    └── driver.cxx
└── win32
    ├── generator.sln
    ├── generator.vcxproj
    └── generator.vcxproj.filters


/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.12)
 2 | 
 3 | set(MY_VCPKG_DIR $ENV{HOMEDRIVE}$ENV{HOMEPATH}\\vcpkg)
 4 | 
 5 | if(NOT EXISTS ${MY_VCPKG_DIR})
 6 |   message("Cloning vcpkg in ${MY_VCPKG_DIR}")
 7 |   execute_process(COMMAND git clone https://github.com/Microsoft/vcpkg.git ${MY_VCPKG_DIR})
 8 | endif()
 9 | 
10 | if(NOT EXISTS ${MY_VCPKG_DIR}\\README.md)
11 |   message(FATAL_ERROR "***** FATAL ERROR: Could not clone vcpkg *****")
12 | endif()
13 | 
14 | if(NOT EXISTS ${MY_VCPKG_DIR}\\vcpkg.exe)
15 |   message("Bootstrapping vcpkg in ${MY_VCPKG_DIR}")
16 |   execute_process(COMMAND ${MY_VCPKG_DIR}\\bootstrap-vcpkg.bat WORKING_DIRECTORY ${MY_VCPKG_DIR})
17 | endif()
18 | 
19 | if(NOT EXISTS ${MY_VCPKG_DIR}\\vcpkg.exe)
20 |   message(FATAL_ERROR "***** FATAL ERROR: Could not bootstrap vcpkg *****")
21 | endif()
22 | 
23 | set(MY_PROJECT_DEPENDENCIES boost-core boost-optional)
24 | message(STATUS "***** Checking project third party dependencies in ${MY_VCPKG_DIR} *****")
25 | execute_process(COMMAND ${MY_VCPKG_DIR}\\vcpkg.exe install ${MY_PROJECT_DEPENDENCIES} WORKING_DIRECTORY ${MY_VCPKG_DIR})
26 | set(CMAKE_TOOLCHAIN_FILE ${MY_VCPKG_DIR}\\scripts\\buildsystems\\vcpkg.cmake)
27 | set(Boost_INCLUDE_DIR ${MY_VCPKG_DIR}\\installed\\x86-windows\\include)
28 | project (CppGenerators)
29 | find_package(Boost 1.67 REQUIRED)
30 | 
31 | message("***** VCPKG INCLUDE DIRS: ${Boost_INCLUDE_DIR} *****")
32 | 
33 | include_directories(${PROJECT_SOURCE_DIR}/include ${Boost_INCLUDE_DIR})
34 | add_executable(driver test/driver.cxx)
35 | set_property(TARGET driver PROPERTY CXX_STANDARD 17)
36 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015, Sumant Tambe
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 | 
 7 | * Redistributions of source code must retain the above copyright notice, this
 8 |   list of conditions and the following disclaimer.
 9 | 
10 | * Redistributions in binary form must reproduce the above copyright notice,
11 |   this list of conditions and the following disclaimer in the documentation
12 |   and/or other materials provided with the distribution.
13 | 
14 | * Neither the name of generators nor the names of its
15 |   contributors may be used to endorse or promote products derived from
16 |   this software without specific prior written permission.
17 | 
18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
22 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 | 
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # generators
2 | Composable Data and Type Generators in C++14
3 | 


--------------------------------------------------------------------------------
/include/generators/gen_factory.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | namespace gen {
  4 | 
  5 |   template <>
  6 |   auto GenFactory<bool>::make()
  7 |   {
  8 |     return make_gen_from([]() {
  9 |       return (random_int32() % 2)? true : false;
 10 |     });
 11 |   }
 12 | 
 13 |   template <>
 14 |   auto GenFactory<char>::make()
 15 |   {
 16 |     return make_printable_gen();
 17 |   }
 18 | 
 19 |   template <>
 20 |   auto GenFactory<int8_t>::make()
 21 |   {
 22 |     return make_gen_from([]() {
 23 |       return static_cast<int8_t>(random_int32() % std::numeric_limits<int8_t>::max());
 24 |     });
 25 |   }
 26 | 
 27 |   template <>
 28 |   auto GenFactory<int16_t>::make()
 29 |   {
 30 |     return make_gen_from([]() {
 31 |       return static_cast<int16_t>(random_int32() % std::numeric_limits<int16_t>::max());
 32 |     });
 33 |   }
 34 | 
 35 |   template <>
 36 |   auto GenFactory<int32_t>::make()
 37 |   {
 38 |     return make_gen_from([]() { 
 39 |       return static_cast<int32_t>(random_int32()); 
 40 |     });
 41 |   }
 42 | 
 43 |   template <>
 44 |   auto GenFactory<int64_t>::make()
 45 |   {
 46 |     return make_gen_from([]() {
 47 |       return (static_cast<int64_t>(random_int32()) << 32) + random_int32();
 48 |     });
 49 |   }
 50 | 
 51 |   template <>
 52 |   auto GenFactory<uint8_t>::make()
 53 |   {
 54 |     return make_gen_from([]() {
 55 |       return static_cast<uint8_t>(random_int32() % std::numeric_limits<uint8_t>::max());
 56 |     });
 57 |   }
 58 | 
 59 |   template <>
 60 |   auto GenFactory<uint16_t>::make()
 61 |   {
 62 |     return make_gen_from([]() {
 63 |       return static_cast<uint16_t>(random_int32() % std::numeric_limits<uint16_t>::max());
 64 |     });
 65 |   }
 66 | 
 67 |   template <>
 68 |   auto GenFactory<uint32_t>::make()
 69 |   {
 70 |     return make_gen_from([]() {
 71 |       return static_cast<uint32_t>(random_int32());
 72 |     });
 73 |   }
 74 | 
 75 |   template <>
 76 |   auto GenFactory<uint64_t>::make()
 77 |   {
 78 |     return make_gen_from([]() {
 79 |       return (static_cast<uint64_t>(random_int32()) << 32) + random_int32();
 80 |     });
 81 |   }
 82 | 
 83 |   template <>
 84 |   auto GenFactory<float>::make()
 85 |   {
 86 |     return make_gen_from([]() {
 87 |       return  static_cast<float>(random_int32()) / random_int32();
 88 |       //std::numeric_limits<int32_t>::max() *
 89 |       //std::numeric_limits<float>::max();
 90 |     });
 91 |   }
 92 | 
 93 |   template <>
 94 |   auto GenFactory<double>::make()
 95 |   {
 96 |     return make_gen_from([]() {
 97 |       return  static_cast<double>((random_int32()) /
 98 |         std::numeric_limits<int32_t>::max() *
 99 |         std::numeric_limits<double>::max());
100 |     });
101 |   }
102 | 
103 |   template <>
104 |   auto GenFactory<long double>::make()
105 |   {
106 |     return make_gen_from([]() {
107 |       return  static_cast<long double>(random_int32()) /
108 |         std::numeric_limits<int32_t>::max() *
109 |         std::numeric_limits<long double>::max();
110 |     });
111 |   }
112 | 
113 |   template <class T>
114 |   struct GenFactory<std::vector<T>>
115 |   {
116 |     template <class TGen>
117 |     static auto make(TGen&& tgen,
118 |                      unsigned int maxlen = DEFAULT_MAX_SEQ_LEN,
119 |                      bool possibly_empty = false)
120 |     {
121 |       typedef typename std::remove_reference<TGen>::type::value_type TGenType;
122 |       static_assert(std::is_same<T, TGenType>::value, "Types don't match");
123 |       return make_seq_gen<std::vector>(std::forward<TGen>(tgen), maxlen, possibly_empty);
124 |     }
125 | 
126 |     static auto make()
127 |     {
128 |       return make_seq_gen<std::vector>(GenFactory<T>::make());
129 |     }
130 | 
131 |   };
132 | 
133 |   template <class T>
134 |   struct GenFactory<std::list<T>>
135 |   {
136 |     template <class TGen>
137 |     static auto make(TGen&& tgen,
138 |                      unsigned int maxlen = DEFAULT_MAX_SEQ_LEN,
139 |                      bool possibly_empty = false)
140 |     {
141 |       typedef typename std::remove_reference<TGen>::type::value_type TGenType;
142 |       static_assert(std::is_same<T, TGenType>::value, "Types don't match");
143 |       return make_seq_gen<std::list>(std::forward<TGen>(tgen), maxlen, possibly_empty);
144 |     }
145 | 
146 |     static auto make()
147 |     {
148 |       return make_seq_gen<std::list>(GenFactory<T>::make());
149 |     }
150 | 
151 |   };
152 | 
153 |   template <class T>
154 |   struct GenFactory<boost::optional<T>>
155 |   {
156 |     static auto make()
157 |     {
158 |       return make_optional_gen(GenFactory<T>::make());
159 |     }
160 | 
161 |     template <class TGen>
162 |     static auto make(TGen&& tgen)
163 |     {
164 |       return make_optional_gen(std::forward<TGen>(tgen));
165 |     }
166 |   };
167 | 
168 |   template <class T, size_t Dim>
169 |   struct GenFactory<std::array<T, Dim>>
170 |   {
171 |     static auto make()
172 |     {
173 |       return make_array_gen(GenFactory<T>::make(), dim_list<Dim>());
174 |     }
175 | 
176 |     template <class TGen>
177 |     static auto make(TGen&& tgen)
178 |     {
179 |       return make_array_gen(std::forward<TGen>(tgen), dim_list<Dim>());
180 |     }
181 |   };
182 | 
183 |   template <class T>
184 |   struct GenFactory<std::shared_ptr<T>>
185 |   {
186 |     static auto make()
187 |     {
188 |       auto tgen = GenFactory<T>::make();
189 |       return make_gen_from([tgen]() mutable {
190 |             return std::make_shared<T>(tgen.generate());
191 |           });
192 |     }
193 |   };
194 | 
195 |   template <class T>
196 |   struct GenFactory<T *>
197 |   {
198 |     static auto make()
199 |     {
200 |       auto tgen = GenFactory<T>::make();
201 |       return make_gen_from([tgen]() mutable {
202 |             return new T(tgen.generate());
203 |           });
204 |     }
205 |   };
206 | 
207 |   template <class... Args>
208 |   struct GenFactory<std::tuple<Args...>>
209 |   {
210 |     static auto make()
211 |     {
212 |       return make_tuple_gen<std::tuple<Args...>>();
213 |     }
214 |   };
215 | 
216 |   template <>
217 |   struct GenFactory<std::string>
218 |   {
219 |     auto make()
220 |     {
221 |       return make_string_gen(make_printable_gen(), 256);
222 |     }
223 |   };
224 | 
225 | } // namespace gen
226 | 


--------------------------------------------------------------------------------
/include/generators/gen_iterator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <iterator>
 4 | 
 5 | namespace gen {
 6 | 
 7 |   template <class T, class Gen>
 8 |   class gen_iterator :
 9 |     public std::iterator<std::input_iterator_tag, T>
10 |   {
11 |     Gen * gen_;
12 |     bool end_;
13 |     T current_;
14 | 
15 |   public:
16 | 
17 |     typedef T  value_type;
18 |     typedef const T & reference;
19 |     typedef const T * pointer;
20 | 
21 |     gen_iterator(Gen & gen, bool end = false) 
22 |       : gen_(&gen),
23 |         end_(end)
24 |     {
25 |       if(!end_)
26 |         ++(*this);
27 |     }
28 | 
29 |     reference operator *() const {
30 |       return current_;
31 |     }
32 | 
33 |     pointer operator ->() const {
34 |       return &current_;
35 |     }
36 | 
37 |     gen_iterator & operator ++ () {
38 |       if (end_)
39 |         throw std::out_of_range("gen_iterator incremented beyond the end");
40 | 
41 |       try {
42 |           current_ = gen_->generate();
43 |       }
44 |       catch (std::out_of_range &) {
45 |           end_ = true;
46 |       }
47 |       return *this;
48 |     }
49 | 
50 |     gen_iterator operator ++ (int) {
51 |       gen_iterator temp(*this);
52 |       ++(*this);
53 |       return temp;
54 |     }
55 | 
56 |     bool operator == (gen_iterator const & gi) const {
57 |       if ((this->gen_ == gi.gen_) &&
58 |           (this->end_ == gi.end_))
59 |         return true;
60 |       else
61 |         return false;
62 |     }
63 | 
64 |     bool operator != (gen_iterator const & gi) const {
65 |       return !(*this == gi);
66 |     }
67 |   };
68 | 
69 | } // namespace gen


--------------------------------------------------------------------------------
/include/generators/generator.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <string>
  4 | #include <cstdlib>
  5 | #include <vector>
  6 | #include <queue>
  7 | #include <list>
  8 | #include <array>
  9 | #include <ctime>
 10 | #include <limits>
 11 | #include <memory>
 12 | #include <stdexcept>
 13 | #include <type_traits>
 14 | 
 15 | #include <boost/optional.hpp>
 16 | 
 17 | namespace gen {
 18 | 
 19 |   constexpr unsigned int DEFAULT_MAX_STR_LEN = 10;
 20 |   constexpr unsigned int DEFAULT_MAX_SEQ_LEN = 10;
 21 | 
 22 |   template <class T, class Gen>
 23 |   class gen_iterator;
 24 | 
 25 | #ifdef WIN32
 26 |   void initialize(unsigned int seed = 0)
 27 |   {
 28 |     if (seed == 0)
 29 |       seed = (unsigned) time(NULL);
 30 |     
 31 |     srand(seed);
 32 |   }
 33 | 
 34 |   int32_t random_int32()
 35 |   {
 36 |     return rand();
 37 |   }
 38 | 
 39 | #else
 40 |   void initialize(unsigned int seed = 0)
 41 |   {
 42 |     if (seed == 0)
 43 |       seed = (unsigned) time(NULL);
 44 | 
 45 |     srandom(seed);
 46 |   }
 47 | 
 48 |   int random_int32()
 49 |   {
 50 |     return static_cast<int>(random());
 51 |   }
 52 | #endif // WIN32
 53 | 
 54 |   template <class GenFunc>
 55 |   auto make_gen_from(GenFunc&& func);
 56 | 
 57 |   template <class T>
 58 |   struct GenFactory
 59 |   {
 60 |     static auto make();
 61 |   };
 62 | 
 63 |   template <class T, class GenFunc>
 64 |   class Gen : GenFunc
 65 |   {
 66 |   public:
 67 |     typedef T value_type;
 68 | 
 69 |     explicit Gen(GenFunc& func)
 70 |       : GenFunc(func)
 71 |     { }
 72 | 
 73 |     explicit Gen(GenFunc&& func)
 74 |       : GenFunc(std::move(func))
 75 |     { }
 76 | 
 77 |     T generate()
 78 |     {
 79 |       return GenFunc::operator()();
 80 |     }
 81 | 
 82 |     gen_iterator<T, Gen> begin() 
 83 |     {
 84 |       return gen_iterator<T, Gen>(*this, false);
 85 |     }
 86 | 
 87 |     gen_iterator<T, Gen> end() 
 88 |     {
 89 |       return gen_iterator<T, Gen>(*this, true);
 90 |     }
 91 | 
 92 |     template <class Func>
 93 |     auto map(Func&& func)
 94 |     {
 95 |       return make_gen_from(
 96 |                 [self = std::move(*this),
 97 |                  func = std::forward<Func>(func)]() mutable {
 98 |                     return func(self.generate());
 99 |                 });
100 |     }
101 | 
102 |     template <class Zipper, class... GenList>
103 |     auto zip_with(Zipper&& func, GenList&&... genlist)
104 |     {
105 |       return make_gen_from(
106 |         [self = std::move(*this),
107 |          genlist...,
108 |          func = std::forward<Zipper>(func)]() mutable {
109 |             return func(self.generate(), genlist.generate()...);
110 |       });
111 |     }
112 | 
113 |     template <class UGen>
114 |     auto amb(UGen&& ugen) 
115 |     {
116 |       return make_gen_from(
117 |          [self = std::move(*this),
118 |           ugen = std::forward<UGen>(ugen)]() mutable {
119 |              return (random_int32() % 2) ? self.generate() : ugen.generate();
120 |       });
121 |     }
122 | 
123 |     auto take(size_t count) 
124 |     {
125 |       return make_gen_from(
126 |              [self = std::move(*this), count]() mutable {
127 |                 if(count-- > 0)
128 |                 {
129 |                   return self.generate();
130 |                 }
131 |                 else
132 |                   throw std::out_of_range("take: generate exceeded take");
133 |           });
134 |     }
135 | 
136 |     template <class ReducerFunc, class Seed>
137 |     auto reduce(ReducerFunc&& reducer, Seed&& seed) 
138 |     {
139 |       return make_gen_from(
140 |                [self = std::move(*this),
141 |                 reducer = std::forward<ReducerFunc>(reducer), 
142 |                 seed = std::forward<Seed>(seed),
143 |                 done = false]() mutable {
144 |                   try {
145 |                     while(!done)
146 |                       seed = reducer(seed, self.generate());
147 |                   }
148 |                   catch(std::out_of_range &) {
149 |                     done = true;
150 |                     return seed;
151 |                   }
152 |                   throw std::out_of_range("reduction completed");
153 |                   return seed;
154 |           });
155 |     }
156 | 
157 |     template <class UGen>
158 |     auto append(UGen&& ugen) 
159 |     {
160 |       return concat(std::forward<UGen>(ugen));
161 |     }
162 | 
163 |     template <class UGen>
164 |     auto concat(UGen&& ugen) 
165 |     {
166 |       return make_gen_from(
167 |           [tgen = std::move(*this),
168 |            ugen = std::forward<UGen>(ugen),
169 |            tdone = false,
170 |            udone = false]() mutable {
171 |              if(!tdone)
172 |              {
173 |                try {
174 |                   return tgen.generate();
175 |                } 
176 |                catch(std::out_of_range &) {
177 |                  tdone = true;
178 |                }
179 |              }
180 | 
181 |              if(!udone)
182 |              {
183 |                try {
184 |                   return ugen.generate();
185 |                } 
186 |                catch(std::out_of_range &) {
187 |                  udone = true;
188 |                }
189 |              }
190 |              
191 |              throw std::out_of_range("concat: both generators completed!");
192 |           });
193 |     }
194 | 
195 |     template <class UGenFunc>
196 |     auto concat_map(UGenFunc&& ugenfunc) 
197 |     {
198 |       typedef decltype(ugenfunc(std::declval<T>())) UGenType;
199 |       return make_gen_from(
200 |           [tgen = std::move(*this),
201 |            ugenfunc = std::forward<UGenFunc>(ugenfunc),
202 |            //ugenopt  = boost::optional<UGenType>(),
203 |            ugenvec  = std::vector<UGenType>(),
204 |            tdone = false,
205 |            udone = true]() mutable {
206 |              if(!udone)
207 |              {
208 |                try {
209 |                  return ugenvec[0].generate();
210 |                  //return ugenopt->generate();
211 |                }
212 |                catch(std::out_of_range &) {
213 |                  udone = true;
214 |                }
215 |              }
216 |              while(!tdone && udone)
217 |              {
218 |                try {
219 |                  //ugenopt.emplace(ugenfunc(tgen.generate()));
220 |                  ugenvec.clear();
221 |                  ugenvec.emplace_back(ugenfunc(tgen.generate()));
222 |                  udone = false;
223 |                }
224 |                catch(std::out_of_range &) {
225 |                  tdone = true;
226 |                  throw;
227 |                }
228 | 
229 |                if(!udone)
230 |                {
231 |                  try {
232 |                    return ugenvec[0].generate();
233 |                    //return ugenopt->generate();
234 |                  }
235 |                  catch(std::out_of_range &) {
236 |                    udone = true;
237 |                  }
238 |                }
239 |              }
240 |              throw std::out_of_range("concat_map completed");
241 |           });
242 |     }
243 | 
244 |     std::vector<T> to_vector() 
245 |     {
246 |       std::vector<T> v;
247 |       try {
248 |         while(true)
249 |           v.push_back(this->generate());
250 |       }
251 |       catch(std::out_of_range &)
252 |       {
253 |         return v;
254 |       }
255 |       return v;
256 |     }
257 | 
258 |   };
259 | 
260 |   template <class GenFunc>
261 |   auto make_gen_from(GenFunc&& func)
262 |   {
263 |     return Gen<decltype(func()), GenFunc>(std::forward<GenFunc>(func));
264 |   }
265 | 
266 |   template <class T>
267 |   auto make_constant_gen(T&& t)
268 |   {
269 |     return make_gen_from([t = std::forward<T>(t)]() { return t; });
270 |   }
271 | 
272 |   template <class T>
273 |   auto make_empty_gen()
274 |   {
275 |     return make_gen_from([]() -> T { 
276 |         throw std::out_of_range("empty generator!"); 
277 |         //return std::declval<T>(); //did not work for int!!
278 |         return *static_cast<T *>(nullptr);
279 |       });
280 |   }
281 | 
282 |   template <class T>
283 |   auto make_single_gen(T&& t)
284 |   {
285 |     return make_gen_from([t = std::forward<T>(t), done = false]() mutable {
286 |         if(!done)
287 |         {
288 |           done = true;
289 |           return t; 
290 |         }
291 |         else
292 |           throw std::out_of_range("single generator completed!");
293 |       });
294 |   }
295 | 
296 |   template <class Integer>
297 |   auto make_range_gen(Integer lo, Integer hi)
298 |   {
299 |     return make_gen_from([lo, hi]() { 
300 |       return static_cast<Integer>(lo + random_int32() % (hi - lo)); 
301 |     });
302 |   }
303 | 
304 |   auto make_printable_gen()
305 |   {
306 |     return make_gen_from([]() {
307 |       auto space = 32;
308 |       auto tilde = 126;
309 |       return static_cast<char>(space + random_int32() % (tilde + 1 - space));
310 |     });
311 |   }
312 | 
313 |   auto make_ascii_gen()
314 |   {
315 |     return make_gen_from([]() {
316 |               return static_cast<char>(random_int32() % 128);
317 |            });
318 |   }
319 | 
320 |   auto make_lowercase_gen()
321 |   {
322 |     return make_gen_from([]() {
323 |       return static_cast<char>('a' + random_int32() % ('z' + 1 - 'a'));
324 |     });
325 |   }
326 | 
327 |   auto make_uppercase_gen()
328 |   {
329 |     return make_gen_from([]() {
330 |       return static_cast<char>('A' + random_int32() % ('Z' + 1 - 'A'));
331 |     });
332 |   }
333 | 
334 |   auto make_alpha_gen()
335 |   {
336 |     return make_gen_from([]() {
337 |       return (random_int32() % 2) ?
338 |         static_cast<char>('a' + random_int32() % ('z' + 1 - 'a')) :
339 |         static_cast<char>('A' + random_int32() % ('Z' + 1 - 'A'));
340 |     });
341 |   }
342 | 
343 |   auto make_digit_gen()
344 |   {
345 |     return make_gen_from([]() {
346 |       return static_cast<char>('0' + random_int32() % ('9' + 1 - '0'));
347 |     });
348 |   }
349 | 
350 |   auto make_alphanum_gen()
351 |   {
352 |     return make_gen_from([]() {
353 |       if (random_int32() % 2)
354 |       {
355 |         return (random_int32() % 2) ?
356 |           static_cast<char>('a' + random_int32() % ('z' + 1 - 'a')) :
357 |           static_cast<char>('A' + random_int32() % ('Z' + 1 - 'A'));
358 |       }
359 |       else
360 |         return static_cast<char>('0' + random_int32() % ('9' + 1 - '0'));
361 |     });
362 |   }
363 | 
364 |   template <class CharGen>
365 |   auto make_string_gen(CharGen&& chargen = make_printable_gen(), 
366 |                        unsigned int maxlen = DEFAULT_MAX_STR_LEN, 
367 |                        bool possibly_empty = false)
368 |   {
369 |     return make_gen_from(
370 |       [chargen=std::forward<CharGen>(chargen),
371 |        maxlen,
372 |        possibly_empty]() mutable {
373 |         std::string str;
374 |         int length =
375 |           possibly_empty ? (random_int32() % (maxlen+1)) :
376 |                            (random_int32() % maxlen) + 1;
377 |         str.reserve(length);
378 |         for (int i = 0; i < length; ++i)
379 |           str.push_back(chargen.generate());
380 |         
381 |         return str;
382 |     });
383 |   }
384 | 
385 |   template <template <class, class> class Container, class ElemGen>
386 |   auto make_seq_gen(ElemGen&& elemgen, 
387 |                     unsigned int maxlen = DEFAULT_MAX_SEQ_LEN,
388 |                     bool possibly_empty = false)
389 |   {
390 |     return make_gen_from([elemgen=std::forward<ElemGen>(elemgen),
391 |                           maxlen,
392 |                           possibly_empty]() mutable 
393 |     {
394 |       typedef typename std::remove_reference<ElemGen>::type ElemGenT;
395 |       typedef typename ElemGenT::value_type ElemType;
396 |       Container<ElemType, std::allocator<ElemType>> container;
397 | 
398 |       int length =
399 |         possibly_empty ? (random_int32() % (maxlen + 1)) :
400 |                          (random_int32() % maxlen) + 1;
401 |       container.reserve(length);
402 |       for (int i = 0; i < length; ++i)
403 |         container.push_back(elemgen.generate());
404 | 
405 |       return container;
406 |     });
407 |   }
408 | 
409 |   template <class Zipper, class... GenList>
410 |   auto make_zip_gen(Zipper&& func, GenList&&... genlist)
411 |   {
412 |     return make_gen_from(
413 |       [genlist...,
414 |        func = std::forward<Zipper>(func)]() mutable {
415 |           return func(genlist.generate()...);
416 |     });
417 |   }
418 | 
419 |   template<size_t... Dims>
420 |   struct dim_list {
421 |     enum { size = sizeof...(Dims) };
422 |   };
423 | 
424 |   namespace detail {
425 | 
426 |     template <class ElemGen, size_t DimListSize, class DimList>
427 |     struct ArrayGen;
428 | 
429 |     template <class ElemGen, size_t DimListSize, size_t Head, size_t... Tail>
430 |     struct ArrayGen<ElemGen, DimListSize, dim_list<Head, Tail...>>
431 |     {
432 |       static auto make(ElemGen & elemgen)
433 |       {
434 |         auto innergen =
435 |           ArrayGen<ElemGen, DimListSize - 1, dim_list<Tail...>>::make(elemgen);
436 |         
437 |         return make_gen_from([innergen=std::move(innergen)]() mutable {
438 | 
439 |           std::array<decltype(innergen.generate()), Head> arr;
440 |           for (auto & elem : arr)
441 |             elem = innergen.generate();
442 | 
443 |           return arr;
444 |         });
445 |       }
446 |     };
447 |     
448 |     template <class ElemGen, size_t Dim>
449 |     struct ArrayGen<ElemGen, 1, dim_list<Dim>>
450 |     {
451 |       static auto make(ElemGen & elemgen)
452 |       {
453 |         return make_gen_from([elemgen]() mutable {
454 |           typedef typename std::remove_reference<ElemGen>::type ElemGenT;
455 |           std::array<typename ElemGenT::value_type, Dim> arr;
456 |           for (auto & elem : arr)
457 |             elem = elemgen.generate();
458 | 
459 |           return arr;
460 |         });
461 |       }
462 |     };
463 | 
464 |     template <class... Args>
465 |     struct TupleGen;
466 | 
467 |     template <class... Args>
468 |     struct TupleGen<std::tuple<Args...>>
469 |     {
470 |       static auto make()
471 |       {
472 |         return make_zip_gen([](auto&&... args) {
473 |           return std::make_tuple(std::forward<decltype(args)>(args)...);
474 |         }, GenFactory<Args>::make()...);
475 |       }
476 |     };
477 | 
478 |   } // anonymous namespace
479 | 
480 |   template <class ElemGen, class DimList>
481 |   auto make_array_gen(ElemGen&& elemgen, DimList)
482 |   {
483 |     typedef typename std::remove_reference<ElemGen>::type ElemGenT;
484 |     return detail::ArrayGen<ElemGenT, DimList::size, DimList>::make(elemgen);
485 |   }
486 | 
487 |   template <class ElemGen>
488 |   auto make_optional_gen(ElemGen&& elemgen)
489 |   {
490 |     typedef typename std::remove_reference<ElemGen>::type ElemGenT;
491 |     typedef typename boost::optional<typename ElemGenT::value_type> Opt;
492 | 
493 |     return make_gen_from([elemgen=std::forward<ElemGen>(elemgen)]() mutable {
494 |       return (random_int32() % 2) ? Opt() : Opt(elemgen.generate());
495 |     });
496 |   }
497 | 
498 |   template <class Iter>
499 |   auto make_inorder_gen(Iter begin, Iter end)
500 |   {
501 |     std::vector<typename std::iterator_traits<Iter>::value_type> 
502 |       range(begin, end);
503 |     
504 |     /*
505 |     auto iter = range.begin();
506 |     return make_gen_from(
507 |         [range = std::move(range),
508 |          iter = std::move(iter)]() mutable {
509 |            if(iter != range.end())
510 |              return *iter++;
511 |            else
512 |              throw std::out_of_range("in_order_gen: Range traversal completed!");
513 |     });*/
514 |     return make_gen_from(
515 |         [range = std::move(range),
516 |          i = 0u]() mutable {
517 |            if(i < range.size())
518 |              return range[i++];
519 |            else
520 |              throw std::out_of_range("in_order_gen: Range traversal completed!");
521 |     });
522 |   }
523 | 
524 |   template <class T>
525 |   auto make_inorder_gen(std::initializer_list<T> list)
526 |   {
527 |     return make_inorder_gen(list.begin(), list.end());
528 |   }
529 | 
530 |   template <class T>
531 |   auto make_oneof_gen(std::initializer_list<T> list)
532 |   {
533 |     std::vector<T> options(list);
534 |     return make_gen_from([options = std::move(options)]() {
535 |       return *(options.begin() + random_int32() % options.size());
536 |     });
537 |   }
538 | 
539 |   template <class T>
540 |   auto make_oneof_gen(std::vector<T> options)
541 |   {
542 |     return make_gen_from([options = std::move(options)]() {
543 |       return *(options.begin() + random_int32() % options.size());
544 |     });
545 |   }
546 | 
547 |   template <class UGen, class VGen>
548 |   auto make_pair_gen(UGen&& ugen, VGen&& vgen)
549 |   {
550 |     return make_gen_from(
551 |       [ugen = std::forward<UGen>(ugen),
552 |        vgen = std::forward<VGen>(vgen)]() mutable {
553 |           return std::make_pair(ugen.generate(), vgen.generate());
554 |     });
555 |   }
556 | 
557 |   template <class... GenList>
558 |   auto make_composed_gen(GenList&&... genlist)
559 |   {
560 |     return make_gen_from(
561 |       [genlist...]() mutable {
562 |       return std::make_tuple(genlist.generate()...);
563 |     });
564 |   }
565 | 
566 |   template <class Tuple>
567 |   auto make_tuple_gen()
568 |   {
569 |     return detail::TupleGen<Tuple>::make();
570 |   }
571 | 
572 |   auto make_stepper_gen(int start = 0, 
573 |                         int max = std::numeric_limits<int>::max(), 
574 |                         int step = 1, 
575 |                         bool cycle = false)
576 |   {
577 |     bool empty = false;
578 |     if(step >= 0)
579 |     {
580 |       if(start > max)
581 |         empty = true;
582 |     }
583 |     else
584 |     {
585 |       if(start < max)
586 |         empty = true;
587 |     }
588 | 
589 |     auto current = start;
590 |     auto init = false;
591 | 
592 |     return make_gen_from([start, max, step, cycle, current, init, empty]() mutable 
593 |            {
594 |                if(empty)
595 |                  throw std::out_of_range("stepper: steps over!");
596 | 
597 |                if(init==false)
598 |                  init = true;
599 |                else
600 |                {
601 |                  if(step >= 0)
602 |                  {
603 |                    if(current + step <= max)
604 |                       current = current + step;
605 |                    else
606 |                    {
607 |                      if(cycle)
608 |                        current = start;
609 |                      else
610 |                        throw std::out_of_range("stepper: steps over!");
611 |                    }
612 |                  }
613 |                  else
614 |                  {
615 |                    if(current + step >= max)
616 |                       current = current + step;
617 |                    else
618 |                    {
619 |                      if(cycle)
620 |                        current = start;
621 |                      else
622 |                        throw std::out_of_range("stepper: stpes over!");
623 |                    }
624 |                  }
625 |                }
626 |                
627 |                return current;
628 |            });
629 |   }
630 | 
631 |   namespace detail {
632 | 
633 |     template <class Gen, class HeapComp>
634 |     auto make_priority_n_gen(Gen&& src_gen, size_t n, HeapComp comp)
635 |     {
636 |       using SrcType = decltype(src_gen.generate());
637 |       std::priority_queue<SrcType, std::vector<SrcType>, HeapComp> heap;
638 | 
639 |       while (1)
640 |       {
641 |         try {
642 |           auto && val = src_gen.generate();
643 |           if (heap.size() < n)
644 |           {
645 |             heap.push(std::move(val));
646 |           }
647 |           else if (comp(val, heap.top()))
648 |           {
649 |             heap.push(std::move(val));
650 |             heap.pop();
651 |           }
652 |         }
653 |         catch (std::out_of_range &)
654 |         {
655 |           break;
656 |         }
657 |       }
658 | 
659 |       return make_gen_from([heap = std::move(heap)]() mutable {
660 |         if (heap.empty())
661 |           throw std::out_of_range("empty heap");
662 |         else
663 |         {
664 |           SrcType val = heap.top();
665 |           heap.pop();
666 |           return val;
667 |         }
668 |       });
669 |     }
670 | 
671 |   } // namespace detail
672 | 
673 |   template <class Gen>
674 |   auto make_lowest_n_gen(Gen&& src_gen, size_t n)
675 |   {
676 |     using MaxHeapComp = std::less<>;
677 |     return detail::make_priority_n_gen(std::forward<Gen>(src_gen), n, MaxHeapComp());
678 |   }
679 | 
680 |   template <class Gen>
681 |   auto make_highest_n_gen(Gen&& src_gen, size_t n)
682 |   {
683 |     using MinHeapComp = std::greater<>;
684 |     return detail::make_priority_n_gen(std::forward<Gen>(src_gen), n, MinHeapComp());
685 |   }
686 | 
687 | #if _MSC_VER == 1900
688 |   
689 |   template <class Func, class... Args>
690 |   auto make_coroutine_gen(Func&& f, Args... args)
691 |   {
692 |     using gentype = decltype(f(args...));
693 |     std::vector<gentype> gen_v;
694 |     std::vector<decltype(std::declval<gentype>().begin())> iter_v;
695 | 
696 |     gen_v.reserve(1);
697 |     iter_v.reserve(2);
698 |     bool first = true;
699 | 
700 |     return make_gen_from(
701 |       [first, 
702 |        gen_v=std::move(gen_v), 
703 |        iter_v=std::move(iter_v), 
704 |        f=std::move(f), 
705 |        args...]() mutable {
706 |       if (first)
707 |       {
708 |         first = false;
709 |         gen_v.emplace_back(f(args...));
710 |         iter_v.emplace_back(gen_v[0].begin());
711 |         iter_v.emplace_back(gen_v[0].end());
712 |       }
713 |       else
714 |         ++iter_v[0];
715 |       
716 |       if (iter_v[0] == iter_v[1])
717 |         throw std::out_of_range("coroutine completed");
718 |       else
719 |       {
720 |         return *iter_v[0];
721 |       }
722 |     });
723 |   }
724 |   
725 | #endif // __MSC_VER
726 | 
727 | } // namespace gen
728 | 
729 | #include "gen_factory.h"
730 | #include "gen_iterator.h"


--------------------------------------------------------------------------------
/include/generators/msft_gen_mod.h:
--------------------------------------------------------------------------------
  1 | /***
  2 | *generator
  3 | *
  4 | *       Copyright (c) Microsoft Corporation. All rights reserved.
  5 | *
  6 | *       Purpose: Library support of coroutines. generator class
  7 | *       http://open-std.org/JTC1/SC22/WG21/docs/papers/2015/p0057r0.pdf
  8 | *
  9 | *       [Public]
 10 | *
 11 | ****/
 12 | #pragma once
 13 | #ifndef _EXPERIMENTAL_GENERATOR_
 14 | #define _EXPERIMENTAL_GENERATOR_
 15 | #ifndef RC_INVOKED
 16 | 
 17 | #ifndef _RESUMABLE_FUNCTIONS_SUPPORTED
 18 |  #error <experimental/generator> requires /await compiler option
 19 | #endif /* _RESUMABLE_FUNCTIONS_SUPPORTED */
 20 | 
 21 | #include <experimental/resumable>
 22 | 
 23 | #pragma pack(push,_CRT_PACKING)
 24 | #pragma push_macro("new")
 25 | #undef new
 26 | 
 27 | _STD_BEGIN
 28 | 
 29 | namespace experimental {
 30 | 
 31 | 	template <typename _Ty, typename _Alloc = allocator<char> >
 32 | 	struct generator
 33 | 	{
 34 | 		struct promise_type
 35 | 		{
 36 | 			_Ty const * _CurrentValue;
 37 | 
 38 | 			promise_type& get_return_object()
 39 | 			{
 40 |         printf("get_return_object %p\n", this);
 41 | 				return *this;
 42 | 			}
 43 | 
 44 | 			bool initial_suspend()
 45 | 			{
 46 |         printf("initial_suspend %p\n", this);
 47 | 				return (true);
 48 | 			}
 49 | 
 50 | 			bool final_suspend()
 51 | 			{
 52 |         printf("final_suspend %p\n", this);
 53 | 				return (true);
 54 | 			}
 55 | 
 56 | 			void yield_value(_Ty const & _Value)
 57 | 			{
 58 |         printf("yield_value %p\n", this);
 59 | 				_CurrentValue = _STD addressof(_Value);
 60 | 			}
 61 | 
 62 | 			using _Alloc_traits = allocator_traits<_Alloc>;
 63 | 			using _Alloc_of_char_type = typename _Alloc_traits::template rebind_alloc<char>;
 64 | 
 65 | 			void* operator new(size_t _Size)
 66 | 			{
 67 | 				_Alloc_of_char_type _Al;
 68 | 				return _Al.allocate(_Size);
 69 | 			}
 70 | 
 71 | 			void operator delete(void* _Ptr, size_t _Size) _NOEXCEPT
 72 | 			{
 73 | 				_Alloc_of_char_type _Al;
 74 | 				return _Al.deallocate(static_cast<char*>(_Ptr), _Size);
 75 | 			}
 76 | 		};
 77 | 
 78 | 		struct iterator
 79 | 			: _STD iterator<input_iterator_tag, _Ty>
 80 | 		{
 81 | 			coroutine_handle<promise_type> _Coro;
 82 | 
 83 | 			iterator(nullptr_t)
 84 | 				: _Coro(nullptr)
 85 | 			{
 86 | 			}
 87 | 
 88 | 			iterator(coroutine_handle<promise_type> _CoroArg)
 89 | 				: _Coro(_CoroArg)
 90 | 			{
 91 | 			}
 92 | 
 93 | 			iterator& operator++()
 94 | 			{
 95 |         printf("resume\n");
 96 | 				_Coro.resume();
 97 | 				if (_Coro.done())
 98 | 					_Coro = nullptr;
 99 | 				return *this;
100 | 			}
101 | 
102 | 			iterator operator++(int) = delete;
103 | 			// generator iterator current_value
104 | 			// is a reference to a temporary on the coroutine frame
105 | 			// implementing postincrement will require storing a copy
106 | 			// of the value in the iterator.
107 | 			//{
108 | 			//	auto _Result = *this;
109 | 			//	++(*this);
110 | 			//	return _Result;
111 | 			//}
112 | 
113 | 			bool operator==(iterator const& _Right) const
114 | 			{
115 | 				return _Coro == _Right._Coro;
116 | 			}
117 | 
118 | 			bool operator!=(iterator const& _Right) const
119 | 			{
120 | 				return !(*this == _Right);
121 | 			}
122 | 
123 | 			_Ty const& operator*() const
124 | 			{
125 | 				return *_Coro.promise()._CurrentValue;
126 | 			}
127 | 
128 | 			_Ty const* operator->() const
129 | 			{
130 | 				return _STD addressof(operator*());
131 | 			}
132 | 
133 | 		};
134 | 
135 | 		iterator begin()
136 | 		{
137 | 			if (_Coro)
138 | 			{
139 |         printf("resume\n");
140 | 				_Coro.resume();
141 | 				if (_Coro.done())
142 | 					return {nullptr};
143 | 			}
144 | 
145 | 			return {_Coro};
146 | 		}
147 | 
148 | 		iterator end()
149 | 		{
150 | 			return {nullptr};
151 | 		}
152 | 
153 | 		explicit generator(promise_type& _Prom)
154 | 			: _Coro(coroutine_handle<promise_type>::from_promise(_STD addressof(_Prom)))
155 | 		{
156 | 		}
157 | 
158 | 		generator() = default;
159 | 
160 | 		generator(generator const&) = delete;
161 | 
162 | 		generator& operator = (generator const&) = delete;
163 | 
164 | 		generator(generator && _Right)
165 | 			: _Coro(_Right._Coro)
166 | 		{
167 | 			_Right._Coro = nullptr;
168 | 		}
169 | 
170 | 		generator& operator = (generator && _Right)
171 | 		{
172 | 			if (&_Right != this)
173 | 			{
174 | 				_Coro = _Right._Coro;
175 | 				_Right._Coro = nullptr;
176 | 			}
177 | 		}
178 | 
179 | 		~generator()
180 | 		{
181 | 			if (_Coro)
182 | 			{
183 | 				_Coro.destroy();
184 | 			}
185 | 		}
186 | 	private:
187 | 		coroutine_handle<promise_type> _Coro = nullptr;
188 | 	};
189 | 
190 | } // namespace experimental
191 | 
192 | _STD_END
193 | 
194 | #pragma pop_macro("new")
195 | #pragma pack(pop)
196 | #endif /* RC_INVOKED */
197 | #endif /* _EXPERIMENTAL_GENERATOR_ */
198 | 


--------------------------------------------------------------------------------
/include/generators/type_generator.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <type_traits>
  4 | 
  5 | #define TYPE_MAP(Idx, Type)   \
  6 |   template <uint16_t seed>    \
  7 |   struct TypeMap<Idx, seed> { \
  8 |     typedef Type type;        \
  9 |   };
 10 | 
 11 | namespace typegen {
 12 | 
 13 |   template <uint16_t seed, uint16_t Size = 24>
 14 |   struct RandomTuple;
 15 | 
 16 |   namespace detail {
 17 | 
 18 |     constexpr uint16_t LFSR_bit(uint16_t prev)
 19 |     {
 20 |       /* taps: 16 14 13 11; feedback polynomial: x^16 + x^14 + x^13 + x^11 + 1 */
 21 |       return ((prev >> 0) ^ (prev >> 2) ^ (prev >> 3) ^ (prev >> 5)) & 1;
 22 |     }
 23 | 
 24 |     // Compile-time Linear Feedback Shift Register (LFSR) random number generator
 25 |     constexpr uint16_t LFSR(uint16_t prev)
 26 |     {
 27 |       return (prev >> 1) | (LFSR_bit(prev) << 15);
 28 |     }
 29 | 
 30 |     template <size_t lfsr, size_t... values>
 31 |     struct oneof
 32 |     {
 33 |       constexpr static size_t val[sizeof...(values)] = { values... };
 34 |       constexpr static size_t value = val[LFSR(lfsr) % sizeof...(values)];
 35 |     };
 36 | 
 37 |     template <uint16_t I, uint16_t seed>
 38 |     struct TypeMap;
 39 | 
 40 |     constexpr uint16_t MAP_SIZE = 19;
 41 | 
 42 |     TYPE_MAP(0,  bool);
 43 |     TYPE_MAP(1,  char);
 44 |     TYPE_MAP(2,  int8_t);
 45 |     TYPE_MAP(3,  int16_t);
 46 |     TYPE_MAP(4,  int32_t);
 47 |     TYPE_MAP(5,  int64_t);
 48 |     TYPE_MAP(6,  uint8_t);
 49 |     TYPE_MAP(7,  uint16_t);
 50 |     TYPE_MAP(8,  uint32_t);
 51 |     TYPE_MAP(9,  uint64_t);
 52 |     TYPE_MAP(10, float);
 53 |     TYPE_MAP(11, double);
 54 |     TYPE_MAP(12, long double);
 55 | 
 56 |     // sequence generator
 57 |     template <uint16_t lfsr>
 58 |     struct TypeMap<13, lfsr>
 59 |     {
 60 |       // avoid sequence<shared_ptr<T>> = 16
 61 |       // avoid sequence<raw pointer> = 17
 62 |       // avoid sequence<optional<T>> = 18
 63 |       constexpr static size_t selection = LFSR(lfsr) % 16; 
 64 |       typedef std::vector<typename TypeMap<selection, LFSR(lfsr)>::type> type;
 65 |     };
 66 | 
 67 |     // array generator
 68 |     template <uint16_t lfsr>
 69 |     struct TypeMap<14, lfsr>
 70 |     {
 71 |       // avoid array<optional<T>> = 18
 72 |       // avoid array<raw pointer> = 18
 73 |       // avoid array<shared_ptr<T>> = 16
 74 |       constexpr static size_t selection = LFSR(lfsr) % 16; 
 75 |       typedef std::array<typename TypeMap<selection, LFSR(lfsr)>::type,
 76 |                          (LFSR(lfsr) % 10) + 1> type;
 77 |     };
 78 | 
 79 |     // tuple generator
 80 |     template <uint16_t lfsr>
 81 |     struct TypeMap<15, lfsr>
 82 |     {
 83 |       constexpr static size_t tuplesize = (LFSR(lfsr) % 18) + 1;
 84 |       typedef typename RandomTuple<LFSR(lfsr), tuplesize>::type type;
 85 |     };
 86 | 
 87 |     // shared_ptr generator
 88 |     template <uint16_t lfsr>
 89 |     struct TypeMap<16, lfsr>
 90 |     {
 91 |       // avoid shared_ptr<shared_ptr<T>> = 16
 92 |       // avoid shared_ptr<raw pointer> = 17
 93 |       // avoid shared_ptr<optional<T>> = 18
 94 |       constexpr static size_t selection = LFSR(lfsr) % 16; 
 95 |       typedef std::shared_ptr<typename TypeMap<selection, LFSR(lfsr)>::type> type;
 96 |     };
 97 | 
 98 |     // raw pointer generator
 99 |     template <uint16_t lfsr>
100 |     struct TypeMap<17, lfsr>
101 |     {
102 |       // avoid raw pointer to shared_ptr<T> = 16
103 |       // avoid raw pointer to raw pointer = 17
104 |       // avoid raw pointer to optional<T> = 18
105 |       constexpr static size_t selection = LFSR(lfsr) % 16; 
106 |       typedef typename std::add_pointer<typename TypeMap<selection, LFSR(lfsr)>::type>::type type;
107 |     };
108 | 
109 |     // optional generator. 
110 |     template <uint16_t lfsr>
111 |     struct TypeMap<18, lfsr>
112 |     {
113 |       // avoid optional<shared_ptr<T>> = 16
114 |       // avoid optional<raw pointer> = 17
115 |       // avoid optional<optional<T>> = 18
116 |       constexpr static size_t selection = LFSR(lfsr) % 16; 
117 |       typedef boost::optional<typename TypeMap<selection, LFSR(lfsr)>::type> type;
118 |     };
119 | 
120 |     template <class Head, class... Tail>
121 |     struct tuple_cons;
122 | 
123 |     template <class Head, class... Tail>
124 |     struct tuple_cons<Head, std::tuple<Tail...>>
125 |     {
126 |       typedef std::tuple<Head, Tail...> type;
127 |     };
128 | 
129 |     template <class T>
130 |     struct identity
131 |     {
132 |       typedef T type;
133 |     };
134 | 
135 |     template <bool, class T, class U>
136 |     struct if_
137 |     {
138 |       typedef typename T::type type;
139 |     };
140 | 
141 |     template <class T, class U>
142 |     struct if_<false, T, U>
143 |     {
144 |       typedef typename U::type type;
145 |     };
146 | 
147 |     template <class Elem, class... Tail>
148 |     struct contains;
149 | 
150 |     template <class Elem, class Head, class... Tail>
151 |     struct contains<Elem, std::tuple<Head, Tail...>>
152 |     {
153 |       constexpr static bool value = contains<Elem, std::tuple<Tail...>>::value;
154 |     };
155 | 
156 |     template <class Elem, class... Tail>
157 |     struct contains<Elem, std::tuple<Elem, Tail...>>
158 |     {
159 |       constexpr static bool value = true;
160 |     };
161 | 
162 |     template <class Elem>
163 |     struct contains<Elem, std::tuple<>>
164 |     {
165 |       constexpr static bool value = false;
166 |     };
167 | 
168 |     template<uint16_t lfsr, class... Args>
169 |     struct NextUniqueType;
170 | 
171 |     template<uint16_t lfsr, class... Args>
172 |     struct NextUniqueType<lfsr, std::tuple<Args...>>
173 |     {
174 |       typedef typename TypeMap<LFSR(lfsr) % MAP_SIZE, LFSR(lfsr)>::type Next;
175 |       typedef typename if_<contains<Next, std::tuple<Args...>>::value,
176 |                            NextUniqueType<LFSR(lfsr), std::tuple<Args...>>,
177 |                            identity<Next>>::type type;
178 |                            
179 |     };
180 | 
181 |     template <size_t size, uint16_t lfsr>
182 |     struct RandomTupleImpl
183 |     {
184 |       typedef typename RandomTupleImpl<size - 1, LFSR(lfsr)>::type Tuple;
185 |       typedef typename NextUniqueType<LFSR(lfsr), Tuple>::type Next;
186 |       // For non-unique types, uncomment the following.
187 |       //typedef typename TypeMap<LFSR(lfsr) % MAP_SIZE, LFSR(lfsr)>::type Next;
188 |       typedef typename tuple_cons<Next, Tuple>::type type;
189 |     };
190 | 
191 |     template <uint16_t lfsr>
192 |     struct RandomTupleImpl<0, lfsr>
193 |     {
194 |       typedef std::tuple<typename TypeMap<LFSR(lfsr) % MAP_SIZE, LFSR(lfsr)>::type> type;
195 |     };
196 | 
197 |   } // namespace detail
198 | 
199 |   template <uint16_t seed, uint16_t Size>
200 |   struct RandomTuple
201 |   {
202 |     typedef typename detail::RandomTupleImpl<Size - 1, detail::LFSR(seed)>::type type;
203 |   };
204 | 
205 |   template <uint16_t seed>
206 |   struct RandomTuple<seed, 0>
207 |   {
208 |     // Size must be > 0
209 |   };
210 | 
211 |   template <uint16_t Size>
212 |   struct RandomTuple<0, Size>
213 |   {
214 |     // LSFR seed must be non-zero
215 |   };
216 | 
217 | } // namespace typegen
218 | 
219 | #undef TYPE_MAP
220 | 


--------------------------------------------------------------------------------
/test/driver.cxx:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <fstream>
  3 | #include <boost/core/demangle.hpp>
  4 | 
  5 | #if _MSC_VER == 1900
  6 | 
  7 | #define CRTDBG_MAP_ALLOC
  8 | #include <stdlib.h>
  9 | #include <crtdbg.h>
 10 | 
 11 | //#include <experimental/generator>
 12 | #include <msft_gen_mod.h>
 13 | 
 14 | #endif
 15 | 
 16 | #include "generators/generator.h"
 17 | #include "generators/type_generator.h"
 18 | 
 19 | #ifndef RANDOM_SEED
 20 |   #define RANDOM_SEED 0xAC0
 21 | #endif 
 22 | 
 23 | // Clang requires forward declarations for overloaded < operators.
 24 | // g++5 does not. Who's correct?
 25 | 
 26 | template <class... Args>
 27 | std::ostream & operator << (std::ostream & o, const std::tuple<Args...> & tuple);
 28 | 
 29 | template <class T>
 30 | std::ostream & operator << (std::ostream & o, const std::vector<T> & vector);
 31 | 
 32 | template <class T>
 33 | std::ostream & operator << (std::ostream & o, const boost::optional<T> & opt);
 34 | 
 35 | template <class T, class U>
 36 | std::ostream & operator << (std::ostream & o, const std::pair<T, U> & pair);
 37 | 
 38 | template <class T, size_t N>
 39 | std::ostream & operator << (std::ostream & o, const std::array<T, N> & arr)
 40 | {
 41 |   for (auto & elem : arr)
 42 |     o << elem;
 43 | 
 44 |   return o << "\n";
 45 | }
 46 | 
 47 | template <class T>
 48 | std::ostream & operator << (std::ostream & o, const std::vector<T> & vector)
 49 | {
 50 |   for (const auto & elem : vector)
 51 |     o << elem << " ";
 52 | 
 53 |   return o;
 54 | }
 55 | 
 56 | template <class T>
 57 | std::ostream & operator << (std::ostream & o, const boost::optional<T> & opt)
 58 | {
 59 |   if (opt)
 60 |     o << opt.get();
 61 | 
 62 |   return o;
 63 | }
 64 | 
 65 | template <class T, class U>
 66 | std::ostream & operator << (std::ostream & o, const std::pair<T, U> & pair)
 67 | {
 68 |   o << "pair.first = " << pair.first << "\n"
 69 |     << "pair.second = " << pair.second;
 70 | 
 71 |   return o;
 72 | }
 73 | 
 74 | template <class Tuple, size_t Size>
 75 | struct TuplePrinter
 76 | {
 77 |   static void print(std::ostream & o, const Tuple & tuple)
 78 |   {
 79 |     TuplePrinter<Tuple, Size-1>::print(o, tuple);
 80 |     o << std::get<Size-1>(tuple) << " ";
 81 |   }
 82 | };
 83 | 
 84 | template <class Tuple>
 85 | struct TuplePrinter<Tuple, 1>
 86 | {
 87 |   static void print(std::ostream & o, const Tuple & tuple)
 88 |   {
 89 |     o << std::get<0>(tuple) << " ";
 90 |   }
 91 | };
 92 | 
 93 | template <class Tuple>
 94 | struct TuplePrinter<Tuple, 0>
 95 | {
 96 |   static void print(std::ostream &, const Tuple &)
 97 |   {
 98 |     // no-op
 99 |   }
100 | };
101 | 
102 | template <class... Args>
103 | std::ostream & operator << (std::ostream & o, const std::tuple<Args...> & tuple)
104 | {
105 |   TuplePrinter<std::tuple<Args...>, sizeof...(Args)>::print(o, tuple);
106 |   return o;
107 | }
108 | 
109 | struct ShapeType
110 | {
111 |   int x, y, shapesize;
112 |   std::string color;
113 | };
114 | 
115 | std::ostream & operator << (std::ostream & o, const ShapeType & shape)
116 | {
117 |   o << "shape.x = "         << shape.x << "\n"
118 |     << "shape.y = "         << shape.y << "\n"
119 |     << "shape.shapesize = " << shape.shapesize << "\n"
120 |     << "shape.color = "     << shape.color << "\n";
121 | 
122 |   return o;
123 | }
124 | 
125 | auto test_shape_gen()
126 | {
127 |   auto xgen = gen::make_range_gen(0, 200);
128 |   auto ygen = gen::make_range_gen(0, 200);
129 |   auto sizegen = gen::make_constant_gen(30);
130 |   auto colorgen = gen::make_oneof_gen({ "RED", "GREEN", "BLUE" });
131 | 
132 |   auto shapegen =
133 |     gen::make_zip_gen(
134 |       [](int x, int y, int size, const char * color) {
135 |           return ShapeType { x, y, size, color };
136 |       }, xgen, ygen, sizegen, colorgen);
137 | 
138 |   std::cout << shapegen.generate() << "\n";
139 | 
140 |   return shapegen;
141 | }
142 | 
143 | void test_generators(void)
144 | {
145 |   gen::initialize();
146 | 
147 |   auto strgen =
148 |     gen::make_string_gen(gen::make_printable_gen());
149 | 
150 |   std::cout << "size of strgen = " << sizeof(strgen) << "\n"
151 |             << "string = " << strgen.generate() << "\n";
152 | 
153 |   auto vecgen =
154 |     //gen::make_seq_gen<std::vector>(gen::GenFactory<int>::make(), 5, true);
155 |     gen::GenFactory<std::vector<int>>::make(gen::GenFactory<int>::make(), 5, true);
156 | 
157 |   std::cout << "vector = " << vecgen.generate() << "\n";
158 | 
159 |   auto optgen = gen::make_optional_gen(strgen);
160 |   std::cout << "optional string = " << optgen.generate() << "\n";
161 | 
162 |   auto pairgen = gen::make_pair_gen(strgen, vecgen);
163 |   std::cout << pairgen.generate() << "\n";
164 | 
165 |   auto tuplegen = gen::make_composed_gen(strgen, vecgen);
166 |   std::cout << tuplegen.generate() << "\n";
167 | 
168 |   auto shapegen = test_shape_gen();
169 | 
170 |   auto arraygen = gen::make_array_gen(shapegen, gen::dim_list<2, 2>());
171 |   std::cout << arraygen.generate() << "\n";
172 | 
173 |   auto inordergen = 
174 |     gen::make_inorder_gen({ 10, 20 });
175 | 
176 |   assert(inordergen.generate() == 10);
177 |   assert(inordergen.generate() == 20);
178 | 
179 |   auto concatgen = 
180 |     gen::make_inorder_gen({ 10, 20 })
181 |        .concat(gen::make_inorder_gen({ 30 }));
182 | 
183 |   assert(concatgen.generate() == 10);
184 |   assert(concatgen.generate() == 20);
185 |   assert(concatgen.generate() == 30);
186 | 
187 |   auto v1 = gen::make_stepper_gen().take(5).to_vector();
188 |   std::vector<int> v2 { 0, 1, 2, 3, 4 };
189 |   assert(v1 == v2);
190 | 
191 |   std::cout << "All assertions satisfied\n";
192 | }
193 | 
194 | void triangle()
195 | {
196 |   auto triangle_gen = 
197 |     gen::make_inorder_gen({1,2,3,4,5,6,7,8,9,10,9,8,7,6,5,4,3,2,1})
198 |         .concat_map([](int i) {
199 |               std::cout << "\n";
200 |               return gen::make_stepper_gen(1, i);
201 |             });
202 | 
203 |   try {
204 |     while(true)
205 |       std::cout << triangle_gen.generate();
206 |   }
207 |   catch(std::out_of_range &) { 
208 |   }
209 |   std::cout << "\n";
210 | }
211 | 
212 | template<class Gen1, class Gen2>
213 | void is_same(Gen1 g1, Gen2 g2)
214 | {
215 |   assert(g1.to_vector() == g2.to_vector());
216 | }
217 | 
218 | void monad_laws()
219 | {
220 |   auto f = [](int i) { return gen::make_stepper_gen(1, i); };
221 |   auto g = [](int i) { return gen::make_stepper_gen(i, 1, -1); };
222 |   auto M = gen::make_single_gen(300);
223 | 
224 |   // left identity
225 |   is_same(M.concat_map(f), f(300));
226 |   
227 |   // right identity
228 |   is_same(M.concat_map([](int i) { 
229 |             return gen::make_single_gen(i); 
230 |           }), M);
231 |   
232 |   // associativity
233 |   is_same(M.concat_map(f).concat_map(g), 
234 |           M.concat_map([f,g](int i) mutable { 
235 |             return f(i).concat_map(g);
236 |           }));
237 | }
238 | 
239 | void test_typegen()
240 | {
241 |   std::cout << "\n Randomly generated std::tuple\n";
242 |   typegen::RandomTuple<RANDOM_SEED>::type tuple;
243 |   std::cout << boost::core::demangle(typeid(tuple).name());
244 | }
245 | 
246 | void test_gen_iterator()
247 | {
248 |   const int SIZE = 6;
249 |   int array [SIZE] = { 1, 2, 3, 4, 5, 6 };
250 |   auto gen = gen::make_inorder_gen(array, array + SIZE);
251 |   int i = 0;
252 |   
253 |   for (auto & g : gen)
254 |   {
255 |     assert(g == array[i++]);
256 |   }
257 | }
258 | 
259 | void test_priority_n()
260 | {
261 |   auto src1  = gen::make_stepper_gen(1).take(100);
262 |   auto src2  = gen::make_stepper_gen(1).take(100);
263 |   auto lown  = gen::make_lowest_n_gen(src1, 10);
264 |   auto highn = gen::make_highest_n_gen(src2, 10);
265 | 
266 |   std::cout << "Lowest N: ";
267 |   for (auto & val : lown)
268 |   {
269 |     std::cout << val << " ";
270 |     assert(val >= 1 && val <= 10);
271 |   }
272 |   
273 |   std::cout << std::endl << "Highest N: ";
274 |   for (auto & val : highn)
275 |   {
276 |     std::cout << val << " ";
277 |     assert(val >= 91 && val <= 100);
278 |   }
279 |   std::cout << std::endl;
280 | }
281 | 
282 | #if _MSC_VER == 1900
283 | 
284 | std::experimental::generator<char> hello_world()
285 | {
286 |   yield 'H';
287 |   yield 'e';
288 |   yield 'l';
289 |   yield 'l';
290 |   yield 'o';
291 |   yield ',';
292 |   yield ' ';
293 |   yield 'w';
294 |   yield 'o';
295 |   yield 'r';
296 |   yield 'l';
297 |   yield 'd';
298 | }
299 | 
300 | void test_hello_world()
301 | {
302 |   for (char ch : hello_world())
303 |     std::cout << ch << std::endl;
304 | 
305 |   std::cout << std::endl;
306 | }
307 | 
308 | class MyFileStream : public std::ifstream
309 | {
310 | public:
311 | 
312 |   MyFileStream(const std::string & filename)
313 |   : std::ifstream(filename)
314 |   {}
315 |   
316 |   ~MyFileStream() {
317 |     std::cout << "\nclosing filestream";
318 |   }
319 | };
320 | 
321 | MyFileStream & operator >> (MyFileStream & m, std::string & str)
322 | {
323 |   static_cast<std::ifstream &>(m) >> str;
324 |   return m;
325 | }
326 | 
327 | std::experimental::generator<std::string> read_file(const std::string & filename)
328 | {
329 |   MyFileStream in(filename);
330 |   std::string str;
331 |   while (in >> str)
332 |     yield str;
333 | }
334 | 
335 | void test_read_file(const std::string filename)
336 | {
337 |   {
338 |     auto & generator = read_file(filename);
339 |     for (auto & str : generator)
340 |     {
341 |       std::cout << str << " ";
342 |     }
343 |     std::cout << "\n";
344 |   }
345 |   std::cout << "finished test_read_file" << std::endl;
346 | }
347 | 
348 | std::experimental::generator<char> msg(std::string s)
349 | {
350 |   for (auto ch : s)
351 |     yield ch;
352 | }
353 | 
354 | void test_multiple()
355 | {
356 |   auto a = msg("Hello");
357 |   auto b = msg("World");
358 | 
359 |   auto i1 = begin(a);
360 |   auto i2 = begin(b);
361 | 
362 |   while (i1 != end(a) && i2 != end(b))
363 |   {
364 |     std::cout << *i1 << *i2 << " ";
365 |     ++i1;
366 |     ++i2;
367 |   }
368 |   std::cout << std::endl;
369 | }
370 | 
371 | std::experimental::generator<char> hello(int add = 0)
372 | {
373 |   for (auto ch : "HELLO, WORLD")
374 |     yield ch + add;
375 | }
376 | 
377 | void test_coroutine_gen()
378 | {
379 |   std::string msg = "HELLO, WORLD";
380 | 
381 |   auto gen = gen::make_coroutine_gen(hello, 32)
382 |                 .map([](char ch) { return char(ch - 32); })
383 |                 .take(msg.size());
384 |   int i = 0;
385 | 
386 |   for (auto ch: gen)
387 |   {
388 |     std::cout << ch;
389 |     //assert(ch == msg[i++]);
390 |   }
391 |   std::cout << std::endl;
392 | }
393 | 
394 | std::experimental::generator<int> range(int start, int count)
395 | {
396 |   if (count > 0) {
397 |     yield start;
398 |     for (auto i : range(start + 1, count - 1))
399 |       yield i;
400 |   }
401 | }
402 | 
403 | void test_recursive_coroutine()
404 | {
405 |   // deliberate leak. Is it the only one?
406 |   new int;
407 | 
408 |   for (int i : range(5, 4)) // 4000 crash
409 |     std::cout << i << " ";
410 | 
411 |   std::cout << std::endl;
412 | }
413 | 
414 | void test_generator_iterator_category()
415 | {
416 |   using Gen = decltype(hello());
417 |   using Category = Gen::iterator::iterator_category;
418 |   const bool test = std::is_same<std::input_iterator_tag, Category>::value;
419 | 
420 |   static_assert(test, "");
421 | }
422 | 
423 | #endif // _MSC_VER
424 | 
425 | int main(void)
426 | {
427 |   try {
428 |     test_generators();
429 |     test_typegen();
430 |     monad_laws();
431 |     triangle();
432 |     test_gen_iterator();
433 |     test_priority_n();
434 | 
435 | #if _MSC_VER == 1900
436 |     //test_read_file("README.md");
437 |     //test_hello_world();
438 |     //test_multiple();
439 |     //test_coroutine_gen();
440 |     //test_recursive_coroutine();
441 |     //test_generator_iterator_category();
442 | 
443 | 
444 |     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_WNDW);
445 |     _CrtDumpMemoryLeaks();
446 | 
447 | #endif // _MSC_VER
448 |   }
449 |   catch (std::out_of_range & ex)
450 |   {
451 |     std::cerr << "Caught std::out_of_range exception: " << ex.what() << std::endl;
452 |   }
453 | }
454 | 


--------------------------------------------------------------------------------
/win32/generator.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 14
 4 | VisualStudioVersion = 14.0.24720.0
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "generator", "generator.vcxproj", "{4942B93A-7C61-43EB-AFD3-E1EB1385794F}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|x64 = Debug|x64
11 | 		Debug|x86 = Debug|x86
12 | 		Release|x64 = Release|x64
13 | 		Release|x86 = Release|x86
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{4942B93A-7C61-43EB-AFD3-E1EB1385794F}.Debug|x64.ActiveCfg = Debug|x64
17 | 		{4942B93A-7C61-43EB-AFD3-E1EB1385794F}.Debug|x64.Build.0 = Debug|x64
18 | 		{4942B93A-7C61-43EB-AFD3-E1EB1385794F}.Debug|x86.ActiveCfg = Debug|Win32
19 | 		{4942B93A-7C61-43EB-AFD3-E1EB1385794F}.Debug|x86.Build.0 = Debug|Win32
20 | 		{4942B93A-7C61-43EB-AFD3-E1EB1385794F}.Release|x64.ActiveCfg = Release|x64
21 | 		{4942B93A-7C61-43EB-AFD3-E1EB1385794F}.Release|x64.Build.0 = Release|x64
22 | 		{4942B93A-7C61-43EB-AFD3-E1EB1385794F}.Release|x86.ActiveCfg = Release|Win32
23 | 		{4942B93A-7C61-43EB-AFD3-E1EB1385794F}.Release|x86.Build.0 = Release|Win32
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | EndGlobal
29 | 


--------------------------------------------------------------------------------
/win32/generator.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Debug|x64">
 13 |       <Configuration>Debug</Configuration>
 14 |       <Platform>x64</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <PropertyGroup Label="Globals">
 22 |     <ProjectGuid>{4942B93A-7C61-43EB-AFD3-E1EB1385794F}</ProjectGuid>
 23 |     <Keyword>Win32Proj</Keyword>
 24 |     <RootNamespace>generator</RootNamespace>
 25 |     <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
 26 |     <ProjectName>driver</ProjectName>
 27 |   </PropertyGroup>
 28 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 29 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 30 |     <ConfigurationType>Application</ConfigurationType>
 31 |     <UseDebugLibraries>true</UseDebugLibraries>
 32 |     <PlatformToolset>v140</PlatformToolset>
 33 |     <CharacterSet>Unicode</CharacterSet>
 34 |   </PropertyGroup>
 35 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 36 |     <ConfigurationType>Application</ConfigurationType>
 37 |     <UseDebugLibraries>false</UseDebugLibraries>
 38 |     <PlatformToolset>v140</PlatformToolset>
 39 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 40 |     <CharacterSet>Unicode</CharacterSet>
 41 |   </PropertyGroup>
 42 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 43 |     <ConfigurationType>Application</ConfigurationType>
 44 |     <UseDebugLibraries>true</UseDebugLibraries>
 45 |     <PlatformToolset>v140</PlatformToolset>
 46 |     <CharacterSet>Unicode</CharacterSet>
 47 |   </PropertyGroup>
 48 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 49 |     <ConfigurationType>Application</ConfigurationType>
 50 |     <UseDebugLibraries>false</UseDebugLibraries>
 51 |     <PlatformToolset>v140</PlatformToolset>
 52 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 53 |     <CharacterSet>Unicode</CharacterSet>
 54 |   </PropertyGroup>
 55 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 56 |   <ImportGroup Label="ExtensionSettings">
 57 |   </ImportGroup>
 58 |   <ImportGroup Label="Shared">
 59 |   </ImportGroup>
 60 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 61 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 62 |   </ImportGroup>
 63 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 64 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 65 |   </ImportGroup>
 66 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 67 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 68 |   </ImportGroup>
 69 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 70 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 71 |   </ImportGroup>
 72 |   <PropertyGroup Label="UserMacros" />
 73 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 74 |     <LinkIncremental>true</LinkIncremental>
 75 |   </PropertyGroup>
 76 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 77 |     <LinkIncremental>true</LinkIncremental>
 78 |   </PropertyGroup>
 79 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 80 |     <LinkIncremental>false</LinkIncremental>
 81 |   </PropertyGroup>
 82 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 83 |     <LinkIncremental>false</LinkIncremental>
 84 |   </PropertyGroup>
 85 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 86 |     <ClCompile>
 87 |       <PrecompiledHeader>
 88 |       </PrecompiledHeader>
 89 |       <WarningLevel>Level3</WarningLevel>
 90 |       <Optimization>Disabled</Optimization>
 91 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 92 |       <SDLCheck>false</SDLCheck>
 93 |       <AdditionalIncludeDirectories>$(SolutionDir)..\include;$(BOOSTHOME)</AdditionalIncludeDirectories>
 94 |       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
 95 |     </ClCompile>
 96 |     <Link>
 97 |       <SubSystem>Console</SubSystem>
 98 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 99 |     </Link>
100 |   </ItemDefinitionGroup>
101 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
102 |     <ClCompile>
103 |       <PrecompiledHeader>
104 |       </PrecompiledHeader>
105 |       <WarningLevel>Level3</WarningLevel>
106 |       <Optimization>Disabled</Optimization>
107 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
108 |       <SDLCheck>false</SDLCheck>
109 |       <AdditionalIncludeDirectories>$(SolutionDir)..\include;$(BOOSTHOME)</AdditionalIncludeDirectories>
110 |       <AdditionalOptions>/await %(AdditionalOptions)</AdditionalOptions>
111 |       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
112 |     </ClCompile>
113 |     <Link>
114 |       <SubSystem>Console</SubSystem>
115 |       <GenerateDebugInformation>true</GenerateDebugInformation>
116 |     </Link>
117 |   </ItemDefinitionGroup>
118 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
119 |     <ClCompile>
120 |       <WarningLevel>Level3</WarningLevel>
121 |       <PrecompiledHeader>
122 |       </PrecompiledHeader>
123 |       <Optimization>MaxSpeed</Optimization>
124 |       <FunctionLevelLinking>true</FunctionLevelLinking>
125 |       <IntrinsicFunctions>true</IntrinsicFunctions>
126 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
127 |       <SDLCheck>true</SDLCheck>
128 |     </ClCompile>
129 |     <Link>
130 |       <SubSystem>Console</SubSystem>
131 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
132 |       <OptimizeReferences>true</OptimizeReferences>
133 |       <GenerateDebugInformation>true</GenerateDebugInformation>
134 |     </Link>
135 |   </ItemDefinitionGroup>
136 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
137 |     <ClCompile>
138 |       <WarningLevel>Level3</WarningLevel>
139 |       <PrecompiledHeader>
140 |       </PrecompiledHeader>
141 |       <Optimization>MaxSpeed</Optimization>
142 |       <FunctionLevelLinking>true</FunctionLevelLinking>
143 |       <IntrinsicFunctions>true</IntrinsicFunctions>
144 |       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
145 |       <SDLCheck>true</SDLCheck>
146 |     </ClCompile>
147 |     <Link>
148 |       <SubSystem>Console</SubSystem>
149 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
150 |       <OptimizeReferences>true</OptimizeReferences>
151 |       <GenerateDebugInformation>true</GenerateDebugInformation>
152 |     </Link>
153 |   </ItemDefinitionGroup>
154 |   <ItemGroup>
155 |     <ClCompile Include="..\test\driver.cxx" />
156 |   </ItemGroup>
157 |   <ItemGroup>
158 |     <ClInclude Include="..\include\generator.h" />
159 |     <ClInclude Include="..\include\gen_factory.h" />
160 |     <ClInclude Include="..\include\gen_iterator.h" />
161 |     <ClInclude Include="..\include\msft_gen_mod.h" />
162 |     <ClInclude Include="..\include\type_generator.h" />
163 |   </ItemGroup>
164 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
165 |   <ImportGroup Label="ExtensionTargets">
166 |   </ImportGroup>
167 | </Project>


--------------------------------------------------------------------------------
/win32/generator.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Resource Files">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClCompile Include="..\test\driver.cxx">
19 |       <Filter>Source Files</Filter>
20 |     </ClCompile>
21 |   </ItemGroup>
22 |   <ItemGroup>
23 |     <ClInclude Include="..\include\gen_factory.h">
24 |       <Filter>Header Files</Filter>
25 |     </ClInclude>
26 |     <ClInclude Include="..\include\gen_iterator.h">
27 |       <Filter>Header Files</Filter>
28 |     </ClInclude>
29 |     <ClInclude Include="..\include\generator.h">
30 |       <Filter>Header Files</Filter>
31 |     </ClInclude>
32 |     <ClInclude Include="..\include\type_generator.h">
33 |       <Filter>Header Files</Filter>
34 |     </ClInclude>
35 |     <ClInclude Include="..\include\msft_gen_mod.h">
36 |       <Filter>Header Files</Filter>
37 |     </ClInclude>
38 |   </ItemGroup>
39 | </Project>


--------------------------------------------------------------------------------