const int MinSizeToCoverExecuteCosts = 10; // from some random testing (depends on pipeline length)
public static void Invoke <TKey, TElement>(Grouping <TKey, TElement> lastGrouping, int count, Chain <IGrouping <TKey, TElement> > chain)
{
try
{
ChainStatus status = ChainStatus.Flow;
if (lastGrouping != null)
{
if (count > MinSizeToCoverExecuteCosts && chain is Optimizations.IHeadStart <IGrouping <TKey, TElement> > optimized)
{
status = optimized.Execute <LookupEnumerable <TKey, TElement>, LookupEnumerator <TKey, TElement> >(new LookupEnumerable <TKey, TElement>(lastGrouping, count));
}
else
{
status = Pipeline(lastGrouping, chain);
}
}
chain.ChainComplete(status & ~ChainStatus.Flow);
}
finally
{
chain.ChainDispose();
}
}
public override ChainStatus ChainComplete(ChainStatus status)
{
if (counter > 0)
{
Result = default(Maths).DivLong(accumulator, counter);
}
return(ChainStatus.Stop);
}
public void MapModelToEntity()
{
var mapper = new DALChainStatusMapper();
ApiChainStatusServerRequestModel model = new ApiChainStatusServerRequestModel();
model.SetProperties("A");
ChainStatus response = mapper.MapModelToEntity(1, model);
response.Name.Should().Be("A");
}
public virtual ApiChainStatusServerResponseModel MapEntityToModel(
ChainStatus item)
{
var model = new ApiChainStatusServerResponseModel();
model.SetProperties(item.Id,
item.Name);
return(model);
}
public virtual BOChainStatus MapEFToBO(
ChainStatus ef)
{
var bo = new BOChainStatus();
bo.SetProperties(
ef.Id,
ef.Name);
return(bo);
}
public virtual ChainStatus MapBOToEF(
BOChainStatus bo)
{
ChainStatus efChainStatus = new ChainStatus();
efChainStatus.SetProperties(
bo.Id,
bo.Name);
return(efChainStatus);
}
public override ChainStatus ChainComplete(ChainStatus status)
{
if (counter == 0)
{
ThrowHelper.ThrowNoElementsException();
}
Result = default(Maths).DivLong(accumulator, counter);
return(ChainStatus.Stop);
}
public void MapEntityToModel()
{
var mapper = new DALChainStatusMapper();
ChainStatus item = new ChainStatus();
item.SetProperties(1, "A");
ApiChainStatusServerResponseModel response = mapper.MapEntityToModel(item);
response.Id.Should().Be(1);
response.Name.Should().Be("A");
}
public virtual ChainStatus MapModelToEntity(
int id,
ApiChainStatusServerRequestModel model
)
{
ChainStatus item = new ChainStatus();
item.SetProperties(
id,
model.Name);
return(item);
}
public void MapBOToEF()
{
var mapper = new DALChainStatusMapper();
var bo = new BOChainStatus();
bo.SetProperties(1, "A");
ChainStatus response = mapper.MapBOToEF(bo);
response.Id.Should().Be(1);
response.Name.Should().Be("A");
}
public void MapEFToBO()
{
var mapper = new DALChainStatusMapper();
ChainStatus entity = new ChainStatus();
entity.SetProperties(1, "A");
BOChainStatus response = mapper.MapEFToBO(entity);
response.Id.Should().Be(1);
response.Name.Should().Be("A");
}
protected async Task <bool> BeUniqueByName(ApiChainStatusServerRequestModel model, CancellationToken cancellationToken)
{
ChainStatus record = await this.ChainStatusRepository.ByName(model.Name);
if (record == null || (this.existingRecordId != default(int) && record.Id == this.existingRecordId))
{
return(true);
}
else
{
return(false);
}
}
public async Task <ApiChainStatusResponseModel> ByName(string name)
{
ChainStatus record = await this.ChainStatusRepository.ByName(name);
if (record == null)
{
return(null);
}
else
{
return(this.BolChainStatusMapper.MapBOToModel(this.DalChainStatusMapper.MapEFToBO(record)));
}
}
public void MapEntityToModelList()
{
var mapper = new DALChainStatusMapper();
ChainStatus item = new ChainStatus();
item.SetProperties(1, "A");
List <ApiChainStatusServerResponseModel> response = mapper.MapEntityToModel(new List <ChainStatus>()
{
{ item }
});
response.Count.Should().Be(1);
}
public async virtual Task <ApiChainStatusServerResponseModel> ByName(string name)
{
ChainStatus record = await this.ChainStatusRepository.ByName(name);
if (record == null)
{
return(null);
}
else
{
return(this.DalChainStatusMapper.MapEntityToModel(record));
}
}
public virtual async Task <ApiChainStatusServerResponseModel> Get(int id)
{
ChainStatus record = await this.ChainStatusRepository.Get(id);
if (record == null)
{
return(null);
}
else
{
return(this.DalChainStatusMapper.MapEntityToModel(record));
}
}
public void MapEFToBOList()
{
var mapper = new DALChainStatusMapper();
ChainStatus entity = new ChainStatus();
entity.SetProperties(1, "A");
List <BOChainStatus> response = mapper.MapEFToBO(new List <ChainStatus>()
{
entity
});
response.Count.Should().Be(1);
}
public virtual async Task <CreateResponse <ApiChainStatusServerResponseModel> > Create(
ApiChainStatusServerRequestModel model)
{
CreateResponse <ApiChainStatusServerResponseModel> response = ValidationResponseFactory <ApiChainStatusServerResponseModel> .CreateResponse(await this.ChainStatusModelValidator.ValidateCreateAsync(model));
if (response.Success)
{
ChainStatus record = this.DalChainStatusMapper.MapModelToEntity(default(int), model);
record = await this.ChainStatusRepository.Create(record);
response.SetRecord(this.DalChainStatusMapper.MapEntityToModel(record));
await this.mediator.Publish(new ChainStatusCreatedNotification(response.Record));
}
return(response);
}
ChainStatus Optimizations.IHeadStart <T> .Execute(ReadOnlySpan <T> source)
{
ChainStatus status = ChainStatus.Flow;
foreach (var input in source)
{
if (_seen.Add(input))
{
status = Next(input);
if (status.IsStopped())
{
break;
}
}
}
return(status);
}
ChainStatus Optimizations.IHeadStart <T> .Execute <Enumerable, Enumerator>(Enumerable source)
{
ChainStatus status = ChainStatus.Flow;
foreach (var input in source)
{
if (_seen.Add(input))
{
status = Next(input);
if (status.IsStopped())
{
break;
}
}
}
return(status);
}
public HighScoreRecordTableUnit(MusicGenre.Unit unit)
{
if (unit == null)
{
throw new ArgumentNullException(nameof(unit));
}
Id = unit.Id;
Name = unit.Name;
Genre = unit.Genre;
Difficulty = unit.Difficulty;
Score = unit.Score;
Rank = unit.Rank;
IsClear = unit.IsClear;
ComboStatus = unit.ComboStatus;
ChainStatus = unit.ChainStatus;
}
ChainStatus Optimizations.ITailEnd <T?> .SelectMany <TSource, TCollection>(TSource source, ReadOnlySpan <TCollection> span, Func <TSource, TCollection, T?> resultSelector)
{
Logic logic = default; logic.Init(Result);
ChainStatus status = ChainStatus.Flow;
foreach (var input in span)
{
if (!logic.Process(resultSelector(source, input)))
{
status = ChainStatus.Stop;
break;
}
}
Result = logic.Result;
return(status);
}
public async void Get_ShouldReturnRecords()
{
var mock = new ServiceMockFacade <IChainStatusService, IChainStatusRepository>();
var record = new ChainStatus();
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(record));
var service = new ChainStatusService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ChainStatusModelValidatorMock.Object,
mock.DALMapperMockFactory.DALChainStatusMapperMock,
mock.DALMapperMockFactory.DALChainMapperMock);
ApiChainStatusServerResponseModel response = await service.Get(default(int));
response.Should().NotBeNull();
mock.RepositoryMock.Verify(x => x.Get(It.IsAny <int>()));
}
public async void ByName_Exists()
{
var mock = new ServiceMockFacade <IChainStatusService, IChainStatusRepository>();
var record = new ChainStatus();
mock.RepositoryMock.Setup(x => x.ByName(It.IsAny <string>())).Returns(Task.FromResult(record));
var service = new ChainStatusService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.ChainStatusModelValidatorMock.Object,
mock.DALMapperMockFactory.DALChainStatusMapperMock,
mock.DALMapperMockFactory.DALChainMapperMock);
ApiChainStatusServerResponseModel response = await service.ByName("test_value");
response.Should().NotBeNull();
mock.RepositoryMock.Verify(x => x.ByName(It.IsAny <string>()));
}
public void Set(IHighScoreRecordTableUnit tableUnit)
{
if (tableUnit == null)
{
throw new ArgumentNullException(nameof(tableUnit));
}
Id = tableUnit.Id;
Name = tableUnit.Name;
Genre = tableUnit.Genre;
Difficulty = tableUnit.Difficulty;
Score = tableUnit.Score;
Rank = tableUnit.Rank;
BaseRating = tableUnit.BaseRating;
Rating = tableUnit.Rating;
IsClear = tableUnit.IsClear;
ComboStatus = tableUnit.ComboStatus;
ChainStatus = tableUnit.ChainStatus;
}
ChainStatus Optimizations.ITailEnd <T?> .Where(ReadOnlySpan <T?> source, Func <T?, bool> predicate)
{
Logic logic = default; logic.Init(Result);
ChainStatus chainStatus = ChainStatus.Flow;
foreach (var input in source)
{
if (predicate(input))
{
if (!logic.Process(input))
{
chainStatus = ChainStatus.Stop;
break;
}
}
}
Result = logic.Result;
return(chainStatus);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ExecutionStatus Next()
{
if (this.ChainStatus == ChainStatus.Done ||
this.ChainStatus == ChainStatus.Error)
{
return(ExecutionStatus.Done);
}
{
var status = Enumerator.Current.Execute();
if (status == ExecutionStatus.Error)
{
ChainStatus = ChainStatus.Error;
OnError(Enumerator.Current.GetError());
}
if (status == ExecutionStatus.Continue)
{
// 中断(coroutine)
ChainStatus = ChainStatus.Continue;
return(ExecutionStatus.Continue);
}
}
if (!Enumerator.MoveNext())
{
// 終了
ChainStatus = ChainStatus.Done;
return(ExecutionStatus.Done);
}
if (Enumerator.Current.Schedulder != null)
{
// Scheduleして中断
ChainStatus = ChainStatus.Continue;
Enumerator.Current.Schedulder.Enqueue(this);
return(ExecutionStatus.Done);
}
return(Next());
}
private static void AssertUnit(
Unit unit,
int id,
string name,
string genre,
Difficulty difficulty,
int score,
Rank rank,
bool isClear,
ComboStatus comboStatus,
ChainStatus chainStatus)
{
Assert.IsNotNull(unit);
Assert.AreEqual(id, unit.Id, "ID");
Assert.AreEqual(name, unit.Name, "楽曲名");
Assert.AreEqual(genre, unit.Genre, "ジャンル");
Assert.AreEqual(difficulty, unit.Difficulty, "難易度");
Assert.AreEqual(score, unit.Score, "スコア");
Assert.AreEqual(rank, unit.Rank, "ランク");
Assert.AreEqual(isClear, unit.IsClear, "クリア");
Assert.AreEqual(comboStatus, unit.ComboStatus, "コンボランプ");
Assert.AreEqual(chainStatus, unit.ChainStatus, "チェインランプ");
}
public virtual async Task <UpdateResponse <ApiChainStatusServerResponseModel> > Update(
int id,
ApiChainStatusServerRequestModel model)
{
var validationResult = await this.ChainStatusModelValidator.ValidateUpdateAsync(id, model);
if (validationResult.IsValid)
{
ChainStatus record = this.DalChainStatusMapper.MapModelToEntity(id, model);
await this.ChainStatusRepository.Update(record);
record = await this.ChainStatusRepository.Get(id);
ApiChainStatusServerResponseModel apiModel = this.DalChainStatusMapper.MapEntityToModel(record);
await this.mediator.Publish(new ChainStatusUpdatedNotification(apiModel));
return(ValidationResponseFactory <ApiChainStatusServerResponseModel> .UpdateResponse(apiModel));
}
else
{
return(ValidationResponseFactory <ApiChainStatusServerResponseModel> .UpdateResponse(validationResult));
}
}
private void UpdateInfoButton(ChainStatus status, string text)
{
if (_isClosing)
{
return;
}
MethodInvoker method = delegate
{
switch (status)
{
case ChainStatus.OutofDate:
buttonInfo.ToolTipText = text;
buttonInfo.Image = Properties.Resources.dialog_warning_4;
break;
case ChainStatus.UptoDate:
buttonInfo.ToolTipText = text;
buttonInfo.Image = Properties.Resources.dialog_clean;
break;
default:
buttonInfo.ToolTipText = text;
buttonInfo.Image = Properties.Resources.dialog_question;
break;
}
};
if (statusStrip.InvokeRequired)
{
BeginInvoke(method);
}
else
{
method.Invoke();
}
}
