Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commitf5c8579

Browse files
2.3.3
internal maintenance update
1 parente55ca6f commitf5c8579

File tree

125 files changed

+18902
-7234
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

125 files changed

+18902
-7234
lines changed
Lines changed: 161 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,161 @@
1+
namespaceffsm2 {
2+
namespacedetail {
3+
4+
////////////////////////////////////////////////////////////////////////////////
5+
6+
template<
7+
FeatureTag NFeatureTag
8+
,typename TContext
9+
,typename TActivation
10+
, Short NSubstitutionLimit
11+
FFSM2_IF_PLANS(, Long NTaskCapacity)
12+
,typename TPayload
13+
>
14+
structG_final {
15+
staticconstexpr FeatureTag FEATURE_TAG = NFeatureTag;
16+
17+
using Context = TContext;
18+
using Activation = TActivation;
19+
20+
#if FFSM2_LOG_INTERFACE_AVAILABLE()
21+
using LoggerInterface = LoggerInterfaceT<FEATURE_TAG, Context>;
22+
#endif
23+
24+
staticconstexpr Short SUBSTITUTION_LIMIT = NSubstitutionLimit;
25+
26+
#if FFSM2_PLANS_AVAILABLE()
27+
staticconstexpr Long TASK_CAPACITY = NTaskCapacity;
28+
#endif
29+
30+
using Payload = TPayload;
31+
using Transition = TransitionT<Payload>;
32+
33+
#if FFSM2_PLANS_AVAILABLE()
34+
using Task = TaskT<Payload>;
35+
#endif
36+
37+
/// @brief Set Context type
38+
/// @tparam T Context type for data shared between states and/or data interface between FSM and external code
39+
template<typename T>
40+
using ContextT = G_<FEATURE_TAG, T , Activation, SUBSTITUTION_LIMITFFSM2_IF_PLANS(, TASK_CAPACITY), Payload>;
41+
42+
/// @brief Select manual activation strategy
43+
using ManualActivation = G_<FEATURE_TAG, Context, Manual , SUBSTITUTION_LIMITFFSM2_IF_PLANS(, TASK_CAPACITY), Payload>;
44+
45+
#if FFSM2_UTILITY_THEORY_AVAILABLE()
46+
#endif
47+
48+
/// @brief Set Substitution limit
49+
/// @tparam N Maximum number times 'guard()' methods can substitute their states for others
50+
template<Long N>
51+
using SubstitutionLimitN = G_<FEATURE_TAG, Context, Activation, NFFSM2_IF_PLANS(, TASK_CAPACITY), Payload>;
52+
53+
#if FFSM2_PLANS_AVAILABLE()
54+
55+
/// @brief Set Task capacity
56+
/// @tparam N Maximum number of tasks across all plans
57+
template<Long N>
58+
using TaskCapacityN = G_<FEATURE_TAG, Context, Activation, SUBSTITUTION_LIMIT , N , Payload>;
59+
60+
#endif
61+
62+
/// @brief Set Transition Payload type
63+
/// @tparam T Utility type for 'TUtility State::utility() const' method
64+
template<typename T>
65+
using PayloadT = G_<FEATURE_TAG, Context, Activation, SUBSTITUTION_LIMITFFSM2_IF_PLANS(, TASK_CAPACITY), T >;
66+
};
67+
68+
////////////////////////////////////////////////////////////////////////////////
69+
70+
template<typename>
71+
structM_;
72+
73+
template<
74+
FeatureTag NFeatureTag
75+
,typename TContext
76+
,typename TActivation
77+
, Short NSubstitutionLimit
78+
FFSM2_IF_PLANS(, Long NTaskCapacity)
79+
,typename TPayload
80+
>
81+
structM_<
82+
G_<
83+
NFeatureTag
84+
, TContext
85+
, TActivation
86+
, NSubstitutionLimit
87+
FFSM2_IF_PLANS(, NTaskCapacity)
88+
, TPayload
89+
>
90+
>final
91+
{
92+
using Cfg = G_<
93+
NFeatureTag
94+
, TContext
95+
, TActivation
96+
, NSubstitutionLimit
97+
FFSM2_IF_PLANS(, NTaskCapacity)
98+
, TPayload
99+
>;
100+
101+
staticconstexpr FeatureTag FEATURE_TAG = NFeatureTag;
102+
103+
using Context= TContext;
104+
105+
using Payload= TPayload;
106+
using Transition= TransitionT<Payload>;
107+
108+
#if FFSM2_LOG_INTERFACE_AVAILABLE()
109+
using LoggerInterface=typename Cfg::LoggerInterface;
110+
#endif
111+
112+
#if FFSM2_UTILITY_THEORY_AVAILABLE()
113+
#endif
114+
115+
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
116+
// COMMON
117+
118+
/// @brief Root
119+
/// @tparam THead Head state
120+
/// @tparam TSubStates Sub-states
121+
template<typename THead,typename... TSubStates>
122+
using Root= RF_<Cfg, CI_<THead, TSubStates...>>;
123+
124+
/// @brief Headless root
125+
/// @tparam TSubStates Sub-states
126+
template<typename... TSubStates>
127+
using PeerRoot= RF_<Cfg, CI_<void, TSubStates...>>;
128+
129+
// COMMON
130+
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
131+
132+
#if FFSM2_UTILITY_THEORY_AVAILABLE()
133+
#endif
134+
};
135+
136+
////////////////////////////////////////////////////////////////////////////////
137+
138+
}
139+
140+
/// @brief Type configuration for MachineT<>
141+
using Config = detail::G_<
142+
FFSM2_FEATURE_TAG
143+
, EmptyContext
144+
, Automatic
145+
,4
146+
FFSM2_IF_PLANS(, INVALID_LONG)
147+
, void
148+
>;
149+
150+
/// @brief 'Template namespace' for FSM classes
151+
/// @tparam TConfig 'ConfigT<>' type configuration for MachineT<>
152+
/// @see ConfigT<>
153+
template<typename TConfig = Config>
154+
using MachineT = detail::M_<TConfig>;
155+
156+
/// @brief 'Template namespace' for FSM classes parametrized with default types
157+
using Machine = MachineT<>;
158+
159+
////////////////////////////////////////////////////////////////////////////////
160+
161+
}

‎development/ffsm2/detail/containers/array.hpp‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -81,13 +81,13 @@ struct StaticArrayT<T, 0> final {
8181
////////////////////////////////////////////////////////////////////////////////
8282

8383
template<typename T, Long NCapacity>
84-
classArrayTfinal {
84+
classDynamicArrayTfinal {
8585
template<typename>
8686
friendclassIteratorT;
8787

8888
public:
89-
using Iterator= IteratorT<ArrayT>;
90-
using CIterator= IteratorT<constArrayT>;
89+
using Iterator= IteratorT<DynamicArrayT>;
90+
using CIterator= IteratorT<constDynamicArrayT>;
9191

9292
using Item= T;
9393
using Index= UCapacity<NCapacity>;
@@ -113,12 +113,12 @@ class ArrayT final {
113113
FFSM2_CONSTEXPR(11)boolempty()constnoexcept{return _count ==0;}
114114

115115
// SPECIFIC
116-
FFSM2_CONSTEXPR(14)ArrayT&operator += (const Item & item)noexcept;
117-
FFSM2_CONSTEXPR(14)ArrayT&operator += (Item&& item)noexcept;
116+
FFSM2_CONSTEXPR(14)DynamicArrayT&operator += (const Item & item)noexcept;
117+
FFSM2_CONSTEXPR(14)DynamicArrayT&operator += ( Item&& item)noexcept;
118118
// SPECIFIC
119119

120120
template<Long N>
121-
FFSM2_CONSTEXPR(14)ArrayT&operator += (constArrayT<Item, N>& other)noexcept;
121+
FFSM2_CONSTEXPR(14)DynamicArrayT&operator += (constDynamicArrayT<Item, N>& other)noexcept;
122122

123123
FFSM2_CONSTEXPR(14) Iteratorbegin()noexcept{returnIterator(*this,first());}
124124
FFSM2_CONSTEXPR(11)CIteratorbegin()constnoexcept{returnCIterator(*this,first());}
@@ -141,7 +141,7 @@ class ArrayT final {
141141
//------------------------------------------------------------------------------
142142

143143
template<typename T>
144-
classArrayT<T,0>final {
144+
classDynamicArrayT<T,0>final {
145145
public:
146146
using Item= T;
147147
using Index= UCapacity<0>;

‎development/ffsm2/detail/containers/array.inl‎

Lines changed: 31 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -3,44 +3,44 @@ namespace detail {
33

44
////////////////////////////////////////////////////////////////////////////////
55

6-
template<typename T, LongNC>
6+
template<typename T, LongNC_>
77
template<typename N>
88
FFSM2_CONSTEXPR(14)
99
T&
10-
StaticArrayT<T,NC>::operator[] (const N index)noexcept{
10+
StaticArrayT<T,NC_>::operator[] (const N index)noexcept{
1111
FFSM2_ASSERT(0 <= index && index < CAPACITY);
1212

1313
return _items[static_cast<Index>(index)];
1414
}
1515

1616
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1717

18-
template<typename T, LongNC>
18+
template<typename T, LongNC_>
1919
template<typename N>
2020
FFSM2_CONSTEXPR(14)
2121
const T&
22-
StaticArrayT<T,NC>::operator[] (const N index)constnoexcept{
22+
StaticArrayT<T,NC_>::operator[] (const N index)constnoexcept{
2323
FFSM2_ASSERT(0 <= index && index < CAPACITY);
2424

2525
return _items[static_cast<Index>(index)];
2626
}
2727

2828
//------------------------------------------------------------------------------
2929

30-
template<typename T, LongNC>
30+
template<typename T, LongNC_>
3131
FFSM2_CONSTEXPR(14)
3232
void
33-
StaticArrayT<T,NC>::fill(const Item filler)noexcept {
33+
StaticArrayT<T,NC_>::fill(const Item filler)noexcept {
3434
for (Item& item : _items)
3535
item = filler;
3636
}
3737

3838
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
3939

40-
template<typename T, LongNC>
40+
template<typename T, LongNC_>
4141
FFSM2_CONSTEXPR(14)
4242
bool
43-
StaticArrayT<T,NC>::empty()constnoexcept {
43+
StaticArrayT<T,NC_>::empty()constnoexcept {
4444
for (const Item& item : _items)
4545
if (item != filler<Item>())
4646
returnfalse;
@@ -50,11 +50,11 @@ StaticArrayT<T, NC>::empty() const noexcept {
5050

5151
////////////////////////////////////////////////////////////////////////////////
5252

53-
template<typename T, LongNC>
53+
template<typename T, LongNC_>
5454
template<typename... TArgs>
5555
FFSM2_CONSTEXPR(14)
56-
typenameArrayT<T,NC>::Index
57-
ArrayT<T,NC>::emplace(const TArgs&... args)noexcept {
56+
typenameDynamicArrayT<T,NC_>::Index
57+
DynamicArrayT<T,NC_>::emplace(const TArgs&... args)noexcept {
5858
FFSM2_ASSERT(_count < CAPACITY);
5959

6060
new (&_items[_count]) Item{args...};
@@ -64,11 +64,11 @@ ArrayT<T, NC>::emplace(const TArgs&... args) noexcept {
6464

6565
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
6666

67-
template<typename T, LongNC>
67+
template<typename T, LongNC_>
6868
template<typename... TArgs>
6969
FFSM2_CONSTEXPR(14)
70-
typenameArrayT<T,NC>::Index
71-
ArrayT<T,NC>::emplace(TArgs&&... args)noexcept {
70+
typenameDynamicArrayT<T,NC_>::Index
71+
DynamicArrayT<T,NC_>::emplace(TArgs&&... args)noexcept {
7272
FFSM2_ASSERT(_count < CAPACITY);
7373

7474
new (&_items[_count]) Item{forward<TArgs>(args)...};
@@ -78,46 +78,46 @@ ArrayT<T, NC>::emplace(TArgs&&... args) noexcept {
7878

7979
//------------------------------------------------------------------------------
8080

81-
template<typename T, LongNC>
81+
template<typename T, LongNC_>
8282
template<typename N>
8383
FFSM2_CONSTEXPR(14)
84-
typenameArrayT<T,NC>::Item&
85-
ArrayT<T,NC>::operator[] (const N index)noexcept {
86-
FFSM2_ASSERT(0 <= index && index <CAPACITY);
84+
typenameDynamicArrayT<T,NC_>::Item&
85+
DynamicArrayT<T,NC_>::operator[] (const N index)noexcept {
86+
FFSM2_ASSERT(0 <= index && index <_count);
8787

8888
return _items[static_cast<Index>(index)];
8989
}
9090

9191
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
9292

93-
template<typename T, LongNC>
93+
template<typename T, LongNC_>
9494
template<typename N>
9595
FFSM2_CONSTEXPR(14)
96-
consttypenameArrayT<T,NC>::Item&
97-
ArrayT<T,NC>::operator[] (const N index)constnoexcept {
98-
FFSM2_ASSERT(0 <= index && index <CAPACITY);
96+
consttypenameDynamicArrayT<T,NC_>::Item&
97+
DynamicArrayT<T,NC_>::operator[] (const N index)constnoexcept {
98+
FFSM2_ASSERT(0 <= index && index <_count);
9999

100100
return _items[static_cast<Index>(index)];
101101
}
102102

103103
//------------------------------------------------------------------------------
104104
// SPECIFIC
105105

106-
template<typename T, LongNC>
106+
template<typename T, LongNC_>
107107
FFSM2_CONSTEXPR(14)
108-
ArrayT<T,NC>&
109-
ArrayT<T,NC>::operator += (const Item& item)noexcept {
108+
DynamicArrayT<T,NC_>&
109+
DynamicArrayT<T,NC_>::operator += (const Item& item)noexcept {
110110
emplace(item);
111111

112112
return *this;
113113
}
114114

115115
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
116116

117-
template<typename T, LongNC>
117+
template<typename T, LongNC_>
118118
FFSM2_CONSTEXPR(14)
119-
ArrayT<T,NC>&
120-
ArrayT<T,NC>::operator += (Item&& item)noexcept {
119+
DynamicArrayT<T,NC_>&
120+
DynamicArrayT<T,NC_>::operator += (Item&& item)noexcept {
121121
emplace(move(item));
122122

123123
return *this;
@@ -126,11 +126,11 @@ ArrayT<T, NC>::operator += (Item&& item) noexcept {
126126
// SPECIFIC
127127
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
128128

129-
template<typename T, LongNC>
129+
template<typename T, LongNC_>
130130
template<Long N>
131131
FFSM2_CONSTEXPR(14)
132-
ArrayT<T,NC>&
133-
ArrayT<T,NC>::operator += (constArrayT<T, N>& other)noexcept {
132+
DynamicArrayT<T,NC_>&
133+
DynamicArrayT<T,NC_>::operator += (constDynamicArrayT<T, N>& other)noexcept {
134134
for (constauto& item : other)
135135
emplace(item);
136136

‎development/ffsm2/detail/containers/bit_array.hpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ namespace detail {
88
template<unsigned NCapacity>
99
classBitArrayTfinal {
1010
public:
11-
using Index= UCapacity<NCapacity>;
11+
using Index= UCapacity<NCapacity>;
1212

1313
staticconstexpr Index CAPACITY = NCapacity;
1414
staticconstexpr Index UNIT_COUNT = contain(CAPACITY,8);

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp