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)
{
}
