public static async Task <Grain> New(Type concreteType, AbstractKey key, IGrainRuntime grainRuntime, IServiceProvider services, StorageCell storage, FakeSerializer serializer)
{
var creator = new GrainCreator(grainRuntime, services);
var stateType = GetStateType(concreteType);
var grain = stateType != null
? creator.CreateGrainInstance(concreteType, key, stateType, new DummyStorageProvider()) //IStorage will be hackily assigned below // new StorageProviderAdaptor(key, store))
: creator.CreateGrainInstance(concreteType, key);
if (stateType != null)
{
var fnStateExtractor = _dStateExtractors.GetOrAdd(concreteType, t => BuildStateExtractor(t));
var fnStorageAssign = _dStorageAssigners.GetOrAdd(concreteType, t => BuildStorageAssigner(t));
var grainState = fnStateExtractor(grain);
var bridge = new GrainStorageBridge(storage, serializer, grainState);
fnStorageAssign(grain, bridge);
await bridge.ReadStateAsync();
}
return(grain);
}
public void Init(InputMappingController controller, AbstractKey key)
{
this.controller = controller;
this.key = key;
UpdateText();
RefreshColor();
}
public void Init(InputMappingController controller, string text, AbstractKey key)
{
this.controller = controller;
label.text = text;
this.key = key;
RefreshColor();
}
protected Task <TResult> Dispatch <TResult>(MethodInfo method, object[] args)
{
var argData = new byte[args.Length][];
for (int i = 0; i < args.Length; i++)
{
var arg = args[i];
//BELOW SHOULD BE IN GENERAL SERIALIZER, RATHER THAN AD-HOC HERE !!!!!!!!!!!!!!!
//so serializer will be sensitive to grains - seems reasonable...
//proxify before passing to grain method
if (arg is Grain && !(arg is GrainProxy)) //nb GrainProxy derives from Grain these days, oddly
{
var argKey = ((IGrain)arg).GetGrainKey(); //NEED TO BURROW IN TO GRAINRUNTIME - WHICH WILL BE GRAINHARNESS
var param = method.GetParameters()[i];
var grainKey = new AbstractKey(param.ParameterType, argKey.Id);
arg = Proxify(Fixture, grainKey);
}
argData[i] = Fixture.Serializer.Serialize(arg);
}
return(Fixture.Dispatcher.Dispatch(Key, a => a.Invoke <TResult>(method, argData)));
}
public Placement Place(AbstractKey key)
{
var concreteType = _typeMapper(key.AbstractType);
//var concreteKey = new ConcreteKey(concreteType, key.Id);
return(new Placement(key, concreteType));
}
public bool GetKey(AbstractKey key)
{
if (!IsEnabled(key))
{
return(false);
}
return(keyStatus[key]);
}
public static GrainProxy Proxify(Fixture fx, AbstractKey key)
{
var proxifier = _dProxifiers.GetOrAdd(
key.AbstractType,
t => BuildProxifier(t));
return(proxifier(fx, key));
}
public bool GetKeyUp(AbstractKey key)
{
if (!IsEnabled(key))
{
return(false);
}
return(keyStatusLastFrame[key] && !keyStatus[key]);
}
public Task <TResult> Dispatch <TResult>(AbstractKey key, Func <IGrainContext, Task <TResult> > fn)
{
var placement = _placer(key);
// one too many dispatchers, surely
//
//
return(_innerDispatcher.Dispatch(placement, fn));
}
public void GrainKey_ObtainableFromGrainProxy()
{
var key = new AbstractKey(typeof(ISomeGrain), Guid.NewGuid());
var proxy = (ISomeGrain)GrainProxy.Proxify(_fx, key);
var foundKey = proxy.GetGrainKey();
Assert.That(foundKey, Is.EqualTo(key));
}
public void AbstractKey_ToString_RoundTrip()
{
var original = new AbstractKey(typeof(ISomeGrain), Guid.NewGuid());
var stringified = AbstractKey.Stringify(original);
var returned = AbstractKey.Parse(stringified);
Assert.That(returned, Is.EqualTo(original));
}
public Reminder(Fixture fx, AbstractKey key, string name) //BUT!!! don't reminders function against abstract type -
{
_fx = fx; //otherwise, how can we upgrade concrete types without ruining reminders???
_key = key;
_name = name;
_status = ReminderState.Normal;
_cancelTokenSource = new CancellationTokenSource();
_tasks = new Queue <Task>();
}
public bool IsEnabled(AbstractKey key)
{
#if !UNITY_EDITOR
if (keyIsEditor[key])
{
return(false);
}
#endif
return(keyEnabled[key]);
}
public TGrainInterface GetGrain <TGrainInterface>(Guid primaryKey, string grainClassNamePrefix = null)
where TGrainInterface : IGrainWithGuidKey
{
Require.That(grainClassNamePrefix == null);
var tAbstract = typeof(TGrainInterface);
var key = new AbstractKey(tAbstract, primaryKey);
var proxy = _proxifier(key);
return((TGrainInterface)proxy);
}
public void SetUp()
{
_key = new AbstractKey(typeof(ITestGrain), Guid.NewGuid());
_placement = new Placement(_key, typeof(TestGrain));
_innerDisp = Substitute.For <IPlacementDispatcher>();
_placer = Substitute.For <Func <AbstractKey, Placement> >();
_placer(Arg.Is(_key)).Returns(_placement);
_disp = new Dispatcher(_placer, _innerDisp);
_fn = a => Task.FromResult(true);
}
public async Task GrainKey_ObtainableFromConcreteGrain()
{
var key = new AbstractKey(typeof(ISomeGrain), Guid.NewGuid());
var grain = await GrainConstructor.New(
typeof(SomeGrain),
key,
Substitute.For <IGrainRuntime>(),
Substitute.For <IServiceProvider>(),
new StorageCell(null),
null
);
var foundKey = grain.GetGrainKey();
Assert.That(foundKey, Is.EqualTo(key));
}
protected GrainProxy(Fixture fx, AbstractKey key)
{
Fixture = fx;
Key = key;
}
private static string AbstractKeyDisplayName(AbstractKey key) =>
I18n.__($"config.key.{Enum.GetName(typeof(AbstractKey), key)}");
public Placement(AbstractKey key, Type type)
{
GrainKey = key;
ConcreteType = type;
}
public bool IsEnabled(AbstractKey key)
{
return(keyEnabled[key]);
}
public void SetEnable(AbstractKey key, bool value)
{
keyEnabled[key] = value;
}
public MeasureAttributes(bool isVisible, AbstractClef clef, AbstractKey key, AbstractTime time) : base(isVisible, clef, key, time)
{
}
public static Task Dispatch(this IDispatcher disp, AbstractKey key, Func <IGrainContext, Task> fn)
=> disp.Dispatch(key, async a => { await fn(a); return(default(VoidType)); });
public List <CompoundKey> GetDefaultCompoundKeys(AbstractKey key)
{
return(defaultKeyboard.Data[key].Select(ck => new CompoundKey(ck)).ToList());
}
public void SetEnable(AbstractKey key, bool value)
{
keyEnabled[key] = value;
keyDownWhenEnabled[key] = false;
keyDownToBeCleared[key] = false;
}