public void UpdateStep(ProgramStep step)
{
using (var dbContextScope = DbContextScopeFactory.Create())
{
_programStepRepositor.Update(step);
dbContextScope.SaveChanges();
}
}
static void Main(string[] args)
{
ProgramStep myProgramStep = new ProgramStep();
bool programActive = true;
List <ProgramStep> nextSteps = new List <ProgramStep>();
while (programActive)
{
switch (myProgramStep)
{
case ProgramStep.init:
nextSteps.Clear();
Console.WriteLine("Welcome to IPchanger2000!");
nextSteps.Add(ProgramStep.chooseNetworkAdapter);
nextSteps.Add(ProgramStep.End);
break;
case ProgramStep.chooseNetworkAdapter:
nextSteps.Clear();
Console.WriteLine("Choosing the network adapter...");
WMIQuery_NetworkAdapter();
nextSteps.Add(ProgramStep.selectConfiguration);
nextSteps.Add(ProgramStep.End);
break;
case ProgramStep.selectConfiguration:
nextSteps.Clear();
Console.WriteLine("Selecting desired configuration...");
nextSteps.Add(ProgramStep.applyConfiguration);
nextSteps.Add(ProgramStep.End);
break;
case ProgramStep.applyConfiguration:
nextSteps.Clear();
Console.WriteLine("Applying choosen configuration...");
nextSteps.Add(ProgramStep.End);
break;
case ProgramStep.End:
Console.WriteLine("Goodbye");
programActive = false;
break;
default:
break;
}
myProgramStep = CaseSelector(nextSteps, myProgramStep);
}
}
public static ProgramStep CaseSelector(List <ProgramStep> stepChoices, ProgramStep currentStep)
{
if (currentStep != ProgramStep.End)
{
Console.WriteLine();
Console.WriteLine("What is the next step?");
foreach (int step in stepChoices)
{
Console.WriteLine("[{0}] - {1}", step, Enum.GetName(typeof(ProgramStep), step));
}
Console.Write("Your choice: ");
int i = Int32.Parse(Console.ReadLine());
return((ProgramStep)i);
}
return(ProgramStep.End);
}
public void UpdateStep(ProgramStepDto step)
{
if (step == null)
{
var fault = new ArgumentFault
{
Message = "Argumnet is null",
ArgumentName = nameof(step)
};
throw new FaultException <ArgumentFault>(fault);
}
ProgramStep stepEntity = Mapper.Map <ProgramStep>(step);
_robotProgramBusinessLogic.UpdateStep(stepEntity);
}
public void AddStep(ProgramStepDto step)
{
// TODO: null-possibility should rather be checked in Buisness logic, and here just try-catch-toFaultConv
if (step == null)
{
var fault = new ArgumentFault
{
Message = "Argumnet is null",
ArgumentName = nameof(step)
};
throw new FaultException <ArgumentFault>(fault);
}
ProgramStep stepEntity = Mapper.Map <ProgramStep>(step);
_robotProgramBusinessLogic.AddStep(stepEntity);
}
private void search(
ProgramStepVertex parentVertex,
IEnumerator instructions)
{
ProgramStepVertex jv = null;
ProgramStepVertex cv = parentVertex;
while (instructions.MoveNext())
{
// add vertex to graph
ProgramStep i = (ProgramStep)instructions.Current;
ControlFlow f = i.Operation.Flow;
// avoid certain instructions
if (f == ControlFlow.Phi ||
f == ControlFlow.Meta)
{
continue;
}
ProgramStepVertex iv = vertexFromOffset((uint)i.Offset);
if (cv != null)
{
graph.AddEdge(cv, iv);
}
// find how to handle the rest
switch (f)
{
case ControlFlow.Next:
cv = iv;
break;
case ControlFlow.Call:
cv = iv;
break;
case ControlFlow.Return:
cv = null;
break;
case ControlFlow.Throw:
cv = null;
break;
case ControlFlow.ConditionalBranch:
if (i.Operation.StringName == "switch")
{
foreach (int target in (int[])i.Operand)
{
jv = vertexFromOffset((uint)target);
graph.AddEdge(iv, jv);
search(iv, instructions);
}
cv = iv;
}
else
{
sbyte targetOffset = (System.SByte)iv.Instruction.Operand;
jv = vertexFromOffset((uint)targetOffset + 3);
graph.AddEdge(iv, jv);
cv = iv;
}
break;
case ControlFlow.Branch:
if (i.Operation.StringName.StartsWith("brtrue") ||
i.Operation.StringName.StartsWith("brfalse")
)
{
// add jump to offset
sbyte targetOffset = (System.SByte)iv.Instruction.Operand;
jv = vertexFromOffset((uint)targetOffset + 3);
if (jv == null)
{
throw new VertexNotFoundException("Could not find vertex");
}
graph.AddEdge(iv, jv);
cv = null;
break;
}
break;
case ControlFlow.Break:
// add jump to offset
jv = vertexFromOffset((uint)iv.Instruction.Offset);
graph.AddEdge(iv, jv);
cv = null;
break;
}
}
}
protected Hashtable GetExceptionMarks()
{
Hashtable retVal = new Hashtable();
ProgramStepCollection ps = this.mTargetMethod.DataFlow;
int cilStart = 0;
ArrayList methodExceptions = null;
if (ps != null && ps.Count > 0)
{
for (int i = 0; i < ps.Count; i++)
{
ProgramStep p = ps[i];
if (p.Operation.Flow == ControlFlow.Throw)
{
// Mark it.
if (retVal.ContainsKey(cilStart) == true)
{
methodExceptions = (ArrayList)retVal[cilStart];
}
else
{
methodExceptions = new ArrayList();
retVal.Add(cilStart, methodExceptions);
}
// Find out what the exception is.
if (p.Stacks != null && p.Stacks.Count > 0)
{
StackPossible currentStack = (StackPossible)p.Stacks[0];
if (currentStack.Elements != null && currentStack.Elements.Count > 0)
{
StackElement exOnStack = (StackElement)currentStack.Elements.Peek();
Type exType = Type.GetType(exOnStack.TypeName, false, false);
if (exType != null)
{
methodExceptions.Add(exType);
}
}
}
}
else if (p.Operation.Flow == ControlFlow.Call)
{
if (p.RawOperand is uint && ((uint)p.RawOperand > 0)) // It should be!
{
MethodBase rGetMethod = typeof(Method).GetMethod(
"GetMethod", BindingFlags.NonPublic | BindingFlags.Static);
Method mCalled = (Method)rGetMethod.Invoke(null, new object[] { this.mTargetMethod.AssemblyName,
this.mTargetMethod.ModuleName, (uint)p.RawOperand });
if (mCalled != null)
{
MethodBase mCalledBase = mCalled.MethodBase;
if (mCalledBase != null)
{
// Check to see if it's been flagged with
// [Throws]
object[] throwsAttribs = mCalledBase.GetCustomAttributes(
typeof(ThrowsAttribute), true);
if (throwsAttribs != null &&
throwsAttribs.Length > 0)
{
if (retVal.ContainsKey(cilStart) == true)
{
methodExceptions = (ArrayList)retVal[cilStart];
}
else
{
methodExceptions = new ArrayList();
retVal.Add(cilStart, methodExceptions);
}
foreach (ThrowsAttribute throws in throwsAttribs)
{
methodExceptions.Add(throws.ExceptionType);
}
}
}
}
}
}
cilStart += p.Length;
}
}
return(retVal);
}
static void Main(string[] args)
{
Building building = new Building(20, new Lift(400, 5));
Passenger passenger = new Passenger("Nurtas", 80);
var error = false;
while (SwitchON)
{
switch (ProgramStatus)
{
case ProgramStep.StarProgram:
if (!building.CheckAvailableLift())
{
building.Lift.LiftMove(1, "down");
Console.WriteLine("Lift arrived");
}
ProgramStatus = ProgramStep.EnterPassengers;
continue;
case ProgramStep.EnterPassengers:
building.Lift.isClosed = false;
if (building.Lift.Passengers.Count == 0)
{
passenger.EnterInLift(building.Lift, passenger);
}
Console.WriteLine("Add one more passenger ? Yes/No");
var answer = Console.ReadLine().ToLower();
if (answer == "yes")
{
Console.WriteLine("Enter the name");
var name = Console.ReadLine();
Console.WriteLine("Enter the weight");
var weight = Convert.ToInt32(Console.ReadLine());
passenger.EnterInLift(building.Lift, new Passenger(name, weight));
}
else if (answer == "no")
{
ProgramStatus = ProgramStep.SelectFloor;
building.Lift.isClosed = true;
}
continue;
case ProgramStep.SelectFloor:
if (building.Lift.isClosed)
{
foreach (var person in building.Lift.Passengers)
{
Console.WriteLine($"Select the floor for {person.Name} (between 1 and {building.NumberOfFloors})");
var selectedFloor = Convert.ToInt32(Console.ReadLine());
if (selectedFloor > building.NumberOfFloors)
{
Console.WriteLine("Wrong value");
error = true;
ProgramStatus = ProgramStep.SelectFloor;
break;
}
else
{
passenger.SelectFloor(selectedFloor, person);
ProgramStatus = !error ? ProgramStep.DeliverPassengers : ProgramStep.SelectFloor;
}
}
}
continue;
case ProgramStep.DeliverPassengers:
var maxFloor = building.Lift.Passengers.Max(p => p.SelectedFloor);
building.Lift.LiftMove(maxFloor, "up");
ProgramStatus = ProgramStep.CloseProgram;
break;
case ProgramStep.CloseProgram:
SwitchON = false;
break;
}
}
}
