public NessDefinition(string name) { Condition.Requires(name).IsNotNullOrEmpty(); this.Name = name; this.ConditionStore = NaturalInMemoryStore.New().IsOf <INessCondition>(); this.OperationStore = NaturalInMemoryStore.New().IsOf <INessOperation>(); }
/// <summary> /// deserializes text to a Node Store. The node values are unhydrated. /// </summary> /// <param name="storeText"></param> /// <returns></returns> public static IStoreOf <GraphNode> HydrateNodeStore(string storeText) { var nodeStore = NaturalInMemoryStore.New().IsOf <GraphNode>(); var list = HydrateNodeList(storeText); nodeStore.SaveItems(list.ConvertListTo <IHasId, GraphNode>()); return(nodeStore); }
public FactoriedEvictingInMemoryStore(LogicOfTo <IStoredObjectId, IHasId> factory, LogicOfTo <IHasId, ICondition> defaultItemEvictionConditionFactory, double backgroundIntervalMSecs = 30000) : base(NaturalInMemoryStore.New() .DecorateWithEviction(NaturalInMemoryStore.New(), defaultItemEvictionConditionFactory, backgroundIntervalMSecs) .DecorateWithFactory(factory)) { }
public RoutingTokenizerDecoration(IForwardMovingTokenizer <T> decorated, bool overridesTokenizerRouting = true, bool tokenizeUnrecognized = true) : base(decorated) { this.TokenizerStore = NaturalInMemoryStore.New().IsOf <TokenizerItem>(); this.OverridesTokenizerRouting = overridesTokenizerRouting; this.TokenizeUnrecognized = tokenizeUnrecognized; }
public StringStateMachineGraph(string initialState) { if (initialState == null) { throw new ArgumentNullException("initialState"); } this.InitialState = initialState; this.CurrentState = initialState; this.Store = NaturalInMemoryStore.New().IsOf <StringStateTransition>(); }
public static ILogger GetFileLogger(string path) { var logger = StoreLogger.New(NaturalInMemoryStore.New().Polls()); logger.Store.GetPoll().SetBackgroundAction(LogicOf <IStore> .New((store) => { var dat = StoreSerializer.SerializeStore(store, ValueManagerChainOfResponsibility.NewDefault()); Debug.WriteLine(dat); dat.MakeStringable().Fileable().Filing(path).Write(); }), 100); return(logger); }
protected StringStateMachineGraph(SerializationInfo info, StreamingContext context) { this.InitialState = info.GetString("InitialState"); this.CurrentState = info.GetString("CurrentState"); List <StringStateTransition> list = (List <StringStateTransition>)info.GetValue("list", typeof(List <StringStateTransition>)); this.Store = NaturalInMemoryStore.New().IsOf <StringStateTransition>(); var newList = list.ConvertListTo <IHasId, StringStateTransition>(); this.Store.SaveItems(newList); }
public TokenLexer(NessManager nessManager, IStoreOf <NamedNaturalInMemoryStore> storeOfStores = null) { if (storeOfStores == null) { this.StoreOfStores = NaturalInMemoryStore.New().IsOf <NamedNaturalInMemoryStore>(); } else { this.StoreOfStores = storeOfStores; } this.NessManager = nessManager; }
private string HandleStoreProtocolRequest(string request) { //decode the request store var requestStore = StoreSerializer.DeserializeStore(request, this.ValueManager); Condition.Requires(requestStore).IsNotNull(); var responseStore = NaturalInMemoryStore.New(); Tuple <IStore, IStore> uow = new Tuple <IStore, IStore>(requestStore, responseStore); this.StoreProtocolLogic.Perform(uow); //encode the response var responseText = StoreSerializer.SerializeStore(uow.Item2, this.ValueManager); return(responseText); }
public static IStore DeserializeStore(string data, ValueManagerChainOfResponsibility managerSet) { if (string.IsNullOrEmpty(data)) { return(null); } var list = LengthEncoder.LengthDecodeList(data); var store = NaturalInMemoryStore.New(); list.WithEach(each => { var item = DeserializeItem(each, managerSet); IHasId obj = item as IHasId; store.SaveItem(obj); }); return(store); }
/// <summary> /// given the object to graph, builds a graph /// </summary> /// <param name="obj"></param> private void BuildGraph(object obj, Func <object, GraphPath, bool> skipFilter = null) { /* * We walk each object in the graph and convert that into a GraphNode (ie. GraphPath + ManagedValue + Sequence) * */ Condition.Requires(obj).IsNotNull(); this.NodeStore = NaturalInMemoryStore.New().IsOf <GraphNode>(); this.Counter = new Counter(); this.SkipFilter = skipFilter; var rootPath = GraphPath.New(); //build the node and recurse, maybe BuildNode(obj, rootPath); }
public CLConfig(NessManager nessManager = null, IStoreOf <NamedNaturalInMemoryStore> storeOfStores = null) { if (storeOfStores == null) { this.StoreOfStores = NaturalInMemoryStore.New().IsOf <NamedNaturalInMemoryStore>(); } else { this.StoreOfStores = storeOfStores; } if (nessManager == null) { this.NessManager = NessManager.New(); } else { this.NessManager = nessManager; } }
public static void RunTest(this ITestable testable) { Condition.Requires(testable).IsNotNull(); var tests = testable.GetTests(); var testStore = testable.GenerateTestInput(); IStore testResultsStore = NaturalInMemoryStore.New(); tests.HandleOperations(testStore, testResultsStore); var errors = tests.GetErrors(testResultsStore); if (errors != null && errors.Count > 0) { //output the stores testResultsStore.JoinStore(testStore); var dump = StoreSerializer.SerializeStore(testResultsStore, ValueManagerChainOfResponsibility.NewDefault()); Debug.WriteLine(dump); throw new InvalidOperationException("test failure"); } }
public EvictingInMemoryStore(Func <IHasId, ICondition> defaultItemEvictionConditionFactory, double backgroundIntervalMSecs = 30000) : base(NaturalInMemoryStore.New().DecorateWithEviction( NaturalInMemoryStore.New(), defaultItemEvictionConditionFactory.MakeLogicOfTo(), backgroundIntervalMSecs)) { }
public EventingInMemoryStore() : base(NaturalInMemoryStore.New().DecorateWithEvents()) { }
public TaskStoreDecoration(IStore store, LogicOfTo <IHasId, IExpirable> evictionPolicy) : base(store.IsOf <ITask>().IsOfUniqueId().Evicting(NaturalInMemoryStore.New(), evictionPolicy, 1000)) { }
public TaskStore(LogicOfTo <IHasId, IExpirable> evictionPolicy) : base(NaturalInMemoryStore.New(), evictionPolicy) { }
public OperationManager() { this.Operations = NaturalInMemoryStore.New().IsOf <IOperation>(); }
public IndexFactory() { this.StoreOfBitLogic = NaturalInMemoryStore.New().IsOf <IndexingBitLogic>(); }
public InMemoryStoreOf() : base(NaturalInMemoryStore.New().DecorateWithIsOf <T>()) { }
/// <summary> /// provide store (with defined eviction strategies) /// </summary> /// <param name="store"></param> public Job(string id, LogicOfTo <IHasId, IExpirable> evictionPolicy) : base(StrategizedTask.NewBlank(id)) { /*Overall process: * -create a managing task (this guy) to manage and store all of the subtasks. * -the core of this managing task is a blank strategized core which is decorated * with a bunch of behaviours that help accomplish the managing task's purpose. * * The layers are described below: * -Core * -PerformLogic - on perform, injects polling strategy checkTriggers() that moves the tasks along * -CancelLogic - cancels all cancellable tasks * -Async * -Complete trigger: When all tasks complete * -Error trigger:When any tasks go wrong * -Events * -OnCancelled, release waithandle * -OnComplete, release waithandle * -OnError, release waithandle * -Polling * -run checkTriggers as injected above * * The job task also contains the TaskStore which all contains all of the tasks to manage. * * RunToCompletion() kicks the job off and waits until it is complete. */ //create new in memory store for the tasks to live in var taskStore = NaturalInMemoryStore.New().MakeTaskStore(evictionPolicy); this.TaskStore = taskStore; //get the core task (is also the Decorated property as we're a 2-layer cake at this point) StrategizedTask coreTask = this.Core as StrategizedTask; //define the Perform and Cancel Logic coreTask.Performs(Logic.New( () => { //the perform task is to turn on the polling process this.As <IPollingDecoration>(false) .SetBackgroundAction(LogicOf <ITask> .New( (x) => { this.checkTriggers(); }) ); })); coreTask.Cancels(Logic.New(() => { this.CancelTasks(); })); //define the action to flip the waithandle that is waited on in RunToCompletion Action flipWaitHandle = () => { lock (_stateLock) { if (this.Status == DecoratidTaskStatusEnum.Cancelled || this.Status == DecoratidTaskStatusEnum.Complete || this.Status == DecoratidTaskStatusEnum.Errored) { Monitor.Pulse(_stateLock); } } }; //now decorate this core task with the layers described above //decorate as asynch (under the hood this will decorate with Trigger Conditions). Also implies that we need a polling process to check the conditions ITask decoratedTask = coreTask.IsAsynchronous( StrategizedCondition.New(() => { return(this.AreTasksComplete()); }), StrategizedCondition.New(() => { return(this.HaveTasksErrored()); })); //decorate with event handlers to flip the wait handle decoratedTask = decoratedTask.Eventing().DoOnTaskCancelled(flipWaitHandle).DoOnTaskCompleted(flipWaitHandle).DoOnTaskErrored(flipWaitHandle); //decorate with polling without a polling strategy decoratedTask = decoratedTask.DecorateWithPolling(); //set the task store decoratedTask.TaskStore = this.TaskStore; decoratedTask.Save(); //inject decoration that we've just built this.ReplaceDecorated((decorated) => { return(decoratedTask); }); //subscribe to eviction event where we initiate a cancel if it happens this.TaskStore.ItemEvicted += Job_ItemEvicted; }
public OperationProtocolClientDecoration(IEndPointClient decorated, ValueManagerChainOfResponsibility valueManager = null) : base(decorated.StoreProtocoling(valueManager)) { this.RequestStore = NaturalInMemoryStore.New(); }