/// <summary>
/// Checks object state per-controller, then calls an action per-object with all controller checks that reported back an object.
/// </summary>
private void remapInteractionObjectStateChecks(ReadonlyHashSet <InteractionController> controllers,
StateChangeCheckFunc stateCheckFunc,
Action <IInteractionBehaviour, List <InteractionController> > actionPerInteractionObject)
{
// Ensure the object->controllers buffer is non-null (ThreadStatic quirk) and clean.
if (s_objControllersMap == null)
{
s_objControllersMap = new Dictionary <IInteractionBehaviour, List <InteractionController> >();
}
s_objControllersMap.Clear();
// In a nutshell, this remaps methods per-controller that output an interaction object if the controller changed that object's state
// to methods per-object with all of the controllers for which the check produced a state-change.
foreach (var controller in controllers)
{
IInteractionBehaviour objectWhoseStateChanged;
if (stateCheckFunc(controller, out objectWhoseStateChanged))
{
if (!s_objControllersMap.ContainsKey(objectWhoseStateChanged))
{
s_objControllersMap[objectWhoseStateChanged] = Pool <List <InteractionController> > .Spawn();
}
s_objControllersMap[objectWhoseStateChanged].Add(controller);
}
}
// Finally, iterate through each (object, controllers) pair and call the action for each pair
foreach (var objControllesPair in s_objControllersMap)
{
actionPerInteractionObject(objControllesPair.Key, objControllesPair.Value);
// Clear each controllers list and return it to the list pool.
objControllesPair.Value.Clear();
Pool <List <InteractionController> > .Recycle(objControllesPair.Value);
}
}
public void ReadonlyHashSetContains()
{
var underTest = new ReadonlyHashSet<string>(_sourceItems);
Assert.True(underTest.Contains("a"));
Assert.True(underTest.Contains("b"));
Assert.True(underTest.Contains("c"));
Assert.False(underTest.Contains("d"));
Assert.False(underTest.Contains(""));
}
public void ReadonlyHashSetContains()
{
var underTest = new ReadonlyHashSet <string>(_sourceItems);
Assert.True(underTest.Contains("a"));
Assert.True(underTest.Contains("b"));
Assert.True(underTest.Contains("c"));
Assert.False(underTest.Contains("d"));
Assert.False(underTest.Contains(""));
}
public static bool Any <T>(this ReadonlyHashSet <T> set, Func <T, Boolean> func)
{
foreach (var x in set)
{
if (func(x))
{
return(true);
}
}
return(false);
}
static ConfigurationHelper()
{
// set all public properties to empty
// PROBLEM: i am using HashSet here in order to make often string lookups efficient. however the collections returned should be
// read-only in order to prevent user code from modifying Configuration settings - in .NET framework there is no easy way of
// wrapping HashSet into ReadOnlyCollection
AllLanguages = new ReadonlyHashSet <string>(StringComparer.OrdinalIgnoreCase);
EALanguages = new ReadonlyHashSet <string>(StringComparer.OrdinalIgnoreCase);
BiDiLanguages = new ReadonlyHashSet <string>(StringComparer.OrdinalIgnoreCase);
CSLanguages = new ReadonlyHashSet <string>(StringComparer.OrdinalIgnoreCase);
}
public void ReadonlyHashSetCantChange()
{
var underTest = new ReadonlyHashSet<string>(new HashSet<string> { "a" });
Assert.Throws<NotSupportedException>(() => underTest.Remove("b"));
Assert.Throws<NotSupportedException>(() => underTest.Add("b"));
Assert.Throws<NotSupportedException>(() => underTest.Clear());
Assert.Throws<NotSupportedException>(() => underTest.ExceptWith(new HashSet<string> { "a" }));
Assert.Throws<NotSupportedException>(() => underTest.UnionWith(new HashSet<string> { "a" }));
Assert.Throws<NotSupportedException>(() => underTest.IntersectWith(new HashSet<string> { "a" }));
Assert.Throws<NotSupportedException>(() => underTest.SymmetricExceptWith(new HashSet<string> { "a" }));
}
private void checkSustainingPrimaryHovers(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapInteractionObjectStateChecks(
controllers: interactionControllers,
stateCheckFunc: (InteractionController maybeSustainedPrimaryHoveringController, out IInteractionBehaviour primaryHoveredObject) => {
return((maybeSustainedPrimaryHoveringController as IInternalInteractionController).CheckPrimaryHoverStay(out primaryHoveredObject));
},
actionPerInteractionObject: (primaryHoveredObject, primaryHoveringControllers) => {
primaryHoveredObject.StayPrimaryHovered(primaryHoveringControllers);
});
}
private void checkEndingGrasps(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapInteractionObjectStateChecks(
controllers: interactionControllers,
stateCheckFunc: (InteractionController maybeReleasingController, out IInteractionBehaviour maybeReleasedObject) => {
return((maybeReleasingController as IInternalInteractionController).CheckGraspEnd(out maybeReleasedObject));
},
actionPerInteractionObject: (releasedObject, releasingIntControllers) => {
releasedObject.EndGrasp(releasingIntControllers);
});
}
private void checkBeginningGrasps(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapInteractionObjectStateChecks(
controllers: interactionControllers,
stateCheckFunc: (InteractionController maybeBeganGraspingController, out IInteractionBehaviour graspedObject) => {
return((maybeBeganGraspingController as IInternalInteractionController).CheckGraspBegin(out graspedObject));
},
actionPerInteractionObject: (newlyGraspedObject, beganGraspingIntControllers) => {
newlyGraspedObject.BeginGrasp(beganGraspingIntControllers);
});
}
private void checkSustainingHovers(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapMultiInteractionObjectStateChecks(
controllers: interactionControllers,
multiObjectStateCheckFunc: (InteractionController maybeSustainedHoveringController, out HashSet <IInteractionBehaviour> hoveredObjects) => {
return((maybeSustainedHoveringController as IInternalInteractionController).CheckHoverStay(out hoveredObjects));
},
actionPerInteractionObject: (hoveredObject, hoveringIntControllers) => {
hoveredObject.StayHovered(hoveringIntControllers);
});
}
private void checkBeginningPrimaryHovers(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapInteractionObjectStateChecks(
controllers: interactionControllers,
stateCheckFunc: (InteractionController maybeBeganPrimaryHoveringController, out IInteractionBehaviour primaryHoveredObject) => {
return((maybeBeganPrimaryHoveringController as IInternalInteractionController).CheckPrimaryHoverBegin(out primaryHoveredObject));
},
actionPerInteractionObject: (newlyPrimaryHoveredObject, beganPrimaryHoveringControllers) => {
newlyPrimaryHoveredObject.BeginPrimaryHover(beganPrimaryHoveringControllers);
});
}
private void checkBeginningContacts(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapMultiInteractionObjectStateChecks(
controllers: interactionControllers,
multiObjectStateCheckFunc: (InteractionController maybeBeganContactingController, out HashSet <IInteractionBehaviour> beganContactedObjects) => {
return((maybeBeganContactingController as IInternalInteractionController).CheckContactBegin(out beganContactedObjects));
},
actionPerInteractionObject: (beganContactedObject, beganContactingIntControllers) => {
beganContactedObject.BeginContact(beganContactingIntControllers);
});
}
private void checkEndingPrimaryHovers(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapInteractionObjectStateChecks(
controllers: interactionControllers,
stateCheckFunc: (InteractionController maybeEndedPrimaryHoveringController, out IInteractionBehaviour endPrimaryHoveredObject) => {
return((maybeEndedPrimaryHoveringController as IInternalInteractionController).CheckPrimaryHoverEnd(out endPrimaryHoveredObject));
},
actionPerInteractionObject: (endPrimaryHoveredObject, noLongerPrimaryHoveringControllers) => {
endPrimaryHoveredObject.EndPrimaryHover(noLongerPrimaryHoveringControllers);
});
}
private void checkEndingHovers(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapMultiInteractionObjectStateChecks(
controllers: interactionControllers,
multiObjectStateCheckFunc: (InteractionController maybeEndedHoveringController, out HashSet <IInteractionBehaviour> endHoveredObjects) => {
return((maybeEndedHoveringController as IInternalInteractionController).CheckHoverEnd(out endHoveredObjects));
},
actionPerInteractionObject: (endHoveredObject, endHoveringIntControllers) => {
endHoveredObject.EndHover(endHoveringIntControllers);
});
}
private void checkSustainingContacts(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapMultiInteractionObjectStateChecks(
controllers: interactionControllers,
multiObjectStateCheckFunc: (InteractionController maybeSustainedContactingController, out HashSet <IInteractionBehaviour> contactedObjects) => {
return((maybeSustainedContactingController as IInternalInteractionController).CheckContactStay(out contactedObjects));
},
actionPerInteractionObject: (contactedObject, contactingIntControllers) => {
contactedObject.StayContacted(contactingIntControllers);
});
}
private void checkSustainingGrasps(ReadonlyHashSet <InteractionController> interactionControllers)
{
remapInteractionObjectStateChecks(
controllers: interactionControllers,
stateCheckFunc: (InteractionController maybeSustainedGraspingController, out IInteractionBehaviour graspedObject) => {
return((maybeSustainedGraspingController as IInternalInteractionController).CheckGraspHold(out graspedObject));
},
actionPerInteractionObject: (contactedObject, contactingIntControllers) => {
contactedObject.StayGrasped(contactingIntControllers);
});
}
private void StartToch()
{
ReadonlyHashSet <InteractionController> controllers = _intObj.contactingControllers;
foreach (var controller in controllers)
{
if (controller != currentController)
{
currentController = controller;
}
}
}
private void StartGrab()
{
ReadonlyHashSet <InteractionController> controllers = _intObj.contactingControllers;
foreach (var controller in controllers)
{
if (controller != currentController)
{
currentController = controller;
}
}
dragView.allowDragging = false;
}
private List <GameObject> GetValidDropTargets(ReadonlyHashSet <IInteractionBehaviour> set)
{
var output = new List <GameObject>();
foreach (var obj in set)
{
if (obj.gameObject == proxyNode.gameObject)
{
continue;
}
output.Add(obj.gameObject);
}
return(output);
}
private void StartGrab()
{
ReadonlyHashSet <InteractionController> controllers = _intObj.contactingControllers;
foreach (var controller in controllers)
{
if (controller != currentController)
{
currentController = controller;
}
}
rotateSphere.SetActive(true);
imageScale._allowScale = false;
}
public static InteractionController GetClosest(this ReadonlyHashSet <InteractionController> set, Vector3 pos, float offset = 0f)
{
float minDist = float.PositiveInfinity;
InteractionController closest = null;
foreach (var controller in set)
{
var dist = Mathf.Abs((controller.position - pos).magnitude - offset);
if (dist < minDist)
{
minDist = dist;
closest = controller;
}
}
return(closest);
}
/// <summary>
/// Cerberus.Executor needs to call this in order to initialize configuration settings based on the config it reads in.
/// This code needs to be maintained in order to be in sync with any changes to the configuration.
/// </summary>
/// <param name="config">Cerberus configuration object</param>
static internal void Initialize(CheckConfiguration config)
{
Func <string, IEnumerable <string> > GetLanguageGroup =
groupName =>
{
var group = config.GetTagLanguages(groupName);
if (!group.Any())
{
throw new InvalidOperationException(String.Format("Invalid Cerberus configuration: unknown language group: {0}", groupName));
}
return(group);
};
EALanguages = new ReadonlyHashSet <string>(GetLanguageGroup("East Asian"), StringComparer.OrdinalIgnoreCase);
BiDiLanguages = new ReadonlyHashSet <string>(GetLanguageGroup("Bidirectional"), StringComparer.OrdinalIgnoreCase);
AllLanguages = new ReadonlyHashSet <string>(config.GetAllLanguages(), StringComparer.OrdinalIgnoreCase);
}
public void ReadonlyHashSetCantChange()
{
var underTest = new ReadonlyHashSet <string>(new HashSet <string> {
"a"
});
Assert.Throws <NotSupportedException>(() => underTest.Remove("b"));
Assert.Throws <NotSupportedException>(() => underTest.Add("b"));
Assert.Throws <NotSupportedException>(() => underTest.Clear());
Assert.Throws <NotSupportedException>(() => underTest.ExceptWith(new HashSet <string> {
"a"
}));
Assert.Throws <NotSupportedException>(() => underTest.UnionWith(new HashSet <string> {
"a"
}));
Assert.Throws <NotSupportedException>(() => underTest.IntersectWith(new HashSet <string> {
"a"
}));
Assert.Throws <NotSupportedException>(() => underTest.SymmetricExceptWith(new HashSet <string> {
"a"
}));
}
public void ReadonlyHashSetCountEqualsSourceSetCount()
{
var underTest = new ReadonlyHashSet<string>(_sourceItems);
Assert.Equal(_sourceItems.Count, underTest.Count);
}
public SetProperty(byte propertyId, IEnumerable <T> propertyValue)
: base(propertyId)
{
_value = new ReadonlyHashSet <T>(propertyValue);
}
public SetProperty(byte propertyId, IEnumerable <T> propertyValue, IEqualityComparer <T> comparer)
: base(propertyId)
{
_value = new ReadonlyHashSet <T>(propertyValue, comparer);
}
public void ReadonlyHashSetCountEqualsSourceSetCount()
{
var underTest = new ReadonlyHashSet <string>(_sourceItems);
Assert.Equal(_sourceItems.Count, underTest.Count);
}
/// <summary>
/// Converts a ReadonlyHashSet object into a query operation, and returns a query
/// wrapper that wraps this new operation.
/// </summary>
public static QueryWrapper <T, EnumerableQueryOp <T, HashSet <T> .Enumerator> > Query <T>(this ReadonlyHashSet <T> hashSet)
{
return(new QueryWrapper <T, EnumerableQueryOp <T, HashSet <T> .Enumerator> >(new EnumerableQueryOp <T, HashSet <T> .Enumerator>(hashSet.GetEnumerator())));
}
