protected ClassSymbol(ClassType type)
 {
     ClassType = type;
     Block = new ProgramContext();
     AppendChild(Block);
     IsInitialize = true;
 }

 public Class(CompilationUnit cu, ClassType t, Modifier m, IRegion region)
 {
     this.cu = cu;
     classType = t;
     this.region = region;
     modifiers = (ModifierEnum)m;
 }

        // define event:
        // !StreetChanged(string street, string houseNo)
        // define command:
        // ?ChangeStreet(Guid addressId, string street, string houseNo)
        public void Parse(string line)
        {
            switch (line[0])
            {
                case '?': this.ClassType = ClassType.Event; break;
                case '!': this.ClassType = ClassType.Command; break;
                case '#': this.ClassType = ClassType.Handler; break;
                default: throw new NotSupportedException(string.Format("Line start [{0}] is not supported.", line[0]));
            }

            line = line.Substring(1);

            int index = line.IndexOf('(');
            this.Name = line.Substring(0, index);
            line = line.Substring(index + 1).Trim(new[] {'(', ')'});

            while (line.Length > 0)
            {
                index = line.IndexOf(',');
                if (index < 0)
                {
                    index = line.Length;
                }

                string prop = line.Substring(0, index).Trim();
                PropertyToGenerate propertyToGenerate = new PropertyToGenerate();
                propertyToGenerate.Parse(prop);
                this.Properties.Add(propertyToGenerate);

                if (index + 1 < line.Length)
                    line = line.Substring(index + 1);
                else
                    break;
            }
        }

 public CycleYear(int year, CycleCode cycleCode, ClassType classType)
     : this()
 {
     Year = year;
     CycleCode = cycleCode;
     ClassType = classType;
 }

 public AirlinerClass(ClassType type, int seatingCapacity)
 {
     this.Type = type;
     this.SeatingCapacity = seatingCapacity;
     this.RegularSeatingCapacity = seatingCapacity;
     this.Facilities = new Dictionary<AirlinerFacility.FacilityType, AirlinerFacility>();
 }

 private static void AssignClassSkills(CharacterBase character, ClassType type)
 {
     switch (type)
     {
         case ClassType.Bard:
             AssignBardSkills(character);
             break;
         case ClassType.Berserker:
             AssignBerserkerSkills(character);
             break;
         case ClassType.Crusader:
             AssignCrusaderSkills(character);
             break;
         case ClassType.Elementalist:
             AssignElementalistSkills(character);
             break;
         case ClassType.Monk:
             AssignMonkSkills(character);
             break;
         case ClassType.Priest:
             AssignPriestSkills(character);
             break;
         case ClassType.Ranger:
             AssignRangerSkills(character);
             break;
         case ClassType.Rogue:
             AssignRogueSkills(character);
             break;
     }
 }

 public ClassProxy(IClass c)
 {
     this.FullyQualifiedName  = c.FullyQualifiedName;
     this.Documentation       = c.Documentation;
     this.modifiers           = c.Modifiers;
     this.classType           = c.ClassType;
 }

 public static int GetPrice(DateTime classDate, ClassType classType)
 {
     int calculatedPrice = int.MaxValue;
     int basePrice = 0;
     int salePrice = 0;
     switch (classType)
     {
         case ClassType.PMP:
             calculatedPrice = basePrice = pmpCost;
             salePrice = pmpCostSale;
             break;
         case ClassType.CAPM:
             calculatedPrice = basePrice = capmCost;
             salePrice = capmCostSale;
             break;
         case ClassType.SixSigmaGreenBelt:
             calculatedPrice = basePrice = l6giCost;
             salePrice = l6giCostSale;
             break;
         case ClassType.SixSigmaBlackBelt:
             calculatedPrice = basePrice = l6biCost;
             salePrice = l6biCostSale;
             break;
     }
     if (salePrice >= 0)
         calculatedPrice = salePrice;
     if (classDate > DateTime.Now.AddDays(earlyBirdDuration))
     {
         calculatedPrice -= earlyBirdDiscountAmount;
     }
     if (calculatedPrice < basePrice)
         return calculatedPrice;
     else
         return basePrice;
 }

        public ClassBlock(string name, ClassType type)
        {
            Name = name;
            Type = type;

            _fields = new List<Field>();
            _methods = new List<Method>();
        }

 public CharacterClass(ClassType classType, int level, IClassModifier modifier)
 {
     ClassType = classType;
     Level = level;
     Modifier = modifier;
     Saves = new ClassSaves(modifier.FortitudeSaveType, modifier.ReflexSaveType, modifier.WillSaveType, Level);
     Attack = new Attack(_attackBonusses[modifier.AttackBonusType], level);
 }

 public FigureToolboxItemNode(string name, ClassType classType, bool isAbstract, Gdk.Pixbuf icon)
     : base()
 {
     is_abstract = isAbstract;
     _classType = classType;
     Name = name;
     Icon = icon;
 }

 public Book(ClassType _t, int _pages, int _pict, int _tables, int _len)
 {
     this.pages = _pages;
     this.type = _t;
     this.pictures = _pict;
     this.tables = _tables;
     this.length = _len;
     //this.signs = new Dictionary<int, int>();
 }

 /// <summary>
 /// Creates a new character and levels it up to the given level
 /// </summary>
 public static ICharacter CreateCharacter(Race race, ClassType classType, int level, Dictionary<AbilityType, int> abilityScores)
 {
     var character = CreateCharacter(race, classType, abilityScores);
     character.Experience.AddLevels(level);
     while (character.Experience.CanLevel) {
         character.LevelUp(classType);
     }
     return character;
 }

 public GameDataObject(string name, string description, ClassType classType)
 {
     Name = name;
     Description = description;
     ClassType = classType;
     BaseClasses = new List<string>();
     Behaviours = new List<Behaviour>();
     Properties = new List<Property>();
     InOuts = new List<IO>();
 }

 public ClassDeclaration(TextPosition tp, string name, ClassType type, TupleLiteral attr, TupleLiteral generic, TupleLiteral inherit, ProgramContext block)
     : base(tp, name, type, block)
 {
     AttributeAccess = attr;
     DecGenerics = generic;
     InheritAccess = inherit;
     AppendChild(AttributeAccess);
     AppendChild(DecGenerics);
     AppendChild(InheritAccess);
 }

        public void ShouldInvokeClassMethodWhenInvokingMethodBaseOfInterface()
        {
            var classType = new ClassType ();

            classType.Called.Should ().BeFalse ();

            var methodBase = typeof(IInterfaceType).GetMethod("Method");
            methodBase.Invoke (classType, new object[0]);

            classType.Called.Should ().BeTrue ();
        }

 public Character(string name, ClassType classType, int age, int hp, int strength, int agility, int intelligence, int gold)
 {
     Name = name;
     Class = classType;
     Age = age;
     MaxHP = hp;
     HP = hp;
     Strength = strength;
     Agility = agility;
     Intelligence = intelligence;
     Gold = gold;
 }

 protected int GradeCount(ClassType ct)
 {
     switch (ct)
     {
         case ClassType.九年一贯制:
             return 9;
         case ClassType.小学:
             return 6;
         default:
             return 3;
     }
 }

 public void EnumFlagTester(ClassType enumFlagArg)
 {
     switch (enumFlagArg)
     {
         case ClassType.DataStructure:
             Console.WriteLine("ds");
             break;
         case ClassType.Hybrid:
             Console.WriteLine("hyb");
             break;
     }
 }

        public DefaultCharacter(Race race, ClassType classType, Dictionary<AbilityType, int> abilityScores, IModifierProvider modifierProvider)
            : this(modifierProvider)
        {
            Race = race;
            InitializeProperties();
            _abilities = new CharacterAbilities(abilityScores);

            var characterClass = ClassProvider.GetNewClass(classType, _modifierProvider);
            Classes.Add(classType, characterClass);
            // Once all the properties are set, OnCreation can be called, which will process all modifiers for this character/class/race
            OnCreation(classType);
        }