Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
QTL
spell-qtl
Commits
29dcc482
Commit
29dcc482
authored
Sep 25, 2013
by
Damien Leroux
Browse files
Work in progress. POP computation not satisfying yet.
parent
dd689f2f
Changes
76
Hide whitespace changes
Inline
Side-by-side
data/toto.gen
View file @
29dcc482
data type f2
backcross
data type f2
3 7
*M1 ABA
*M2 ADC
...
...
include/algebraic_genotype.h
View file @
29dcc482
#ifndef _
MCQT
L_ALGEBRAIC_GENOTYPE_H_
#define _
MCQT
L_ALGEBRAIC_GENOTYPE_H_
#ifndef _
SPE
L_ALGEBRAIC_GENOTYPE_H_
#define _
SPE
L_ALGEBRAIC_GENOTYPE_H_
#include
"fast_polynom.h"
#include
"markov_population.h"
...
...
include/all.h
0 → 100644
View file @
29dcc482
#include
<x2c/x2c.h>
#define EIGEN_NO_DEPRECATED_WARNING
#include
<cctype>
#include
<locale>
#include
<string>
#include
<vector>
#include
<map>
#include
<set>
#include
<algorithm>
#include
<iostream>
#include
<iomanip>
#include
"outbred.h"
#include
"chrono.h"
#include
"input.h"
#include
"settings.h"
#include
"banner.h"
#include
"model.h"
template
<
typename
T1
,
typename
T2
>
std
::
ostream
&
operator
<<
(
std
::
ostream
&
os
,
const
std
::
pair
<
T1
,
T2
>&
p
)
{
return
os
<<
p
.
first
<<
':'
<<
p
.
second
;
}
template
<
typename
T1
,
typename
T2
>
std
::
ostream
&
operator
<<
(
std
::
ostream
&
os
,
const
std
::
map
<
T1
,
T2
>&
m
)
{
auto
i
=
m
.
begin
(),
j
=
m
.
end
();
os
<<
'{'
;
if
(
i
!=
j
)
{
os
<<
(
*
i
);
for
(
++
i
;
i
!=
j
;
++
i
)
{
os
<<
' '
<<
(
*
i
);
}
}
return
os
<<
'}'
;
}
#include
"computations.h"
include/banner.h
View file @
29dcc482
#ifndef _
MCQT
L_BANNER_H_
#define _
MCQT
L_BANNER_H_
#ifndef _
SPE
L_BANNER_H_
#define _
SPE
L_BANNER_H_
/*#define VERSION_MAJOR "0"*/
/*#define VERSION_MINOR "1"*/
...
...
include/cache.h
View file @
29dcc482
#ifndef _
MCQT
L_CACHE_H_
#define _
MCQT
L_CACHE_H_
#ifndef _
SPE
L_CACHE_H_
#define _
SPE
L_CACHE_H_
/*#include "cache/call_tuple.h"*/
#include
<iostream>
struct
md5_digest
;
namespace
cache
{
template
<
typename
V
>
struct
value
;
...
...
@@ -9,6 +12,23 @@ namespace cache {
template
<
typename
V
>
struct
collection
;
template
<
typename
C
,
typename
T
,
typename
...
D
>
struct
computed_value
;
template
<
typename
V
>
struct
computed_collection
;
template
<
typename
X
>
struct
is_value
{
static
const
X
&
_
();
template
<
typename
V
>
static
std
::
true_type
check
(
const
value
<
V
>&
);
static
std
::
false_type
check
(...);
static
const
bool
value
=
decltype
(
check
(
_
()))
::
value
;
};
struct
with_output_func
{
virtual
~
with_output_func
()
{}
virtual
std
::
ostream
&
output
(
std
::
ostream
&
os
)
const
=
0
;
virtual
md5_digest
&
to_md5
(
md5_digest
&
)
const
=
0
;
virtual
size_t
hash
()
const
=
0
;
/*virtual cache_input& from_cache(cache_input&) = 0;*/
/*virtual cache_output& to_cache(cache_output&) = 0;*/
};
}
#include
"cache/md5.h"
...
...
include/cache/call_tuple.h
View file @
29dcc482
#ifndef _
MCQT
L_3RD_PARTY_TUPLE_CALL_CODE_H_
#define _
MCQT
L_3RD_PARTY_TUPLE_CALL_CODE_H_
#ifndef _
SPE
L_3RD_PARTY_TUPLE_CALL_CODE_H_
#define _
SPE
L_3RD_PARTY_TUPLE_CALL_CODE_H_
/* from http://stackoverflow.com/a/10766422 */
...
...
include/cache/cartesian_product.h
View file @
29dcc482
#ifndef _
MCQT
L_CACHE_CARTESIAN_PRODUCT_H_
#define _
MCQT
L_CACHE_CARTESIAN_PRODUCT_H_
#ifndef _
SPE
L_CACHE_CARTESIAN_PRODUCT_H_
#define _
SPE
L_CACHE_CARTESIAN_PRODUCT_H_
namespace
cache
{
...
...
@@ -45,22 +45,45 @@ template <typename Item>
}
};
struct
cartesian_product_at_end_exception
:
std
::
exception
{};
template
<
typename
...
ITEMS
>
struct
cartesian_product
{
typedef
typename
make_sequence
<
sizeof
...(
ITEMS
)
>::
type
indices
;
template
<
typename
X
>
struct
to_bool
{
typedef
bool
type
;
};
std
::
tuple
<
iterator_context
<
ITEMS
>
...
>
iter
;
typedef
std
::
tuple
<
iterator_context
<
ITEMS
>
...
>
iter_type
;
iter_type
iter
;
bool
at_end
;
cartesian_product
()
:
iter
(),
at_end
(
true
)
{}
cartesian_product
(
const
ITEMS
&
...
x
)
:
iter
(
x
...),
at_end
(
false
)
{}
{
_debug_types
();
}
cartesian_product
(
const
std
::
tuple
<
ITEMS
...
>&
x
)
:
iter
(
x
),
at_end
(
false
)
{}
{
_debug_types
();
}
cartesian_product
(
const
cartesian_product
<
ITEMS
...
>&
cp
)
:
iter
(
cp
.
iter
),
at_end
(
cp
.
at_end
)
{}
{
_debug_types
();
}
template
<
int
I
,
int
N
>
struct
_debug_types_impl
{
typedef
typename
std
::
tuple_element
<
I
,
std
::
tuple
<
ITEMS
...
>>::
type
etype
;
typedef
typename
std
::
tuple_element
<
I
,
iter_type
>::
type
::
iterator
::
value_type
itype
;
void
operator
()
()
{
/*MSG_DEBUG('#' << I << ": " << typeid(etype).name() << " / " << typeid(itype).name());*/
_debug_types_impl
<
I
+
1
,
N
>
()();
}
};
template
<
int
N
>
struct
_debug_types_impl
<
N
,
N
>
{
void
operator
()
()
{}
};
void
_debug_types
()
const
{
_debug_types_impl
<
0
,
sizeof
...(
ITEMS
)
>
()();
}
cartesian_product
<
ITEMS
...
>&
operator
=
(
const
cartesian_product
&
cp
)
{
...
...
@@ -97,7 +120,7 @@ template <typename... ITEMS>
/*return getter::process(iter);*/
return
_get
<
indices
>::
get
(
iter
);
}
throw
0
;
throw
cartesian_product_at_end_exception
()
;
}
struct
iterator
{
...
...
@@ -120,8 +143,8 @@ template <typename... ITEMS>
return
ret
;
}
iterator
begin
()
{
std
::
cout
<<
"BEGIN"
<<
std
::
endl
;
return
{
*
this
};
}
iterator
end
()
{
std
::
cout
<<
"END"
<<
std
::
endl
;
return
{{}};
}
iterator
begin
()
{
return
{
*
this
};
}
iterator
end
()
{
return
{{}};
}
};
/*template <typename... E>*/
...
...
include/cache/factory.h
View file @
29dcc482
#ifndef _
MCQT
L_CACHE_FACTORY_H_
#define _
MCQT
L_CACHE_FACTORY_H_
#ifndef _
SPE
L_CACHE_FACTORY_H_
#define _
SPE
L_CACHE_FACTORY_H_
#include
<vector>
#include
<memory>
...
...
@@ -16,9 +16,43 @@
#include
"cartesian_product.h"
#include
"file.h"
template
<
typename
T
>
using
only_if_derives_from_wof
=
typename
std
::
enable_if
<
std
::
is_base_of
<
cache
::
with_output_func
,
T
>::
value
,
T
>::
type
;
namespace
std
{
template
<
typename
...
Elem
>
struct
hash
<
std
::
tuple
<
Elem
...
>>
{
typedef
std
::
tuple
<
Elem
...
>
TupleType
;
template
<
int
I
,
int
N
>
struct
hash_elem
{
size_t
operator
()
(
const
TupleType
&
t
)
const
{
/*std::hash<typename std::tuple_element<I, TupleType>::type> h;*/
return
std
::
get
<
I
>
(
t
).
hash
()
^
hash_elem
<
I
+
1
,
N
>
()(
t
);
}
};
template
<
int
N
>
struct
hash_elem
<
N
,
N
>
{
size_t
operator
()
(
const
TupleType
&
t
)
const
{
return
0
;
}
};
size_t
operator
()
(
const
TupleType
&
t
)
const
{
return
hash_elem
<
0
,
sizeof
...(
Elem
)
>
()(
t
);
}
};
/*template <typename T>*/
/*struct hash<only_if_derives_from_wof<T>> : hash<cache::with_output_func> {};*/
}
#define DEFAULT_CACHE_DIR "tmp/"
msg_handler_t
::
lock_type
msg_handler_t
::
mutex
;
/*
msg_handler_t::lock_type msg_handler_t::mutex;
*/
namespace
cache
{
namespace
predicate
{
...
...
@@ -68,8 +102,8 @@ template <>
struct
launch_impl
<
true
>
{
static
std
::
launch
&
policy
()
{
/*
static std::launch _ = std::launch::async | std::launch::deferred;
*/
static
std
::
launch
_
=
std
::
launch
::
deferred
;
static
std
::
launch
_
=
std
::
launch
::
async
|
std
::
launch
::
deferred
;
/*
static std::launch _ = std::launch::deferred;
*/
return
_
;
}
...
...
@@ -101,7 +135,7 @@ template <>
static
Type
access
(
computed_type
<
Type
>&
ct
)
{
return
ct
;
}
};
typedef
launch_impl
<
fals
e
>
launch
;
typedef
launch_impl
<
tru
e
>
launch
;
template
<
typename
Type
>
using
computed_type
=
launch
::
computed_type
<
Type
>
;
...
...
@@ -112,6 +146,7 @@ struct async_computed_value : value<computed_type<Type>> {
/*virtual Type do_compute(const Dependencies&...) = 0;*/
typedef
typename
make_sequence
<
sizeof
...(
Dependencies
)
>::
type
indices
;
using
value
<
computed_type
<
Type
>>::
output
;
typedef
async_computed_value
<
Class
,
Type
,
Dependencies
...
>
task_type
;
std
::
tuple
<
Dependencies
...
>
dependencies
;
Type
val_cache
;
...
...
@@ -133,7 +168,7 @@ struct async_computed_value : value<computed_type<Type>> {
async_computed_value
(
const
async_computed_value
<
Class
,
Type
,
Dependencies
...
>&
)
=
delete
;
async_computed_value
(
async_computed_value
<
Class
,
Type
,
Dependencies
...
>&&
)
=
delete
;
virtual
~
async_computed_value
()
{
/*DEBUG("destroying task " << dependencies);*/
}
virtual
~
async_computed_value
()
{
/*
MSG_
DEBUG("destroying task " << dependencies);*/
}
std
::
string
cache_filename
()
const
{
...
...
@@ -151,16 +186,18 @@ struct async_computed_value : value<computed_type<Type>> {
return
f
.
str
();
}
void
_fetch
()
void
_fetch
()
const
{
if
(
!
fetched
)
{
fetched
=
true
;
val_cache
=
launch
::
access
(
val
);
task_type
*
mut
=
const_cast
<
task_type
*>
(
this
);
if
(
!
mut
->
fetched
)
{
mut
->
fetched
=
true
;
mut
->
val_cache
=
launch
::
access
(
mut
->
val
);
}
}
Type
v
()
{
_fetch
();
return
val_cache
;
}
operator
Type
()
{
_fetch
();
return
val_cache
;
}
const
Type
&
v
()
const
{
_fetch
();
return
val_cache
;
}
operator
const
Type
&
()
const
{
_fetch
();
return
val_cache
;
}
operator
Type
&
()
{
_fetch
();
return
val_cache
;
}
void
move
(
Type
&
dest
)
{
_fetch
();
dest
=
val_cache
;
}
...
...
@@ -177,20 +214,17 @@ private:
file_stat
fs
(
path
);
if
(
fs
.
exists
)
{
if
(
!
fs
.
readable
)
{
ERROR
(
"File "
<<
path
<<
" is not readable."
,
"Check permissions for file "
<<
path
);
MSG_
ERROR
(
"File "
<<
path
<<
" is not readable."
,
"Check permissions for file "
<<
path
);
unlink
(
path
.
c_str
());
}
else
if
(
load
(
path
,
ret
))
{
/*INFO(dependencies << " Reloading data from path " << path);*/
INFO
(
"Reloading data from path "
<<
path
);
/*MSG_INFO("Reloading data from path " << path);*/
return
ret
;
}
else
{
/*INFO(dependencies << " Cache invalid. Computing data and caching in " << path);*/
INFO
(
"Cache invalid. Computing data and caching in "
<<
path
);
/*MSG_INFO("Cache invalid. Computing data and caching in " << path);*/
compute_and_save
(
path
,
ret
);
}
}
else
{
/*INFO(dependencies << " Computing data and caching in " << path);*/
INFO
(
"Computing data and caching in "
<<
path
);
/*MSG_INFO("Computing data and caching in " << path);*/
compute_and_save
(
path
,
ret
);
}
return
ret
;
...
...
@@ -206,28 +240,14 @@ private:
bool
load
(
const
std
::
string
&
filename
,
Type
&
v
)
{
DEBUG
(
__FILE__
<<
':'
<<
__LINE__
<<
'\t'
<<
__func__
);
std
::
ifstream
ifs
(
filename
);
DEBUG
(
__FILE__
<<
':'
<<
__LINE__
<<
'\t'
<<
__func__
);
cache_input
ar
(
ifs
);
DEBUG
(
__FILE__
<<
':'
<<
__LINE__
<<
'\t'
<<
__func__
);
#if 1
std
::
string
check
;
DEBUG
(
__FILE__
<<
':'
<<
__LINE__
<<
'\t'
<<
__func__
);
ar
&
check
;
DEBUG
(
__FILE__
<<
':'
<<
__LINE__
<<
'\t'
<<
__func__
);
if
(
check
!=
dependencies_digest
())
{
#else
std
::
tuple
<
Dependencies
...
>
check
;
ar
&
check
;
if
(
check
!=
dependencies
)
{
#endif
DEBUG
(
__FILE__
<<
':'
<<
__LINE__
<<
'\t'
<<
__func__
);
return
false
;
}
DEBUG
(
__FILE__
<<
':'
<<
__LINE__
<<
'\t'
<<
__func__
);
ar
&
v
;
DEBUG
(
__FILE__
<<
':'
<<
__LINE__
<<
'\t'
<<
__func__
);
return
true
;
}
...
...
@@ -254,7 +274,7 @@ private:
{
return
Class
::
do_compute
(
t
...);
/*Class* tmp = reinterpret_cast<Class*>(this);*/
/*DEBUG(__FILE__ << ':' << __LINE__ << " compute_@" << tmp << " from @" << this);*/
/*
MSG_
DEBUG(__FILE__ << ':' << __LINE__ << " compute_@" << tmp << " from @" << this);*/
/*return tmp->do_compute(t...);*/
}
...
...
@@ -263,9 +283,9 @@ private:
{
return
Class
::
do_compute
(
std
::
get
<
Indices
>
(
t
)...);
/*Class* tmp = reinterpret_cast<Class*>(this);*/
/*DEBUG("type of *this = " << typeid(*this).name());*/
/*DEBUG("type of Class = " << typeid(Class).name());*/
/*DEBUG(__FILE__ << ':' << __LINE__ << " compute_@" << tmp << " from @" << this);*/
/*
MSG_
DEBUG("type of *this = " << typeid(*this).name());*/
/*
MSG_
DEBUG("type of Class = " << typeid(Class).name());*/
/*
MSG_
DEBUG(__FILE__ << ':' << __LINE__ << " compute_@" << tmp << " from @" << this);*/
/*return tmp->do_compute(std::get<Indices>(t)...);*/
}
...
...
@@ -313,21 +333,26 @@ private:
tuple_digest_
<
0
,
sizeof
...(
Dependencies
)
>::
append
(
s
,
dependencies
);
}
typedef
std
::
unordered_map
<
std
::
tuple
<
Dependencies
...
>
,
std
::
shared_ptr
<
Class
>
>
registry_t
;
typedef
std
::
unordered_map
<
std
::
tuple
<
Dependencies
...
>
,
task_type
*
>
registry_t
;
public:
#if
0
#if
1
static
registry_t
&
registry
()
{
static
registry_t
_
;
return
_
;
}
static
std::shared_ptr<Class>
get(const std::tuple<Dependencies...>& t)
static
task_type
*
get
(
const
std
::
tuple
<
Dependencies
...
>&
t
)
{
std::shared_ptr<Class>
& ret = registry()[t];
task_type
*
&
ret
=
registry
()[
t
];
if
(
!
ret
)
{
ret = new
Class
(t);
ret
=
new
task_type
(
t
);
}
return
ret
;
}
static
task_type
*
get
(
const
Dependencies
&
...
t
)
{
return
get
(
std
::
make_tuple
(
t
...));
}
static
void
clear_registry
()
{
registry
().
clear
();
}
#else
static
Class
*
get
(
std
::
tuple
<
Dependencies
...
>&&
t
)
...
...
@@ -363,19 +388,18 @@ struct computed_value : value<Type> {
typedef
async_computed_value
<
Class
,
Type
,
Dependencies
...
>
task_type
;
using
value
<
Type
>::
output
;
using
value
<
Type
>::
val
;
std
::
shared_ptr
<
task_type
>
task
;
bool
fetched
;
task_type
*
task
;
computed_value
(
Dependencies
&&
...
d
)
:
value
<
Type
>
(),
task
(
new
task_type
(
d
...))
:
value
<
Type
>
(),
task
(
task_type
::
get
(
d
...))
{}
computed_value
(
const
Dependencies
&
...
d
)
:
value
<
Type
>
(),
task
(
new
task_type
(
d
...))
:
value
<
Type
>
(),
task
(
task_type
::
get
(
d
...))
{}
computed_value
(
std
::
tuple
<
Dependencies
...
>&&
t
)
:
value
<
Type
>
(),
task
(
new
task_type
(
t
))
:
value
<
Type
>
(),
task
(
task_type
::
get
(
t
))
{}
computed_value
(
const
std
::
tuple
<
Dependencies
...
>&
t
)
:
value
<
Type
>
(),
task
(
new
task_type
(
t
))
:
value
<
Type
>
(),
task
(
task_type
::
get
(
t
))
{}
computed_value
(
const
computed_value
<
Class
,
Type
,
Dependencies
...
>&
cv
)
:
value
<
Type
>
(
cv
.
val
),
task
(
cv
.
task
)
...
...
@@ -384,40 +408,48 @@ struct computed_value : value<Type> {
:
value
<
Type
>
(
cv
.
val
),
task
(
cv
.
task
)
{}
template
<
typename
...
DerDep
>
computed_value
(
const
std
::
tuple
<
DerDep
...
>&
ddt
)
:
value
<
Type
>
(),
task
(
task_type
::
get
(
std
::
tuple
<
Dependencies
...
>
(
ddt
)))
{}
template
<
typename
...
DerDep
>
computed_value
(
const
DerDep
&
...
dd
)
:
value
<
Type
>
(),
task
(
task_type
::
get
(((
const
Dependencies
&
)
dd
)...))
{}
computed_value
()
:
value
<
Type
>
(),
task
()
{}
void
__init
(
const
std
::
tuple
<
Dependencies
...
>&
d
)
{
task
=
new
task_type
(
d
);
task
=
task_type
::
get
(
d
);
}
Class
&
operator
=
(
const
Class
&
c
)
Class
&
operator
=
(
const
computed_value
<
Class
,
Type
,
Dependencies
...
>
&
c
)
{
if
(
task
)
{
delete
task
;
}
/*
if (task) {
*/
/*
delete task;
*/
/*}*/
task
=
c
.
task
;
return
*
static_cast
<
Class
*>
(
this
);
}
Class
&
operator
=
(
Class
&&
c
)
Class
&
operator
=
(
computed_value
<
Class
,
Type
,
Dependencies
...
>
&&
c
)
{
if
(
task
)
{
delete
task
;
}
/*
if (task) {
*/
/*
delete task;
*/
/*}*/
task
=
std
::
move
(
c
.
task
);
return
*
static_cast
<
Class
*>
(
this
);
}
operator
Type
()
const
operator
const
Type
&
()
const
{
return
*
task
;
}
Type
v
()
const
{
return
*
task
;
}
/*Type& v() const { return *task; }*/
const
Type
&
v
()
const
{
return
*
task
;
}
static
const
bool
composite
=
false
;
...
...
@@ -434,6 +466,38 @@ struct computed_value : value<Type> {
{
return
task
->
to_md5
(
md5
);
}
virtual
size_t
hash
()
const
{
std
::
hash
<
dependencies_type
>
h
;
return
h
(
task
->
dependencies
);
}
bool
operator
==
(
const
Class
&
v
)
const
{
return
task
==
v
.
task
;
}
struct
iterator
{
/*typedef computed_value<Class, Type, Dependencies...> value_type;*/
typedef
const
Class
value_type
;
/*computed_value<Class, Type, Dependencies...> val;*/
const
Class
*
val
;
bool
end
;
iterator
(
const
value_type
&
v
)
:
val
(
&
v
)
{}
iterator
()
:
val
(),
end
(
true
)
{}
iterator
(
const
iterator
&
i
)
:
val
(
i
.
val
)
{}
const
value_type
&
operator
*
()
const
{
return
*
val
;
}
iterator
&
operator
++
()
{
val
=
NULL
;
return
*
this
;
}
iterator
&
operator
++
(
int
)
{
val
=
NULL
;
return
*
this
;
}
bool
operator
!=
(
const
iterator
&
i
)
const
{
return
val
!=
i
.
val
;
}
bool
operator
==
(
const
iterator
&
i
)
const
{
return
val
==
i
.
val
;
}
iterator
&
operator
=
(
const
iterator
&
i
)
{
val
=
i
.
val
;
return
*
this
;
}
};
iterator
begin
()
const
{
return
{
*
this
};
}
iterator
end
()
const
{
return
{};
}
typedef
iterator
const_iterator
;
};
...
...
@@ -479,8 +543,8 @@ struct make_task_helper<true, TASK_CLASS, Elems...> {
cartesian_product
<
Elems
...
>
cp
(
t
);
do
{
/*ret.emplace_back(TASK_CLASS::get(*cp));*/
/*DEBUG("make_task " << (*cp));*/
ret
.
emplace_back
(
TASK_CLASS
(
*
cp
)
)
;
/*
MSG_
DEBUG("make_task " << (*cp));*/
ret
.
emplace_back
(
*
cp
);
}
while
(
cp
.
next
());
return
ret
;
}
...
...
@@ -498,7 +562,7 @@ template <typename TASK_CLASS, typename... Elems>
auto
make_task
(
const
std
::
tuple
<
Elems
...
>&
t
)
->
typename
detect_composite
<
TASK_CLASS
,
Elems
...
>::
type
{
/*DEBUG("make_task with " << t);*/
/*
MSG_
DEBUG("make_task with " << t);*/
return
make_task_helper
<
detect_composite
<
TASK_CLASS
,
Elems
...
>::
composite
,
TASK_CLASS
,
Elems
...
>::
make
(
t
);
}
...
...
@@ -506,10 +570,22 @@ template <typename TASK_CLASS, typename... Elems>
auto
make_task
(
std
::
tuple
<
Elems
...
>&&
t
)
->
typename
detect_composite
<
TASK_CLASS
,
Elems
...
>::
type
{
/*DEBUG("make_task with " << t);*/
/*
MSG_
DEBUG("make_task with " << t);*/
return
make_task_helper
<
detect_composite
<
TASK_CLASS
,
Elems
...
>::
composite
,
TASK_CLASS
,
Elems
...
>::
make
(
std
::
move
(
t
));
}
template
<
typename
TASK_CLASS
,
typename
...
Elems
>
auto
make_task_composite
(
const
std
::
tuple
<
Elems
...
>&
t
)
->
decltype
(
make_task_helper
<
true
,
TASK_CLASS
,
Elems
...
>::
make
)
{
return
make_task_helper
<
true
,
TASK_CLASS
,
Elems
...
>::
make
(
t
);
}
template
<
typename
TASK_CLASS
,
typename
...
Elems
>
std
::
vector
<
TASK_CLASS
>
make_task_composite
(
std
::
tuple
<
Elems
...
>&&
t
)
{
return
make_task_helper
<
true
,
TASK_CLASS
,
Elems
...
>::
make
(
std
::
forward
<
std
::
tuple
<
Elems
...
>>
(
t
));
}
template
<
typename
Class
>
struct
computed_collection
:
collection
<
std
::
vector
<
Class
>>
{
...
...
@@ -522,6 +598,7 @@ struct computed_collection : collection<std::vector<Class>> {
/*: value<std::vector<Class>>({make_task<Class>(t)})*/
:
collection
<
std
::
vector
<
Class
>>
{
value_cache
}
{
/*value_cache = make_task_composite<Class>(t);*/
value_cache
=
make_task
<
Class
>
(
t
);
}
...
...
@@ -530,6 +607,7 @@ struct computed_collection : collection<std::vector<Class>> {
/*: value<std::vector<Class>>({make_task<Class>(t)})*/
:
collection
<
std
::
vector
<
Class
>>
{
value_cache
}
{
/*value_cache = make_task_composite<Class>(std::make_tuple(deps...));*/
value_cache
=
make_task
<
Class
>
(
std
::
make_tuple
(
deps
...));
}
...
...
@@ -538,105 +616,42 @@ struct computed_collection : collection<std::vector<Class>> {
return
value_cache
;
}
size_t
size
()
{
return
value_cache
.
size
();
}
size_t
size
()
const
{
return
value_cache
.
size
();
}
Class
&
operator
[]
(
size_t
i
)
{
return
value_cache
[
i
];
}
const
Class
&
operator
[]
(
size_t
i
)
const
{
return
value_cache
[
i
];
}
static
const
bool
composite
=
true
;
};
#if 0
template <typename Class>
struct computed_collection : collection<std::vector<Class>> {
/*template <typename DepTuple> struct expand_tuple;*/
/*template <typename... Dependencies>*/
/*struct expand_tuple<std::tuple<Dependencies...>> {*/
/*typedef async_computed_value<computed_collection<Class>, std::vector<Class>, Dependencies...>*/
/*};*/
/*using value<std::vector<Class>>::val;*/
typedef std::vector<Class> value_type;