public State <TS, TD, TE> Copy(TimeSpan?timeout, FSMBase.Reason stopReason = null,
List <object> replies = null, ILinearSeq <TE> domainEvents = null, Action <TD> afterTransitionDo = null)
{
return(new State <TS, TD, TE>(StateName, StateData, timeout ?? Timeout, stopReason ?? StopReason,
replies ?? Replies,
domainEvents ?? DomainEvents, afterTransitionDo ?? AfterTransitionHandler));
}
/// <summary>
/// Specify domain events to be applied when transitioning to the new state.
/// </summary>
/// <param name="events"></param>
/// <returns></returns>
public State <TS, TD, TE> Applying(ILinearSeq <TE> events)
{
if (DomainEvents == null)
{
return(Copy(null, null, null, events));
}
return(Copy(null, null, null, new ArrayLinearSeq <TE>(DomainEvents.Concat(events).ToArray())));
}
public State(TS stateName, TD stateData, TimeSpan?timeout = null, FSMBase.Reason stopReason = null,
List <object> replies = null, ILinearSeq <TE> domainEvents = null, Action <TD> afterTransitionDo = null)
: base(stateName, stateData, timeout, stopReason, replies)
{
AfterTransitionHandler = afterTransitionDo;
DomainEvents = domainEvents;
Notifies = true;
}
public State Copy(
TimeSpan?timeout,
FSMBase.Reason stopReason = null,
List <object> replies = null,
ILinearSeq <TEvent> domainEvents = null,
Action <TData> afterTransitionDo = null)
{
return(_state.Copy(timeout, stopReason, replies, domainEvents, afterTransitionDo));
}
public bool MoveNext()
{
if (_seq.IsEmpty)
{
return(false);
}
_current = _seq.Head;
_seq = _seq.Tail();
return(true);
}
public State(
TState stateName,
TData stateData,
TimeSpan?timeout = null,
FSMBase.Reason stopReason = null,
List <object> replies = null,
ILinearSeq <TEvent> domainEvents = null,
Action <TData> afterTransitionDo = null)
{
_state = new State(stateName, stateData, timeout, stopReason, replies, domainEvents, afterTransitionDo);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="n">TBD</param>
/// <returns>TBD</returns>
public override ByteIterator Take(int n)
{
var rest = n;
var builder = new List <ByteArrayIterator>();
while (rest > 0 && !_iterators.IsEmpty)
{
Current.Take(rest);
if (Current.HasNext)
{
rest -= Current.Len;
builder.Add(Current);
}
_iterators = _iterators.Tail();
}
_iterators = new ArrayLinearSeq <ByteArrayIterator>(builder.ToArray());
return(Normalize());
}
private MultiByteIterator Normalize()
{
Func <ILinearSeq <ByteArrayIterator>, ILinearSeq <ByteArrayIterator> > norm = null;
norm = xs =>
{
if (xs.IsEmpty)
{
return(ClearedList);
}
if (!xs.Head.HasNext)
{
return(norm(xs.Tail()));
}
return(xs);
};
_iterators = norm(_iterators);
return(this);
}
private MultiByteIterator Normalize()
{
Func <IEnumerable <ByteArrayIterator>, IEnumerable <ByteArrayIterator> > norm = null;
norm = xs =>
{
if (!xs.Any())
{
return(ClearedList);
}
if (!xs.First().HasNext)
{
return(norm(xs.Skip(1)));
}
return(xs);
};
_iterators = new ArrayLinearSeq <ByteArrayIterator>(norm(_iterators).ToArray());
return(this);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="p">TBD</param>
/// <returns>TBD</returns>
public override ByteIterator TakeWhile(Func <byte, bool> p)
{
var stop = false;
var builder = new List <ByteArrayIterator>();
while (!stop && !_iterators.IsEmpty)
{
var lastLen = Current.Len;
Current.TakeWhile(p);
if (Current.HasNext)
{
builder.Add(Current);
}
if (Current.Len < lastLen)
{
stop = true;
}
DropCurrent();
}
_iterators = new ArrayLinearSeq <ByteArrayIterator>(builder.ToArray());
return(Normalize());
}
public Enumerator(ILinearSeq <T> seq)
{
_seq = seq;
_orig = _seq;
}
/// <summary>
/// TBD
/// </summary>
protected override void Clear()
{
_iterators = new ArrayLinearSeq <ByteArrayIterator>(new ByteArrayIterator[0]);
}
private void DropCurrent()
{
_iterators = _iterators.Tail();
}
/// <summary>
/// TBD
/// </summary>
/// <param name="iterators">TBD</param>
public MultiByteIterator(params ByteArrayIterator[] iterators)
{
_iterators = new ArrayLinearSeq <ByteArrayIterator>(iterators);
Normalize();
}
public bool MoveNext()
{
_seq = _seq.Tail();
return(!_seq.IsEmpty);
}
public State Applying(ILinearSeq <TEvent> events)
{
return(_state.Applying(events));
}
public void Reset()
{
_seq = _orig;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="iterators">TBD</param>
public MultiByteIterator(ILinearSeq <ByteArrayIterator> iterators)
{
_iterators = iterators;
Normalize();
}
