public AnalysisResult Analyze(CommonSyntaxTree tree, SemanticModel model, ClassInfo classInfo)
        {
            //TODO: Refactor this whole method later and make it more robust

            if (classInfo.GuardedFields.Count <= 1)
            {
                return AnalysisResult.Succeeded;
            }

            foreach (GuardedFieldInfo first in classInfo.GuardedFields)
            {
                foreach (GuardedFieldInfo second in classInfo.GuardedFields)
                {
                    if (first == second)
                    {
                        continue;
                    }

                    if (LockHierarchy.Conflicts(first.DeclaredLockHierarchy, second.DeclaredLockHierarchy))
                    {
                        return new AnalysisResult(new Issue(
                            ErrorCode.GUARDED_FIELD_LOCK_HIERARCHY_DECLARATION_CONFLICT,
                            second.Declaration,
                            second.Symbol));
                    }
                }
            }

            return AnalysisResult.Succeeded;
        }

 public GetFieldRunnable(IClassRepository repository, ClassInfo classInfo, Instruction instruction, BlockDecomposer block)
 {
     this.repository = repository;
     this.classInfo = classInfo;
     this.instruction = instruction;
     this.block = block;
 }

 public void AddClass(ClassInfo classInfo)
 {
     _rapidAccessForClassesByName.Add(classInfo.UnderlyingType, classInfo);
     _existingClasses.Add(classInfo.UnderlyingType);
     _rapidAccessForClassesByOid.Add(classInfo.ClassInfoId, classInfo);
     _allClassInfos.Add(classInfo);
 }

 public void AddClass(ClassInfo classInfo)
 {
     if (!classes.Contains(classInfo.Name))
     {
         classes.Add(classInfo.Name, classInfo);
     }
 }

        public ClassInfo GetClassInfo(ClassDeclarationSyntax classDeclaration)
        {
            _walker.Visit(classDeclaration);

            ClassInfo classInfo = new ClassInfo(classDeclaration, _semanticModel, _semanticModel.GetDeclaredSymbol(classDeclaration));

            classInfo.Locks.AddRange(_walker.Locks);
            classInfo.GuardedFields.AddRange(_walker.GuardedFields);
            classInfo.Members.AddRange(_walker.Members);

            foreach (LockInfo lockInfo in classInfo.Locks)
            {
                lockInfo.Parent = classInfo;
            }

            foreach (GuardedFieldInfo fieldInfo in classInfo.GuardedFields)
            {
                fieldInfo.Parent = classInfo;
            }

            foreach (MemberInfo memberInfo in classInfo.Members)
            {
                memberInfo.Parent = classInfo;
            }

            return classInfo;
        }

 private bool TryGetClass(ModuleDefinition module, string className, out ClassInfo clazz)
 {
     var visitor = new ModuleInfoVisitor(this, className);
     module.Accept(visitor);
     clazz = visitor.GetClassInfo();
     return clazz != null;
 }

        //public FieldVisitor(ClassInfo classInfo, string name, string descriptor, string signature, object value, 
        //    bool isFinal, bool isStatic, bool isPrivate)
        //{
        //    Type type = ClrType.FromDescriptor(descriptor);

        //    classInfo.AddField(new FieldInfo(classInfo, name, type, isFinal, isStatic, isPrivate));
        //}

        public FieldVisitor(ClassInfo classInfo, FieldDefinition fieldDefinition)
        {
            //classInfo.AddField();
            //Type type = ClrType.FromName(fieldDefinition.FieldType.FullName);
            Type type = ClrType.FromDescriptor(fieldDefinition.FieldType.FullName);
            classInfo.AddField(new FieldInfo(classInfo, fieldDefinition.Name, type, false, fieldDefinition.IsStatic, fieldDefinition.IsPrivate));
        }

        public IList<TeacherClass> Fill(ClassInfo classInfo)
        {
            if (classInfo == null)
            {
                return null;
            }

            IList<Core.Business.TeacherClass> teacherClasslist = new List<Core.Business.TeacherClass>();

            SqlServerUtility sql = new SqlServerUtility();

            sql.AddParameter("@ClassCode", SqlDbType.NVarChar, classInfo.ClassCode, 30);

            SqlDataReader reader = sql.ExecuteSqlReader(SqlFillTeacherClassByClassInfo);

            if (reader != null)
            {
                while (reader.Read())
                {
                    Core.Business.TeacherClass teacherClass = new Core.Business.TeacherClass();

                    if (!reader.IsDBNull(0)) teacherClass.Id = reader.GetInt32(0);
                    if (!reader.IsDBNull(1)) teacherClass.TeacherCode = reader.GetString(1);
                    if (!reader.IsDBNull(2)) teacherClass.ClassCode = reader.GetString(2);
                    if (!reader.IsDBNull(3)) teacherClass.IsState = reader.GetBoolean(3);

                    teacherClass.MarkOld();
                    teacherClasslist.Add(teacherClass);
                }
                reader.Close();
            }
            return teacherClasslist;
        }

        private Issue AnalyzeMember(MemberInfo memberInfo, SemanticModel model, ClassInfo classInfo)
        {
            foreach (BlockSyntax block in memberInfo.Blocks)
            {
                var identifiers = block.DescendantNodes().OfType<IdentifierNameSyntax>().ToList();

                foreach (IdentifierNameSyntax identifierName in identifiers)
                {
                    SymbolInfo identifierSymbol = model.GetSymbolInfo(identifierName);

                    //Does this symbol refer to a GuardedField?
                    GuardedFieldInfo foundGuardedField = classInfo.GuardedFields.FirstOrDefault(field => field.Symbol == identifierSymbol.Symbol);

                    if (foundGuardedField != null)
                    {
                        //We must be inside a lock statement
                        LockHierarchy controlFlowHierarchy = CreateLockHiearchyFromIdentifier(identifierName);

                        bool lockHierarchySatisfied = LockHierarchy.IsSatisfiedBy(foundGuardedField.DeclaredLockHierarchy, controlFlowHierarchy);

                        if (!lockHierarchySatisfied)
                        {
                            return new Issue(
                                ErrorCode.GUARDED_FIELD_ACCESSED_OUTSIDE_OF_LOCK,
                                identifierName,
                                identifierSymbol.Symbol);
                        }
                    }
                }
            }

            return null;
        }

 public MethodNotFoundException(ClassInfo classInfo, string methodName)
     : base("Method '" + methodName + "' not found in class '"
            + classInfo.Name + "'")
 {
     this.MethodName = methodName;
     this.ClassInfo = classInfo;
 }

        public Class Parse(String json, String className)
        {
            Class result = new Class(AccessModifier.Public, className);

            var oo = JsonConvert.DeserializeObject(json);
            var c = new ClassInfo(className);
            if (oo is JArray)
            {
                foreach (var jo in (JArray)oo)
                {
                    if (jo is JObject)
                    {
                        SetProperties(c, (JObject)jo);
                    }
                    else if (jo is JValue)
                    {
                        var pi = new PropertyInfo();
                        pi.Validate(jo);
                        return new Class(AccessModifier.Public, pi.GetCSharpTypeName());
                    }
                }
            }
            else if (oo is JObject)
            {
                SetProperties(c, (JObject)oo);
            }
            SetProperties(result, c);

            return result;
        }

 /// <summary>Constructor.</summary>
 /// <param name="classInfo">The test-class that this method is a member of.</param>
 /// <param name="name">The name of the method.</param>
 public MethodInfo(ClassInfo classInfo, string name)
 {
     this.classInfo = classInfo;
     this.name = name;
     displayName = FormatName(name);
     isSpecial = MethodHelper.IsSpecial(Name);
 }

        /// <summary>Constructor.</summary>
        /// <param name="classInfo">The test-class this node represents.</param>
        public ClassListItem(ClassInfo classInfo)
        {
            // Setup initial conditions.
            this.classInfo = classInfo;

            // Set default values.
            Text = classInfo.DisplayName;
        }

 /**
    * Computing the ClassCost for a ClassInfo involves tallying up all the MethodCosts contained
    * in the class. Then an overall cost is calculated, based on the {@code CostModel} the metric
    * computer is using.
    *
    * @param clazz to compute the metric for.
    * @return classCost
    */
 public ClassCost compute(ClassInfo clazz)
 {
     IList<MethodCost> methods = new ArrayList<MethodCost>();
     foreach (MethodInfo method in clazz.GetMethods())
     {
         methods.Add(compute(method));
     }
     return new ClassCost(clazz.Name, methods);
 }

 public FieldInfo(string fieldName, ClassInfo fieldClass, bool isPrimitive, bool isArray
     , bool isNArray)
 {
     _fieldName = fieldName;
     _fieldClass = fieldClass;
     _isPrimitive = isPrimitive;
     _isArray = isArray;
     _isNArray = isNArray;
 }

 public static List<Account> GetAccounts(
     string name,
     int gender,
     string bloodType,
     int birthYear,
     int birthMonth,
     int birthDate,
     City hometownCity,
     Province homwtownProvince,
     City resideCity,
     Province resideProvince,
     ClassInfo classInfo,
     Grade grade,
     Major major,
     College college,
     University university,
     string code,
     bool? hasAvatar,
     string nickName,
     bool? isProtected,
     int minViewCount,
     int maxViewCount,
     bool? isPublic,
     int minYear,
     int maxYear,
     string interest,
     PagingInfo pagingInfo)
 {
     return provider.GetAccounts(
         name,
         gender,
         bloodType,
         birthYear,
         birthMonth,
         birthDate,
         hometownCity,
         homwtownProvince,
         resideCity,
         resideProvince,
         classInfo,
         grade,
         major,
         college,
         university,
         code,
         hasAvatar,
         nickName,
         isProtected,
         minViewCount,
         maxViewCount,
         isPublic,
         minYear,
         maxYear,
         interest,
         pagingInfo);
 }

 public ChangedObjectInfo(ClassInfo oldCi, ClassInfo newCi, int fieldIndex, AbstractObjectInfo oldValue,
                          AbstractObjectInfo newValue, string message, int objectRecursionLevel)
 {
     _oldCi = oldCi;
     _newCi = newCi;
     _fieldIndex = fieldIndex;
     _oldValue = oldValue;
     _newValue = newValue;
     _message = message;
     _objectRecursionLevel = objectRecursionLevel;
 }

        private void CheckClass(IDictionary<Type, ClassInfo> currentCIs, ClassInfo persistedCI)
        {
            var currentCI = currentCIs[persistedCI.UnderlyingType];
            var classInfoCompareResult = persistedCI.ExtractDifferences(currentCI, true);

            if (!classInfoCompareResult.IsCompatible())
                throw new OdbRuntimeException(NDatabaseError.IncompatibleMetamodel.AddParameter(currentCI.ToString()));

            if (classInfoCompareResult.HasCompatibleChanges())
                _results.Add(classInfoCompareResult);
        }

        public NonNativeObjectInfo(ObjectInfoHeader oip, ClassInfo classInfo) : base(null)
        {
            _classInfo = classInfo;
            _objectHeader = oip;

            if (classInfo != null)
            {
                _maxNbattributes = classInfo.MaxAttributeId;
                _attributeValues = new AbstractObjectInfo[_maxNbattributes];
            }
        }

    public void UpdateScore()
    {
        //checks for score things, sets them to black
        bool hasAPlus = false;
        ClassInfo[] plusCubes = new ClassInfo[]{grid[0,0]}; // or it throws an error
        int rowAt = 1;
        int colAt = 1;
        //for all center columns
        while (colAt != yMax-1 && hasAPlus == false) {
            //check for a +
            while (rowAt != xMax-1) {
                if (grid [rowAt - 1, colAt].IsColor () && grid [rowAt, colAt].IsColor () && grid [rowAt + 1, colAt].IsColor ()
                    && grid [rowAt, colAt + 1].IsColor () && grid [rowAt, colAt - 1].IsColor ()) {
                    hasAPlus = true;
                    plusCubes = new ClassInfo[]{grid [rowAt - 1, colAt], grid [rowAt, colAt], grid [rowAt + 1, colAt], grid [rowAt, colAt + 1], grid [rowAt, colAt - 1]};
                }
                if (grid [rowAt, colAt - 1].IsColor () && grid [rowAt, colAt].IsColor () && grid [rowAt, colAt + 1].IsColor ()
                    && grid [rowAt + 1, colAt].IsColor () && grid [rowAt - 1, colAt].IsColor ()) {
                    hasAPlus = true;
                    plusCubes = new ClassInfo[]{grid [rowAt, colAt - 1], grid [rowAt, colAt], grid [rowAt, colAt + 1], grid [rowAt + 1, colAt], grid [rowAt - 1, colAt]};
                }
                rowAt++;
            }
            colAt++;
            rowAt = 1;
        }

        if (hasAPlus) {
            Color baseColor = plusCubes[0].GetColor ();
            if(plusCubes[1].GetColor ()==baseColor && plusCubes[2].GetColor ()==baseColor && plusCubes[3].GetColor ()==baseColor && plusCubes[4].GetColor ()==baseColor){
                score = score + plusScoreOne;
                int changingAt=0;
                while(changingAt < 5){
                    plusCubes[changingAt].SetColor(Color.black);
                    changingAt++;
                }
            }
            else{if(
                    (plusCubes[1].GetColor () != baseColor && plusCubes[2].GetColor () != baseColor && plusCubes[3].GetColor () != baseColor && plusCubes[4].GetColor () != baseColor)
                    && (plusCubes[2].GetColor () != plusCubes[1].GetColor () && plusCubes[3].GetColor () != plusCubes[1].GetColor () && plusCubes[4].GetColor () != plusCubes[1].GetColor ())
                    && (plusCubes[3].GetColor () != plusCubes[2].GetColor () && plusCubes[4].GetColor () != plusCubes[2].GetColor ())
                    && (plusCubes[4].GetColor () != plusCubes[3].GetColor ())
                 ){
                    score = score + plusScoreMany;
                    int changingAt=0;
                    while(changingAt < 5){
                        plusCubes[changingAt].SetColor(Color.gray);
                        changingAt++;
                    }
                }
            }//if all diffrent colors
        }
    }