public void _test1() { var innerInt = new Inner(7); var innerUInt = new Inner( (uint)42); AssertEquals(7, innerInt.I); AssertEquals(42, innerUInt.I); }
public void Run() { var inner = new Inner(new [] {"a", "b", "c", "d", "b"}); var inner2 = new Inner(new[] { "c", "d", "e", "f" }); var inner3 = new Inner(new[] { "g", "h" }); IEnumerable<Inner> inners = new[] {inner, inner2, inner3}; var list = (from v in inner.Strings select v).Distinct(); Utility.Dump(list); var l2 = list as IEnumerable<string>; Utility.Dump(l2); }
static void Main() { { Inner inner = new Inner(5); Outer outer = new Outer(); Inner newInner = outer.doubleInnerValue(inner); if (newInner.getValue() != 10) throw new Exception("inner failed"); } { Outer outer = new Outer(); Inner inner = outer.createInner(3); Inner newInner = outer.doubleInnerValue(inner); if (outer.getInnerValue(newInner) != 6) throw new Exception("inner failed"); } }
public Task<StreamConsumerInfo[]> StreamConsumerInfoAsync(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) { return Inner.StreamConsumerInfoAsync(ToInner(key), groupName, flags); }
public Task<StreamGroupInfo[]> StreamGroupInfoAsync(RedisKey key, CommandFlags flags = CommandFlags.None) { return Inner.StreamGroupInfoAsync(ToInner(key), flags); }
public static PaginaWeb GetPaginaWeb(Inner element) { return DslModeling::DomainRoleInfo.GetLinkedElement(element, InnerDomainRoleId) as PaginaWeb; }
/// <summary>Function with a public inner class oject parameter.</summary> public void TestInnerClassObject(Inner TheInner) { }
public void ArrayShape() { _inner = new ArrayInner(); }
public void TypeClass() { _inner = new TypeInner(); }
private Comparator(string name, Func<NativeArray, NativeArray, int> cmp) { var inner = new Inner(); try { this.Handle = inner.Init(name, cmp); } finally { if (this.Handle == default(IntPtr)) inner.Dispose(); } }
public Task<long> SortedSetCombineAndStoreAsync(SetOperation operation, RedisKey destination, RedisKey first, RedisKey second, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetCombineAndStoreAsync(operation, ToInner(destination), ToInner(first), ToInner(second), aggregate, flags); }
public Task<long> SortedSetCombineAndStoreAsync(SetOperation operation, RedisKey destination, RedisKey[] keys, double[] weights = null, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetCombineAndStoreAsync(operation, ToInner(destination), ToInner(keys), weights, aggregate, flags); }
public Task<bool> SortedSetAddAsync(RedisKey key, RedisValue member, double score, When when = When.Always, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetAddAsync(ToInner(key), member, score, when, flags); }
public Task<bool> SortedSetAddAsync(RedisKey key, RedisValue member, double score, CommandFlags flags) { return Inner.SortedSetAddAsync(ToInner(key), member, score, flags); }
public Task<long> SortedSetAddAsync(RedisKey key, SortedSetEntry[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetAddAsync(ToInner(key), values, when, flags); }
public static DslModeling::LinkedElementCollection<EditItem> GetEditItems(Inner element) { return GetRoleCollection<DslModeling::LinkedElementCollection<EditItem>, EditItem>(element, InnerDomainRoleId); }
public static void SetInner(EditItem element, Inner newInner) { DslModeling::DomainRoleInfo.SetLinkedElement(element, EditItemDomainRoleId, newInner); }
public Task<long> StreamDeleteAsync(RedisKey key, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) { return Inner.StreamDeleteAsync(ToInner(key), messageIds, flags); }
public static void TestDisplayBoolAsString() { Inner innerInstance = new Inner(); innerInstance.DisplayBoolAsString(true); }
public Task<GeoPosition?> GeoPositionAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) => Inner.GeoPositionAsync(ToInner(key), member, flags);
/// <summary> /// Constructor /// Creates a InnerHasEditItems link in the same Partition as the given Inner /// </summary> /// <param name="source">Inner to use as the source of the relationship.</param> /// <param name="target">EditItem to use as the target of the relationship.</param> public InnerHasEditItems(Inner source, EditItem target) : base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(InnerHasEditItems.InnerDomainRoleId, source), new DslModeling::RoleAssignment(InnerHasEditItems.EditItemDomainRoleId, target)}, null) { }
public Task<double> SortedSetIncrementAsync(RedisKey key, RedisValue member, double value, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetIncrementAsync(ToInner(key), member, value, flags); }
public void TypeSimple(byte elemType) { _inner = new SimpleInner(ToType(elemType)); }
public Task<long> SortedSetLengthAsync(RedisKey key, double min = -1.0 / 0.0, double max = 1.0 / 0.0, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetLengthAsync(ToInner(key), min, max, exclude, flags); }
public Outer() { var i = new Inner(); i.InnerField = 4; }
public Task<SortedSetEntry[]> SortedSetRangeByRankWithScoresAsync(RedisKey key, long start = 0, long stop = -1, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetRangeByRankWithScoresAsync(ToInner(key), start, stop, order, flags); }
public Outer(Inner inner, int logLevel) { this.Inner = inner; this.LogLevel = logLevel; }
public Task<SortedSetEntry[]> SortedSetRangeByScoreWithScoresAsync(RedisKey key, double start = -1.0 / 0.0, double stop = 1.0 / 0.0, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetRangeByScoreWithScoresAsync(ToInner(key), start, stop, exclude, order, skip, take, flags); }
public Task<bool> StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue? position = null, CommandFlags flags = CommandFlags.None) { return Inner.StreamCreateConsumerGroupAsync(ToInner(key), groupName, position, flags); }
public Task<RedisValue[]> SortedSetRangeByValueAsync(RedisKey key, RedisValue min, RedisValue max, Exclude exclude, long skip, long take, CommandFlags flags) { return Inner.SortedSetRangeByValueAsync(ToInner(key), min, max, exclude, Order.Ascending, skip, take, flags); }
public Task<long> HashDecrementAsync(RedisKey key, RedisValue hashField, long value = 1, CommandFlags flags = CommandFlags.None) { return Inner.HashDecrementAsync(ToInner(key), hashField, value, flags); }
public Task<RedisValue[]> SortedSetRangeByValueAsync(RedisKey key, RedisValue min = default(RedisValue), RedisValue max = default(RedisValue), Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long take = -1, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetRangeByValueAsync(ToInner(key), min, max, exclude, order, skip, take, flags); }
public Task<long> StreamLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None) { return Inner.StreamLengthAsync(ToInner(key), flags); }
public Task<long?> SortedSetRankAsync(RedisKey key, RedisValue member, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetRankAsync(ToInner(key), member, order, flags); }
public Task<bool> StreamDeleteConsumerGroupAsync(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) { return Inner.StreamDeleteConsumerGroupAsync(ToInner(key), groupName, flags); }
public Task<bool> SortedSetRemoveAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetRemoveAsync(ToInner(key), member, flags); }
public Outter() { InnerProperty = new Inner(); }
public void TypePointer() { _inner = new PointerInner(); }
public Task<GeoRadiusResult[]> GeoRadiusAsync(RedisKey key, double longitude, double latitude, double radius, GeoUnit unit = GeoUnit.Meters, int count = -1, Order? order = null, GeoRadiusOptions options = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => Inner.GeoRadiusAsync(ToInner(key), longitude, latitude, radius, unit, count, order, options, flags);
public static void SetPaginaWeb(Inner element, PaginaWeb newPaginaWeb) { DslModeling::DomainRoleInfo.SetLinkedElement(element, InnerDomainRoleId, newPaginaWeb); }
public void GenericInst(int count) { _inner = new GenericInner(count); }
public Task<long> SortedSetRemoveRangeByRankAsync(RedisKey key, long start, long stop, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetRemoveRangeByRankAsync(ToInner(key), start, stop, flags); }
public void TypeValueType() { _inner = new TypeInner(); }
public Task<long> SortedSetRemoveRangeByScoreAsync(RedisKey key, double start, double stop, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetRemoveRangeByScoreAsync(ToInner(key), start, stop, exclude, flags); }
public void TypeInternal(IntPtr ptr) { _inner = new SimpleInner(_parent._typeFactory.FromHandle(ptr)); }
public Task<long> SortedSetRemoveRangeByValueAsync(RedisKey key, RedisValue min, RedisValue max, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetRemoveRangeByValueAsync(ToInner(key), min, max, exclude, flags); }
public void TypeSzArray() { _inner = new SzArrayInner(); }
public Task<double?> SortedSetScoreAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetScoreAsync(ToInner(key), member, flags); }
public static bool testMethod() { Inner Test = new Inner(); if (Test.IntI == 2) { return true; } else { return false; } }
public Task<SortedSetEntry[]> SortedSetPopAsync(RedisKey key, long count, Order order = Order.Ascending, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetPopAsync(ToInner(key), count, order, flags); }
public Task<long> StreamAcknowledgeAsync(RedisKey key, RedisValue groupName, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) { return Inner.StreamAcknowledgeAsync(ToInner(key), groupName, messageIds, flags); }
public Task<RedisValue> StreamAddAsync(RedisKey key, NameValueEntry[] streamPairs, RedisValue? messageId = null, int? maxLength = null, bool useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None) { return Inner.StreamAddAsync(ToInner(key), streamPairs, messageId, maxLength, useApproximateMaxLength, flags); }
public Middle(Inner inner) { Inner = inner; }
public Task<RedisValue[]> StreamClaimIdsOnlyAsync(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) { return Inner.StreamClaimIdsOnlyAsync(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, messageIds, flags); }
public Middle (Inner middle) { ConstructorArgInject = middle; }
/// <summary> /// Constructor /// Creates a PaginaWebHasInners link in the same Partition as the given PaginaWeb /// </summary> /// <param name="source">PaginaWeb to use as the source of the relationship.</param> /// <param name="target">Inner to use as the target of the relationship.</param> public PaginaWebHasInners(PaginaWeb source, Inner target) : base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(PaginaWebHasInners.PaginaWebDomainRoleId, source), new DslModeling::RoleAssignment(PaginaWebHasInners.InnerDomainRoleId, target)}, null) { }