88#include " Time.inl"
99#include " Code.inl"
1010#include " Resolvable.inl"
11+ #include " Temporal.hpp"
1112#include " inner/Missing.hpp"
1213#include " inner/Entangled.hpp"
13- #include " Temporal .hpp"
14+ #include " inner/Redundant .hpp"
1415
1516#if 1
1617 #define VERBOSE_ENABLED () 1
@@ -28,17 +29,75 @@ using namespace Langulus::Flow;
2829// / Default constructor, add the initial missing future point
2930// / @param environment - the initial flow environment
3031Temporal::Temporal () {
31- mPriorityStack << Inner:: MissingFuture {};
32- mFuture = mPriorityStack .Get <Inner:: MissingFuture*>();
32+ mPriorityStack << MissingFuture {};
33+ mFuture = mPriorityStack .Get <MissingFuture*>();
3334}
3435
3536// / Construct as a sub-flow
3637// / @attention assumes parent is a valid pointer
3738// / @param parent - the parent flow
3839Temporal::Temporal (Temporal* parent)
3940 : mParent {parent} {
40- mPriorityStack << Inner::MissingFuture {};
41- mFuture = mPriorityStack .Get <Inner::MissingFuture*>();
41+ mPriorityStack << MissingFuture {};
42+ mFuture = mPriorityStack .Get <MissingFuture*>();
43+ }
44+
45+ Temporal::Temporal (Temporal&& other) noexcept
46+ : mParent {::std::move (other.mParent )}
47+ , mStart {::std::move (other.mStart )}
48+ , mNow {::std::move (other.mNow )}
49+ , mPrevTime {::std::move (other.mPrevTime )}
50+ , mTimePeriod {::std::move (other.mTimePeriod )}
51+ , mRatePeriod {::std::move (other.mRatePeriod )}
52+ , mPriorityStack {::std::move (other.mPriorityStack )}
53+ , mFuture {::std::move (other.mFuture )}
54+ , mTimeStack {::std::move (other.mTimeStack )}
55+ , mFrequencyStack {::std::move (other.mFrequencyStack )}
56+ , mEntanglements {::std::move (other.mEntanglements )} {}
57+
58+ Temporal::Temporal (const Temporal& other) noexcept
59+ : mParent {other.mParent }
60+ , mStart {other.mStart }
61+ , mNow {other.mNow }
62+ , mPrevTime {other.mPrevTime }
63+ , mTimePeriod {other.mTimePeriod }
64+ , mRatePeriod {other.mRatePeriod }
65+ , mPriorityStack {other.mPriorityStack }
66+ , mFuture {other.mFuture }
67+ , mTimeStack {other.mTimeStack }
68+ , mFrequencyStack {other.mFrequencyStack }
69+ , mEntanglements {other.mEntanglements } {}
70+
71+ Temporal::~Temporal () {}
72+
73+ Temporal& Temporal::operator = (Temporal&& rhs) noexcept {
74+ mParent = ::std::move (rhs.mParent );
75+ mStart = ::std::move (rhs.mStart );
76+ mNow = ::std::move (rhs.mNow );
77+ mPrevTime = ::std::move (rhs.mPrevTime );
78+ mTimePeriod = ::std::move (rhs.mTimePeriod );
79+ mRatePeriod = ::std::move (rhs.mRatePeriod );
80+ mPriorityStack = ::std::move (rhs.mPriorityStack );
81+ mFuture = ::std::move (rhs.mFuture );
82+ mTimeStack = ::std::move (rhs.mTimeStack );
83+ mFrequencyStack = ::std::move (rhs.mFrequencyStack );
84+ mEntanglements = ::std::move (rhs.mEntanglements );
85+ return *this ;
86+ }
87+
88+ Temporal& Temporal::operator = (const Temporal& rhs) noexcept {
89+ mParent = rhs.mParent ;
90+ mStart = rhs.mStart ;
91+ mNow = rhs.mNow ;
92+ mPrevTime = rhs.mPrevTime ;
93+ mTimePeriod = rhs.mTimePeriod ;
94+ mRatePeriod = rhs.mRatePeriod ;
95+ mPriorityStack = rhs.mPriorityStack ;
96+ mFuture = rhs.mFuture ;
97+ mTimeStack = rhs.mTimeStack ;
98+ mFrequencyStack = rhs.mFrequencyStack ;
99+ mEntanglements = rhs.mEntanglements ;
100+ return *this ;
42101}
43102
44103// / Serialize temporal as Code
@@ -72,11 +131,11 @@ void Temporal::ResetInner(Many& scope) {
72131 if (m.IsDense ())
73132 ResetInner (m);
74133 },
75- [&](Inner:: Missing& missing) {
134+ [&](Missing& missing) {
76135 if (missing.mContent .IsDense ())
77136 ResetInner (missing.mContent );
78137 },
79- [&](Inner:: Entangled& entangled) {
138+ [&](Entangled& entangled) {
80139 if (entangled.mTrueContent .IsDense ())
81140 ResetInner (entangled.mTrueContent );
82141 if (entangled.mFalseContent .IsDense ())
@@ -288,12 +347,12 @@ Many Temporal::Compile(const Many& scope, Real priority) {
288347
289348 if (scope.IsPast ()) {
290349 // Convert the scope to a MissingPast intermediate format
291- result = Inner:: MissingPast {nullptr , scope, priority};
350+ result = MissingPast {nullptr , scope, priority};
292351 return Abandon (result);
293352 }
294353 else if (scope.IsFuture ()) {
295354 // Convert the scope to a MissingFuture intermediate format
296- result = Inner:: MissingFuture {nullptr , scope, 0 };
355+ result = MissingFuture {nullptr , scope, 0 };
297356 return Abandon (result);
298357 }
299358 else if (scope.IsDeep ()) {
@@ -359,11 +418,11 @@ Many Temporal::Compile(const Many& scope, Real priority) {
359418// / Link a scope's past points to future points that are on the stack
360419// / @param scope - the scope to link and insert
361420// / @param entanglementAbove - an optional entanglement from above scope
362- void Temporal::Link (const Many& scope, const Entanglement& entanglementAbove) {
421+ void Temporal::Link (const Many& scope, const Ref< Entanglement> & entanglementAbove) {
363422 LANGULUS_ASSUME (DevAssumes, mFuture , " Invalid future"
364423
365424 // Every time we push an OR scope we create an entanglement
366- Entanglement entanglement;
425+ Ref< Entanglement> entanglement;
367426 if (scope.IsOr ()) {
368427 entanglement = mEntanglements .Emplace (IndexBack)
369428 .New (entanglementAbove ? entanglementAbove->mParent : nullptr );
@@ -476,12 +535,12 @@ void Temporal::Link(const Many& scope, const Entanglement& entanglementAbove) {
476535void Temporal::LinkRelative (
477536 const Many& scope,
478537 const Verb& override ,
479- const Entanglement& entanglementAbove
538+ const Ref< Entanglement> & entanglementAbove
480539) {
481540 LANGULUS_ASSUME (DevAssumes, mFuture , " Invalid future"
482541
483542 // Every time we push an OR scope we create an entanglement
484- Entanglement entanglement;
543+ Ref< Entanglement> entanglement;
485544 if (scope.IsOr ()) {
486545 entanglement = mEntanglements .Emplace (IndexBack)
487546 .New (entanglementAbove ? entanglementAbove->mParent : nullptr );
@@ -665,8 +724,8 @@ void Temporal::LinkRelative(
665724// / 'future', or in any of the futures below it
666725bool Temporal::PushFutures (
667726 const Many& scope,
668- Inner:: MissingFuture& future,
669- const Entanglement& entanglementAbove
727+ MissingFuture& future,
728+ const Ref< Entanglement> & entanglementAbove
670729) noexcept {
671730 bool atLeastOneSuccess = false ;
672731 try {
@@ -679,7 +738,7 @@ bool Temporal::PushFutures(
679738 // If reached, then scope wasn't linked in the immediate future
680739 // Dig deeper for any future points below the provided one
681740 if (not atLeastOneSuccess or not scope.IsExecutableDeep ()) {
682- future.mBelow .ForEach ([&](Inner:: MissingFuture& below) {
741+ future.mBelow .ForEach ([&](MissingFuture& below) {
683742 atLeastOneSuccess |= PushFutures (scope, below, entanglementAbove);
684743 // Continue linking only if the future is uncertain
685744 // return not (future.mBelow.IsOr() and atLeastOneSuccess);
0 commit comments