public DatabaseFileStorage(IDispatcher dispatcher)
{
if (dispatcher == null)
throw new ArgumentNullException(nameof(dispatcher));
_dispatcher = dispatcher;
}
public BroadphaseProxy createProxy(ref btVector3 aabbMin,ref btVector3 aabbMax,
BroadphaseNativeTypes shapeType, object userPtr,
short collisionFilterGroup, short collisionFilterMask, IDispatcher dispatcher,
object multiSapProxy)
{
DbvtProxy proxy = new DbvtProxy(aabbMin, aabbMax, userPtr,
collisionFilterGroup,
collisionFilterMask);
DbvtAabbMm aabb;// = DbvtAabbMm.FromMM(aabbMin, aabbMax);
DbvtAabbMm.FromMM(ref aabbMin, ref aabbMax, out aabb);
//bproxy->aabb = btDbvtVolume::FromMM(aabbMin,aabbMax);
proxy.stage = m_stageCurrent;
proxy.m_uniqueId = ++m_gid;
proxy.leaf = m_sets[0].insert(ref aabb, proxy);
listappend(ref proxy, ref m_stageRoots[m_stageCurrent]);
if (!m_deferedcollide)
{
DbvtTreeCollider collider = new DbvtTreeCollider(this);
collider.proxy = proxy;
m_sets[0].collideTV(m_sets[0].m_root, ref aabb, collider);
m_sets[1].collideTV(m_sets[1].m_root,ref aabb, collider);
}
return (proxy);
}
public OAuthConsumer()
{
AuthProperties = new OAuthProperties();
AuthRequestMethod = RequestMethod.Header;
HttpMethod = HttpAction.GET;
_dispatcher = new Dispatcher();
}
internal MethodEntityProcessor(MethodEntity methodEntity,
IDispatcher dispatcher, ICodeProvider codeProvider, IEntityDescriptor entityDescriptor = null,
bool verbose = false)
: base(methodEntity, entityDescriptor, dispatcher)
{
Contract.Assert(methodEntity != null);
this.MethodEntity = methodEntity;
this.EntityDescriptor = entityDescriptor==null?methodEntity.EntityDescriptor
:entityDescriptor;
this.Verbose = true; // verbose;
// It gets a code provider for the method.
if (codeProvider!=null || dispatcher is OrleansDispatcher)
{
this.codeProvider = codeProvider;
//this.codeProvider = ProjectGrainWrapper.CreateProjectGrainWrapperAsync(methodEntity.MethodDescriptor).Result;
//SetCodeProviderAsync(methodEntity.MethodDescriptor);
}
else
{
var pair = ProjectCodeProvider.GetProjectProviderAndSyntaxAsync(methodEntity.MethodDescriptor).Result;
if (pair != null)
{
this.codeProvider = pair.Item1;
}
}
// We use the codeProvider for Propagation and HandleCall and ReturnEvents (in the method DiffProp that uses IsAssignable)
// We can get rid of this by passing codeProvider as parameter in this 3 methods
this.MethodEntity.PropGraph.SetCodeProvider(this.codeProvider);
}
public DynamicsWorld(IDispatcher dispatcher, IBroadphaseInterface broadphase, ICollisionConfiguration collisionConfiguration)
: base(dispatcher, broadphase, collisionConfiguration)
{
InternalTickCallback = null;
InternalPreTickCallback = null;
m_worldUserInfo = null;
}
///this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those
public DiscreteDynamicsWorld(IDispatcher dispatcher, IBroadphaseInterface pairCache, IConstraintSolver constraintSolver, ICollisionConfiguration collisionConfiguration)
: base(dispatcher, pairCache, collisionConfiguration)
{
m_ownsIslandManager = true;
m_constraints = new ObjectArray<TypedConstraint>();
m_actions = new List<IActionInterface>();
m_nonStaticRigidBodies = new ObjectArray<RigidBody>();
m_islandManager = new SimulationIslandManager();
m_constraintSolver = constraintSolver;
Gravity = new Vector3(0, -10, 0);
m_localTime = 1f / 60f;
m_profileTimings = 0;
m_synchronizeAllMotionStates = false;
if (m_constraintSolver == null)
{
m_constraintSolver = new SequentialImpulseConstraintSolver();
m_ownsConstraintSolver = true;
}
else
{
m_ownsConstraintSolver = false;
}
}
public MyNodeOverlapCallback(MultiSapBroadphase multiSap,MultiSapProxy multiProxy,IDispatcher dispatcher)
{
m_multiSap = multiSap;
m_multiProxy = multiProxy;
m_dispatcher = dispatcher;
}
public ResolveOperationViewModel(
string resolveOperationId,
IHistoricalItemStore<ResolveOperation> historicalItemStore,
IDispatcher dispatcher)
{
if (resolveOperationId == null) throw new ArgumentNullException("resolveOperationId");
if (historicalItemStore == null) throw new ArgumentNullException("historicalItemStore");
dispatcher.Background(() =>
{
ResolveOperation resolveOperation;
if (historicalItemStore.TryGetItem(resolveOperationId, out resolveOperation))
{
var subOperations = Traverse.PreOrder(resolveOperation, r => r.SubOperations)
.Select(o => new SubResolveOperationViewModel(o))
.ToList();
dispatcher.Foreground(() =>
{
foreach (var subResolveOperationViewModel in subOperations)
_subOperations.Add(subResolveOperationViewModel);
});
}
});
}
public Publisher(PublisherSettings settings, IHandlerSource handlerSource, IDispatcher[] dispatchers)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (handlerSource == null)
{
throw new ArgumentNullException("handlerSource");
}
if (dispatchers == null)
{
throw new ArgumentNullException("dispatchers");
}
if (dispatchers.Any(x => ReferenceEquals(x, null)))
{
throw new ArgumentException("At least one of dispatches is null.", "dispatchers");
}
_settings = settings;
_handlerSource = handlerSource;
_dispatchers = dispatchers;
}
public SolverService(
[NotNull] IMessageBus messageBus,
[NotNull] IGameService gameService,
[NotNull] IBoardSolverService boardSolverService,
[NotNull] IDispatcher dispatcher)
{
if (messageBus == null)
{
throw new ArgumentNullException(nameof(messageBus));
}
if (gameService == null)
{
throw new ArgumentNullException(nameof(gameService));
}
if (boardSolverService == null)
{
throw new ArgumentNullException(nameof(boardSolverService));
}
if (dispatcher == null)
{
throw new ArgumentNullException(nameof(dispatcher));
}
this.messageBus = messageBus;
this.gameService = gameService;
this.boardSolverService = boardSolverService;
this.dispatcher = dispatcher;
this.messageBus.Subscribe<BoardScrambled>(this.OnBoardScrambled);
this.messageBus.Subscribe<BoardResetted>(this.OnBoardResetted);
this.messageBus.Subscribe<SlideHappened>(this.OnSlideHappened);
}
public Object RemoveOverlappingPair(BroadphaseProxy proxy0, BroadphaseProxy proxy1, IDispatcher dispatcher)
{
if (!HasDeferredRemoval())
{
BroadphasePair findPair = new BroadphasePair(proxy0,proxy1);
int findIndex = m_overlappingPairArray.IndexOf(findPair);
if (findIndex >= 0 && findIndex < m_overlappingPairArray.Count)
{
OverlappingPairCacheGlobals.gOverlappingPairs--;
BroadphasePair pair = m_overlappingPairArray[findIndex];
Object userData = pair.m_internalInfo1;
CleanOverlappingPair(pair,dispatcher);
if (m_ghostPairCallback != null)
{
m_ghostPairCallback.RemoveOverlappingPair(proxy0, proxy1,dispatcher);
}
//BroadphasePair temp = m_overlappingPairArray[findIndex];
//m_overlappingPairArray[findIndex] = m_overlappingPairArray[m_overlappingPairArray.Count-1];
//m_overlappingPairArray[m_overlappingPairArray.Count-1] = temp;
m_overlappingPairArray.RemoveAt(m_overlappingPairArray.Count - 1);
return userData;
}
}
return 0;
}
public QueueSubscriptionFactory( ISubscriptionManager subscriptions, IDispatcher dispatcher,
IChannelProxyFactory proxyFactory )
{
Subscriptions = subscriptions;
Dispatcher = dispatcher;
ProxyFactory = proxyFactory;
}
public DynamicsWorld(IDispatcher dispatcher,IBroadphaseInterface broadphase,ICollisionConfiguration collisionConfiguration)
:base(dispatcher,broadphase,collisionConfiguration)
{
m_internalTickCallback = null;
m_worldUserInfo = null;
m_solverInfo = new ContactSolverInfo();
}
public MemoryImageViewModel(IGameBoy gameBoy, IDispatcher dispatcher)
{
_gameBoy = gameBoy;
_dispatcher = dispatcher;
_gameBoy.FrameCompleted += OnFrameCompleted;
_memoryImage = new WriteableBitmap(256, 256, 96, 96, PixelFormats.Gray8, null);
}
/// <summary>
/// this btSimpleDynamicsWorld constructor creates dispatcher, broadphase pairCache and constraintSolver
/// </summary>
/// <param name="dispatcher"></param>
/// <param name="pairCache"></param>
/// <param name="constraintSolver"></param>
public SimpleDynamicsWorld(IDispatcher dispatcher, OverlappingPairCache pairCache, IConstraintSolver constraintSolver)
: base(dispatcher, pairCache)
{
_constraintSolver = constraintSolver;
_ownsConstraintSolver = false;
_gravity = new Vector3(0, 0, -10);
}
public ListViewModel(
IToDoService toDoService,
IMessenger messenger,
IDispatcher dispatcher,
ISearchService searchService,
ISharingService sharingService
)
{
_toDoService = toDoService;
_searchService = searchService;
_dispatcher = dispatcher;
_messenger = messenger;
_sharingService = sharingService;
Items = new ObservableCollection<ToDoItem>();
SearchResult = new ObservableCollection<ToDoItem>();
RegisterSubscriptions();
SetupCommands();
Items.CollectionChanged += (s, c) =>
{
var count = Items.Count;
Count = count;
messenger.Send(new ItemCountChanged { Count = count });
};
PopulateItems();
}
public PersonDirectoryViewModel(IPersonService personService, IDispatcher dispatcher, IEventAggregator aggregator, IDialogService dialogService)
: base(personService, dispatcher, aggregator, dialogService)
{
personDirectory = new RangeEnabledObservableCollection<Person>();
aggregator.GetEvent<PersonDirectoryUpdatedEvent>().Subscribe(OnPersonDirectoryUpdated, ThreadOption.BackgroundThread);
aggregator.GetEvent<PersonDeletedEvent>().Subscribe(OnPersonDeleted, ThreadOption.UIThread);
}
/// <summary>
/// this constructor doesn't own the dispatcher and paircache/broadphase
/// </summary>
/// <param name="dispatcher"></param>
/// <param name="pairCache"></param>
public CollisionWorld(IDispatcher dispatcher, OverlappingPairCache pairCache)
{
_dispatcher = dispatcher;
_broadphasePairCache = pairCache;
_ownsDispatcher = false;
_ownsBroadphasePairCache = false;
}
public Acceptor(TcpListener listener, IDispatcher dispatcher)
{
_listener = listener;
_listener.Start();
_dispatcher = dispatcher;
_dispatcher.Register(this);
}
public LoadSolutionsCommand(SolutionsLauncherViewModel solutionsLauncherViewModel, ISolutionDetector solutionDetector, ISolutionPriorityResolver solutionPriorityResolver, IDispatcher dispatcher)
{
_solutionsLauncherViewModel = solutionsLauncherViewModel;
_solutionDetector = solutionDetector;
_solutionPriorityResolver = solutionPriorityResolver;
_dispatcher = dispatcher;
}
public APUViewModel(IGameBoy gameBoy, IDispatcher dispatcher)
{
_gameBoy = gameBoy;
_dispatcher = dispatcher;
_gameBoy.FrameCompleted += OnFrameCompleted;
_spectrogram = new WriteableBitmap(_numberOfFramesPerImage, _fftSize, 96, 96, PixelFormats.Bgr32, null);
}
//--------------------------------------
// INITIALIZE
//--------------------------------------
public CEvent(int id, string name, object data, IDispatcher dispatcher)
{
_id = id;
_name = name;
_data = data;
_dispatcher = dispatcher;
}
public void PromptAndImportEntities()
{
//files.Add(new FileInfo(@"C:\database1.xml"));
//files.Add(new FileInfo(@"C:\database2.xml"));
//files.Add(new FileInfo(@"C:\database3.xml"));
// DeleteData();
current = Dispatchers.Current;
Dispatchers.Main.BeginInvoke(() =>
{
SelectFileWindow.FileWindowArgument Argument = new SelectFileWindow.FileWindowArgument { FileAccess = System.IO.FileAccess.Read, Multiselect=true , FileFilter = "xml (*.xml)|*.xml" };
SelectFileWindow selectFileWindow = new SelectFileWindow(Argument);
selectFileWindow.Closed += new EventHandler(selectFileWindow_Closed);
selectFileWindow.Show();
});
}
/// <summary>
/// Initializes a new instance of the <see cref="UnmanagedBitmapRenderer" /> class.
/// </summary>
/// <param name="threadManager">The thread manager.</param>
/// <param name="dispatcher">The dispatcher.</param>
public UnmanagedBitmapRenderer(IThreadManager threadManager, IDispatcher dispatcher)
: base(threadManager)
{
threadManager.Guard("threadManager");
dispatcher.Guard("dispatcher");
this.dispatcher = dispatcher;
}
public ComponentDetailViewModel(string componentId, IDispatcher dispatcher, IActiveItemRepository<Component> components)
{
dispatcher.Background(() =>
{
Component component;
if (!components.TryGetItem(componentId, out component))
throw new ArgumentException("Unknown component.");
var description = component.Description;
var services = component.DescribeServices();
var metadata = component.Metadata;
var sharing = component.Sharing;
var lifetime = component.Lifetime;
var activator = component.Activator;
var ownership = component.Ownership;
var target = component.TargetComponentId;
var id = component.Id;
dispatcher.Foreground(() =>
{
Description = description;
Metadata = metadata;
Services = services;
Sharing = sharing.ToString();
Lifetime = lifetime.ToString();
Activator = activator.ToString();
Ownership = ownership.ToString();
Target = target;
Id = id;
});
});
}
public ViewModelBase(IPersonService personService, IDispatcher dispatcher, IEventAggregator aggregator, IDialogService dialogService)
{
if (personService == null)
{
throw new ArgumentNullException("personService");
}
if (dispatcher == null)
{
throw new ArgumentNullException("dispatcher");
}
if (aggregator == null)
{
throw new ArgumentNullException("aggregator");
}
if (dialogService == null)
{
throw new ArgumentNullException("dialogService");
}
this.personService = personService;
this.dispatcher = dispatcher;
this.aggregator = aggregator;
this.dialogService = dialogService;
isBusy = false;
}
/// <summary>Initializes a new instance of the <see cref="UndoRedoManager"/> class.</summary>
/// <param name="root">The root.</param>
/// <param name="dispatcher">The dispatcher.</param>
/// <param name="excludedRootProperties">The excluded root properties.</param>
public UndoRedoManager(GraphObservableObject root, IDispatcher dispatcher, string[] excludedRootProperties = null)
{
_root = root;
_dispatcher = dispatcher;
_excludedRootProperties = excludedRootProperties ?? new string[] { };
root.GraphPropertyChanged += OnGraphPropertyChanged;
}
public ProcessorManager(IDispatcher dispatcher, IConstants constants)
{
this.Constants = constants;
this.Clients = GlobalHost.ConnectionManager.GetHubContext<StebsHub>().Clients;
this.Dispatcher = dispatcher;
this.Dispatcher.StateChanged += StateChanged;
this.Dispatcher.FinishedStep += FinishedStep;
}
public ClosestNotMeConvexResultCallback(CollisionObject me, ref Vector3 fromA, ref Vector3 toA, IOverlappingPairCache pairCache, IDispatcher dispatcher) :
base(ref fromA, ref toA)
{
m_allowedPenetration = 0.0f;
m_me = me;
m_pairCache = pairCache;
m_dispatcher = dispatcher;
}
public PopUpViewModel(IDispatcher dispatcher, ISessionTimer sessionTimer)
{
_Dispatcher = dispatcher;
_SessionTimer = sessionTimer;
Visible = false;
sessionTimer.BreakNeeded += OnBreakNeeded;
sessionTimer.BreakTaken += OnBreakTaken;
}
public virtual Object RemoveOverlappingPair(BroadphaseProxy proxy0, BroadphaseProxy proxy1, IDispatcher dispatcher)
{
CollisionObject colObj0 = proxy0.m_clientObject as CollisionObject;
CollisionObject colObj1 = proxy1.m_clientObject as CollisionObject;
GhostObject ghost0 = GhostObject.Upcast(colObj0);
GhostObject ghost1 = GhostObject.Upcast(colObj1);
if (ghost0 != null)
{
ghost0.RemoveOverlappingObjectInternal(proxy1, dispatcher, proxy0);
}
if (ghost1 != null)
{
ghost1.RemoveOverlappingObjectInternal(proxy0, dispatcher, proxy1);
}
return(null);
}
public virtual void RemoveOverlappingPairsContainingProxy(BroadphaseProxy proxy0, IDispatcher dispatcher)
{
Debug.Assert(false);
//need to keep track of all ghost objects and call them here
//m_hashPairCache->removeOverlappingPairsContainingProxy(proxy0,dispatcher);
}
public HomeController(IDispatcher dispatcher,
IConfiguration configuration,
IOptions <AppOptions> appOptions) : base(dispatcher, configuration, appOptions)
{
}
public Task <string> HandleAsync(TestCommand command, CancellationToken token, IDispatcher dispatcher)
{
return(Task.FromResult($"command payload: {command.Id}"));
}
///this method is mainly for expert/internal use only.
public virtual void RemoveOverlappingObjectInternal(BroadphaseProxy otherProxy, IDispatcher dispatcher, BroadphaseProxy thisProxy)
{
CollisionObject otherObject = otherProxy.m_clientObject as CollisionObject;
Debug.Assert(otherObject != null);
///if this linearSearch becomes too slow (too many overlapping objects) we should add a more appropriate data structure
{
m_overlappingObjects.RemoveQuick(otherObject);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HeartbeatRequestCommandHandler"/> class.
/// </summary>
/// <param name="commandProcessor">The command processor.</param>
/// <param name="dispatcher">The dispatcher.</param>
public HeartbeatRequestCommandHandler(IAmACommandProcessor commandProcessor, IDispatcher dispatcher)
{
_commandProcessor = commandProcessor;
_dispatcher = dispatcher;
}
public virtual void DispatchAllCollisionPairs(IOverlappingPairCache pairCache, DispatcherInfo dispatchInfo, IDispatcher dispatcher)
{
m_collisionCallback.Initialize(dispatchInfo, this);
pairCache.ProcessAllOverlappingPairs(m_collisionCallback, dispatcher);
m_collisionCallback.cleanup();
}
public BookServiceDispatcher(IOptions <BookServiceEndPointConstants> bookServiceEndPoints,
IDispatcher dispatcher)
{
_bookServiceEndPoints = bookServiceEndPoints;
_dispatcher = dispatcher;
}
/// <summary>Loads a <see cref="JsonDocumentModel"/> from a file path. The schema path is automatically determined. </summary>
/// <param name="filePath">The file path. </param>
/// <param name="dispatcher">The UI dispatcher. </param>
/// <returns>The <see cref="JsonDocumentModel"/>. </returns>
public static Task <JsonDocumentModel> LoadAsync(string filePath, IDispatcher dispatcher)
{
var schemaPath = GetDefaultSchemaPath(filePath);
return(LoadAsync(filePath, schemaPath, dispatcher));
}
/// <summary>Loads a <see cref="JsonDocumentModel"/> from a file path and schema path. </summary>
/// <param name="filePath">The file path. </param>
/// <param name="schemaPath">The schema path. </param>
/// <param name="dispatcher">The UI dispatcher. </param>
/// <returns>The <see cref="JsonDocumentModel"/>. </returns>
public static Task <JsonDocumentModel> LoadAsync(string filePath, string schemaPath, IDispatcher dispatcher)
{
return(Task.Run(() =>
{
var schema = JsonSchema4.FromJson(File.ReadAllText(schemaPath, Encoding.UTF8));
var data = JsonObjectModel.FromJson(File.ReadAllText(filePath, Encoding.UTF8), schema);
var document = new JsonDocumentModel();
document.Initialize(data, dispatcher);
document.FilePath = filePath;
document.SchemaPath = schemaPath;
return document;
}));
}
/// <summary>Initializes the document. </summary>
/// <param name="data">The JSON data. </param>
/// <param name="dispatcher">The UI dispatcher. </param>
public void Initialize(JsonObjectModel data, IDispatcher dispatcher)
{
UndoRedoManager = new UndoRedoManager(data, dispatcher);
Data = data;
}
public override void RemoveOverlappingObjectInternal(BroadphaseProxy otherProxy, IDispatcher dispatcher, BroadphaseProxy thisProxy)
{
CollisionObject otherObject = otherProxy.m_clientObject as CollisionObject;
BroadphaseProxy actualThisProxy = thisProxy != null ? thisProxy : GetBroadphaseHandle();
Debug.Assert(actualThisProxy != null);
Debug.Assert(otherObject != null);
if (m_overlappingObjects.Remove(otherObject))
{
m_hashPairCache.RemoveOverlappingPair(actualThisProxy, otherProxy, dispatcher);
}
}
public void RegisterHandlers(IMessageInvoker invoker, IDispatcher dispatcher)
{
_invoker = invoker;
_dispatcher = dispatcher;
}
public TagsByUserIdQuery(IDispatcher dispatcher) : base(dispatcher)
{
}
public override async Task HandleAsync(FetchWorkbanchItemsAction action, IDispatcher dispatcher)
{
var items = await _workbanchService.GetAllItems(action.SearchString /*, action.Type*/);
dispatcher.Dispatch(new FetchWorkbanchItemsResultAction(items));
}
public DiscountsController(IDispatcher dispatcher)
{
_dispatcher = dispatcher;
}
public AppointmentsController(IDispatcher dispatcher)
{
_dispatcher = dispatcher;
}
public override Task HandleAsync(SetWorkbanchSearchTypeAction action, IDispatcher dispatcher)
{
dispatcher.Dispatch(new FetchWorkbanchItemsAction(_state.Value.SearchString /*, action.SearchType*/));
return(Task.CompletedTask);
}
private TestCircuitHost(IServiceScope scope, CircuitClientProxy client, RendererRegistry rendererRegistry, RemoteRenderer renderer, IList <ComponentDescriptor> descriptors, IDispatcher dispatcher, RemoteJSRuntime jsRuntime, CircuitHandler[] circuitHandlers, ILogger logger)
: base(scope, client, rendererRegistry, renderer, descriptors, dispatcher, jsRuntime, circuitHandlers, logger)
{
}
public TestController(IDispatcher dispatcher)
{
_controller = new PhoneBookController(dispatcher);
}
protected override Task HandleAsync(UpdateObjectiveAction action, IDispatcher dispatcher)
{
return _gameService.UpdateObjectiveAsync(action.Objective, action.IsEnabled);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectOperator<TSource, TResult>"/> class.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="projector">The projector.</param>
/// <param name="dispatcher">The dispatcher.</param>
public ProjectOperator(IBindable <TSource> source, Func <TSource, TResult> projector, IDispatcher dispatcher)
: base(source, dispatcher)
{
_projector = projector;
}
