public void TakesTrackMutations()
{
foreach (var last in new[] { false, true })
{
var li = 3.Range().ToList();
var s = Taker(last)(li, 2);
foreach (var action in new Action[] { () => li.Add(3), () => li.Remove(2), () => li.Remove(3), () => li.Clear() })
{
action();
s.AssertListEquals(ReferenceImplementation(last)(li, 2));
}
}
}
void Giver <NounCommonSenseUnit, string> .Give(string key, Taker <NounCommonSenseUnit> colletor)
{
helper.CountUp();
clientGiver.nounCSGiver.Give(key, new CountingTaker <NounCommonSenseUnit> {
clientTaker = colletor, helper = helper
});
}
public static void TakeScreenshot()
{
var now = DateTime.Now;
_screenshots.Add(new Screenshot(now));
Taker.TakeScreenshot(Output.GetScreenshotsPath(NunitGoHelper.Configuration.LocalOutputPath), now);
}
void AssetReferInterface.PickContent <ContentType>(string path, Taker <ContentType> collector)
{
if (string.IsNullOrEmpty(path))
{
if (typeof(ContentType) == typeof(MonoBAUICustomizer))
{
basicAssetIO.assetOut.PickAssetAtPath("Customizer.prefab", new StdBridgeBasicColl <ContentType> {
collector = collector
});
}
else if (typeof(ContentType) == typeof(MonoBAUIntegrator))
{
basicAssetIO.assetOut.PickAssetAtPath("Integrator.prefab", new StdBridgeBasicColl <ContentType> {
collector = collector
});
}
else
{
collector.None();
}
}
else
{
basicAssetIO.assetOut.PickAssetAtPath(path, new StdBridgeBasicColl <ContentType> {
collector = collector
});
}
}
IEnumerator RemoteSPCo(string eWords, Taker <GrammarBlock> listener)
{
inteceptHelper.OnBeginSession(listener);
var form = new WWWForm();
bool didCollect = false;
form.AddBinaryData("ewords", System.Text.Encoding.UTF8.GetBytes(eWords));
UnityWebRequest www = UnityWebRequest.Post(uri, form);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log("HTML_MonoBLProcessor: " + www.error);
}
else
{
Debug.Log(Encoding.UTF8.GetString(www.downloadHandler.data));
var gblock = RequiredFuncs.FromJson <DeserializedGBlock>(www.downloadHandler.data);
listener.Take(gblock);
didCollect = true;
}
inteceptHelper.OnEndSession(listener);
if (!didCollect)
{
listener.None();
}
}
public IActionResult Put(int id, [FromBody] Taker taker)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != taker.TakerId)
{
return(BadRequest());
}
_context.Entry(taker).State = EntityState.Modified;
try
{
_context.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TakerExists(taker.TakerId))
{
return(NotFound());
}
else
{
throw;
}
}
return(new StatusCodeResult(StatusCodes.Status204NoContent));
}
void NaturalLanguageProcessor.PerformSyntacticProcess(string behaviorExpression, Taker <GrammarBlock> listener)
{
helper.CountUp();
clientProcessor.PerformSyntacticProcess(behaviorExpression, new CountingTaker <GrammarBlock> {
helper = helper, clientTaker = listener
});
}
public TestScreenshot()
{
var now = DateTime.Now;
Name = Taker.GetScreenName(now);
Date = now;
}
void Giver <AudioClip, SpeechSetting> .Give(SpeechSetting request, Taker <AudioClip> taker)
{
var found = nameAndURL.Find((elem) => request.speech.Equals(elem.name, System.StringComparison.CurrentCultureIgnoreCase));
if (!string.IsNullOrEmpty(found.url))
{
NetworkUtil.DownloadAudio(found.url, taker);
}
}
public void Delete(int takerId)
{
var taker = new Taker {
TakerId = takerId
};
var dataContext = _dataContext as DataContext;
dataContext.Entry(taker).State = EntityState.Deleted;
_dataContext.Save();
}
//public TakerBLL(ITakerRepository takerRepository)
//{
// _takerRepository = takerRepository;
//}
public void CreateTaker(TakerRegistrationViewModel registrationViewModel)
{
var taker = new Taker
{
TakerName = registrationViewModel.TakerName
};
var createdTaker = _takerRepository.Create(taker);
_userRepository.CreateUser(registrationViewModel.TakerUserName, registrationViewModel.TakerPassword, UserType.Taker, createdTaker.TakerId);
}
public void ImplementInternal <AssetType>(Taker <AssetType> collecor, AssetReferInterface assetReferInterface, IEnumerable <string> textAssets)
{
if (textAssets != null)
{
foreach (var erwcFileName in textAssets)
{
assetReferInterface.PickContent(erwcFileName, collecor);
}
}
}
void ConfigurationListener.OnEnableConfigure <Type>(string name, Taker <Type> collector, Type initialValue)
{
if (typeof(Type) == typeof(bool))
{
bool _initialValue = (bool)(object)initialValue;
var settingContent = GameObject.Instantiate(settingContentPrefab, fieldRootGObj.transform);
settingContent.isOn = _initialValue;
settingContent.onValueChanged.AddListener(new UnityEngine.Events.UnityAction <bool>((toggleValue) => { collector.Take((Type)(object)toggleValue); }));
}
}
void AssetReferInterface.PickContent <ContentType>(string path, Taker <ContentType> collector)
{
var enumerator = cluster.GetEnumerator();
if (enumerator.MoveNext())
{
enumerator.Current.referer.PickContent(path, new PrvtColl <ContentType> {
path = path, clientTaker = collector, enumerator = enumerator
});
}
}
public void TakesLikeEnumerable()
{
foreach (var last in new[] { false, true })
{
// fails on invalid arguments
TestUtil.AssertThrows <ArgumentException>(() => Taker(last)(2.Range(), -1));
TestUtil.AssertThrows <ArgumentException>(() => Taker(last)(NullList, 0));
// matches on valid arguments
foreach (var i in 3.Range())
{
foreach (var n in 4.Range())
{
// fixed size (allows extra optimizations)
AssertTakesProperly(Enumerable.Range(0, i).ToArray(), n, last);
// dynamic size (prevents some optimizations)
AssertTakesProperly(Enumerable.Range(0, i).ToList(), n, last);
}
}
}
}
public static ITestRun TakeScreenshot(this ITestRun testRun, string testPath, bool takeScreenshotAfterFail)
{
if (!takeScreenshotAfterFail || !testRun.FailedOrBroken)
{
return(testRun);
}
var date = DateTime.Now;
var s = new TestScreenshot(date);
Taker.TakeScreenshot(Path.Combine(testPath, "img"), date);
testRun.Screenshots.Add(s);
return(testRun);
}
void AssetReferInterface.PickContent <ContentType>(string assetName, Taker <ContentType> collector)
{
if (obtainedInterface != null)
{
obtainedInterface.referer.PickContent(assetName, collector);
}
else
{
tasks.Add(
() => { obtainedInterface.referer.PickContent(assetName, collector); }
);
}
}
void AvatarPhysicalizeInterface.Search(GrammarBlock attribute, Taker <IEnumerable <BehaverAgent> > asyncTaker)
{
var pickedAgents = new List <BehaverAgent>();
foreach (var agent in agents)
{
if (agent.MatchAttribue(attribute) == AttributeMatchResult.POSITIVE)
{
pickedAgents.Add(agent);
}
}
asyncTaker.Take(pickedAgents);
}
void MorphemeAnalyzer.AnalyzeFormat(string naturalLanguage, Taker <DivisibleEnumerable <Morpheme> > listener)
{
var result = AnalyzeImmediate(naturalLanguage);
if (result != null)
{
listener.Take(result);
}
else
{
listener.None();
}
}
/// Internal implementation detail.
internal override void DoJob(ref Worker wr, Cont <T> aK)
{
Spin:
var state = this.State;
if (state < Running)
{
goto Completed;
}
if (state == Locked)
{
goto Spin;
}
if (state != Interlocked.CompareExchange(ref this.State, Locked, state))
{
goto Spin;
}
if (state == Running)
{
goto Running;
}
var job = this.Readers as Cont;
var taker = new Taker <T>();
taker.Cont = aK;
taker.Next = taker;
this.Readers = taker;
this.State = Running;
job.DoWork(ref wr);
return;
Running:
WaitQueue.AddTaker(ref this.Readers, aK);
this.State = Running;
return;
Completed:
if (state == Completed)
{
aK.DoCont(ref wr, this.Value);
}
else
{
aK.DoHandle(ref wr, (this.Readers as Fail).exn);
}
}
void SyntacticProcessor.PerformSyntacticProcess(byte[] behaviorExpression, Taker <GrammarBlock> listener)
{
try {
System.IntPtr marshalArray = Marshal.AllocHGlobal(behaviorExpression.Length);
Marshal.Copy(behaviorExpression, 0, marshalArray, behaviorExpression.Length);
var gBlockPtr = PerformSyntacticProcess(fAnalyser.implPtr, gAnalyser.implPtr, marshalArray, behaviorExpression.Length);
Marshal.FreeHGlobal(marshalArray);
listener.Take(NativeGrammarBlockUtils.GBlockPtrToGBlock(gBlockPtr));
listener.OnFinish();
} catch (Exception e) {
Debug.Log(e);
listener.OnFinish();
}
}
void Giver<IEnumerable<BehaverAgent>, GrammarBlock>.Give(GrammarBlock key, Taker<IEnumerable<BehaverAgent>> colletor) {
if (GrammarBlockUtils.IsUnit(key, "button")) {
GrammarBlockUtils.ForEachUnits(
key.modifier,
(unit) => {
MonoBBehaverAgent newButton;
nameToButtonDict[unit.word] = newButton = GameObject.Instantiate(textButtonPrefab);
newButton.GetComponent<TextViewer>().SetText(unit.word);
newButton.GetComponent<BehaverAgent>().TryFittingSpace(new Vector3(0.4f, 1f, 1));
colletor.Take(new List<BehaverAgent> { newButton.behaverAgent });
}
);
}
}
private void TakeScreenshotIfFailed()
{
try
{
if (!_nunitGoTest.IsSuccess() && _configuration.TakeScreenshotAfterTestFailed)
{
var now = DateTime.Now;
_nunitGoTest.Screenshots.Add(new Screenshot(now));
Taker.TakeScreenshot(_screenshotsPath, now);
}
}
catch (Exception ex)
{
Log.Exception(ex, "Exception in TakeScreenshot");
}
}
public IActionResult Get(int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Taker taker = _context.Takers.Single(m => m.TakerId == id);
if (taker == null)
{
return(NotFound());
}
return(Ok(taker));
}
void Giver <NounCommonSenseUnit, string> .Give(string key, Taker <NounCommonSenseUnit> collector)
{
pendingNCSReq.units.Add(new NounCommonSenseRequestUnit {
word = key
});
if (!pendingNCSTakers.TryGetValue(key, out var collectorList))
{
collectorList = new List <Taker <NounCommonSenseUnit> >();
pendingNCSTakers[key] = collectorList;
}
collectorList.Add(collector);
if (isGateOpen)
{
SendNCSRequest(new StubSimpleProcessListener());
}
}
public void SaveScreenshot(Bitmap screen)
{
lock (_lock)
{
_actionHelper.SafeAction(() =>
{
var testGuid = _currentTestRun.TestInfo.Guid.ToString();
var date = DateTime.Now;
var s = new TestScreenshot(date);
Taker.SaveScreenshot(Path.Combine(TestsPath, testGuid, "img"), screen, date);
_currentTestRun.Screenshots.Add(s);
_currentTestRuns.First(
tr => tr.TestInfo.Guid.Equals(_currentTestRun.TestInfo.Guid))
.Screenshots.Add(s);
});
}
}
void AssetMediator.SeekAsset <ContentType>(GrammarBlock gBlock, Taker <ContentType> collLis)
{
var implementer = implementerGetter.assetImplGetter.GetAssetImplementer <ContentType>(gBlock);
if (implementer != null)
{
implementer.SeekAsset(gBlock, new PrvtSeekLis <ContentType> {
collLis = collLis, parent = this
});
return;
}
//stub: should seek asset tool
else
{
collLis.None();
}
}
public IActionResult Delete(int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Taker taker = _context.Takers.Single(m => m.TakerId == id);
if (taker == null)
{
return(NotFound());
}
_context.Takers.Remove(taker);
_context.SaveChanges();
return(Ok(taker));
}
static void Main(string[] args)
{
Console.WriteLine("Yeni bir Nesne !");
Model bookA = new Model("SampleA");
Console.WriteLine(bookA);
Taker taker = new Taker();
taker.backup = bookA.Recover();
Console.WriteLine("\nManipüle Ettik.");
bookA._name = "SampleB";
Console.WriteLine(bookA);
Console.WriteLine("\nRestore Ettik !");
bookA.Restore(taker.backup);
Console.WriteLine(bookA);
}
void AssetReferInterface.PickContent <ContentType>(string path, Taker <ContentType> collector)
{
var tempPath = string.IsNullOrEmpty(path) ? "Main.json" : path;
if (typeof(ContentType) == typeof(MainContentType))
{
basicAssetIO.assetOut.PickAssetAtPath(tempPath, new StdBridgeBasicColl <ContentType> {
collector = collector
});
}
else if (typeof(ContentType) == typeof(MainContentBaseType))
{
basicAssetIO.assetOut.PickAssetAtPath(tempPath, new StdBridgeBasicColl <MainContentType> {
collector = new ToBaseTaker <MainContentType, ContentType> {
baseTaker = collector
}
});
}
}
