示例#1
0
        /// <summary>
        /// Emits the property values filtered by the given keyvalue filter.
        /// </summary>
        /// <typeparam name="TKey">The type of the keys.</typeparam>
        /// <typeparam name="TValue">The type of the values.</typeparam>
        /// <param name="Properties">An object implementing IReadOnlyProperties&lt;TKey, TValue&gt;.</param>
        /// <param name="KeyValueFilter">An optional delegate for keyvalue filtering.</param>
        /// <returns>The property values of the given property keys.</returns>
        public static PropertiesPipe <TKey, TValue> Ps <TKey, TValue>(this IReadOnlyProperties <TKey, TValue> Properties,
                                                                      KeyValueFilter <TKey, TValue> KeyValueFilter)

            where TKey : IEquatable <TKey>, IComparable <TKey>, IComparable
        {
            return(new PropertiesPipe <TKey, TValue>(Properties, KeyValueFilter));
        }
示例#2
0
        /// <summary>
        /// Emits the property values filtered by the given keyvalue filter.
        /// </summary>
        /// <typeparam name="TKey">The type of the keys.</typeparam>
        /// <typeparam name="TValue">The type of the values.</typeparam>
        /// <param name="IEnumerable">An enumeration of IReadOnlyProperties&lt;TKey, TValue&gt;.</param>
        /// <param name="KeyValueFilter">An optional delegate for keyvalue filtering.</param>
        /// <returns>The property values of the given property keys.</returns>
        public static PropertyPipe <TKey, TValue> P <TKey, TValue>(this IEndPipe <IReadOnlyProperties <TKey, TValue> > SourcePipe,
                                                                   KeyValueFilter <TKey, TValue> KeyValueFilter)

            where TKey : IEquatable <TKey>, IComparable <TKey>, IComparable
        {
            return(new PropertyPipe <TKey, TValue>(SourcePipe, KeyValueFilter));
        }
示例#3
0
        /// <summary>
        /// Emits the property values filtered by the given keyvalue filter.
        /// </summary>
        /// <param name="SourcePipe">A pipe as element source.</param>
        /// <param name="KeyValueFilter">An optional delegate for keyvalue filtering.</param>
        public PropertiesPipe(IEndPipe <IReadOnlyProperties <TKey, TValue> > SourcePipe,
                              KeyValueFilter <TKey, TValue> KeyValueFilter)

            : base(SourcePipe)

        {
            this.KeyValueFilter = (KeyValueFilter != null) ? KeyValueFilter : (k, v) => true;
        }
示例#4
0
        /// <summary>
        /// Emits the property values filtered by the given keyvalue filter.
        /// </summary>
        /// <param name="SourcePipe">A pipe as element source.</param>
        /// <param name="KeyValueFilter">An optional delegate for keyvalue filtering.</param>
        public PropertiesPipe(IReadOnlyProperties <TKey, TValue> SourceElement,
                              KeyValueFilter <TKey, TValue> KeyValueFilter)

            : base(SourceElement)

        {
            this.KeyValueFilter = (KeyValueFilter != null) ? KeyValueFilter : (k, v) => true;
        }
示例#5
0
        /// <summary>
        /// Retrieves a list of key value objects
        /// </summary>
        /// <param name="filter">
        /// A filter object to filter key value objects on the
        /// server.If omitted, the server will return all objects as a
        /// paginated response.
        /// </param>
        /// <returns>A list of key value objects</returns>
        public KeyValueList GetKeyValues(KeyValueFilter filter)
        {
            // setup parameters
            GraphQLParameters parameters = new GraphQLParameters();

            parameters.Add("filter", filter);

            return(RunQuery <KeyValueList>(@"getKeyValues", parameters));
        }
示例#6
0
        public static List <K> FilterBy <K, V>(this Dictionary <K, V> items, KeyValueFilter <K, V> filter)
        {
            var result = new List <K>();

            foreach (KeyValuePair <K, V> element in items)
            {
                if (filter(element.Key, element.Value))
                {
                    result.Add(element.Key);
                }
            }
            return(result);
        }
示例#7
0
        /// <summary>
        /// Emits the property values filtered by the given keyvalue filter.
        /// </summary>
        /// <typeparam name="TKey">The type of the keys.</typeparam>
        /// <typeparam name="TValue">The type of the values.</typeparam>
        /// <param name="Properties">An object implementing IReadOnlyProperties&lt;TKey, TValue&gt;.</param>
        /// <param name="KeyValueFilter">An optional delegate for keyvalue filtering.</param>
        /// <returns>The property values of the given property keys.</returns>
        public static IDictionary <TKey, IEnumerable <TValue> > PMap <TKey, TValue>(this IReadOnlyProperties <TKey, TValue> Properties,
                                                                                    KeyValueFilter <TKey, TValue> KeyValueFilter)

            where TKey : IEquatable <TKey>, IComparable <TKey>, IComparable
        {
            var _Lookup = new Dictionary <TKey, IEnumerable <TValue> >();

            foreach (var Property in Properties)
            {
                if (KeyValueFilter(Property.Key, Property.Value))
                {
                    _Lookup.Add(Property.Key, new List <TValue>()
                    {
                        Property.Value
                    });
                }
            }

            return(_Lookup);
        }
示例#8
0
        /// <summary>
        /// Emits the property values filtered by the given keyvalue filter.
        /// </summary>
        /// <typeparam name="TKey">The type of the keys.</typeparam>
        /// <typeparam name="TValue">The type of the values.</typeparam>
        /// <param name="IEnumerable">An enumeration of IReadOnlyProperties&lt;TKey, TValue&gt;.</param>
        /// <param name="KeyValueFilter">An optional delegate for keyvalue filtering.</param>
        /// <returns>The property values of the given property keys.</returns>
        public static IDictionary <TKey, IEnumerable <TValue> > PMap <TKey, TValue>(this IEnumerable <IReadOnlyProperties <TKey, TValue> > IEnumerable,
                                                                                    KeyValueFilter <TKey, TValue> KeyValueFilter)

            where TKey : IEquatable <TKey>, IComparable <TKey>, IComparable
        {
            var _Lookup = new Dictionary <TKey, List <TValue> >();

            foreach (var Properties in IEnumerable)
            {
                foreach (var Property in Properties)
                {
                    if (KeyValueFilter(Property.Key, Property.Value))
                    {
                        if (!_Lookup.ContainsKey(Property.Key))
                        {
                            _Lookup.Add(Property.Key, new List <TValue>()
                            {
                                Property.Value
                            });
                        }
                        else
                        {
                            _Lookup[Property.Key].Add(Property.Value);
                        }
                    }
                }
            }


            var _Lookup2 = new Dictionary <TKey, IEnumerable <TValue> >();

            foreach (var KeyValuePair in _Lookup)
            {
                _Lookup2.Add(KeyValuePair.Key, KeyValuePair.Value);
            }

            return(_Lookup2);
        }