private void AnalyzeParameter(SymbolAnalysisContext context, [NotNull] SymbolAnalyzerFactory factory,
                                      [NotNull] ImmutableDictionary <string, string> properties)
        {
            ParameterAnalyzer analyzer = factory.GetParameterAnalyzer(context);

            analyzer.Analyze(ruleForParameter, properties);
        }
Esempio n. 2
0
        /// <summary>
        /// This will check with some analyzers if it's possible to rename a member def { TypeDef, PropertyDef, MethodDef, EventDef, FieldDef, Parameter (NOT DEF) }.
        /// </summary>
        /// <param name="obj">The determinate to check.</param>
        /// <returns>If the determinate can be renamed.</returns>
        public static bool CanRename(object obj)
        {
            DefAnalyzer analyze;

            if (obj is MethodDef)
            {
                analyze = new MethodDefAnalyzer();
            }
            else if (obj is PropertyDef)
            {
                analyze = new PropertyDefAnalyzer();
            }
            else if (obj is EventDef)
            {
                analyze = new EventDefAnalyzer();
            }
            else if (obj is FieldDef)
            {
                analyze = new FieldDefAnalyzer();
            }
            else if (obj is Parameter)
            {
                analyze = new ParameterAnalyzer();
            }
            else
            {
                return(false);
            }
            return(analyze.Execute(obj));
        }
Esempio n. 3
0
 private void AnalyzeParameter(SymbolAnalysisContext context, [NotNull] SymbolAnalyzerFactory factory,
                               [NotNull] ImmutableDictionary <string, string> properties)
 {
     // Bug workaround for https://github.com/dotnet/roslyn/issues/16209
     if (context.Symbol != null)
     {
         ParameterAnalyzer analyzer = factory.GetParameterAnalyzer(context);
         analyzer.Analyze(ruleForParameter, properties);
     }
 }
        public async Task <IList <AnswerRecordPresenter> > BuildAnswerRecordPresenterList(int?assignmentRecordID)
        {
            var answerRecordList = await _arDbContext.AnswserRecords.ToListAsync();

            if (assignmentRecordID != null)
            {
                answerRecordList = answerRecordList.Where(ar => ar.AssignmentRecordID == assignmentRecordID).ToList();
            }

            var answerRecordPresenterCollection = new List <AnswerRecordPresenter>();

            foreach (var answerRecord in answerRecordList)
            {
                var answerRecordPresenter = Mapper.Map <AnswerRecord, AnswerRecordPresenter>(answerRecord);

                var movementCollection = await _arDbContext.Movements.Where(m => m.AnswerRecordID == answerRecord.ID).ToListAsync();

                // Parameter Analyze
                answerRecordPresenter.DDIntervalAVG        = ParameterAnalyzer.CalculateDDIntervalAVG(movementCollection);
                answerRecordPresenter.DDIntervalMAX        = ParameterAnalyzer.CalculateDDIntervalMAX(movementCollection);
                answerRecordPresenter.DDIntervalMIN        = ParameterAnalyzer.CalculateDDIntervalMIN(movementCollection);
                answerRecordPresenter.DDProcessAVG         = ParameterAnalyzer.CalculateDDProcessAVG(movementCollection);
                answerRecordPresenter.DDProcessMAX         = ParameterAnalyzer.CalculateDDProcessMAX(movementCollection);
                answerRecordPresenter.DDProcessMIN         = ParameterAnalyzer.CalculateDDProcessMIN(movementCollection);
                answerRecordPresenter.TotalDistance        = ParameterAnalyzer.CalculateTotalDistance(movementCollection);
                answerRecordPresenter.DDSpeedAVG           = ParameterAnalyzer.CalculateDDSpeedAVG(movementCollection);
                answerRecordPresenter.DDSpeedMAX           = ParameterAnalyzer.CalculateDDSpeedMAX(movementCollection);
                answerRecordPresenter.DDSpeedMIN           = ParameterAnalyzer.CalculateDDSpeedMIN(movementCollection);
                answerRecordPresenter.DDFirstTime          = ParameterAnalyzer.CalculateDDFirstTime(movementCollection);
                answerRecordPresenter.DDCount              = ParameterAnalyzer.CalculateDDCount(movementCollection);
                answerRecordPresenter.UTurnHorizontalCount = ParameterAnalyzer.CalculateUTurnHorizontalCount(movementCollection);
                answerRecordPresenter.UTurnVerticalCount   = ParameterAnalyzer.CalculateUTurnVerticalCount(movementCollection);

                answerRecordPresenterCollection.Add(answerRecordPresenter);
            }

            return(answerRecordPresenterCollection);
        }
        public async Task <IActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var answerRecord = await _arDbContext.AnswserRecords.SingleOrDefaultAsync(q => q.ID == id);

            if (answerRecord == null)
            {
                return(NotFound());
            }

            var vm = Mapper.Map <AnswerRecord, AnswerRecordManageDetailsViewModel>(answerRecord);

            var splitConfusionElement = answerRecord.ConfusionElement.Split('#');
            var splitDivision         = answerRecord.Division.Split('|');
            var sortedWordCollection  = new List <string>();

            foreach (var confusionElement in splitConfusionElement)
            {
                if (confusionElement != "")
                {
                    sortedWordCollection.Add(splitDivision[Convert.ToInt32(confusionElement)]);
                }
            }
            vm.ConfusionWordString = StringConverter.ConvertToSingleString(sortedWordCollection, ",");

            var movementCollection = await _arDbContext.Movements.Where(m => m.AnswerRecordID == answerRecord.ID).ToListAsync();

            var deviceAccelerationCollection = await _arDbContext.DeviceAccelerations.Where(da => da.AnswerRecordID == answerRecord.ID).ToListAsync();

            // supervise process
            var movementSupervisor           = new MovementSupervisor(movementCollection, deviceAccelerationCollection);
            var movementSupervisedCollection = movementSupervisor.SuperviseByAcceleration();

            vm.MovementCollection           = movementCollection;
            vm.DeviceAccelerationCollection = deviceAccelerationCollection;

            // Parameter Analyze
            vm.DDIntervalAVG        = ParameterAnalyzer.CalculateDDIntervalAVG(movementCollection);
            vm.DDIntervalMAX        = ParameterAnalyzer.CalculateDDIntervalMAX(movementCollection);
            vm.DDIntervalMIN        = ParameterAnalyzer.CalculateDDIntervalMIN(movementCollection);
            vm.DDProcessAVG         = ParameterAnalyzer.CalculateDDProcessAVG(movementCollection);
            vm.DDProcessMAX         = ParameterAnalyzer.CalculateDDProcessMAX(movementCollection);
            vm.DDProcessMIN         = ParameterAnalyzer.CalculateDDProcessMIN(movementCollection);
            vm.TotalDistance        = ParameterAnalyzer.CalculateTotalDistance(movementCollection);
            vm.DDSpeedAVG           = ParameterAnalyzer.CalculateDDSpeedAVG(movementCollection);
            vm.DDSpeedMAX           = ParameterAnalyzer.CalculateDDSpeedMAX(movementCollection);
            vm.DDSpeedMIN           = ParameterAnalyzer.CalculateDDSpeedMIN(movementCollection);
            vm.DDFirstTime          = ParameterAnalyzer.CalculateDDFirstTime(movementCollection);
            vm.DDCount              = ParameterAnalyzer.CalculateDDCount(movementCollection);
            vm.UTurnHorizontalCount = ParameterAnalyzer.CalculateUTurnHorizontalCount(movementCollection);
            vm.UTurnVerticalCount   = ParameterAnalyzer.CalculateUTurnVerticalCount(movementCollection);

            // ParameterFixed Analyze
            vm.DDProcessAVGFixed         = ParameterAnalyzerForMovementSupervised.CalculateDDProcessAVG(movementSupervisedCollection);
            vm.DDProcessMAXFixed         = ParameterAnalyzerForMovementSupervised.CalculateDDProcessMAX(movementSupervisedCollection);
            vm.DDProcessMINFixed         = ParameterAnalyzerForMovementSupervised.CalculateDDProcessMIN(movementSupervisedCollection);
            vm.TotalDistanceFixed        = ParameterAnalyzerForMovementSupervised.CalculateTotalDistance(movementSupervisedCollection);
            vm.DDSpeedAVGFixed           = ParameterAnalyzerForMovementSupervised.CalculateDDSpeedAVG(movementSupervisedCollection);
            vm.DDSpeedMAXFixed           = ParameterAnalyzerForMovementSupervised.CalculateDDSpeedMAX(movementSupervisedCollection);
            vm.DDSpeedMINFixed           = ParameterAnalyzerForMovementSupervised.CalculateDDSpeedMIN(movementSupervisedCollection);
            vm.UTurnHorizontalCountFixed = ParameterAnalyzerForMovementSupervised.CalculateUTurnHorizontalCount(movementSupervisedCollection);
            vm.UTurnVerticalCountFixed   = ParameterAnalyzerForMovementSupervised.CalculateUTurnVerticalCount(movementSupervisedCollection);

            //
            var experimentStatistician = new ExperimentStatistician();

            vm.Precision = experimentStatistician.CalculatePrecision(movementSupervisedCollection);
            vm.Recall    = experimentStatistician.CalculateRecall(movementSupervisedCollection);
            vm.FMeasure  = experimentStatistician.CalculateFMeasure(movementSupervisedCollection);

            return(View(vm));
        }
Esempio n. 6
0
        public async Task <IActionResult> Details(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var assignmentRecord = await _arDbContext.AssignmentRecords.SingleOrDefaultAsync(ar => ar.ID == id);

            if (assignmentRecord == null)
            {
                return(NotFound());
            }

            var vm = Mapper.Map <AssignmentRecord, AssignmentRecordManageDetailsViewModel>(assignmentRecord);

            vm.Username     = (await _userManager.FindByIdAsync(assignmentRecord.UserID)).UserName;
            vm.ExerciseName = (await _arDbContext.Exercises.FindAsync(assignmentRecord.ExerciseID)).Name;

            var sortedQuestions = (from q in _arDbContext.Questions
                                   join eqc in _arDbContext.ExerciseQuestionRelationMap on q.ID equals eqc.QuestionID
                                   where eqc.ExerciseID == assignmentRecord.ExerciseID
                                   orderby eqc.SerialNumber ascending
                                   select q).ToList();

            vm.CurrentProgress = String.Format("{0}/{1}", assignmentRecord.CurrentQuestionIndex, sortedQuestions.Count);

            // Get AnswerRecordPresenterCollection
            var answerRecordList = await _arDbContext.AnswserRecords.Where(ar => ar.AssignmentRecordID == assignmentRecord.ID).ToListAsync();

            var answerRecordPresenterCollection = new List <AnswerRecordPresenter>();

            foreach (var answerRecord in answerRecordList)
            {
                var answerRecordPresenter = Mapper.Map <AnswerRecord, AnswerRecordPresenter>(answerRecord);

                var movementCollection = await _arDbContext.Movements.Where(m => m.AnswerRecordID == answerRecord.ID).ToListAsync();

                // Parameter Analyze
                answerRecordPresenter.DDIntervalAVG        = ParameterAnalyzer.CalculateDDIntervalAVG(movementCollection);
                answerRecordPresenter.DDIntervalMAX        = ParameterAnalyzer.CalculateDDIntervalMAX(movementCollection);
                answerRecordPresenter.DDIntervalMIN        = ParameterAnalyzer.CalculateDDIntervalMIN(movementCollection);
                answerRecordPresenter.DDProcessAVG         = ParameterAnalyzer.CalculateDDProcessAVG(movementCollection);
                answerRecordPresenter.DDProcessMAX         = ParameterAnalyzer.CalculateDDProcessMAX(movementCollection);
                answerRecordPresenter.DDProcessMIN         = ParameterAnalyzer.CalculateDDProcessMIN(movementCollection);
                answerRecordPresenter.TotalDistance        = ParameterAnalyzer.CalculateTotalDistance(movementCollection);
                answerRecordPresenter.DDSpeedAVG           = ParameterAnalyzer.CalculateDDSpeedAVG(movementCollection);
                answerRecordPresenter.DDSpeedMAX           = ParameterAnalyzer.CalculateDDSpeedMAX(movementCollection);
                answerRecordPresenter.DDSpeedMIN           = ParameterAnalyzer.CalculateDDSpeedMIN(movementCollection);
                answerRecordPresenter.DDFirstTime          = ParameterAnalyzer.CalculateDDFirstTime(movementCollection);
                answerRecordPresenter.DDCount              = ParameterAnalyzer.CalculateDDCount(movementCollection);
                answerRecordPresenter.UTurnHorizontalCount = ParameterAnalyzer.CalculateUTurnHorizontalCount(movementCollection);
                answerRecordPresenter.UTurnVerticalCount   = ParameterAnalyzer.CalculateUTurnVerticalCount(movementCollection);

                answerRecordPresenterCollection.Add(answerRecordPresenter);
            }

            vm.AnswerRecordPresenterCollection = answerRecordPresenterCollection;

            return(View(vm));
        }
Esempio n. 7
0
 private IParameterType getResult(string parameter, IParameterStyle style = null)
 {
     return(style == null?ParameterAnalyzer.analyze(parameter) :
                ParameterAnalyzer.analyze(parameter, style));
 }