private void OnEnable()
 {
     this.dataProvider = base.GetComponent <ListDataProvider>();
     this.dataProvider ??= base.gameObject.AddComponent <DefaultListDataProvider>();
     this.dataProvider.DataChanged += new Action <ListDataProvider>(this.UpdateBounds);
     this.UpdateBounds(this.dataProvider);
 }
Example #2
0
        public override async Task <DbDataReader> ExecuteAsync(CancellationToken cancellationToken = default)
        {
            var provider         = new ListDataProvider();
            var tableDescription = await Context.GetTableDescriptionAsync(QueryInfo.TableName, cancellationToken);

            provider.AddColumn("IndexType", typeof(string));
            provider.AddColumn("IndexArn", typeof(string));
            provider.AddColumn("IndexName", typeof(string));
            provider.AddColumn("IndexSizeBytes", typeof(long));
            provider.AddColumn("ItemCount", typeof(long));
            provider.AddColumn("HashKeyName", typeof(string));
            provider.AddColumn("SortKeyName", typeof(string));
            provider.AddColumn("ProjectionType", typeof(string));
            provider.AddColumn("NonKeyAttributes", typeof(string));

            foreach (var localIndex in tableDescription.LocalSecondaryIndexes)
            {
                var hashKeyName = localIndex.KeySchema.First(schema => schema.KeyType == KeyType.HASH).AttributeName;
                var sortKeyName = localIndex.KeySchema.FirstOrDefault(schema => schema.KeyType == KeyType.RANGE)?.AttributeName;

                provider.AddRow(
                    "LOCAL",
                    localIndex.IndexArn,
                    localIndex.IndexName,
                    localIndex.IndexSizeBytes,
                    localIndex.ItemCount,
                    hashKeyName,
                    sortKeyName,
                    localIndex.Projection.ProjectionType.Value,
                    string.Join(", ", localIndex.Projection.NonKeyAttributes)
                    );
            }

            foreach (var globalIndex in tableDescription.GlobalSecondaryIndexes)
            {
                var hashKeyName = globalIndex.KeySchema.First(schema => schema.KeyType == KeyType.HASH).AttributeName;
                var sortKeyName = globalIndex.KeySchema.FirstOrDefault(schema => schema.KeyType == KeyType.RANGE)?.AttributeName;

                provider.AddRow(
                    "GLOBAL",
                    globalIndex.IndexArn,
                    globalIndex.IndexName,
                    globalIndex.IndexSizeBytes,
                    globalIndex.ItemCount,
                    hashKeyName,
                    sortKeyName,
                    globalIndex.Projection.ProjectionType.Value,
                    string.Join(", ", globalIndex.Projection.NonKeyAttributes)
                    );
            }

            return(new PrimarSqlDataReader(provider));
        }
Example #3
0
        public override async Task <DbDataReader> ExecuteAsync(CancellationToken cancellationToken = default)
        {
            var response = await Context.Client.ListTablesAsync(cancellationToken);

            var provider = new ListDataProvider();

            provider.AddColumn("name", typeof(string));

            foreach (string tableName in response.TableNames)
            {
                provider.AddRow(tableName);
            }

            return(new PrimarSqlDataReader(provider));
        }
Example #4
0
        public override async Task <DbDataReader> ExecuteAsync(CancellationToken cancellationToken = default)
        {
            var provider = new ListDataProvider();
            var response = await Context.Client.DescribeEndpointsAsync(new DescribeEndpointsRequest(), cancellationToken);

            provider.AddColumn("Address", typeof(string));
            provider.AddColumn("CachePeriodInMinutes", typeof(long));

            foreach (var endpoint in response.Endpoints)
            {
                provider.AddRow(endpoint.Address, endpoint.CachePeriodInMinutes);
            }

            return(new PrimarSqlDataReader(provider));
        }
 private void UpdateBounds(ListDataProvider provider)
 {
     this.UpdateSize();
     if (provider.Selected != null)
     {
         this.ScrollToSelection();
         this.Layout();
         foreach (ListItem item in this.generatedItems)
         {
             if (item.Data == provider.Selected)
             {
                 item.Select(false);
                 break;
             }
         }
     }
 }
Example #6
0
        public override async Task <DbDataReader> ExecuteAsync(CancellationToken cancellationToken = default)
        {
            var provider = new ListDataProvider();
            var response = await Context.Client.DescribeLimitsAsync(new DescribeLimitsRequest(), cancellationToken);

            provider.AddColumn("TableMaxReadCapacityUnits", typeof(long));
            provider.AddColumn("TableMaxWriteCapacityUnits", typeof(long));
            provider.AddColumn("AccountMaxReadCapacityUnits", typeof(long));
            provider.AddColumn("AccountMaxWriteCapacityUnits", typeof(long));

            provider.AddRow(
                response.TableMaxReadCapacityUnits,
                response.TableMaxWriteCapacityUnits,
                response.AccountMaxReadCapacityUnits,
                response.AccountMaxWriteCapacityUnits
                );

            return(new PrimarSqlDataReader(provider));
        }
        public static void Test()
        {
            NLua.Lua state = new NLua.Lua();

            NLua.Lua state2 = new NLua.Lua();

            someData sd = new someData();

            sd.ID = 25;
            sd.sList.AddRange(new String[] { "this", " is", " a", " test", " list" });
            luaData ld = new luaData(sd);


            //var test = state.DoString("return 10 + 3*(5 + 2)")[0];
            //var type = test.GetType();

            //int value = 6;
            //state["test"] = value;
            //var result = state.DoString("return test*3+(test-3)")[0];

            //state.DoString(@"
            // function ScriptFunc (val1, val2)
            //     val1=val1+2
            //     val2=val2+3
            //     return val1, val2
            //  end");

            //var scriptFunc = state["ScriptFunc"] as NLua.LuaFunction;
            //var res = scriptFunc.Call(3, 5);

            testClass tc = new testClass("Some test string here");

            tc.list.Add(25);
            state["provision"] = "Random piece of information";



            testClass tc2 = new testClass("Indirect summon");

            tc2.data = ld;
            tc2.ProvideInfoToLua(state);
            //state["testObj"] = tc;

            state.LoadCLRPackage();
            // state.DoString(@" import ('The betrayer', 'TBAGW.Utilities')
            //   import ('System.Web')
            //    import ('System')");

            // var testStringFromObject = state.DoString("return TestObject.testList[0]")[0];
            // var elementType = testStringFromObject.GetType();
            // testClass testObjFromLUA = state.DoString("return TestObject")[0] as testClass;
            //bool bWhat = testObjFromLUA.GetType() == tc.GetType();

            state.DoString("print(\"Hello World\")");

            System.Windows.Forms.OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog();
            ofd.Filter           = "LUA files (*.lua)|*.lua";
            ofd.InitialDirectory = Game1.rootContent;
            if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                state = new NLua.Lua();
                state.LoadCLRPackage();
                state.DoFile(ofd.FileName);
                var time = System.IO.File.GetLastWriteTime(ofd.FileName);
            }
            //var statsTest = ((state["generateSomeStats"] as NLua.LuaFunction).Call()[0] as LuaStatEdit).ExtractStatChart();

            //BaseSprite bs = new BaseSprite();
            //bs.position = new Vector2(136, 2556);
            //if (Scenes.Editor.MapBuilder.loadedMap != null)
            //{
            //    bs.UpdatePosition();
            //}
            // List<List<Object>> luaStuff = new List<List<object>>();
            //var ttt = (state["save"] as NLua.LuaFunction).Call()[0].GetType();
            (state["save"] as NLua.LuaFunction).Call();
            var st = LuaSaveData.getGlobalData("My Collection", "luaStuff");

            (state["loadProcess"] as NLua.LuaFunction).Call();
            //var dabdab = ((state["getShapeData"] as NLua.LuaFunction).Call(bs));
            //  NLua.LuaFunction savedFunction = state["e1.Test"] as NLua.LuaFunction;
            uic = ((state["createUI"] as NLua.LuaFunction).Call()[0] as LuaUICollection).ConvertFromLua(state);
            goto skip;
            var luaRect = ShapeAnimation.animFromLuaInfo(((state["generateAnimation"] as NLua.LuaFunction).Call()[0] as LuaShapeAnimationInfo));
            var resldo  = (state["returnLuaSpecificData"] as NLua.LuaFunction).Call()[0];

            NLua.LuaTable lt = (state["returnLuaSpecificData"] as NLua.LuaFunction).Call()[0] as NLua.LuaTable;
            (state["GenerateSomeStuff"] as NLua.LuaFunction).Call();
            ListDataProvider.setLuaData(state);
            (state["publicStaticCall"] as NLua.LuaFunction).Call();
            (state["internalStaticCall"] as NLua.LuaFunction).Call();
            state["testObj"] = tc;
            var ele2                     = (state["attempt"] as NLua.LuaFunction).Call()[0];
            var returnedData             = (state["returnData"] as NLua.LuaFunction).Call()[0];
            var oldProvision             = state["provision"];
            var value2                   = state["testObj.i"];
            var function                 = state["MyFunc"] as NLua.LuaFunction;
            var funcRes                  = function.Call(state["testObj.i"])[0];
            var tableResult              = (state["returnTable"] as NLua.LuaFunction).Call()[0];
            var bCompare1                = tableResult.GetType() == typeof(NLua.LuaTable);
            var tableToList              = LUAUtilities.LUATableToListUtility(typeof(testClass), tableResult as NLua.LuaTable).Cast <testClass>().ToList();
            var tableToListGenericObject = LUAUtilities.LUATableToListUtility(typeof(testClass), tableResult as NLua.LuaTable);
            var listType                 = tableToList.GetType();
            var listTypeGO               = tableToListGenericObject.GetType();



            state = new NLua.Lua();
            state.LoadCLRPackage();
            state.DoFile(ofd.FileName);
            List <testClass> tcl = new List <testClass>();

            tcl.Add(new testClass(""));
            tcl.Last().i = 25;
            tcl.Add(new testClass(""));
            tcl.Last().i = 0;
            tcl.Add(new testClass(""));
            tcl.Last().i = 10;
            foreach (var item in tcl)
            {
                (state["setStuff"] as NLua.LuaFunction).Call(item);
            }

            tcl = LUAUtilities.LUATableToListUtility(typeof(testClass), (state["doStuff"] as NLua.LuaFunction).Call()[0] as NLua.LuaTable).Cast <testClass>().ToList();
            skip : { }
            bDoTest = false;
        }
Example #8
0
        public override async Task <DbDataReader> ExecuteAsync(CancellationToken cancellationToken = default)
        {
            var provider         = new ListDataProvider();
            var tableDescription = await Context.GetTableDescriptionAsync(QueryInfo.TableName, cancellationToken);

            List <KeySchemaElement>    keySchema            = tableDescription.KeySchema;
            List <AttributeDefinition> attributeDefinitions = tableDescription.AttributeDefinitions;

            var hashKeyName = keySchema
                              .First(schema => schema.KeyType == KeyType.HASH)
                              .AttributeName;

            var sortKeyName = keySchema
                              .FirstOrDefault(schema => schema.KeyType == KeyType.RANGE)?
                              .AttributeName;

            var hashKeyType = attributeDefinitions
                              .First(definition => definition.AttributeName == hashKeyName)
                              .AttributeType
                              .Value;

            var sortKeyType = attributeDefinitions
                              .FirstOrDefault(definition => definition.AttributeName == sortKeyName)?
                              .AttributeType
                              .Value;

            provider.AddColumn("TableArn", typeof(string));
            provider.AddColumn("TableId", typeof(string));
            provider.AddColumn("TableName", typeof(string));
            provider.AddColumn("TableSizeBytes", typeof(long));
            provider.AddColumn("TableStatus", typeof(string));
            provider.AddColumn("LocalIndexCount", typeof(long));
            provider.AddColumn("GlobalIndexCount", typeof(long));
            provider.AddColumn("ItemCount", typeof(long));
            provider.AddColumn("CreationDateTime", typeof(DateTime));
            provider.AddColumn("HashKeyName", typeof(string));
            provider.AddColumn("HashKeyType", typeof(string));
            provider.AddColumn("SortKeyName", typeof(string));
            provider.AddColumn("SortKeyType", typeof(string));
            provider.AddColumn("BillingMode", typeof(string));
            provider.AddColumn("LastUpdateToPayPerRequestDateTime", typeof(DateTime));

            provider.AddRow(
                tableDescription.TableArn,
                tableDescription.TableId,
                tableDescription.TableName,
                tableDescription.TableSizeBytes,
                tableDescription.TableStatus.Value,
                tableDescription.LocalSecondaryIndexes.Count,
                tableDescription.GlobalSecondaryIndexes.Count,
                tableDescription.ItemCount,
                tableDescription.CreationDateTime,
                hashKeyName,
                hashKeyType,
                sortKeyName,
                sortKeyType,
                tableDescription.BillingModeSummary?.BillingMode.Value,
                tableDescription.BillingModeSummary?.LastUpdateToPayPerRequestDateTime
                );

            return(new PrimarSqlDataReader(provider));
        }