public FieldWrapper(Field field)
        {
            Sitecore.Diagnostics.Assert.ArgumentNotNull(field, "field");

            _modified = false;
            _field = field;
        }

        private void CustomizeCompomentForKeywordField(Component component)
        {
            component.Schema.RootElementName = "hasKeyword";
            Field headingField = new Field() { Name = "heading", Values = new List<string> { "some heading" } };

            FieldSet metadataFields = new FieldSet();
            metadataFields.Add(headingField.Name, headingField);


            Field keywordField = new Field()
            {
                Name = "keyword",
                KeywordValues = new List<Keyword>() 
                {
                    new Keyword()
                    {
                        MetadataFields = metadataFields,
                        Id = Randomizer.AnyUri(1024),
                        Title = Randomizer.AnyString(33),
                        Description = Randomizer.AnyString(33)
                    }                        
                }
            };
            component.Fields.Add(keywordField.Name, keywordField);
        }

        protected override void CustomFieldTypeValidation(AssertPair<FieldDefinition, Field> assert, Field spObject, FieldDefinition definition)
        {
            var typedObject = spObject.Context.CastTo<FieldLookup>(spObject);
            var typedDefinition = definition.WithAssertAndCast<LookupFieldDefinition>("model", value => value.RequireNotNull());

            // https://github.com/SubPointSolutions/spmeta2/issues/310
            // AllowMultipleValues - TRUE - LookupMulti
            // AllowMultipleValues - FALSE - Lookup
            assert.ShouldBeEqual((p, s, d) =>
            {
                var srcProp = s.GetExpressionValue(m => m.FieldType);
                var dstProp = d.GetExpressionValue(m => d.TypeAsString);

                var isValid = typedDefinition.AllowMultipleValues
                    ? typedObject.TypeAsString == "LookupMulti"
                    : typedObject.TypeAsString == "Lookup";

                return new PropertyValidationResult
                {
                    Tag = p.Tag,
                    Src = srcProp,
                    Dst = dstProp,
                    IsValid = isValid
                };
            });
        }

 /// <summary>
 /// Gets the nearest set ancestor that has the field with a value
 /// </summary>
 /// <param name="field">The field.</param>
 /// <returns></returns>
 private Item GetFallbackItem(Field field)
 {
     using (new SecurityDisabler())
     {
         return field.Item.Axes.GetAncestors().Where(ancestor => DoesItemHaveFieldWithValue(ancestor, field.ID, true)).LastOrDefault();
     }
 }

        public override bool VisitFieldDecl(Field field)
        {
            if (!VisitDeclaration(field))
                return false;

            var type = field.Type;

            Declaration decl;
            type.TryGetDeclaration(out decl);
            string msg = "internal";
            if (decl == null || (decl.GenerationKind != GenerationKind.Internal && !HasInvalidType(type, out msg)))
                return false;

            field.GenerationKind = GenerationKind.Internal;

            var @class = (Class)field.Namespace;

            var cppTypePrinter = new CppTypePrinter();
            var typeName = type.Visit(cppTypePrinter);

            Log.Debug("Field '{0}::{1}' was ignored due to {2} type '{3}'",
                @class.Name, field.Name, msg, typeName);

            return true;
        }

		private void Draw(Field field, FileInfo file)
		{
			var xMax = 10;
			var yMax = field.RowCount;

			var image = new Bitmap(xMax * BlockSize, yMax * BlockSize);

			for (var y = 0; y < yMax; y++)
			{
				var row = field[y];

				for (var x = 0; x < xMax; x++)
				{
					if ((Row.Flag[x] & row) != 0)
					{
						DrawPixel(image, x, y, Color.Red);
					}
					else
					{
						DrawPixel(image, x, y, Color.White);
					}
				}
			}
			image.Save(file.FullName, ImageFormat.Png);
		}

        public Fields Read(AbstractConnection connection, string process, string prefix, string name, string schema, bool isMaster = false) {
            var fields = new Fields();

            using (var cn = connection.GetConnection()) {
                cn.Open();
                var sql = PrepareSql();
                connection.Logger.EntityDebug(name, sql);

                var results = cn.Query(sql, new { name, schema });

                foreach (var result in results) {
                    var columnName = result.COLUMN_NAME;
                    var type = GetSystemType(result.DATA_TYPE);
                    var length = result.CHARACTER_MAXIMUM_LENGTH == "0" || result.CHARACTER_MAXIMUM_LENGTH == "-1" ? "64" : result.CHARACTER_MAXIMUM_LENGTH;
                    var fieldType = (bool)result.IS_PRIMARY_KEY ? (isMaster ? FieldType.MasterKey : FieldType.PrimaryKey) : FieldType.NonKey;
                    var field = new Field(type, length, fieldType, true, string.Empty) {
                        Name = columnName,
                        Entity = name,
                        Process = process,
                        Index = Convert.ToInt16(result.ORDINAL_POSITION - 1),
                        Schema = schema,
                        Input = true,
                        Precision = result.NUMERIC_PRECISION,
                        Scale = result.NUMERIC_SCALE,
                        Alias = prefix + columnName
                    };
                    fields.Add(field);
                }
            }

            return fields;
        }

        /// <summary>
        /// Gets the raw string (xml) from the broker db by URL
        /// </summary>
        /// <param name="Url">URL of the page</param>
        /// <returns>String with page xml or empty string if no page was found</returns>
        public string GetContentByUrl(string Url)
        {
            Page page = new Page();
            page.Title = Randomizer.AnyString(15);
            page.Id = Randomizer.AnyUri(64);
            page.Filename = Randomizer.AnySafeString(8) + ".html";

            PageTemplate pt = new PageTemplate();
            pt.Title = Randomizer.AnyString(20);
            Field ptfieldView = new Field();
            ptfieldView.Name = "view";
            ptfieldView.Values.Add("Standard");
            pt.MetadataFields = new FieldSet();
            pt.MetadataFields.Add(ptfieldView.Name, ptfieldView);

            page.PageTemplate = pt;

            page.ComponentPresentations = new List<ComponentPresentation>();

            string cpString = ComponentPresentationProvider.GetContent("");
            page.ComponentPresentations.Add(SerializerService.Deserialize<ComponentPresentation>(cpString));

            FieldSet metadataFields = new FieldSet();
            page.MetadataFields = metadataFields;

            return SerializerService.Serialize<Page>(page);
        }

        private object GetField(Field field)
        {
            if (_fields.ContainsKey(field))
                return _fields[field];

            return null;
        }

 public void BadBlockPlacementTest( int x, int y )
 {
     Field field = new Field( 2, 10 );
     IBlock block = new Block();
     block.Grid [ 2 ] [ 2 ] = Color.Tomato;
     field.SetBlock( block, new Point( x, y ) );
 }

 public PartialViewResult GetFilterView(Field targetField, string filterString)
 {
     FilterBag fb = FilterBag.createFromURLQuery(Request.QueryString.ToString());
     ViewBag.FilterString = fb.JsonEncode();
     ViewBag.inputID = Guid.NewGuid();
     return PartialView("_FilterEditPartial", targetField);
 }

 public void BadBigBlockPlacementTest( int x, int y )
 {
     Field field = new Field( 5, 10 );
     IBlock block = new Block();
     createBigBlock( block );
     field.SetBlock( block, new Point( x, y ) );
 }

 public HttpResponseMessage Post(HttpRequestMessage request, CreateFieldCommand command)
 {
     var repository = new FieldRepository();
     var field = new Field(command.Name, command.Description, command.DataType, command.FieldType);
     repository.AddField(field);
     return request.CreateResponse(HttpStatusCode.Created, new FieldViewModel(field));
 }

 public Batch(int id, double amountOfFruit, string team, double sellAbleAmount, Field field)
 {
     Id = id;
     AmountOfFruit = amountOfFruit;
     SellAbleAmount = sellAbleAmount;
     Field = field;
 }

 public void TestLevel3Description()
 {
     var field = new Field(3, 4, 1, 1, 'S');
     Assert.That(field.GetSequence(), Is.EqualTo(new[] {1, 5, 9, 10, 6, 2, 3, 7, 11, 12, 8, 4}));
     field = new Field(5, 2, 5, 2, 'N');
     Assert.That(field.GetSequence(), Is.EqualTo(new[] {10, 8, 6, 4, 2, 1, 3, 5, 7, 9}));
 }

		public Field[] GetMoves(Field field, bool IsRed)
		{
			var moves = new Field[7];

			var occupied = field.Occupied;

			for (var col = 0; col < 7; col++)
			{
				var test = (occupied >> col) & RowMask;
				var row = 0;

				switch (test)
				{
					case 0x000000000000: break;
					case 0x000000000001: row = 1; break;
					case 0x000000000101: row = 2; break;
					case 0x000000010101: row = 3; break;
					case 0x000001010101: row = 4; break;
					case 0x000101010101: row = 5; break;
					case 0x010101010101: row = 6; break;
					default: break;
				}
				if (row != 6)
				{
					var move = 1UL << ((row << 3) | col);
					moves[col] = IsRed ? field.MoveRed(move) : field.MoveYellow(move);
				}
			}
			return moves;
		}

        private object[] ConvertArguments(MethodInfo methodInfo, IRequest request, Field[] args)
        {
            var methodParams = methodInfo.GetParameters();

            if (methodParams.Length != args.Length)
                throw new InvalidOperationException();		// TODO: support the case of the Unbounded parameters

            var values = new object[args.Length];
            for (int i = 0; i < args.Length; i++) {
                var paramType = methodParams[i].ParameterType;
                if ((paramType == typeof (ISession) ||
                    paramType == typeof(IRequest) ||
                    paramType == typeof(IQuery)) &&
                    i > 0)
                        throw new InvalidOperationException("The request parameter must be the first in method signature.");

                object arg;

                if (paramType == typeof (ISession)) {
                    arg = request.Query.Session;
                } else if (paramType == typeof (IQuery)) {
                    arg = request.Query;
                } else if (paramType == typeof(IRequest)) {
                    arg = request.CreateBlock();
                } else {
                    var sqlType = PrimitiveTypes.FromType(paramType);
                    arg = sqlType.ConvertTo(args[i].Value, paramType);
                }

                values[i] = arg;
            }

            return values;
        }

 public FieldViewModel(Field field)
 {
     Name = field.Name;
     Description = field.Description;
     DataType = field.DataType;
     FieldType = field.FieldType;
 }

    public MenuInGame(FSM parentFsm, UIManager2 panel1, UIManager2 panel2)
        : base(parentFsm, panel1, panel2, "MenuInGame.fsm")
    {
        timeClient = TimeManager.Instance.Create();

        InitUI();

        int stageId = (int)parentFsm.Variables["stageId"];

        /*
        // ddong
        if (stageId < 2000)
        {
            stageId += 2000;
        }
        */

        InitStage(stageId, out stageEntity, out gameEntity);

        Rect fieldArea = UI.GetFieldArea();
        field = CreateField(stageEntity, fieldArea, timeClient, fsm);

        // ddong
        int subClassCode = 11;
        int level = 1;
        int trainLevel = 1;

        this.subClassEntity = TableLoader.GetTable<SubClassEntity>().Get(subClassCode);
        ClassLevelEntity levelEntity = TableLoader.GetTable<ClassLevelEntity>().Get(subClassEntity.classCode, level);
        TrainLevelEntity trainLevelEntity = TableLoader.GetTable<TrainLevelEntity>().Get(subClassEntity.classCode, trainLevel);
        FieldObjectEntity objectField = TableLoader.GetTable<FieldObjectEntity>().Get(subClassEntity.objectCode);

        Rect puzzleArea = UI.GetPuzzleArea();
        CreatePuzzle(puzzleArea, timeClient, subClassCode, out puzzleRecord, out puzzlePanel);

        user = CreateUser(stageEntity, UI, fsm);
        heroCharacter = CreateCharacter(objectField, levelEntity, trainLevelEntity, subClassEntity, user, puzzlePanel, itemDropManager, UI.AddBuffIcon, UI.RemoveBuffIcon, fsm);
        itemDropManager = new ConsumableSpawn(stageEntity.gameModeCode, levelEntity.consumableTier);

        Func<float> getLifeDrainRate = (() => gameEntity.defaultHP);
        new PlayerCharacter(user, heroCharacter, getLifeDrainRate, fsm);
        /*
        heroCharacter.Status.RegisterOnChangeEvent(HeroCharacter.Character.HP, OnCharacterHPChanged);
        heroCharacter.Status.RegisterOnChangeEvent(HeroCharacter.Character.HP, UI.ChangeHP);
        heroCharacter.Status.RegisterOnChangeEvent(HeroCharacter.Character.MP, UI.ChangeMana);
        heroCharacter.Status.RegisterOnChangeEvent(HeroCharacter.Character.Armor, UI.ChangeShield);
        */

        UI.InitCommendSlots(fsm, heroCharacter);

        field.AddPlayerCharacter(heroCharacter);
        field.FocusOnForced(heroCharacter, 0);
        puzzlePanel.SetQueue(user.commandQueue);

        var screenPosTable = TableLoader.GetTable<ScreenPositionEntity2>();
        var hpToPos = screenPosTable.Values.Select(x => new KeyValuePair<float, float>(x.hp, x.screenPos));
        convertHPRatioToScreenPos = new RangeConvertor(hpToPos).Convert;

        SetFocusTarget(heroCharacter);
    }

        public FileInformation Read(FileInfo fileInfo) {

            var fileInformation = new FileInformation(fileInfo);
            var names = new List<string>();

            var stream = System.IO.File.Open(fileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            var isXml = fileInfo.Extension.Equals(".xlsx", StringComparison.OrdinalIgnoreCase);

            var excelReader = isXml ? ExcelReaderFactory.CreateOpenXmlReader(stream) : ExcelReaderFactory.CreateBinaryReader(stream);
            excelReader.Read();
            for (var i = 0; i < excelReader.FieldCount; i++) {
                var name = excelReader.GetString(i);
                if (name != null)
                    names.Add(name);
            }

            excelReader.Close();
            foreach (var name in names) {
                var field = new Field("string", _request.DefaultLength, FieldType.NonKey, true, string.Empty) {
                    Name = name
                };
                fileInformation.Fields.Add(field);
            }

            return fileInformation;
        }