Esempio n. 1
0
        /// <summary>
        /// コンストラクタ
        /// </summary>
        public GpioHub()
        {
            // 初期化
            init();

            // リスナーにイベントを登録
            GpioPinListener = Observable.Interval(TimeSpan.FromMilliseconds(100))
                              // ピンのステータス変更を検知
                              .Scan((GpioValueList.ToReadOnlyCollection(), GpioValueList.ToReadOnlyCollection()),
                                    (x, y) => _ = (x.Item2, Pi.Gpio.Pins.Select(z => z.ReadValue()).ToList().ToReadOnlyCollection()))
                              // ピンの値変更があった場合のみ動作させる
                              .Where(x => !x.Item1.SequenceEqual(x.Item2))
                              // 実行
                              .Subscribe(x => {
                // GPIOピン4番(タクトスイッチ)のONを検出する
                if (x.Item2[4] == GpioPinValue.High)
                {
                    SwitchCount++;
                }

                // GPIOピン6番(モーションセンサスイッチ)の状態をセットする
                Motion = x.Item2[6] == GpioPinValue.High;
            });


            void init()
            {
                // ピンリストの初期状態をセット
                this.GpioValueList = Pi.Gpio.Pins.Select(x => x.ReadValue()).ToList();
                // タクトスイッチのON回数をリセット
                this.SwitchCount = 0;
                // モーションセンサスイッチの状態をリセット
                this.Motion = Pi.Gpio.Pins[6].Read();
            }
        }
Esempio n. 2
0
        /// <summary>
        /// コンストラクタ
        /// </summary>
        public GpioHub()
        {
            // 初期化処理
            void init()
            {
                // ピンリストの初期状態をセット
                this.GpioValueList = Pi.Gpio.Pins.Select(x => x.ReadValue()).ToList();
                // タクトスイッチのON回数をリセット
                this.SwitchCount = 0;
                // GPIOピン3番(赤色LED)の値をリセット
                this.IsRedOn = Pi.Gpio.Pins[3].Read();
                // GPIOピン21番(黄色LED)の値をリセット
                this.IsYellowOn = Pi.Gpio.Pins[21].Read();
                // GPIOピン22番(緑色LED)の値をリセット
                this.IsGreenOn = Pi.Gpio.Pins[22].Read();
                // モーションセンサスイッチの状態をリセット
                this.IsDitected = Pi.Gpio.Pins[26].Read();
            }

            // 初期化
            init();

            // リスナーにイベントを登録
            GpioPinListener = Observable.Interval(TimeSpan.FromMilliseconds(100))
                              // ピンのステータス変更を検知
                              .Scan((GpioValueList.ToReadOnlyCollection(), GpioValueList.ToReadOnlyCollection()),
                                    (x, y) => _ = (x.Item2, Pi.Gpio.Pins.Select(z => z.ReadValue()).ToList().ToReadOnlyCollection()))
                              // ピンの値変更があった場合のみ動作させる
                              .Where(x => !x.Item1.SequenceEqual(x.Item2))
                              // 実行
                              .Subscribe(x => {
                // GPIOピン25番(タクトスイッチ)のONを検出する
                if (x.Item2[25] == GpioPinValue.High)
                {
                    SwitchCount++;
                }
                // GPIOピン3番(赤色LED)の値を検出する
                IsRedOn = x.Item2[3] == GpioPinValue.High;

                // GPIOピン21番(黄色LED)の値を検出する
                IsYellowOn = x.Item2[21] == GpioPinValue.High;

                // GPIOピン22番(緑色LED)の値を検出する
                IsGreenOn = x.Item2[22] == GpioPinValue.High;

                // GPIOピン26番(モーションセンサスイッチ)の状態をセットする
                IsDitected = x.Item2[26] == GpioPinValue.High;
            });
        }
Esempio n. 3
0
        private ConfigFactory()
        {
            // things that must be true
            // only one ctor
            // for every param in the ctor, there must be one public property that
            // 1) matches the name of the param name (invariant culture, ignore-case)
            // 2) matches the type of the param (exactly)
            // 3) has a default value defined (via [DefaultValue] attribute)
            // 4) if the default value is not a valid constant value for an attribute, it must be convertable from the provided value

            // will fail if we can't convert the DefaultValueAttribute value to the target type
            _targetTypes = (from prop in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                            where prop.CanRead                          // must be readable
                            where prop.GetIndexParameters().Length == 0 // no index properties
                            let attr = prop.GetCustomAttributes <DefaultValueAttribute>(false).SingleOrDefault()
                                       where attr != null               // must have a default value
                                       let value = convert(attr.Value, prop.PropertyType)
                                                   select new { prop, value }).ToDictionary(a => a.prop.Name, a => Tuple.Create(a.prop, a.value));

            // wil fail if more than one ctor
            var ctor    = typeof(T).GetConstructors().Single();
            var ctorMap = new List <string>();

            foreach (var param in ctor.GetParameters())
            {
                // will fail unless onle one matching property exists
                var prop = (from kvp in _targetTypes
                            where kvp.Key.Equals(param.Name, StringComparison.InvariantCultureIgnoreCase)
                            select kvp.Value.Item1).Single();

                Util.ThrowUnless <InvalidOperationException>(prop.PropertyType == param.ParameterType);
                ctorMap.Add(prop.Name);
            }
            _ctorParamMap = ctorMap.ToReadOnlyCollection();
        }
Esempio n. 4
0
        public MessageKeyboard CreateKeyboard(List <string> labels)
        {
            if (labels == null)
            {
                return(null);
            }

            var buttons = new List <ReadOnlyCollection <MessageKeyboardButton> >();

            for (var i = 0; i < labels.Count; i += 4)
            {
                var countRange  = labels.Count - i < 4 ? labels.Count - i : 4;
                var range       = labels.GetRange(i, countRange);
                var keyboardRow = CreateMessageKeyboardRow(range);
                buttons.Add(keyboardRow);
            }

            buttons.Add(CreateMessageKeyboardRow(new List <string> {
                "Случайный стикер"
            }));

            return(new MessageKeyboard
            {
                Buttons = buttons.ToReadOnlyCollection()
            });
        }
Esempio n. 5
0
        /// <inheritdoc />
        public ReadOnlyCollection <User> GetChatUsers(IEnumerable <long> chatIds, UsersFields fields, NameCase nameCase)
        {
            var collection = chatIds.ToList();

            var parameters = new VkParameters
            {
                { "chat_ids", collection },
                { "fields", fields },
                { "name_case", nameCase }
            };

            var response = _vk.Call(methodName: "messages.getChatUsers", parameters: parameters);

            var list = new List <User>();

            foreach (var chatId in collection)
            {
                var chatResponse = response[key : chatId.ToString()];
                var users        = chatResponse.ToReadOnlyCollectionOf(selector: x => fields != null ? x : new User {
                    Id = (long)x
                });

                foreach (var user in users)
                {
                    var exist = list.Exists(match: first => first.Id == user.Id);

                    if (!exist)
                    {
                        list.Add(item: user);
                    }
                }
            }

            return(list.ToReadOnlyCollection());
        }
        /// <summary>
        ///         执行启动过程的具体步骤.
        /// </summary>
        /// <returns>成功返回True, 否则返回False.</returns>
        /// <remarks>
        ///         若启动过程有多个步骤, 遇到返回错误的步骤立即停止向下执行.
        /// </remarks>
        protected override bool StartCore()
        {
            if (!base.StartCore())
            {
                return(false);
            }

            var deviceInfoList = new DeviceInformationCollection();
            var errorCode      = EnumDevices(ref deviceInfoList);

            if (errorCode != ErrorCode.MV_OK)
            {
                return(false);
            }

            var cameras = new List <InstalledMachineVisionCamera>();

            var deviceInfoType = typeof(DeviceInformation);

            foreach (var deviceInfoPtr in deviceInfoList.DeviceInfoPtrs)
            {
                if (deviceInfoPtr != IntPtr.Zero)
                {
                    var di = (DeviceInformation)Marshal.PtrToStructure(deviceInfoPtr, deviceInfoType);
                    cameras.Add(new InstalledMachineVisionCamera(di));

                    this.Info("检测到摄像机" + di.GigeDeviceInformation.GetCurrentIpAddress());
                }
            }

            InstalledMachineVisionCameras = cameras.ToReadOnlyCollection();

            return(true);
        }
Esempio n. 7
0
        /// <summary>
        ///         执行启动过程的具体步骤.
        /// </summary>
        /// <returns>成功返回True, 否则返回False.</returns>
        /// <remarks>
        ///         若启动过程有多个步骤, 遇到返回错误的步骤立即停止向下执行.
        /// </remarks>
        protected override bool StartCore()
        {
            if (!base.StartCore())
            {
                return(false);
            }

            var server = new OPCServer();

            //此处必须为object类型,使用var自动推导将导致后续转换失败
            object addresses = server.GetOPCServers();

            var addressList = ((Array)addresses).Cast <string>().ToList();
            List <InstalledOpcServer> installedOpcServers = new List <InstalledOpcServer>(addressList.Count);

            foreach (var address in addressList)
            {
                InstalledOpcServer installedOpcServer = new InstalledOpcServer(address);
                installedOpcServer.Parent = this;
                installedOpcServers.Add(installedOpcServer);
            }

            InstalledOpcServers = installedOpcServers.ToReadOnlyCollection();

            return(true);
        }
 public void GenerateInstallEvents()
 {
     //TEMP: this is really part of the extension manager's job. an extension
     // install event is being simulated here on each web app startup
     var enabled = new List<ExtensionEntry>();
     foreach (var extension in _extensionManager.ActiveExtensions_Obsolete()) {
         var context = new ExtensionEventContext {
                                                     Extension = extension,
                                                     EnabledExtensions = enabled.ToReadOnlyCollection(),
                                                 };
         _extensionEvents.Invoke(x => x.Enabling(context), Logger);
         enabled.Add(extension);
         context.EnabledExtensions = enabled.ToReadOnlyCollection();
         _extensionEvents.Invoke(x => x.Enabled(context), Logger);
     }
 }
        internal static ChannelCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
        {
            var changes    = entry.Changes;
            var overwrites = new List <Overwrite>();

            var overwritesModel = changes.FirstOrDefault(x => x.ChangedProperty == "permission_overwrites");
            var typeModel       = changes.FirstOrDefault(x => x.ChangedProperty == "type");
            var nameModel       = changes.FirstOrDefault(x => x.ChangedProperty == "name");

            var type = typeModel.NewValue.ToObject <ChannelType>();
            var name = nameModel.NewValue.ToObject <string>();

            foreach (var overwrite in overwritesModel.NewValue)
            {
                var deny  = overwrite.Value <ulong>("deny");
                var _type = overwrite.Value <string>("type");
                var id    = overwrite.Value <ulong>("id");
                var allow = overwrite.Value <ulong>("allow");

                PermissionTarget permType = _type == "member" ? PermissionTarget.User : PermissionTarget.Role;

                overwrites.Add(new Overwrite(id, permType, new OverwritePermissions(allow, deny)));
            }

            return(new ChannelCreateAuditLogData(entry.TargetId.Value, name, type, overwrites.ToReadOnlyCollection()));
        }
Esempio n. 10
0
        public void TestReadonlyIfCollectionIsAlreadyReadonly()
        {
            var readonlyList = new List <int> {
                1, 2, 3, 4, 5
            };

            Assert.AreSame(readonlyList, readonlyList.ToReadOnlyCollection());
        }
Esempio n. 11
0
        public void Returns_Same_Instance_When_Implementing_Read_Only_List()
        {
            var source = new List <int> {
                1, 2, 3
            };
            var actual = source.ToReadOnlyCollection();

            Assert.ReferenceEquals(source, actual);
        }
Esempio n. 12
0
        public IReadOnlyCollection <Post> FetchPosts(long groupId)
        {
            var dateTimeOffset = _dateTimeOffsetFetcher.GetDateTime();

            GetPosts(groupId);

            CutOldPosts();

            return(_wallPostCollection.ToReadOnlyCollection());
        }
        private static ReadOnlyCollection <string> GetNameSpacesForType(Type type)
        {
            var namespaces = new List <string> {
                type.Namespace
            };

            if (type.IsGenericType)
            {
                namespaces.AddRange(type.GetGenericArguments().SelectMany(argType => GetNameSpacesForType(argType)));
            }

            return(namespaces.ToReadOnlyCollection());
        }
Esempio n. 14
0
        public MineField(int rows = DefaultHeight, int columns = DefaultWidth, int mineCount = DefaultMineCount)
        {
            Contract.Requires(rows > 0);
            Contract.Requires(columns > 0);
            Contract.Requires(mineCount > 0 && mineCount <= rows * columns);

            _rows         = rows;
            _columns      = columns;
            _mineCount    = mineCount;
            _clearedCount = 0;
            _squareCount  = _rows * _columns;
            _state        = WinState.Unknown;

            bool[] live = new bool[_squareCount];
            Random rnd  = Util.Rnd;
            int    ith;

            for (int i = 0; i < _mineCount; i++)
            {
                ith = rnd.Next(_squareCount - i);
                for (int j = 0; j < _squareCount; j++)
                {
                    if (live[j] == false)
                    {
                        if (ith == 0)
                        {
                            live[j] = true;
                            break;
                        }
                        ith--;
                    }
                }
            }

            var squares = new List <Square>();

            for (int y = 0; y < _rows; y++)
            {
                for (int x = 0; x < _columns; x++)
                {
                    var index = y * _columns + x;

                    var square = new Square(this, y, x, live[index]);
                    square.PropertyChanged += square_PropertyChanged;

                    squares.Add(square);
                }
            }

            _squares = squares.ToReadOnlyCollection();
        }
Esempio n. 15
0
        public ReadOnlyCollection<ExternalLink> GetAllLinks()
        {
            const int count = 50;
            var i = 0;
            var allExternalLinks = new List<ExternalLink>();

            do
            {
                var currentLinks = _fave.GetLinks(count, i * count);
                if (currentLinks != null) allExternalLinks.AddRange(currentLinks);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return allExternalLinks.ToReadOnlyCollection();
        }
Esempio n. 16
0
        public ReadOnlyCollection<Photo> GetAllPhotos()
        {
            const int count = 50;
            var i = 0;
            var allPhotos = new List<Photo>();

            do
            {
                var currentPhotos = _fave.GetPhotos(count, i * count);
                if (currentPhotos != null) allPhotos.AddRange(currentPhotos);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return allPhotos.ToReadOnlyCollection();
        }
Esempio n. 17
0
        public ReadOnlyCollection<Video> GetAll(long? ownerId = null, long? albumId = null, VideoWidth width = VideoWidth.Medium160, bool extended = false)
        {
            const int count = 200;
            var i = 0;
            var result = new List<Video>();

            do
            {
                var currentItems = _video.Get(ownerId, albumId, width, count, i * count, extended);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 18
0
        public ReadOnlyCollection<Group> GetAll(long uid, bool extended = false, GroupsFilters filters = null, GroupsFields fields = null)
        {
            const int count = 1000;
            var i = 0;
            var result = new List<Group>();

            do
            {
                var currentItems = _groups.Get(uid, extended, filters, fields, i * count, count);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 19
0
        public ReadOnlyCollection<User> GetAllBanned(long groupId)
        {
            const int count = 200;
            var i = 0;
            var result = new List<User>();

            do
            {
                var currentItems = _groups.GetBanned(groupId, count, i * count);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
        internal static MemberRoleAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
        {
            API.AuditLogChangeJson[] changes = entry.Changes;

            List <MemberRoleEditInfo> roleInfos = changes.SelectMany(x => x.NewValue.ToObject <API.RoleJson[]>(discord.ApiClient.Serializer),
                                                                     (model, role) => new { model.ChangedProperty, Role = role })
                                                  .Select(x => new MemberRoleEditInfo(x.Role.Name, x.Role.Id, x.ChangedProperty == "$add"))
                                                  .ToList();

            API.UserJson userInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
            RestUser     user     = RestUser.Create(discord, userInfo);

            return(new MemberRoleAuditLogData(roleInfos.ToReadOnlyCollection(), user));
        }
        public ReadOnlyCollection<City> GetAllCities(int countryId, int? regionId = null, string query = "", bool? needAll = false)
        {
            const int count = 1000;
            var i = 0;
            var result = new List<City>();

            do
            {
                var currentItems = _database.GetCities(countryId, regionId, query, needAll, count, i * count);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 22
0
        public ReadOnlyCollection<User> GetAll(long uid, ProfileFields fields = null, FriendsOrder order = null, NameCase nameCase = null, int? listId = null)
        {
            const int count = 50;
            var i = 0;
            var result = new List<User>();

            do
            {
                var currentItems = _friends.Get(uid, fields, count, i * count, order, nameCase, listId);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 23
0
        public ReadOnlyCollection<User> GetAllFollowers(long? userId = null, ProfileFields fields = null, NameCase nameCase = null)
        {
            const int count = 1000;
            var i = 0;
            var result = new List<User>();

            do
            {
                var currentItems = _users.GetFollowers(userId, count, i * count, fields, nameCase);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 24
0
        public static void AddSquidexApps(this IServiceCollection services)
        {
            services.AddTransientAs <AppDomainObject>()
            .AsSelf();

            services.AddSingletonAs <RolePermissionsProvider>()
            .AsSelf();

            services.AddSingletonAs <AppHistoryEventsCreator>()
            .As <IHistoryEventsCreator>();

            services.AddSingletonAs <DefaultAppImageStore>()
            .As <IAppImageStore>();

            services.AddSingletonAs <AppProvider>()
            .As <IAppProvider>();

            services.AddSingletonAs <AppUISettings>()
            .As <IAppUISettings>();

            services.AddSingletonAs <AppSettingsSearchSource>()
            .As <ISearchSource>();

            services.AddSingleton(c =>
            {
                var uiOptions = c.GetRequiredService <IOptions <MyUIOptions> >().Value;

                var patterns = new List <Pattern>();

                if (uiOptions.RegexSuggestions != null)
                {
                    foreach (var(key, value) in uiOptions.RegexSuggestions)
                    {
                        if (!string.IsNullOrWhiteSpace(key) &&
                            !string.IsNullOrWhiteSpace(value))
                        {
                            patterns.Add(new Pattern(key, value));
                        }
                    }
                }

                return(new InitialSettings
                {
                    Settings = new AppSettings
                    {
                        Patterns = patterns.ToReadOnlyCollection()
                    }
                });
            });
        }
Esempio n. 25
0
        public ReadOnlyCollection<Document> GetAll(long? owner_id = null)
        {
            const int count = 50;
            var i = 0;
            var result = new List<Document>();

            do
            {
                var currentItems = _docs.Get(count, i * count, owner_id);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 26
0
        public ReadOnlyCollection<Audio> GetAll(long uid, out User user, long? albumId = null, IEnumerable<long> aids = null)
        {
            const int count = 6000;
            var i = 0;
            var result = new List<Audio>();

            do
            {
                var currentItems = _audio.Get(uid, out user, albumId, aids, count, i * count);
                if (currentItems != null) result.AddRange(currentItems);
            } while ((++i * count < (_vk.CountFromLastResponse ?? 0)) && (i * count < 6000));

            return result.ToReadOnlyCollection();
        }
Esempio n. 27
0
        public ReadOnlyCollection<Post> GetAll(long ownerId, WallFilter filter = WallFilter.All)
        {
            const int count = 100;
            var i = 0;
            var allPosts = new List<Post>();

            do
            {
                int totalCount;
                var currentPosts = _wall.Get(ownerId, out totalCount, count, i * count, filter);
                if (currentPosts != null) allPosts.AddRange(currentPosts);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return allPosts.ToReadOnlyCollection();
        }
Esempio n. 28
0
        public IEnumerable<User> GetAllBanned()
        {
            const int count = 200;
            var i = 0;
            var result = new List<User>();

            do
            {
                int total;
                var currentItems = _account.GetBanned(out total, i * count, count);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
        /// <summary>
        /// Creates multiple temp files.
        /// </summary>
        /// <param name="count">The count.</param>
        /// <returns>ImmutableArray&lt;System.String&gt;.</returns>
        public IReadOnlyCollection <string> CreateFiles(int count)
        {
            count = count.EnsureMinimumValue(1);
            var files = new List <string>(count);

            for (var fileCount = 0; fileCount < count; fileCount++)
            {
                var fileName = GenerateRandomFile();

                files.Add(fileName);
            }

            this._files.AddRange(files);

            return(files.ToReadOnlyCollection());
        }
Esempio n. 30
0
        public void ToReadOnlyCollection_Enumerable_Should_Be_True()
        {
            // Arrange
            IList <string> items = new List <string>()
            {
                "Pazartesi", "Salı"
            };

            // Act
            var readOnlyItem = items.ToReadOnlyCollection();

            var result = readOnlyItem.IsReadOnly;

            // Assert
            result.Should().BeTrue();
        }
Esempio n. 31
0
        public static IEnumerable <Folder> GetFolders(XElement element, out IDictionary <Guid, Folder> folderMapper)
        {
            Contract.Requires(element.Name == "Folders");
            var    list = new List <Folder>();
            Guid   key;
            Folder folder;

            folderMapper = new Dictionary <Guid, Folder>();
            foreach (var folderElement in element.Elements())
            {
                list.Add(folder   = GetFolder(folderElement, out key));
                folderMapper[key] = folder;
            }

            return(list.ToReadOnlyCollection());
        }
Esempio n. 32
0
        public void Load(OpcGroupModel model)
        {
            base.Load(model);

            Address = model.Address;

            var items = new List <OpcItem>();

            foreach (var itemModel in model.OpcItemModels)
            {
                var item = new OpcItem();
                item.Parent = this;
                item.Load(itemModel);
                items.Add(item);
            }
            OpcItems = items.ToReadOnlyCollection();
        }
        protected override Expression VisitMethodDefinitionExpression(MethodDefinitionExpression method)
        {
            var methodName = method.Name.ToCamelCase();

            var body = new Expression[]
            {
                Expression.Return(Expression.Label(), Expression.Constant(null)).ToStatement()
            };

            var responseType = ObjectiveBinderHelpers.GetWrappedResponseType(this.CodeGenerationContext, method.ReturnType);

            var newParameters = new List<Expression>(method.Parameters)
            {
                FickleExpression.Parameter(new FickleDelegateType(typeof(void), new FickleParameterInfo(responseType, "response")), "callback")
            };

            return new MethodDefinitionExpression(methodName, newParameters.ToReadOnlyCollection(), typeof(void), Expression.Block(body), true, null);
        }
        private MethodDefinitionExpression CreateInitMethod(TypeDefinitionExpression expression)
        {
            var        type = expression.Type;
            Expression superInitExpression;

            var parameters = new List <Expression>
            {
                Expression.Parameter(new FickleType("NSDictionary"), "properties")
            };

            var methodBodyExpressions = new List <Expression>();

            if (type.BaseType.IsServiceType())
            {
                superInitExpression = Expression.Call(Expression.Parameter(type.BaseType, "super"), new FickleMethodInfo(type.BaseType, type, "initWithPropertyDictionary", new [] { new FickleParameterInfo(parameters[0].Type, "dictionary") }), parameters[0]);
            }
            else
            {
                superInitExpression = Expression.Call(Expression.Parameter(type.BaseType, "super"), new FickleMethodInfo(type.BaseType, type, "init", new ParameterInfo[0]));
            }

            var assignExpression        = Expression.Assign(Expression.Parameter(type, "self"), superInitExpression);
            var compareToNullExpression = Expression.ReferenceEqual(assignExpression, Expression.Constant(null, type));
            int count;

            methodBodyExpressions.Add(Expression.IfThen(compareToNullExpression, Expression.Block(Expression.Return(Expression.Label(), Expression.Constant(null)).ToStatement())));
            methodBodyExpressions.Add(PropertiesFromDictionaryExpressonBinder.Bind(expression, out count));
            methodBodyExpressions.Add(Expression.Return(Expression.Label(), Expression.Parameter(type, "self")).ToStatement());

            IEnumerable <ParameterExpression> variables;

            if (count > 0)
            {
                variables = new[] { Expression.Parameter(FickleType.Define("id"), "currentValueFromDictionary") };
            }
            else
            {
                variables = new ParameterExpression[0];
            }

            var methodBody = Expression.Block(variables, (Expression)methodBodyExpressions.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide));

            return(new MethodDefinitionExpression("initWithPropertyDictionary", parameters.ToReadOnlyCollection(), typeof(object), methodBody, false, null));
        }
Esempio n. 35
0
        public RepositoryAnalyzerViewModel(ITestsService testsService)
        {
            Commands     = UICommand.GenerateFromMessageButton(MessageButton.OK, new DialogService(), MessageResult.OK);
            ElapsedTimes = new Dictionary <string, IReadOnlyCollection <TimingModel> >();
            var versions = new List <string>();

            if (testsService.SelectedState.ElapsedTimes == null || testsService.SelectedState.ElapsedTimes.Count == 0)
            {
                return;
            }
            foreach (var et in testsService.SelectedState.ElapsedTimes)
            {
                ElapsedTimes.Add(et.Key.Version, et.Value.Select(eti => new TimingModel(eti.Name, eti.Time)).ToReadOnlyCollection());
                versions.Add(et.Key.Version);
            }
            versions.Sort();
            Versions       = versions.ToReadOnlyCollection();
            CurrentVersion = versions.Last();
        }
        public ReadOnlyCollection<Message> GetAll(
            MessageType type,
            out int totalCount,
            TimeSpan? timeOffset = null,
            MessagesFilter? filter = null,
            int? previewLength = null,
            long? lastMessageId = null)
        {
            const int count = 200;
            var i = 0;
            var result = new List<Message>();

            do
            {
                var currentItems = _messages.Get(type, out totalCount, count, i * count, timeOffset, filter, previewLength, lastMessageId);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 37
0
            ReadOnlyCollection <ITagSpan <TextMarkerTag> > IAsyncTaggerSource <string, TextMarkerTag> .GetTagsInBackground(string value, SnapshotSpan span, CancellationToken cancellationToken)
            {
                Assert.False(InMainThread);

                _backgroundCallback?.Invoke(value, span);

                cancellationToken.ThrowIfCancellationRequested();

                if (_backgroundFunc != null)
                {
                    return(_backgroundFunc(span));
                }

                if (_backgroundTags != null)
                {
                    return(_backgroundTags.ToReadOnlyCollection());
                }

                throw new Exception("Couldn't get background tags");
            }
Esempio n. 38
0
        protected virtual IReadOnlyList <SqlColumnDeclaration> VisitColumnDeclarations(IReadOnlyList <SqlColumnDeclaration> columns)
        {
            var i = 0;
            List <SqlColumnDeclaration> alternate = null;

            foreach (var column in columns)
            {
                var e = this.Visit(column.Expression);

                if (alternate == null && e != column.Expression)
                {
                    alternate = columns.Take(i).ToList();
                }

                alternate?.Add(new SqlColumnDeclaration(column.Name, e));

                i++;
            }

            return(alternate != null?alternate.ToReadOnlyCollection() : columns);
        }
Esempio n. 39
0
        public static ReadOnlyCollection <Line> ToLines(this string text, string indentation)
        {
            var lines = new List <Line>();

            using (var stringReader = new StringReader(text))
            {
                while (true)
                {
                    if (stringReader.Peek() == -1)
                    {
                        break;
                    }

                    var lineString = stringReader.ReadLine();
                    var line       = lineString.ToLine(indentation);
                    lines.Add(line);
                }
            }

            return(lines.ToReadOnlyCollection());
        }
        public void When_converting_an_enumerable_to_a_read_only_collection()
        {
            var intArray            = new[] { 1, 2, 3, 4, 5 };
            var readOnlyIntSequence = intArray.ToReadOnlyCollection();

            readOnlyIntSequence.Count().ShouldBe(intArray.Length);
            readOnlyIntSequence.ShouldBe(intArray);

            var    localCopy = readOnlyIntSequence;
            Action convertBackToOriginalArray = () =>
            {
                // ReSharper disable once UnusedVariable
                var originalIntArray = (int[])localCopy;
            };

            convertBackToOriginalArray.ShouldThrow <InvalidCastException>();

            var intList = new List <int> {
                1, 2, 3, 4, 5
            };

            readOnlyIntSequence = intList.ToReadOnlyCollection();

            readOnlyIntSequence.Count().ShouldBe(intList.Count);
            readOnlyIntSequence.ShouldBe(intList);

            Action convertBackToOriginalList = () =>
            {
                // ReSharper disable once UnusedVariable
                var originalIntArray = (int[])readOnlyIntSequence;
            };

            convertBackToOriginalList.ShouldThrow <InvalidCastException>();

            readOnlyIntSequence.ShouldNotContain(-1);
            intList.Add(-1);
            readOnlyIntSequence.ShouldContain(-1);
        }
		protected override Expression VisitSelect(SqlSelectExpression select)
		{
			select = (SqlSelectExpression)base.VisitSelect(select);

			if (this.aggregateSubqueriesBySelectAlias.Contains(select.Alias))
			{
				var columnsIncludingAggregates = new List<SqlColumnDeclaration>(select.Columns);

				foreach (var aggregateSubqueryExpression in this.aggregateSubqueriesBySelectAlias[select.Alias])
				{
					var name = "__AGGR" + columnsIncludingAggregates.Count;

					var columnDeclaration = new SqlColumnDeclaration(name, aggregateSubqueryExpression.AggregateInGroupSelect);

					this.aggregateSubqueryInstances.Add(aggregateSubqueryExpression, new SqlColumnExpression(aggregateSubqueryExpression.Type, aggregateSubqueryExpression.GroupByAlias, name));

					columnsIncludingAggregates.Add(columnDeclaration);
				}

				return new SqlSelectExpression(select.Type, select.Alias, columnsIncludingAggregates.ToReadOnlyCollection(), select.From, select.Where, select.OrderBy, select.GroupBy, select.Distinct, select.Skip, select.Take, select.ForUpdate);
			}

			return select;
		}
Esempio n. 42
0
        protected override Expression VisitSelect(SqlSelectExpression select)
        {
            select = (SqlSelectExpression)base.VisitSelect(select);

            if (this.aggregateSubqueriesBySelectAlias.Contains(select.Alias))
            {
                var columnsIncludingAggregates = new List <SqlColumnDeclaration>(select.Columns);

                foreach (var aggregateSubqueryExpression in this.aggregateSubqueriesBySelectAlias[select.Alias])
                {
                    var name = "__AGGR" + columnsIncludingAggregates.Count;

                    var columnDeclaration = new SqlColumnDeclaration(name, aggregateSubqueryExpression.AggregateInGroupSelect);

                    this.aggregateSubqueryInstances.Add(aggregateSubqueryExpression, new SqlColumnExpression(aggregateSubqueryExpression.Type, aggregateSubqueryExpression.GroupByAlias, name));

                    columnsIncludingAggregates.Add(columnDeclaration);
                }

                return(new SqlSelectExpression(select.Type, select.Alias, columnsIncludingAggregates.ToReadOnlyCollection(), select.From, select.Where, select.OrderBy, select.GroupBy, select.Distinct, select.Skip, select.Take, select.ForUpdate));
            }

            return(select);
        }
Esempio n. 43
0
        /// <summary>
        /// Sends a message to Steam as a job with multiple responses.
        /// </summary>
        /// <typeparam name="TResponse">The type of the response</typeparam>
        /// <typeparam name="TResult">The type of the returned result</typeparam>
        /// <param name="message">The message to send</param>
        /// <param name="completionFunc">The function to evaluate if the job is complete</param>
        /// <param name="selector">The function to combine all responses into one result</param>
        protected internal async Task <TResult> SendJobAsync <TResponse, TResult>(NetworkMessage message, Func <TResponse, bool> completionFunc, Func <IEnumerable <TResponse>, TResult> selector)
        {
            (var task, var job) = _jobs.AddJob();
            message             = message.WithJobId(job);

            await SendAsync(message).ConfigureAwait(false);

            List <TResponse> responses = new List <TResponse>();
            NetworkMessage   response  = await task.ConfigureAwait(false);

            TResponse result = response.Deserialize <TResponse>();

            while (!completionFunc(result))
            {
                responses.Add(result);

                task     = _jobs.AddJob(job);
                response = await task.ConfigureAwait(false);

                result = response.Deserialize <TResponse>();
            }

            return(selector(responses.ToReadOnlyCollection()));
        }
        private MethodDefinitionExpression CreateInitMethod(TypeDefinitionExpression expression)
        {
            var type = expression.Type;
            Expression superInitExpression;

            var parameters = new List<Expression>
            {
                Expression.Parameter(new FickleType("NSDictionary"), "properties")
            };

            var methodBodyExpressions = new List<Expression>();

            if (type.BaseType.IsServiceType())
            {
                superInitExpression = Expression.Call(Expression.Parameter(type.BaseType, "super"), new FickleMethodInfo(type.BaseType, type, "initWithPropertyDictionary", new [] { new FickleParameterInfo(parameters[0].Type, "dictionary")}), parameters[0]);
            }
            else
            {
                superInitExpression = Expression.Call(Expression.Parameter(type.BaseType, "super"), new FickleMethodInfo(type.BaseType, type, "init", new ParameterInfo[0]));
            }

            var assignExpression = Expression.Assign(Expression.Parameter(type, "self"), superInitExpression);
            var compareToNullExpression = Expression.ReferenceEqual(assignExpression, Expression.Constant(null, type));
            int count;

            methodBodyExpressions.Add(Expression.IfThen(compareToNullExpression, Expression.Block(Expression.Return(Expression.Label(), Expression.Constant(null)).ToStatement())));
            methodBodyExpressions.Add(PropertiesFromDictionaryExpressonBinder.Bind(expression, out count));
            methodBodyExpressions.Add(Expression.Return(Expression.Label(), Expression.Parameter(type, "self")).ToStatement());

            IEnumerable<ParameterExpression> variables;

            if (count > 0)
            {
                variables = new[] { Expression.Parameter(FickleType.Define("id"), "currentValueFromDictionary") };
            }
            else
            {
                variables = new ParameterExpression[0];
            }

            var methodBody = Expression.Block(variables, (Expression)methodBodyExpressions.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide));

            return new MethodDefinitionExpression("initWithPropertyDictionary", parameters.ToReadOnlyCollection(), typeof(object), methodBody, false, null);
        }
Esempio n. 45
0
        public ReadOnlyCollection<AudioAlbum> GetAllAlbums(long ownerid)
        {
            const int count = 100;
            var i = 0;
            var result = new List<AudioAlbum>();

            do
            {
                var currentItems = _audio.GetAlbums(ownerid, count, i * count);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 46
0
 ReadOnlyCollection <ITagSpan <TextMarkerTag> > IBasicTaggerSource <TextMarkerTag> .GetTags(SnapshotSpan span)
 {
     return(_tags.ToReadOnlyCollection());
 }
Esempio n. 47
0
        public ReadOnlyCollection<long> GetAllRequests(bool extended = false, bool needMutual = false, bool @out = false, bool sort = false, bool suggested = false)
        {
            const int count = 1000;
            var i = 0;
            var result = new List<long>();

            do
            {
                var currentItems = _friends.GetRequests(count, i * count, extended, needMutual, @out, sort, suggested);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 48
0
        protected override Expression VisitMethodDefinitionExpression(MethodDefinitionExpression method)
        {
            var methodName       = method.Name.Uncapitalize();
            var methodParameters = new List <Expression>(method.Parameters);
            var methodVariables  = new List <ParameterExpression>();
            var methodStatements = new List <Expression>();

            var requestParameters = new List <Expression>(method.Parameters);

            var httpMethod = method.Attributes["Method"];
            var hostname   = currentTypeDefinitionExpression.Attributes["Hostname"];
            var path       = "http://" + hostname + method.Attributes["Path"];

            var client   = Expression.Variable(webServiceClientType, "webServiceClient");
            var callback = Expression.Parameter(typeof(object), "onComplete");

            methodParameters.Add(callback);

            var url = Expression.Variable(typeof(string), "url");

            methodVariables.Add(url);
            methodStatements.Add(Expression.Assign(url, Expression.Constant(path)));

            Object serviceCallArguments;

            if (httpMethod.Equals("post", StringComparison.InvariantCultureIgnoreCase) ||
                httpMethod.Equals("put", StringComparison.InvariantCultureIgnoreCase))
            {
                var contentParameterName = method.Attributes["Content"];

                var contentParam = requestParameters.FirstOrDefault(x => ((ParameterExpression)x).Name.Equals(contentParameterName, StringComparison.InvariantCultureIgnoreCase));

                if (contentParam == null)
                {
                    throw new Exception("Post or Put method defined with null Content. You must define a @content field in your FicklefileKeyword");
                }

                requestParameters = requestParameters.Where(x => x != contentParam).ToList();

                var payloadVar = Expression.Variable(typeof(string), "requestPayload");

                methodVariables.Add(payloadVar);

                var jsonBuilder = FickleType.Define("DefaultJsonBuilder");

                var jsonBuilderInstance = FickleExpression.StaticCall(jsonBuilder, "instance");

                var toJsonCall = FickleExpression.Call(jsonBuilderInstance, typeof(String), "toJson", contentParam);

                var payloadAssign = Expression.Assign(payloadVar, toJsonCall);

                methodStatements.Add(payloadAssign);

                serviceCallArguments = new
                {
                    url,
                    payloadVar,
                    callback
                };
            }
            else
            {
                serviceCallArguments = new
                {
                    url,
                    callback
                };
            }

            foreach (var parameter in requestParameters)
            {
                var param = (ParameterExpression)parameter;

                if (param.Type is FickleNullable)
                {
                    param = FickleExpression.Parameter(param.Type.GetUnwrappedNullableType(), param.Name);
                }

                var valueToReplace = Expression.Constant("{" + param.Name + "}", typeof(String));
                var valueAsString  = FickleExpression.Call(param, param.Type, typeof(String), SourceCodeGenerator.ToStringMethod, parameter);

                var replaceArgs = new
                {
                    valueToReplace,
                    valueAsString
                };

                methodStatements.Add(Expression.Assign(url, FickleExpression.Call(url, typeof(String), "replace", replaceArgs)));
            }

            methodStatements.Add(FickleExpression.Call(client, httpMethod, serviceCallArguments));

            var methodBody = FickleExpression.Block
                             (
                methodVariables.ToArray(),
                methodStatements.ToArray()
                             );

            return(new MethodDefinitionExpression(methodName, methodParameters.ToReadOnlyCollection(), AccessModifiers.Public, typeof(void), methodBody, false, null));
        }
        protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression)
        {
            var includeExpressions = new List<IncludeExpression>();
            var importExpressions = new List<Expression>();
            var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(expression);
            referencedTypes.Sort((x, y) => String.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase));

            var lookup = new HashSet<Type>(referencedTypes.Where(TypeSystem.IsPrimitiveType));

            if (!this.codeGenerationContext.Options.ImportDependenciesAsFramework)
            {
                if (lookup.Contains(typeof(Guid)) || lookup.Contains(typeof(Guid?)))
                {
                    includeExpressions.Add(FickleExpression.Include("PKUUID.h"));
                }

                if (lookup.Contains(typeof(TimeSpan)) || lookup.Contains(typeof(TimeSpan?)))
                {
                    includeExpressions.Add(FickleExpression.Include("PKTimeSpan.h"));
                }

                includeExpressions.Add(FickleExpression.Include("PKDictionarySerializable.h"));
                includeExpressions.Add(FickleExpression.Include("PKFormEncodingSerializable.h"));
            }
            else
            {
                importExpressions.Add(new CodeLiteralExpression(c => c.WriteLine("@import PlatformKit;")));
            }

            if (ObjectiveBinderHelpers.TypeIsServiceClass(expression.Type.BaseType))
            {
                includeExpressions.Add(FickleExpression.Include(expression.Type.BaseType.Name + ".h"));
            }

            includeExpressions.AddRange(referencedTypes.Where(c => c.IsEnum).Select(c => FickleExpression.Include(c.Name + ".h")));

            includeExpressions.Sort(IncludeExpression.Compare);

            var comment = new CommentExpression("This file is AUTO GENERATED");

            var headerExpressions = new List<Expression>()
            {
                new[] { comment }.ToStatementisedGroupedExpression(),
                importExpressions.Count == 0 ? null : importExpressions.ToStatementisedGroupedExpression(),
                includeExpressions.ToStatementisedGroupedExpression()
            };

            var referencedTypeExpressions = referencedTypes
                .Where(ObjectiveBinderHelpers.TypeIsServiceClass)
                .Where(c => c != expression.Type.BaseType)
                .OrderBy(x => x.Name.Length)
                .ThenBy(x => x.Name)
                .Select(c => (Expression)new ReferencedTypeExpression(c)).ToList();

            if (referencedTypeExpressions.Count > 0)
            {
                headerExpressions.Add(referencedTypeExpressions.ToStatementisedGroupedExpression());
            }

            var header = headerExpressions.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide);

            var propertyBody = this.Visit(expression.Body);

            var interfaceTypes = new List<Type>
            {
                FickleType.Define("NSCopying"),
                FickleType.Define("PKDictionarySerializable"),
                FickleType.Define("PKFormEncodingSerializable")
            };

            return new TypeDefinitionExpression(expression.Type, header, propertyBody, true, expression.Attributes, interfaceTypes.ToReadOnlyCollection());
        }
        protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression)
        {
            var includeExpressions = new List<IncludeExpression>();
            var importExpressions = new List<Expression>();

            var optionsProperty = new PropertyDefinitionExpression("options", FickleType.Define("NSDictionary"), true);
            var responseFilterProperty = new PropertyDefinitionExpression("responseFilter", FickleType.Define("FKGatewayResponseFilter", isInterface:true), true, new[] { "weak" });

            var body = FickleExpression.GroupedWide
            (
                optionsProperty,
                responseFilterProperty,
                new GroupedExpressionsExpression(methods.Select(c => c.ChangePredeclaration(true)))
            );

            var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(body);
            referencedTypes.Sort((x, y) => String.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase));

            var lookup = new HashSet<Type>(referencedTypes.Where(TypeSystem.IsPrimitiveType));

            if (!this.CodeGenerationContext.Options.ImportDependenciesAsFramework)
            {
                if (lookup.Contains(typeof(Guid)) || lookup.Contains(typeof(Guid?)))
                {
                    includeExpressions.Add(FickleExpression.Include("PKUUID.h"));
                }

                if (lookup.Contains(typeof(TimeSpan)) || lookup.Contains(typeof(TimeSpan?)))
                {
                    includeExpressions.Add(FickleExpression.Include("PKTimeSpan.h"));
                }

                includeExpressions.Add(FickleExpression.Include("PKWebServiceClient.h"));
                includeExpressions.Add(FickleExpression.Include("PKDictionarySerializable.h"));
            }
            else
            {
                importExpressions.Add(new CodeLiteralExpression(c => c.WriteLine("@import PlatformKit;")));
            }

            includeExpressions.Add(FickleExpression.Include("FKGatewayResponseFilter.h"));

            var referencedUserTypes = referencedTypes
                .Where(c => (c is FickleType && ((FickleType)c).ServiceClass != null) || c is FickleType && ((FickleType)c).ServiceEnum != null)
                .Sorted((x, y) => x.Name.Length == y.Name.Length ? String.CompareOrdinal(x.Name, y.Name) : x.Name.Length - y.Name.Length);

            includeExpressions.AddRange(referencedUserTypes.Select(c => FickleExpression.Include(c.Name + ".h")));

            var comment = new CommentExpression("This file is AUTO GENERATED");

            var header = new Expression[]
            {
                comment,
                importExpressions.Count == 0 ? null : importExpressions.ToStatementisedGroupedExpression(),
                includeExpressions.Sorted(IncludeExpression.Compare).ToStatementisedGroupedExpression()
            }.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide);

            var interfaceTypes = new List<Type>();

            if (expression.InterfaceTypes != null)
            {
                interfaceTypes.AddRange(expression.InterfaceTypes);
            }

            interfaceTypes.Add(FickleType.Define("PKWebServiceClientDelegate"));

            return new TypeDefinitionExpression(expression.Type, header, body, true, expression.Attributes, interfaceTypes.ToReadOnlyCollection());
        }
Esempio n. 51
0
        public ReadOnlyCollection<Comment> GetAllComments(
            long ownerId,
            long postId,
            CommentsSort sort = null,
            bool needLikes = false,
            int previewLength = 0)
        {
            const int count = 100;
            var i = 0;
            var allComments = new List<Comment>();

            do
            {
                int totalCount;
                var currentComments = _wall.GetComments(ownerId, postId, out totalCount, sort, needLikes, count, i * count, previewLength);
                if (currentComments != null) allComments.AddRange(currentComments);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return allComments.ToReadOnlyCollection();
        }
Esempio n. 52
0
        private void Initialize()
        {
            var content = new StringBuilder();
            var prettyPrintedContent = new StringBuilder();

            var parts = new List<SymbolDisplayPart>();
            var prettyPrintedParts = new List<SymbolDisplayPart>();

            var parameters = new List<IParameter>();

            var signaturePrefixParts = _signatureHelpItem.PrefixDisplayParts;
            var signaturePrefixContent = _signatureHelpItem.PrefixDisplayParts.GetFullText();

            AddRange(signaturePrefixParts, parts, prettyPrintedParts);
            Append(signaturePrefixContent, content, prettyPrintedContent);

            var separatorParts = _signatureHelpItem.SeparatorDisplayParts;
            var separatorContent = separatorParts.GetFullText();

            var newLinePart = new SymbolDisplayPart(SymbolDisplayPartKind.LineBreak, null, "\r\n");
            var newLineContent = newLinePart.ToString();
            var spacerPart = new SymbolDisplayPart(SymbolDisplayPartKind.Space, null, new string(' ', signaturePrefixContent.Length));
            var spacerContent = spacerPart.ToString();

            var paramColumnCount = 0;

            for (int i = 0; i < _signatureHelpItem.Parameters.Length; i++)
            {
                var sigHelpParameter = _signatureHelpItem.Parameters[i];

                var parameterPrefixParts = sigHelpParameter.PrefixDisplayParts;
                var parameterPrefixContext = sigHelpParameter.PrefixDisplayParts.GetFullText();

                var parameterParts = AddOptionalBrackets(sigHelpParameter.IsOptional, sigHelpParameter.DisplayParts);
                var parameterContent = parameterParts.GetFullText();

                var parameterSuffixParts = sigHelpParameter.SuffixDisplayParts;
                var parameterSuffixContext = sigHelpParameter.SuffixDisplayParts.GetFullText();

                paramColumnCount += separatorContent.Length + parameterPrefixContext.Length + parameterContent.Length + parameterSuffixContext.Length;

                if (i > 0)
                {
                    AddRange(separatorParts, parts, prettyPrintedParts);
                    Append(separatorContent, content, prettyPrintedContent);

                    if (paramColumnCount > MaxParamColumnCount)
                    {
                        prettyPrintedParts.Add(newLinePart);
                        prettyPrintedParts.Add(spacerPart);
                        prettyPrintedContent.Append(newLineContent);
                        prettyPrintedContent.Append(spacerContent);

                        paramColumnCount = 0;
                    }
                }

                AddRange(parameterPrefixParts, parts, prettyPrintedParts);
                Append(parameterPrefixContext, content, prettyPrintedContent);

                parameters.Add(new Parameter(this, sigHelpParameter, parameterContent, content.Length, prettyPrintedContent.Length));

                AddRange(parameterParts, parts, prettyPrintedParts);
                Append(parameterContent, content, prettyPrintedContent);

                AddRange(parameterSuffixParts, parts, prettyPrintedParts);
                Append(parameterSuffixContext, content, prettyPrintedContent);
            }

            AddRange(_signatureHelpItem.SuffixDisplayParts, parts, prettyPrintedParts);
            Append(_signatureHelpItem.SuffixDisplayParts.GetFullText(), content, prettyPrintedContent);

            if (_parameterIndex >= 0)
            {
                var sigHelpParameter = _signatureHelpItem.Parameters[_parameterIndex];

                AddRange(sigHelpParameter.SelectedDisplayParts, parts, prettyPrintedParts);
                Append(sigHelpParameter.SelectedDisplayParts.GetFullText(), content, prettyPrintedContent);
            }

            AddRange(_signatureHelpItem.DescriptionParts, parts, prettyPrintedParts);
            Append(_signatureHelpItem.DescriptionParts.GetFullText(), content, prettyPrintedContent);

            var documentation = _signatureHelpItem.DocumentationFactory(CancellationToken.None).ToList();
            if (documentation.Count > 0)
            {
                AddRange(new[] { newLinePart }, parts, prettyPrintedParts);
                Append(newLineContent, content, prettyPrintedContent);

                AddRange(documentation, parts, prettyPrintedParts);
                Append(documentation.GetFullText(), content, prettyPrintedContent);
            }

            _content = content.ToString();
            _prettyPrintedContent = prettyPrintedContent.ToString();
            _displayParts = parts.ToImmutableArrayOrEmpty();
            _prettyPrintedDisplayParts = prettyPrintedParts.ToImmutableArrayOrEmpty();
            _parameters = parameters.ToReadOnlyCollection();
        }
Esempio n. 53
0
        public ReadOnlyCollection<Audio> SearchAll(
            string query,
            out int totalCount,
            bool? autoComplete = null,
            AudioSort? sort = null,
            bool? findLyrics = null)
        {
            const int count = 300;
            var i = 0;
            var result = new List<Audio>();

            do
            {
                var currentItems = _audio.Search(query, out totalCount, autoComplete, sort, findLyrics, count, i * count);
                if (currentItems != null) result.AddRange(currentItems);
            } while ((++i * count < (_vk.CountFromLastResponse ?? 0)) && (i * count < 1000));

            return result.ToReadOnlyCollection();
        }
Esempio n. 54
0
        public ReadOnlyCollection<Audio> GetAllPopular(bool onlyEng = false, AudioGenre? genre = null)
        {
            const int count = 1000;
            var i = 0;
            var result = new List<Audio>();

            do
            {
                var currentItems = _audio.GetPopular(onlyEng, genre, count, i * count);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }
Esempio n. 55
0
        protected override Expression VisitMethodDefinitionExpression(MethodDefinitionExpression method)
        {
            var methodName = method.Name.Uncapitalize();
            var methodParameters = new List<Expression>(method.Parameters);
            var methodVariables = new List<ParameterExpression>();
            var methodStatements = new List<Expression>();

            var requestParameters = new List<Expression>(method.Parameters);

            var httpMethod = method.Attributes["Method"];
            var hostname = currentTypeDefinitionExpression.Attributes["Hostname"];
            var path = "http://" + hostname + method.Attributes["Path"];

            var client = Expression.Variable(webServiceClientType, "webServiceClient");
            var responseType = JavaBinderHelpers.GetWrappedResponseType(this.CodeGenerationContext, method.ReturnType);
            var responseTypeArgument = Expression.Variable(typeof(String), responseType.Name + ".class");
            var callback = Expression.Parameter(new FickleType("RequestCallback<" + responseType.Name + ">"), "callback");

            methodParameters.Add(callback);

            var url = Expression.Variable(typeof(string), "url");

            methodVariables.Add(url);
            methodStatements.Add(Expression.Assign(url, Expression.Constant(path)));

            Object serviceCallArguments;

            if (httpMethod.Equals("post", StringComparison.InvariantCultureIgnoreCase)
                || httpMethod.Equals("put", StringComparison.InvariantCultureIgnoreCase))
            {
                var contentParameterName = method.Attributes["Content"];

                var contentParam = requestParameters.FirstOrDefault(x => ((ParameterExpression)x).Name.Equals(contentParameterName, StringComparison.InvariantCultureIgnoreCase));

                if (contentParam == null)
                {
                    throw new Exception("Post or Put method defined with null Content. You must define a @content field in your FicklefileKeyword");
                }

                requestParameters = requestParameters.Where(x => x != contentParam).ToList();

                var payloadVar = Expression.Variable(typeof(string), "requestPayload");

                methodVariables.Add(payloadVar);

                var jsonBuilder = FickleType.Define("DefaultJsonBuilder");

                var jsonBuilderInstance = FickleExpression.StaticCall(jsonBuilder, "instance");

                var toJsonCall = FickleExpression.Call(jsonBuilderInstance, typeof(String), "toJson", contentParam);

                var payloadAssign = Expression.Assign(payloadVar, toJsonCall);

                methodStatements.Add(payloadAssign);

                serviceCallArguments = new
                {
                    url,
                    responseTypeArgument,
                    payloadVar,
                    callback
                };
            }
            else
            {
                serviceCallArguments = new
                {
                    url,
                    responseTypeArgument,
                    callback
                };
            }

            foreach (var parameter in requestParameters)
            {
                var param = (ParameterExpression)parameter;

                if (param.Type is FickleNullable)
                {
                    param = FickleExpression.Parameter(param.Type.GetUnwrappedNullableType(), param.Name);
                }

                var valueToReplace = Expression.Constant("{" + param.Name + "}", typeof(String));
                var valueAsString = FickleExpression.Call(param, param.Type, typeof(String), SourceCodeGenerator.ToStringMethod, parameter);

                var replaceArgs = new
                {
                    valueToReplace,
                    valueAsString
                };

                methodStatements.Add(Expression.Assign(url, FickleExpression.Call(url, typeof(String), "replace", replaceArgs)));
            }

            methodStatements.Add(FickleExpression.Call(client, httpMethod, serviceCallArguments));

            var methodBody = FickleExpression.Block
            (
                methodVariables.ToArray(),
                methodStatements.ToArray()
            );

            return new MethodDefinitionExpression(methodName, methodParameters.ToReadOnlyCollection(), AccessModifiers.Public, typeof(void), methodBody, false, null);
        }
        protected override Expression VisitMethodDefinitionExpression(MethodDefinitionExpression method)
        {
            var client = Expression.Variable(this.httpClientType, HttpClientFieldName);

            var methodName = method.Name;
            var methodParameters = new List<Expression>(method.Parameters);
            var methodVariables = new List<ParameterExpression>();
            var methodStatements = new List<Expression>();

            var hostname = this.currentTypeDefinitionExpression.Attributes["Hostname"];
            var fullPath = "http://" + hostname + method.Attributes["Path"];
            var relativePath = method.Attributes["Path"];

            if (relativePath.StartsWith("/"))
            {
                relativePath = relativePath.Substring(1);
            }

            var requestUrl = Expression.Variable(typeof(InterpolatedString), "requestUrl");
            methodVariables.Add(requestUrl);

            var baseAddressProperty = FickleExpression.Property(client, this.httpClientType, "BaseAddress");
            methodStatements.Add(Expression.IfThenElse(Expression.Equal(baseAddressProperty, Expression.Constant(null)),
                Expression.Assign(requestUrl, Expression.Constant(new InterpolatedString(fullPath))).ToStatementBlock(),
                Expression.Assign(requestUrl, Expression.Constant(new InterpolatedString(relativePath))).ToStatementBlock()));

            var httpMethodType = FickleType.Define("HttpMethod");
            var httpRequestMessageType = FickleType.Define("HttpRequestMessage");
            var httpRequestMessagesArgs = new
            {
                httpMethod = FickleExpression.New(httpMethodType, "HttpMethod", method.Attributes["Method"]),
                requestUrl
            };

            var httpRequestMessageNew = FickleExpression.New(httpRequestMessageType, "HttpRequestMessage", httpRequestMessagesArgs);
            var httpRequestMessage = Expression.Variable(httpRequestMessageType, "httpRequestMessage");
            methodVariables.Add(httpRequestMessage);
            methodStatements.Add(Expression.Assign(httpRequestMessage, httpRequestMessageNew));

            var streamType = FickleType.Define("Stream");
            var httpStreamSerializer = Expression.Variable(this.httpStreamSerializerType, HttpStreamSerializerFieldName);

            var contentParameterName = method.Attributes["Content"];

            if (!string.IsNullOrEmpty(contentParameterName))
            {
                var contentParam = method.Parameters.FirstOrDefault(x => ((ParameterExpression)x).Name.Equals(contentParameterName, StringComparison.InvariantCultureIgnoreCase));

                if (contentParam == null)
                {
                    throw new Exception("Content paramter not found");
                }

                var serializeCall = FickleExpression.Call(httpStreamSerializer, typeof(string), "Serialize", contentParam);
                var stringContentNew = FickleExpression.New(FickleType.Define("StringContent"), "StringContent", serializeCall);
                methodStatements.Add(Expression.Assign(FickleExpression.Property(httpRequestMessage, httpRequestMessageType, "Content"), stringContentNew));
            }

            var httpResponseMessageType = FickleType.Define("HttpResponseMessage");
            var httpResponseMessage = Expression.Variable(httpResponseMessageType, "httpResponseMessage");
            methodVariables.Add(httpResponseMessage);

            var clientCall = FickleExpression.Call(client, new CSharpAwaitedTaskType(httpResponseMessageType), "SendAsync", httpRequestMessage);
            methodStatements.Add(Expression.Assign(httpResponseMessage, clientCall));
            methodStatements.Add(FickleExpression.Call(httpResponseMessage, "EnsureSuccessStatusCode", null));

            if (method.ReturnType != typeof (void))
            {
                var result = Expression.Variable(method.ReturnType, "result");
                methodVariables.Add(result);

                var contentStream = Expression.Variable(streamType, "contentStream");
                methodVariables.Add(contentStream);
                methodStatements.Add(Expression.Assign(contentStream, Expression.Constant(null)));

                var responseContent = Expression.Property(httpResponseMessage, "Content");
                var contentStreamCall = FickleExpression.Call(responseContent, new CSharpAwaitedTaskType(streamType), "ReadAsStreamAsync", null);

                var deserializeCall = FickleExpression.Call(httpStreamSerializer, method.ReturnType, "Deserialize", contentStream);
                deserializeCall.Method.MakeGenericMethod(method.ReturnType);

                var tryBlock = FickleExpression.Grouped(
                    Expression.Assign(contentStream, contentStreamCall).ToStatement(),
                    Expression.Assign(result, deserializeCall).ToStatement()
                    );

                var diposeStream = Expression.IfThen(Expression.NotEqual(contentStream, Expression.Constant(null)), FickleExpression.Call(contentStream, "Dispose", null).ToStatementBlock());

                var tryFinally = Expression.TryFinally(tryBlock, diposeStream);
                methodStatements.Add(tryFinally);

                methodStatements.Add(FickleExpression.Return(result));
            }

            var methodBody = FickleExpression.Block
            (
                methodVariables.ToArray(),
                methodStatements.ToArray()
            );

            var returnType = method.ReturnType != typeof (void) ? method.ReturnType : null;
            var returnTaskType = new CSharpAwaitedTaskType(returnType);

            return new MethodDefinitionExpression(methodName, methodParameters.ToReadOnlyCollection(), AccessModifiers.Public, returnTaskType, methodBody, false, null);
        }
Esempio n. 57
0
        public static IEnumerable<Folder> GetFolders(XElement element, out IDictionary<Guid, Folder> folderMapper)
        {
            Contract.Requires(element.Name == "Folders");
            var list = new List<Folder>();
            Guid key;
            Folder folder;
            folderMapper = new Dictionary<Guid, Folder>();
            foreach (var folderElement in element.Elements())
            {
                list.Add(folder = GetFolder(folderElement, out key));
                folderMapper[key] = folder;
            }

            return list.ToReadOnlyCollection();
        }
        protected override Expression VisitTypeDefinitionExpression(TypeDefinitionExpression expression)
        {
            var includeExpressions = new List<IncludeExpression>();
            var optionsProperty = new PropertyDefinitionExpression("options", FickleType.Define("NSDictionary"), true);

            var body = FickleExpression.GroupedWide
            (
                optionsProperty,
                FickleExpression.Grouped
                (
                    this.CreateInitWithOptionsMethod(),
                    this.Visit(expression.Body)
                )
            );

            var referencedTypes = ReferencedTypesCollector.CollectReferencedTypes(body);
            referencedTypes.Sort((x, y) => String.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase));

            var lookup = new HashSet<Type>(referencedTypes.Where(TypeSystem.IsPrimitiveType));

            if (lookup.Contains(typeof(Guid)) || lookup.Contains(typeof(Guid?)))
            {
                includeExpressions.Add(FickleExpression.Include("PKUUID.h"));
            }

            if (lookup.Contains(typeof(TimeSpan)) || lookup.Contains(typeof(TimeSpan?)))
            {
                includeExpressions.Add(FickleExpression.Include("PKTimeSpan.h"));
            }

            includeExpressions.Add(FickleExpression.Include("PKDictionarySerializable.h"));
            includeExpressions.Add(FickleExpression.Include("PKWebServiceClient.h"));

            var referencedUserTypes = referencedTypes
                .Where(c => (c is FickleType && ((FickleType)c).ServiceClass != null) || c is FickleType && ((FickleType)c).ServiceEnum != null)
                .Sorted((x, y) => x.Name.Length == y.Name.Length ? String.CompareOrdinal(x.Name, y.Name) : x.Name.Length - y.Name.Length);

            includeExpressions.AddRange(referencedUserTypes.Select(c => FickleExpression.Include(c.Name + ".h")));

            var comment = new CommentExpression("This file is AUTO GENERATED");
            var header = new Expression[] { comment, includeExpressions.Sorted(IncludeExpression.Compare).ToStatementisedGroupedExpression() }.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide);

            var interfaceTypes = new List<Type>();

            if (expression.InterfaceTypes != null)
            {
                interfaceTypes.AddRange(expression.InterfaceTypes);
            }

            interfaceTypes.Add(FickleType.Define("PKWebServiceClientDelegate"));

            return new TypeDefinitionExpression(expression.Type, header, body, true, expression.Attributes, interfaceTypes.ToReadOnlyCollection());
        }
Esempio n. 59
0
        internal static ChannelCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
        {
            var changes    = entry.Changes;
            var overwrites = new List <Overwrite>();

            var overwritesModel       = changes.FirstOrDefault(x => x.ChangedProperty == "permission_overwrites");
            var typeModel             = changes.FirstOrDefault(x => x.ChangedProperty == "type");
            var nameModel             = changes.FirstOrDefault(x => x.ChangedProperty == "name");
            var rateLimitPerUserModel = changes.FirstOrDefault(x => x.ChangedProperty == "rate_limit_per_user");
            var nsfwModel             = changes.FirstOrDefault(x => x.ChangedProperty == "nsfw");
            var bitrateModel          = changes.FirstOrDefault(x => x.ChangedProperty == "bitrate");

            var  type             = typeModel.NewValue.ToObject <ChannelType>(discord.ApiClient.Serializer);
            var  name             = nameModel.NewValue.ToObject <string>(discord.ApiClient.Serializer);
            int? rateLimitPerUser = rateLimitPerUserModel?.NewValue?.ToObject <int>(discord.ApiClient.Serializer);
            bool?nsfw             = nsfwModel?.NewValue?.ToObject <bool>(discord.ApiClient.Serializer);
            int? bitrate          = bitrateModel?.NewValue?.ToObject <int>(discord.ApiClient.Serializer);

            foreach (var overwrite in overwritesModel.NewValue)
            {
                var deny     = overwrite["deny"].ToObject <ulong>(discord.ApiClient.Serializer);
                var permType = overwrite["type"].ToObject <PermissionTarget>(discord.ApiClient.Serializer);
                var id       = overwrite["id"].ToObject <ulong>(discord.ApiClient.Serializer);
                var allow    = overwrite["allow"].ToObject <ulong>(discord.ApiClient.Serializer);

                overwrites.Add(new Overwrite(id, permType, new OverwritePermissions(allow, deny)));
            }

            return(new ChannelCreateAuditLogData(entry.TargetId.Value, name, type, rateLimitPerUser, nsfw, bitrate, overwrites.ToReadOnlyCollection()));
        }
Esempio n. 60
0
        public ReadOnlyCollection<Audio> GetAllRecommendations(long? userId = null, bool shuffle = true, string targetAudio = "")
        {
            const int count = 1000;
            var i = 0;
            var result = new List<Audio>();

            do
            {
                var currentItems = _audio.GetRecommendations(userId, count, i * count, shuffle, targetAudio);
                if (currentItems != null) result.AddRange(currentItems);
            } while (++i * count < (_vk.CountFromLastResponse ?? 0));

            return result.ToReadOnlyCollection();
        }