/// <summary>
/// Removes a transition type
/// </summary>
/// <param name="type"></param>
private void RemovePriorityMapping(TransitionRequest type, bool remapPrioritesToLinear = true)
{
requestPriorityMapping.Remove(type);
if (remapPrioritesToLinear)
{
RemapTransitionRequestPriority();
}
}
public Transition(TransitionRequest request, uint nextState, MovementState state)
{
if (state != null)
{
stateBelongingTo = state;
}
this.Type = request;
NextStateID = nextState;
}
/// <summary>
/// makes a prioriticed request, either from mapping
/// or if request unmapped it gets the lowest possible priority (less then the least prioriticed mapped request)
/// </summary>
/// <param name="request">the request we want to get the priority for</param>
/// <returns>a prioriticed transition request</returns>
public PriorityTransitionRequest GetPriorityTransitionRequest(TransitionRequest request)
{
//TODO couple request type with priority
if (requestPriorityMapping.ContainsKey(request))
{
return(new PriorityTransitionRequest(request, requestPriorityMapping[request]));
}
return(new PriorityTransitionRequest(request, minPriorityValue));
}
/// <summary>
/// swaps the priority values of two request types
/// </summary>
/// <param name="req1">first type</param>
/// <param name="req2">second type</param>
public void SwapPriority(TransitionRequest req1, TransitionRequest req2)
{
if (requestPriorityMapping.ContainsKey(req1) && requestPriorityMapping.ContainsKey(req2))
{
int valueReq1 = requestPriorityMapping[req1];
requestPriorityMapping[req1] = requestPriorityMapping[req2];
requestPriorityMapping[req2] = valueReq1;
}
}
/// <summary>
/// informs state machine of state change request
/// </summary>
/// <param name="request">the transition request type</param>
public void RequestStateChange(TransitionRequest request)
{
var tra = CheckTransitionRequest(request);
if (tra != null)
{
StateMachine.EnqueRequestStateChange(GetPriorityTransitionRequest(request), tra);
}
}
public TransitionOutPoint(EditorStateNode node, NodeLayout layout, TransitionRequest requestType, float buttonSize = 5f)
{
this.layout = layout;
this.Node = node ?? throw new ArgumentNullException(nameof(node));
Transition = null;
Type = requestType;
this.buttonSize = buttonSize;
var info = Type.GetInfo();
toolTip = info != null ? info.DisplayName : Type.GetType().Name;
}
/// <summary>
/// removes transition based on request type
/// </summary>
/// <param name="type">the type of transition to remove</param>
/// <returns>if it could be removed or not</returns>
public bool RemoveTransition(TransitionRequest type)
{
for (int i = transitions.Count - 1; i >= 0; i--)
{
if (transitions[i].Type.IsSameRequest(type))
{
transitions.RemoveAt(i);
return(true);
}
}
return(false);
}
public void RemapTransitionRequestPriority()
{
minPriorityValue = 0;
requestPriorityMapping.Clear();
var list = GetPossibleTransitionRequests();
for (int i = 0; i < list.Count; i++)
{
TransitionRequest req = list[i];
AddPriorityRequest(req, i);
}
}
/// <summary>
/// adds a new priority request mapping
/// </summary>
/// <param name="request">the new request</param>
/// <param name="value">the new priority value</param>
/// <param name="updateIfExisting">if true already existing value is updated</param>
public void AddPriorityRequest(TransitionRequest request, int value, bool updateIfExisting = true)
{
bool change = false;
if (!requestPriorityMapping.ContainsKey(request))
{
//Add new
change = true;
requestPriorityMapping.Add(request, value);
}
else if (updateIfExisting)
{
change = true;
requestPriorityMapping[request] = value;
}
if (change && value >= minPriorityValue)
{
minPriorityValue = value + 1;
}
}
private static TransitionRequest PushTransitionRequest(GrammarVocabulary transition, PredictionTreeBranch path, bool usePrevious, bool isReduction)
{
var fKey = Tuple.Create(usePrevious, isReduction);
lock (transitionRequests)
{
List <TransitionRequest> resultSet;
if (!transitionRequests.TryGetValue(fKey, transition, path, out resultSet))
{
transitionRequests.Add(fKey, transition, path, resultSet = new List <TransitionRequest>());
}
lock (resultSet)
{
TransitionRequest result = resultSet.FirstOrDefault(p => p.DeviationDetail.SequenceEqual(path.deviations));
if (result == null)
{
resultSet.Add(result = new TransitionRequest(transition, path, usePrevious, isReduction));
}
return(result);
}
}
}
public async Task <bool> PerformTransition(string issueKey, string transitionId)
{
HttpResponseMessage response = null;
var requestUrl = string.Format("{0}issue/{1}/transitions", App.BaseUrl, issueKey);
var transitionRequest = new TransitionRequest
{
Transition = new Transition {
Id = transitionId
}
};
var data = JsonConvert.SerializeObject(transitionRequest);
try
{
response = await httpManager.PostAsync(requestUrl, data, true, App.UserName, App.Password);
response.EnsureSuccessStatusCode();
}
catch (Exception exception)
{
var extras = BugSenseHandler.Instance.CrashExtraData;
extras.Add(new CrashExtraData
{
Key = "Method",
Value = "JiraService.PerformTransition"
});
BugSenseHandler.Instance.LogException(exception, extras);
}
// ReSharper disable once PossibleNullReferenceException
if (response.StatusCode == HttpStatusCode.NoContent)
{
return(true);
}
return(false);
}
internal void RemoveTransitionsForNodeOfType(EditorStateNode editorStateNode, Type[] types)
{
TransitionRequest[] requestTypes = new TransitionRequest[types.Length];
for (int i = 0; i < types.Length; i++)
{
requestTypes[i] = TransitionRequest.Factory.BuildRequest(types[i]);
}
for (int i = Transitions.Count - 1; i >= 0; i--)
{
var tran = transitions[i].Transition;
if (tran.StateBelongingToID == editorStateNode.ID)
{
//this transition belongs to this node
//check if we have a type in our list same as this transition
if (requestTypes.Any(t => t.IsSameRequest(tran.Type)))
{
transitions.RemoveAt(i);
}
}
}
}
public TransitionOutPoint GetTransitionOutPoint(TransitionRequest request)
{
return(outPoints.Find(p => p.Type.IsSameRequest(request)));
}
public PriorityTransitionRequest(TransitionRequest type, int priority) : this()
{
Type = type ?? throw new ArgumentNullException(nameof(type));
Priority = priority;
}
/// <summary>
/// chekc if they are the same type
/// </summary>
/// <param name="req">the request to check against</param>
/// <returns>ture if same type</returns>
public virtual bool IsSameRequest(TransitionRequest req)
{
return(this.GetType() == req.GetType());
}
/// <summary>
/// checks if this state has a transition correponding to this request
/// </summary>
/// <param name="request">the request type</param>
/// <returns>the transition if the state has one, null otherwise</returns>
public Transition CheckTransitionRequest(TransitionRequest request)
{
return(transitions.Find(tra => tra.CheckRequest(request)));
}
/// <summary>
/// enquues a request in the state machiene queue
/// </summary>
/// <param name="request">the request being enqueued</param>
void Enqueue(TransitionRequest request)
{
machine.CurrentState.RequestStateChange(request);
}
/// <summary>
/// informs handler of state change request
/// </summary>
/// <param name="request">the request that is being made</param>
protected void RequestStateChange(TransitionRequest request)
{
handler.RequestStateChange(request);
}
/// <summary>
/// requests state change from movement state
/// </summary>
/// <param name="request">the request being made</param>
public void RequestStateChange(TransitionRequest request)
{
stateBelongingToo.RequestStateChange(request);
}
public Transition(TransitionRequest requestType, uint nextState, uint stateID, MovementStateMachine machine)
{
this.stateBelongingTo = machine.GetStateByID(stateID);
this.Type = requestType;
NextStateID = nextState;
}
public override bool IsSameRequest(TransitionRequest req)
{
return(false);
}
/// <summary>
/// checks if this transition rquest is represented by this transition
/// </summary>
/// <param name="request">the type of request made</param>
/// <returns>true if Type is same request as Reqeust</returns>
public bool CheckRequest(TransitionRequest request)
{
return(Type.IsSameRequest(request));
}
