public void Two_aggregates_with_same_id_should_be_equal()
{
object aggregate1 = new Aggregate("id");
object aggregate2 = new Aggregate("id");
aggregate1.Equals(aggregate2).Should().BeTrue();
}
internal AggregateNode(DataTable table, FunctionId aggregateType, string columnName, bool local, string relationName) : base(table) {
Debug.Assert(columnName != null, "Invalid parameter column name (null).");
this.aggregate = (Aggregate)(int)aggregateType;
if (aggregateType == FunctionId.Sum)
this.type = AggregateType.Sum;
else if (aggregateType == FunctionId.Avg)
this.type = AggregateType.Mean;
else if (aggregateType == FunctionId.Min)
this.type = AggregateType.Min;
else if (aggregateType == FunctionId.Max)
this.type = AggregateType.Max;
else if (aggregateType == FunctionId.Count)
this.type = AggregateType.Count;
else if (aggregateType == FunctionId.Var)
this.type = AggregateType.Var;
else if (aggregateType == FunctionId.StDev)
this.type = AggregateType.StDev;
else {
throw ExprException.UndefinedFunction(Function.FunctionName[(Int32)aggregateType]);
}
this.local = local;
this.relationName = relationName;
this.columnName = columnName;
}
public void When_taking_uncommitted_events_then_original_version_should_equal_version()
{
var aggregate = new Aggregate("id");
aggregate.Command();
((IAggregate)aggregate).TakeUncommittedEvents();
((IAggregate)aggregate).OriginalVersion.Should().Be(1);
}
public void should_publish_events_from_internal_entities() {
var aggregate = new Aggregate(Guid.Empty);
var guid = Guid.NewGuid();
aggregate.GenerateEntityEvent(new EntityCreated(guid));
var events = aggregate.GetUncommittedChanges();
Assert.That(
events.Any(@event => @event.GetType() == typeof (EntityCreated)));
}
public void Should_not_require_an_explicit_handler()
{
var aggregate = new Aggregate("id");
aggregate.Command();
aggregate.Version.Should().Be(1);
}
public void When_applying_command_then_version_should_be_incremented()
{
var aggregate = new Aggregate("id");
aggregate.Command();
((IAggregate)aggregate).OriginalVersion.Should().Be(0);
aggregate.Version.Should().Be(1);
}
public void When_raising_null_event_then_should_have_no_uncommitted_events()
{
var aggregate = new Aggregate("id");
aggregate.CommandThatDoesNothing();
var uncommittedEvents = ((IAggregate)aggregate).TakeUncommittedEvents();
uncommittedEvents.Count.Should().Be(0);
}
/// <summary>
/// Returns an object that represents the aggregate of the items in an IEnumerable defined
/// by the delegate supplied. An optional seed parameter is used as the aggregate collector.
/// </summary>
/// <param name="e">The IEnumerable to iterate.</param>
/// <param name="seed">Optional. The object to seed the delegate.</param>
/// <param name="a">The delegate which is applied to each element.</param>
/// <returns>An object that is the result of the aggregate being applied to each element.</returns>
public static object Aggregate(this IEnumerable e, object seed, Aggregate a)
{
foreach (var o in e)
{
seed = a(seed, o);
}
return seed;
}
private void writeAggregateDetails(Aggregate<IEventLogRecord> aggregate)
{
StreamWriter details =
new StreamWriter(File.Open(_folder + "\\" + _fileNameGenerator.NextName, FileMode.Create));
foreach (IEventLogRecord record in aggregate.Entries)
{
details.WriteLine(csv(record));
}
details.Close();
}
//this function computes the TeamBall Possession data for a specified time duration timeWindowInSec
public static IObservable<TeamBallPossession> computeTeamBallPossessionTW(IObservable<PlayerBallPossession> src,int timeWindowInSec)
{
var timeWindowInPico = timeWindowInSec * MetaData.SECOND_TO_PICO;
// List<PlayerBallPossession> list_of_values = new List<PlayerBallPossession>();
Aggregate seed= new Aggregate { currTeam = "", pTimeA = 0.0, pTimeB = 0.0, ts = 0 };
return src
.TimeWindowForTsDataAggregate(timeWindowInPico, "ts", seed, aggregatorFunction)
.Select(b => getTeamPossessionData(b));
}
public void UsingDefaultConstructorReturnsInstanceWithExpectedProperties()
{
var id = Guid.NewGuid();
var version = Aggregate.InitialVersion;
var root = new DummyAggregateRootEntity();
var sut = new Aggregate(id, version, root);
Assert.That(sut.Id, Is.EqualTo(id));
Assert.That(sut.Version, Is.EqualTo(version));
Assert.That(sut.Root, Is.EqualTo(root));
}
public static ICollection<ServerModeSummaryDescriptor> AddSummaryDesciptor(this ICollection<ServerModeSummaryDescriptor> source, Aggregate summaryType, string propertyName)
{
var result = source != null
? new List<ServerModeSummaryDescriptor>(source)
: new List<ServerModeSummaryDescriptor>();
var summaryDescriptor = summaryType.CreateDescriptorFor(propertyName);
result.Add(summaryDescriptor);
return result;
}
public void TestMethod1()
{
var value = new Aggregate { Base = new Derived() };
using (var stream = new MemoryStream())
{
Serializer.Serialize(stream, value);
stream.Position = 0;
var obj = Serializer.Deserialize<Aggregate>(stream);
Assert.AreEqual(typeof(Derived), obj.Base.GetType());
}
}
public void Should_route_event()
{
object @event = null;
var aggregate = new Aggregate("id", e => @event = e);
var eventThatIsRouted = new EventThatIsRouted();
using (var rehydrate = ((IAggregate)aggregate).BeginRehydrate())
{
rehydrate.ApplyEvent(eventThatIsRouted);
}
@event.Should().Be(eventThatIsRouted);
}
private static void replay(IEnumerable<Event> changeEvents, Aggregate aggregate)
{
foreach (var @event in changeEvents)
try
{
aggregate.AsDynamic().Receive(@event);
}
catch (ApplicationException e)
{
if (e.Source == "ReflectionMagic")
throw new MissingMethodException(aggregate.GetType().FullName, "Receive(" + @event.GetType() + ")");
throw;
}
}
public EventHandlerDiscovery Scan(Aggregate aggregate)
{
var handlerInterface = typeof(IHandle<>);
var aggType = aggregate.GetType();
var interfaces = aggType.GetInterfaces();
var instances = from i in aggType.GetInterfaces()
where (i.IsGenericType && handlerInterface.IsAssignableFrom(i.GetGenericTypeDefinition()))
select i.GenericTypeArguments[0];
foreach (var i in instances)
{
Handlers.Add(i, aggregate);
}
return this;
}
public MainWindow()
{
InitializeComponent();
// populate Aggregate combobox
var aggregates = new Aggregate[]
{
Aggregate.None,
Aggregate.Sum,
Aggregate.Average,
Aggregate.Maximum,
Aggregate.Minimum,
Aggregate.Count
};
foreach (var agg in aggregates)
{
_cmbAggregates.Items.Add(agg);
}
_cmbAggregates.SelectedIndex = 1; // Aggregate.Sum
// build data source
var view = Product.GetProducts(200);
// set up grouping
var gd = view.GroupDescriptions;
gd.Add(new PropertyGroupDescription("Total")); // grand total group
gd.Add(new PropertyGroupDescription("Line")); // group by product line
gd.Add(new PropertyGroupDescription("Color")); // group by product color
gd.Add(new PropertyGroupDescription("Price")); // group by price range
var pgdPrice = gd[gd.Count - 1] as PropertyGroupDescription;
pgdPrice.Converter = new PriceRangeConverter();
// assign data source to grid
_flex.ItemsSource = view;
// provide choices in grid editors
_flex.Columns["Line"].ValueConverter = new ColumnValueConverter(Product.GetLines(), true);
_flex.Columns["Color"].ValueConverter = new ColumnValueConverter(Product.GetColors(), false);
// needed to show aggregates
_flex.AreRowGroupHeadersFrozen = false;
}
//calculates the team ball possession data from player ball possession
private static Aggregate aggregatorFunction(Aggregate seed, PlayerBallPossession curr,
IList<PlayerBallPossession> expList, long count)
{
double pTimeA = seed.pTimeA, pTimeB = seed.pTimeB;
//remove expired possession time from the aggregate team possession time information
foreach (var ele in expList)
{
if (MetaData.PLAYER_TEAM_MAP[ele.player_id].Equals("A"))
pTimeA -= ele.time;
else
pTimeB -= ele.time;
}
string team_name = MetaData.PLAYER_TEAM_MAP[curr.player_id];
//if the player for which this PlayerBallPossession information(curr) belongs to Team A
//then add possession time of this player to pTimeA else to pTimeB
if (team_name.Equals("A"))
pTimeA = seed.pTimeA + curr.time;
else
pTimeB = seed.pTimeB + curr.time;
//return updated team possession time information
return new Aggregate { currTeam = team_name, pTimeA = pTimeA, pTimeB = pTimeB, ts = curr.ts };
}
protected override String GetOperatorString(Aggregate operatorType)
{
return base.GetOperatorString(operatorType);
}
public override void PreSave(Aggregate aggregate, CommandContext context)
{
base.PreSave(null, null); PreSaveHandled = true;
}
/// <summary>
/// Creates Entities from aggregates (collections of components)
/// </summary>
/// <param name="aggregate">The specific aggreage to create</param>
public void CreateFromAggregate(Aggregate aggregate)
{
switch (aggregate)
{
case Aggregate.FairyPlayer:
uint entityID = Entity.NextEntity();
Texture2D spriteSheet = game.Content.Load<Texture2D>("Spritesheets/wind_fae");
spriteSheet.Name = "Spritesheets/wind_fae";
Position position = new Position()
{
EntityID = entityID,
Center = new Vector2(400, 50),
Radius = 32f,
};
game.PositionComponent[entityID] = position;
Movement movement = new Movement() {
EntityID = entityID,
Direction = new Vector2(0, 1),
Speed = 200f,
};
game.MovementComponent[entityID] = movement;
MovementSprite movementSprite = new MovementSprite() {
EntityID = entityID,
Facing = Facing.South,
SpriteSheet = spriteSheet,
SpriteBounds = new Rectangle(0, 0, 64, 64),
Timer = 0f,
};
game.MovementSpriteComponent[entityID] = movementSprite;
Local local = new Local(){
EntityID = entityID,
};
game.LocalComponent[entityID] = local;
Player player = new Player()
{
EntityID = entityID,
PlayerIndex = PlayerIndex.One,
};
game.PlayerComponent[entityID] = player;
break;
case Aggregate.CultistPlayer:
break;
case Aggregate.CyborgPlayer:
break;
case Aggregate.EarthianPlayer:
break;
case Aggregate.GargranianPlayer:
break;
case Aggregate.SpacePiratePlayer:
break;
case Aggregate.ZombiePlayer:
break;
}
}
public bool TryCreateObject(ObjectType objectType, out IPersistable persistObj)
{
switch (objectType)
{
case ObjectType.Aggregate:
persistObj = new Aggregate();
break;
case ObjectType.AggregateRow:
persistObj = new AggregateRow();
break;
case ObjectType.Avg:
persistObj = new Avg();
break;
case ObjectType.BTree:
persistObj = new BTree();
break;
case ObjectType.BTreeNode:
persistObj = new BTreeNode();
break;
case ObjectType.BTreeNodeTupleList:
persistObj = new BTreeNodeTupleList();
break;
case ObjectType.BTreeNodeTuple:
persistObj = new BTreeNodeTuple();
break;
case ObjectType.BTreeNodeHierarchyObj:
persistObj = new BTreeNodeHierarchyObj();
break;
case ObjectType.CalculatedFieldWrapperImpl:
persistObj = new CalculatedFieldWrapperImpl();
break;
case ObjectType.ChildLeafInfo:
persistObj = new ChildLeafInfo();
break;
case ObjectType.Count:
persistObj = new Count();
break;
case ObjectType.CountDistinct:
persistObj = new CountDistinct();
break;
case ObjectType.CountRows:
persistObj = new CountRows();
break;
case ObjectType.DataAggregateObj:
persistObj = new DataAggregateObj();
break;
case ObjectType.DataAggregateObjResult:
persistObj = new DataAggregateObjResult();
break;
case ObjectType.DataFieldRow:
persistObj = new DataFieldRow();
break;
case ObjectType.DataRegionMemberInstance:
persistObj = new DataRegionMemberInstance();
break;
case ObjectType.FieldImpl:
persistObj = new FieldImpl();
break;
case ObjectType.First:
persistObj = new First();
break;
case ObjectType.Last:
persistObj = new Last();
break;
case ObjectType.Max:
persistObj = new Max();
break;
case ObjectType.Min:
persistObj = new Min();
break;
case ObjectType.Previous:
persistObj = new Previous();
break;
case ObjectType.RuntimeCells:
persistObj = new RuntimeCells();
break;
case ObjectType.RuntimeChartCriCell:
persistObj = new RuntimeChartCriCell();
break;
case ObjectType.RuntimeChartCriGroupLeafObj:
persistObj = new RuntimeChartCriGroupLeafObj();
break;
case ObjectType.RuntimeChartObj:
persistObj = new RuntimeChartObj();
break;
case ObjectType.RuntimeGaugePanelObj:
persistObj = new RuntimeGaugePanelObj();
break;
case ObjectType.RuntimeCriObj:
persistObj = new RuntimeCriObj();
break;
case ObjectType.RuntimeDataTablixGroupRootObj:
persistObj = new RuntimeDataTablixGroupRootObj();
break;
case ObjectType.RuntimeDataTablixMemberObj:
persistObj = new RuntimeDataTablixMemberObj();
break;
case ObjectType.RuntimeExpressionInfo:
persistObj = new RuntimeExpressionInfo();
break;
case ObjectType.RuntimeHierarchyObj:
persistObj = new RuntimeHierarchyObj();
break;
case ObjectType.RuntimeRICollection:
persistObj = new RuntimeRICollection();
break;
case ObjectType.RuntimeSortDataHolder:
persistObj = new RuntimeSortDataHolder();
break;
case ObjectType.RuntimeSortFilterEventInfo:
persistObj = new RuntimeSortFilterEventInfo();
break;
case ObjectType.RuntimeSortHierarchyObj:
persistObj = new RuntimeSortHierarchyObj();
break;
case ObjectType.RuntimeDataRowSortHierarchyObj:
persistObj = new RuntimeDataRowSortHierarchyObj();
break;
case ObjectType.RuntimeTablixCell:
persistObj = new RuntimeTablixCell();
break;
case ObjectType.RuntimeTablixGroupLeafObj:
persistObj = new RuntimeTablixGroupLeafObj();
break;
case ObjectType.RuntimeTablixObj:
persistObj = new RuntimeTablixObj();
break;
case ObjectType.RuntimeUserSortTargetInfo:
persistObj = new RuntimeUserSortTargetInfo();
break;
case ObjectType.ScopeLookupTable:
persistObj = new ScopeLookupTable();
break;
case ObjectType.SortExpressionScopeInstanceHolder:
persistObj = new RuntimeSortFilterEventInfo.SortExpressionScopeInstanceHolder();
break;
case ObjectType.SortFilterExpressionScopeObj:
persistObj = new RuntimeSortFilterEventInfo.SortFilterExpressionScopeObj();
break;
case ObjectType.SortHierarchyStruct:
persistObj = new RuntimeSortHierarchyObj.SortHierarchyStructure();
break;
case ObjectType.SortScopeValuesHolder:
persistObj = new RuntimeSortFilterEventInfo.SortScopeValuesHolder();
break;
case ObjectType.StDev:
persistObj = new StDev();
break;
case ObjectType.StDevP:
persistObj = new StDevP();
break;
case ObjectType.StorageItem:
persistObj = new StorageItem();
break;
case ObjectType.Sum:
persistObj = new Sum();
break;
case ObjectType.Var:
persistObj = new Var();
break;
case ObjectType.VarP:
persistObj = new VarP();
break;
case ObjectType.FilterKey:
persistObj = new Filters.FilterKey();
break;
case ObjectType.LookupMatches:
persistObj = new LookupMatches();
break;
case ObjectType.LookupMatchesWithRows:
persistObj = new LookupMatchesWithRows();
break;
case ObjectType.LookupTable:
persistObj = new LookupTable();
break;
case ObjectType.Union:
persistObj = new Union();
break;
case ObjectType.RuntimeMapDataRegionObj:
persistObj = new RuntimeMapDataRegionObj();
break;
case ObjectType.DataScopeInfo:
persistObj = new DataScopeInfo();
break;
case ObjectType.BucketedDataAggregateObjs:
persistObj = new BucketedDataAggregateObjs();
break;
case ObjectType.DataAggregateObjBucket:
persistObj = new DataAggregateObjBucket();
break;
case ObjectType.RuntimeGroupingObjHash:
persistObj = new RuntimeGroupingObjHash();
break;
case ObjectType.RuntimeGroupingObjTree:
persistObj = new RuntimeGroupingObjTree();
break;
case ObjectType.RuntimeGroupingObjDetail:
persistObj = new RuntimeGroupingObjDetail();
break;
case ObjectType.RuntimeGroupingObjDetailUserSort:
persistObj = new RuntimeGroupingObjDetailUserSort();
break;
case ObjectType.RuntimeGroupingObjLinkedList:
persistObj = new RuntimeGroupingObjLinkedList();
break;
case ObjectType.RuntimeGroupingObjNaturalGroup:
persistObj = new RuntimeGroupingObjNaturalGroup();
break;
default:
persistObj = null;
return(false);
}
return(true);
}
public long ZsetUnionStore(RedisKey dest, RedisKey first, RedisKey second, Aggregate aggregate)
{
return(m_DataBase.SortedSetCombineAndStore(SetOperation.Union, dest, first, second, aggregate));
}
public void should_handle_single_return_value()
{
Aggregate.Do(new Hide());
Assert.False(State.IsVisible);
}
/// <summary>
/// Returns an object that represents the aggregate of the items in an IEnumerable defined
/// by the delegate supplied. An optional seed parameter is used as the aggregate collector.
/// </summary>
/// <param name="e">The IEnumerable to iterate.</param>
/// <param name="a">The delegate which is applied to each element.</param>
/// <returns>An object that is the result of the aggregate being applied to each element.</returns>
public static object Aggregate(this IEnumerable e, Aggregate a)
{
return(Aggregate(e, new object(), a));
}
private IObservable <TdApi.Message> LoadAggregateMessages(
Aggregate aggregate,
AggregateLoadingState state)
{
var actualLimit = _limit;
var list = aggregate.Chats.Select(f =>
{
var stackedCount = state.CountStackedMessages(f.ChatData.Id);
return(Enumerable.Range(0, stackedCount)
.Select(_ => state.PopMessageFromStack(f.ChatData.Id)) // get stacked messages for this chat
.ToObservable()
.Concat(stackedCount < _limit
? LoadChannelMessages(f, new ChatLoadingState // load messages from the server
{
LastMessageId = state.GetLastMessageId(f.ChatData.Id)
}, _limit, 0)
: Observable.Empty <TdApi.Message>())
.Aggregate(new List <TdApi.Message>(), (l, m) =>
{
l.Add(m);
return l;
})
.Do(l =>
{
// api has no guarantees about actual number of messages returned
// actual limit would be equal to min number of messages for all feeds
// unless it is zero
if (l.Count > 0 && l.Count < actualLimit)
{
actualLimit = l.Count;
}
})
.SelectMany(messages => messages));
});
return(list.Merge()
.Aggregate(new List <TdApi.Message>(), (l, m) =>
{
l.Add(m);
return l;
})
.SelectMany(l =>
{
// make sure all messages are unique
var all = l.GroupBy(m => m.Id)
.Select(g => g.First())
.OrderByDescending(m => m.Date)
.ToArray();
var toBeReturned = all.Take(actualLimit);
var toBeStacked = all.Skip(actualLimit);
// remember last message id
foreach (var message in all.Reverse())
{
state.SetLastMessageId(message.ChatId, message.Id);
}
// put into stack
foreach (var message in toBeStacked.Reverse())
{
state.PushMessageToStack(message.ChatId, message);
}
return toBeReturned;
}));
}
public static ICollection <ServerModeSummaryDescriptor> AddSummaryDesciptor(this ICollection <ServerModeSummaryDescriptor> source, Aggregate summaryType, string propertyName)
{
var result = source != null
? new List <ServerModeSummaryDescriptor>(source)
: new List <ServerModeSummaryDescriptor>();
var summaryDescriptor = summaryType.CreateDescriptorFor(propertyName);
result.Add(summaryDescriptor);
return(result);
}
public static ServerModeSummaryDescriptor CreateDescriptorFor(this string propertyName, Aggregate summaryType)
{
return(new ServerModeSummaryDescriptor(new OperandProperty(propertyName), summaryType));
}
private static string CalculateKeyPart(Aggregate source)
{
return(source.ToString());
}
private Task Save(Aggregate agg, string entityName, Guid userId)
{
return(_aggregateStorage.SaveEventsAsync(agg, entityName, userId));
}
public void Save(Aggregate aggregate)
{
_store.AddEvents(aggregate.Id, aggregate.GetEvents());
}
public Task <long> SortedSetCombineAndStoreAsync(SetOperation operation, RedisKey destination, RedisKey first, RedisKey second, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None)
{
return(this.db.SortedSetCombineAndStoreAsync(operation, destination, first, second, aggregate, flags));
}
public override void PreSave(Aggregate aggregate, CommandContext context)
{
}
public void Sum()
{
// NOTE: fully qualifying the type name matters. If this were a real thing, you could put in default namespaces.
var summer = new Aggregate<Event<long>>("(sum, @event) => new RoslynRx.Tests.Event<long>(0, sum.Data + @event.Data)");
var testInterval = new TestInterval();
long sum = long.MinValue;
testInterval.Interval.Link(summer).Subscribe(i => sum = i.Data);
testInterval.Start();
sum.Should().Be(1770);
}
private void _createFromState(TAggregateState state)
{
Aggregate.SetState(state);
}
public void SetUp()
{
_createSomething = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_sampleCommandSequence = new sampleCommandSequence();
_commandResponse = new CommandResponse {
Events = _events, Result = "Result"
};
_domainCommandResponse = new CommandResponse {
Events = _aggregate.Events, Result = "Result"
};
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.Publish(_aggregateCreatedConcrete));
_storeProvider = new Mock <IStoreProvider>();
_storeProvider
.Setup(x => x.Save(It.IsAny <SaveStoreData>()))
.Callback <SaveStoreData>(x => _storeDataSaved = x);
_eventFactory = new Mock <IEventFactory>();
_eventFactory
.Setup(x => x.CreateConcreteEvent(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_eventFactory
.Setup(x => x.CreateConcreteEvent(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_validationService = new Mock <IValidationService>();
_validationService
.Setup(x => x.Validate(_createAggregate));
_commandHandler = new Mock <ICommandHandler <CreateSomething> >();
_commandHandler
.Setup(x => x.Handle(_createSomething))
.Returns(_commandResponse);
_domainCommandHandler = new Mock <ICommandHandler <CreateAggregate> >();
_domainCommandHandler
.Setup(x => x.Handle(_createAggregate))
.Returns(_domainCommandResponse);
_sequenceCommandHandler = new Mock <ISequenceCommandHandler <ICommand> >();
_sequenceCommandHandler
.Setup(x => x.Handle(It.IsAny <ICommand>(), It.IsAny <CommandResponse>()))
.Returns(It.IsAny <CommandResponse>());
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler(_createSomething, typeof(ICommandHandler <>)))
.Returns(_commandHandler.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(_createAggregate, typeof(ICommandHandler <>)))
.Returns(_domainCommandHandler.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(It.IsAny <ICommand>(), typeof(ISequenceCommandHandler <>)))
.Returns(_sequenceCommandHandler.Object);
_optionsMock = new Mock <IOptions <Options> >();
_optionsMock
.Setup(x => x.Value)
.Returns(new Options());
_sut = new CommandSender(_handlerResolver.Object,
_eventPublisher.Object,
_eventFactory.Object,
_storeProvider.Object,
_validationService.Object,
_optionsMock.Object);
}
public SceneDescription(Aggregate aggr, IEnumerable <Light> lights, Camera camera)
{
Scene = new Scene(aggr, lights);
Camera = camera;
}
public ExecutionReport VariantAnalysis(char strand, Dictionary <string, Dictionary <char, List <I> > > references, Aggregate aggregate, out FunctionOutput <Output <C, I, M> > result, MaxDegreeOfParallelism maxDegreeOfParallelism, out Dictionary <uint, int> newRes)
{
return(genome.VariantAnalysis(references, strand, aggregate, out result, out newRes, maxDegreeOfParallelism));
}
public List <DomainEvent> EventsForAggregate(Aggregate aggregate)
{
return(EventsForAggregate(new AggregateKey(aggregate)));
}
private static List <Declaration> BuildDeclarations()
{
return(new List <Declaration>(83)
{
Aggregate.GetDeclaration(),
AggregateRow.GetDeclaration(),
Avg.GetDeclaration(),
BTree.GetDeclaration(),
BTreeNode.GetDeclaration(),
BTreeNodeTuple.GetDeclaration(),
BTreeNodeTupleList.GetDeclaration(),
BTreeNodeHierarchyObj.GetDeclaration(),
CalculatedFieldWrapperImpl.GetDeclaration(),
ChildLeafInfo.GetDeclaration(),
Count.GetDeclaration(),
CountDistinct.GetDeclaration(),
CountRows.GetDeclaration(),
DataAggregateObj.GetDeclaration(),
DataAggregateObjResult.GetDeclaration(),
DataRegionMemberInstance.GetDeclaration(),
DataFieldRow.GetDeclaration(),
FieldImpl.GetDeclaration(),
First.GetDeclaration(),
Last.GetDeclaration(),
Max.GetDeclaration(),
Min.GetDeclaration(),
Previous.GetDeclaration(),
RuntimeCell.GetDeclaration(),
RuntimeCells.GetDeclaration(),
RuntimeCellWithContents.GetDeclaration(),
RuntimeChartCriCell.GetDeclaration(),
RuntimeChartCriGroupLeafObj.GetDeclaration(),
RuntimeChartCriObj.GetDeclaration(),
RuntimeChartObj.GetDeclaration(),
RuntimeCriObj.GetDeclaration(),
RuntimeDataRegionObj.GetDeclaration(),
RuntimeDataTablixObj.GetDeclaration(),
RuntimeDataTablixGroupLeafObj.GetDeclaration(),
RuntimeDataTablixGroupRootObj.GetDeclaration(),
RuntimeDataTablixMemberObj.GetDeclaration(),
RuntimeDataTablixWithScopedItemsObj.GetDeclaration(),
RuntimeDataTablixWithScopedItemsGroupLeafObj.GetDeclaration(),
RuntimeDetailObj.GetDeclaration(),
RuntimeExpressionInfo.GetDeclaration(),
RuntimeGroupLeafObj.GetDeclaration(),
RuntimeGroupObj.GetDeclaration(),
RuntimeGroupRootObj.GetDeclaration(),
RuntimeGroupingObj.GetDeclaration(),
RuntimeHierarchyObj.GetDeclaration(),
RuntimeMemberObj.GetDeclaration(),
RuntimeRDLDataRegionObj.GetDeclaration(),
RuntimeRICollection.GetDeclaration(),
RuntimeSortDataHolder.GetDeclaration(),
RuntimeSortFilterEventInfo.GetDeclaration(),
RuntimeSortFilterEventInfo.SortExpressionScopeInstanceHolder.GetDeclaration(),
RuntimeSortFilterEventInfo.SortFilterExpressionScopeObj.GetDeclaration(),
RuntimeSortFilterEventInfo.SortScopeValuesHolder.GetDeclaration(),
RuntimeSortHierarchyObj.GetDeclaration(),
RuntimeSortHierarchyObj.SortHierarchyStructure.GetDeclaration(),
RuntimeDataRowSortHierarchyObj.GetDeclaration(),
RuntimeTablixCell.GetDeclaration(),
RuntimeTablixGroupLeafObj.GetDeclaration(),
RuntimeTablixObj.GetDeclaration(),
RuntimeUserSortTargetInfo.GetDeclaration(),
ScopeInstance.GetDeclaration(),
ScopeLookupTable.GetDeclaration(),
StDev.GetDeclaration(),
StDevP.GetDeclaration(),
Sum.GetDeclaration(),
Var.GetDeclaration(),
VarBase.GetDeclaration(),
VarP.GetDeclaration(),
Filters.FilterKey.GetDeclaration(),
RuntimeGaugePanelObj.GetDeclaration(),
LookupMatches.GetDeclaration(),
LookupMatchesWithRows.GetDeclaration(),
LookupTable.GetDeclaration(),
RuntimeMapDataRegionObj.GetDeclaration(),
DataScopeInfo.GetDeclaration(),
BucketedDataAggregateObjs.GetDeclaration(),
DataAggregateObjBucket.GetDeclaration(),
RuntimeGroupingObjHash.GetDeclaration(),
RuntimeGroupingObjTree.GetDeclaration(),
RuntimeGroupingObjDetail.GetDeclaration(),
RuntimeGroupingObjDetailUserSort.GetDeclaration(),
RuntimeGroupingObjLinkedList.GetDeclaration(),
RuntimeGroupingObjNaturalGroup.GetDeclaration()
});
}
public long ZsetUnionStore(RedisKey dest, RedisKey[] keys, double[] weights, Aggregate aggregate)
{
return(m_DataBase.SortedSetCombineAndStore(SetOperation.Union, dest, keys, weights, aggregate));
}
/// <summary>
/// Returns an object that represents the aggregate of the items in an IEnumerable defined
/// by the delegate supplied. An optional seed parameter is used as the aggregate collector.
/// </summary>
/// <param name="e">The IEnumerable to iterate.</param>
/// <param name="seed">Optional. The object to seed the delegate.</param>
/// <param name="a">The aggregate delegate which is applied to each element.</param>
/// <param name="s">Optional. A selector delegate used to select the result from the seed.</param>
/// <returns>An object that is the result of the aggregate being applied to each element.</returns>
public static object Aggregate(this IEnumerable e, object seed, Aggregate a, Selector s)
{
return(s(Aggregate(e, seed, a)));
}
public IAttributeDefinition Aggregate(Aggregate aggregate)
{
if (IsMultiValue)
{
switch (aggregate)
{
case APIClient.Aggregate.Min:
switch (AttributeType)
{
case AttributeType.Numeric:
return(metaModel.GetAttributeDefinition(Token + ".@Min"));
case AttributeType.Date:
return(metaModel.GetAttributeDefinition(Token + ".@MinDate"));
}
throw new MetaException("Must aggregate MIN of numerics and dates");
case APIClient.Aggregate.Max:
switch (AttributeType)
{
case AttributeType.Numeric:
return(metaModel.GetAttributeDefinition(Token + ".@Max"));
case AttributeType.Date:
return(metaModel.GetAttributeDefinition(Token + ".@MaxDate"));
}
throw new MetaException("Must aggregate MAX of numerics and dates");
case APIClient.Aggregate.Count:
if (AttributeType == AttributeType.Relation)
{
return(metaModel.GetAttributeDefinition(Token + ".@Count"));
}
throw new MetaException("Must aggregate COUNT of relations");
case APIClient.Aggregate.Sum:
if (AttributeType == AttributeType.Numeric)
{
return(metaModel.GetAttributeDefinition(Token + ".@Sum"));
}
throw new MetaException("Must aggregate SUM of numerics");
case APIClient.Aggregate.And:
if (AttributeType == AttributeType.Boolean)
{
return(metaModel.GetAttributeDefinition(Token + ".@And"));
}
throw new MetaException("Must aggregate AND of booleans");
case APIClient.Aggregate.Or:
if (AttributeType == AttributeType.Boolean)
{
return(metaModel.GetAttributeDefinition(Token + ".@Or"));
}
throw new MetaException("Must aggregate OR of booleans");
}
}
throw new MetaException("Must aggregate multi-value attributes");
}
public override void PostGet(Aggregate aggregate)
{
base.PostGet(null); PostGetHandled = true;
}
public async Task Cleanup()
{
await Aggregate.ScheduleDeleteAsync(SutSchedule);
}
public override void PostSave(Aggregate aggregate, Commit commit, Exception error)
{
base.PostSave(null, null, null); PostSaveHandled = true;
}
private IEnumerable <object> GetClasses(Aggregate aggregate, Entity entity)
{
var classContexts = GetClassGenerationContexts(entity);
foreach (var classContext in classContexts)
{
var contextualSuffixes = GetContextualClassAndPropertyNameSuffixes(entity);
foreach (var contextualSuffix in contextualSuffixes)
{
yield return
(new
{
AggregateName = aggregate.Name, ClassName = entity.Name, TableName = entity.Name, SchemaName = entity.Schema,
ClassNameSuffix = QueryModelSuffix, ContextualClassNameSuffix = contextualSuffix.ClassNameSuffix, entity.IsAggregateRoot,
entity.IsAbstract, entity.IsDerived, classContext.IsConcreteEntityBaseClass,
classContext.IsConcreteEntityChildClassForBase, BaseAggregateRootRelativeNamespace =
entity.IsDerived
? entity.BaseEntity.GetRelativeEntityNamespace(
entity.BaseEntity.SchemaProperCaseName(),
true,
!entity.BaseEntity.IsEdFiStandardEntity)
+ (!entity.BaseEntity.IsAbstract
? "Base"
: string.Empty)
+ QueryModelSuffix
: NotRendered,
PrimaryKey = new
{
ParentReference = entity.ParentAssociation != null
? new
{
ParentClassName = entity.Parent.Name, FullyQualifiedParentClassName =
$"{entity.GetRelativeAggregateNamespace(entity.Parent.IsEdFiStandardEntity ? EdFiConventions.ProperCaseName : TemplateContext.SchemaProperCaseName, isQueryModel: true)}.{entity.Parent.Name}",
ContextualSuffix = (classContext.IsConcreteEntityChildClassForBase
? "Base"
: string.Empty)
+ QueryModelSuffix
}
: NotRendered,
NonParentProperties = entity
.Identifier
.Properties
.Where(p => !p.IsFromParent)
.Select(
p => new
{
entity.IsAbstract,
NeedsOverride = entity.IsDerived && !p.IsInheritedIdentifyingRenamed,
CSharpDeclaredType =
p.PropertyType.ToCSharp(includeNullability: true),
CSharpSafePropertyName =
p.PropertyName.MakeSafeForCSharpClass(entity.Name)
})
},
Properties = GetMappedProperties(entity, contextualSuffix)
.OrderBy(p => p.PropertyName)
.Select(
p => new
{
CSharpDeclaredType = p.PropertyType.ToCSharp(includeNullability: true), PropertyName = p.PropertyName.ToMixedCase()
}),
HasOneToOnes = GetMappedNavigableOneToOnes(entity).Any(), OneToOnes = GetMappedNavigableOneToOnes(entity)
.Select(
a => new
{
OtherClassName = a.OtherEntity.Name, ClassNameSuffix = QueryModelSuffix
}),
NavigableChildren = GetMappedCollectionAssociations(entity)
.Where(a => _shouldRenderEntityForSchema(a.OtherEntity))
.OrderBy(a => a.Name)
.SelectMany(a => GetContextualNavigableChildren(a, classContext)),
HasNonNavigableChildren = GetMappedExternalCollectionAssociations(entity)
.Any(a => _shouldRenderEntityForSchema(a.OtherEntity)),
NonNavigableChildren = GetMappedExternalCollectionAssociations(entity)
.Where(a => _shouldRenderEntityForSchema(a.OtherEntity))
.OrderBy(a => a.Name)
.SelectMany(GetContextualNonNavigableChildren),
HasNonNavigableParents = GetMappedExternalParentAssociations(entity)
.Any(a => _shouldRenderEntityForSchema(a.OtherEntity)),
NonNavigableParents = GetMappedExternalParentAssociations(entity)
.Where(a => _shouldRenderEntityForSchema(a.OtherEntity))
.OrderBy(a => a.Name)
.Select(
a => new
{
AggregateRelativeNamespace = a.OtherEntity.GetRelativeAggregateNamespace(
TemplateContext.SchemaProperCaseName,
isQueryModel: true,
isExtensionContext: TemplateContext.IsExtension),
ClassName = a.OtherEntity.Name, ClassNameSuffix = QueryModelSuffix,
AssociationName = a.Name
})
});
}
}
}
public override void PostGet(Aggregate aggregate)
{
}
public long SortedSetCombineAndStore(SetOperation operation, RedisKey destination, RedisKey[] keys, double[] weights = null, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None)
{
return(Inner.SortedSetCombineAndStore(operation, ToInner(destination), ToInner(keys), weights, aggregate, flags));
}
public override void PostSave(Aggregate aggregate, Commit commit, Exception error)
{
}
public long SortedSetCombineAndStore(SetOperation operation, RedisKey destination, RedisKey first, RedisKey second, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None)
{
return(Inner.SortedSetCombineAndStore(operation, ToInner(destination), ToInner(first), ToInner(second), aggregate, flags));
}
public void Get_hash_code_should_be_id()
{
var aggregate = new Aggregate("id");
aggregate.GetHashCode().Should().Be("id".GetHashCode());
}
public ExecutionReport Cover(CoverVariation coverVariation, char strand, int minAcc, int maxAcc, Aggregate aggregate, out FunctionOutput <Output <C, I, M> > result, MaxDegreeOfParallelism maxDegreeOfParallelism)
{
return(genome.Cover(coverVariation, strand, minAcc, maxAcc, aggregate, out result, maxDegreeOfParallelism));
}
/// <summary>
/// Convenience extension to wrap Aggregate for numeric operations with an initial seed value of 0.
/// </summary>
/// <param name="e">The IEnumerable to iterate. Should be a ValueType array or collection.</param>
/// <param name="seed">The initial value to start the sum. This must be the same type as used in the aggregate delegate.</param>
/// <param name="a">The aggregate delegate used to perform the sum operation on the elements.</param>
/// <param name="s">Optional. A selector delegate used to select the value from an object.</param>
/// <returns>ValueType with the sum value.</returns>
public static ValueType Sum(this IEnumerable e, ValueType seed, Aggregate a, Selector s)
{
return(Aggregate(e, seed, a, s) as ValueType);
}
public ExecutionReport Map(char strand, Dictionary <string, Dictionary <char, List <I> > > references, Aggregate aggregate, out FunctionOutput <Output <C, I, M> > result, MaxDegreeOfParallelism maxDegreeOfParallelism)
{
return(genome.Map(references, strand, aggregate, out result, maxDegreeOfParallelism));
}
// CONSIDER: configure the scanner : local info
internal ExpressionNode Parse()
{
// free all nodes
_expression = null;
StartScan();
int cParens = 0;
OperatorInfo opInfo;
while (_token != Tokens.EOS)
{
loop:
Scan();
switch (_token)
{
case Tokens.EOS:
// End of string: must be operand; force out expression;
// check for bomb; check nothing left on stack.
if (_prevOperand == Empty)
{
if (_topNode == 0)
{
// we have an empty expression
break;
}
// set error missing operator
// read the last operator info
opInfo = _ops[_topOperator - 1];
throw ExprException.MissingOperand(opInfo);
}
// collect all nodes
BuildExpression(Operators.priLow);
if (_topOperator != 1)
{
throw ExprException.MissingRightParen();
}
break;
case Tokens.Name:
case Tokens.Parent:
case Tokens.Numeric:
case Tokens.Decimal:
case Tokens.Float:
case Tokens.StringConst:
case Tokens.Date:
ExpressionNode node = null;
string str = null;
/* Constants and identifiers: create leaf node */
if (_prevOperand != Empty)
{
// set error missing operator
throw ExprException.MissingOperator(new string(_text, _start, _pos - _start));
}
if (_topOperator > 0)
{
// special check for IN without parentheses
opInfo = _ops[_topOperator - 1];
if (opInfo._type == Nodes.Binop && opInfo._op == Operators.In && _token != Tokens.Parent)
{
throw ExprException.InWithoutParentheses();
}
}
_prevOperand = Scalar;
switch (_token)
{
case Tokens.Parent:
string relname;
string colname;
// parsing Parent[(relation_name)].column_name)
try
{
// expecting an '(' or '.'
Scan();
if (_token == Tokens.LeftParen)
{
//read the relation name
ScanToken(Tokens.Name);
relname = NameNode.ParseName(_text, _start, _pos);
ScanToken(Tokens.RightParen);
ScanToken(Tokens.Dot);
}
else
{
relname = null;
CheckToken(Tokens.Dot);
}
}
catch (Exception e) when(Common.ADP.IsCatchableExceptionType(e))
{
throw ExprException.LookupArgument();
}
ScanToken(Tokens.Name);
colname = NameNode.ParseName(_text, _start, _pos);
opInfo = _ops[_topOperator - 1];
node = new LookupNode(_table, colname, relname);
break;
case Tokens.Name:
/* Qualify name now for nice error checking */
opInfo = _ops[_topOperator - 1];
/* Create tree element - */
// CONSIDER: Check for reserved proc names here
node = new NameNode(_table, _text, _start, _pos);
break;
case Tokens.Numeric:
str = new string(_text, _start, _pos - _start);
node = new ConstNode(_table, ValueType.Numeric, str);
break;
case Tokens.Decimal:
str = new string(_text, _start, _pos - _start);
node = new ConstNode(_table, ValueType.Decimal, str);
break;
case Tokens.Float:
str = new string(_text, _start, _pos - _start);
node = new ConstNode(_table, ValueType.Float, str);
break;
case Tokens.StringConst:
Debug.Assert(_text[_start] == '\'' && _text[_pos - 1] == '\'', "The expression contains an invalid string constant");
Debug.Assert(_pos - _start > 1, "The expression contains an invalid string constant");
// Store string without quotes..
str = new string(_text, _start + 1, _pos - _start - 2);
node = new ConstNode(_table, ValueType.Str, str);
break;
case Tokens.Date:
Debug.Assert(_text[_start] == '#' && _text[_pos - 1] == '#', "The expression contains invalid date constant.");
Debug.Assert(_pos - _start > 2, "The expression contains invalid date constant '{0}'.");
// Store date without delimiters(#s)..
str = new string(_text, _start + 1, _pos - _start - 2);
node = new ConstNode(_table, ValueType.Date, str);
break;
default:
Debug.Assert(false, "unhandled token");
break;
}
NodePush(node);
goto loop;
case Tokens.LeftParen:
cParens++;
if (_prevOperand == Empty)
{
// Check for ( following IN/IFF. if not, we have a normal (.
// Peek: take a look at the operators stack
Debug.Assert(_topOperator > 0, "Empty operator stack!!");
opInfo = _ops[_topOperator - 1];
if (opInfo._type == Nodes.Binop && opInfo._op == Operators.In)
{
/* IN - handle as procedure call */
node = new FunctionNode(_table, "In");
NodePush(node);
/* Push operator decriptor */
_ops[_topOperator++] = new OperatorInfo(Nodes.Call, Operators.Noop, Operators.priParen);
}
else
{ /* Normal ( */
/* Push operator decriptor */
_ops[_topOperator++] = new OperatorInfo(Nodes.Paren, Operators.Noop, Operators.priParen);
}
}
else
{
// This is a procedure call or () qualification
// Force out any dot qualifiers; check for bomb
BuildExpression(Operators.priProc);
_prevOperand = Empty;
ExpressionNode nodebefore = NodePeek();
if (nodebefore == null || nodebefore.GetType() != typeof(NameNode))
{
// this is more like an assert, so we not care about "nice" exception text..
throw ExprException.SyntaxError();
}
/* Get the proc name */
NameNode name = (NameNode)NodePop();
// Make sure that we can bind the name as a Function
// then get the argument count and types, and parse arguments..
node = new FunctionNode(_table, name._name);
// check to see if this is an aggregate function
Aggregate agg = (Aggregate)(int)((FunctionNode)node).Aggregate;
if (agg != Aggregate.None)
{
node = ParseAggregateArgument((FunctionId)(int)agg);
NodePush(node);
_prevOperand = Expr;
goto loop;
}
NodePush(node);
_ops[_topOperator++] = new OperatorInfo(Nodes.Call, Operators.Noop, Operators.priParen);
}
goto loop;
case Tokens.RightParen:
{
/* Right parentheses: Build expression if we have an operand. */
if (_prevOperand != Empty)
{
BuildExpression(Operators.priLow);
}
/* We must have Tokens.LeftParen on stack. If no operand, must be procedure call. */
if (_topOperator <= 1)
{
// set error, syntax: too many right parens..
throw ExprException.TooManyRightParentheses();
}
Debug.Assert(_topOperator > 1, "melformed operator stack.");
_topOperator--;
opInfo = _ops[_topOperator];
if (_prevOperand == Empty && opInfo._type != Nodes.Call)
{
// set error, syntax: missing operand.
throw ExprException.MissingOperand(opInfo);
}
Debug.Assert(opInfo._priority == Operators.priParen, "melformed operator stack.");
if (opInfo._type == Nodes.Call)
{
/* add argument to the function call. */
if (_prevOperand != Empty)
{
// read last function argument
ExpressionNode argument = NodePop();
/* Get the procedure name and append argument */
Debug.Assert(_topNode > 0 && NodePeek().GetType() == typeof(FunctionNode), "The function node should be created on '('");
FunctionNode func = (FunctionNode)NodePop();
func.AddArgument(argument);
func.Check();
NodePush(func);
}
}
else
{
/* Normal parentheses: create tree node */
// Construct & Put the Nodes.Paren node on node stack
node = NodePop();
node = new UnaryNode(_table, Operators.Noop, node);
NodePush(node);
}
_prevOperand = Expr;
cParens--;
goto loop;
}
case Tokens.ListSeparator:
{
/* Comma encountered: Must be operand; force out subexpression */
if (_prevOperand == Empty)
{
throw ExprException.MissingOperandBefore(",");
}
/* We are be in a procedure call */
/* build next argument */
BuildExpression(Operators.priLow);
opInfo = _ops[_topOperator - 1];
if (opInfo._type != Nodes.Call)
{
throw ExprException.SyntaxError();
}
ExpressionNode argument2 = NodePop();
/* Get the procedure name */
FunctionNode func = (FunctionNode)NodePop();
func.AddArgument(argument2);
NodePush(func);
_prevOperand = Empty;
goto loop;
}
case Tokens.BinaryOp:
if (_prevOperand == Empty)
{
/* Check for unary plus/minus */
if (_op == Operators.Plus)
{
_op = Operators.UnaryPlus;
// fall through to UnaryOperator;
}
else if (_op == Operators.Minus)
{
/* Unary minus */
_op = Operators.Negative;
// fall through to UnaryOperator;
}
else
{
// Error missing operand:
throw ExprException.MissingOperandBefore(Operators.ToString(_op));
}
}
else
{
_prevOperand = Empty;
/* CNSIDER: If we are going to support BETWEEN Translate AND to special BetweenAnd if it is. */
/* Force out to appropriate precedence; push operator. */
BuildExpression(Operators.Priority(_op));
// PushOperator descriptor
_ops[_topOperator++] = new OperatorInfo(Nodes.Binop, _op, Operators.Priority(_op));
goto loop;
}
goto
case Tokens.UnaryOp; // fall through to UnaryOperator;
case Tokens.UnaryOp:
/* Must be no operand. Push it. */
_ops[_topOperator++] = new OperatorInfo(Nodes.Unop, _op, Operators.Priority(_op));
goto loop;
case Tokens.ZeroOp:
// check the we have operator on the stack
if (_prevOperand != Empty)
{
// set error missing operator
throw ExprException.MissingOperator(new string(_text, _start, _pos - _start));
}
// PushOperator descriptor
_ops[_topOperator++] = new OperatorInfo(Nodes.Zop, _op, Operators.priMax);
_prevOperand = Expr;
goto loop;
case Tokens.Dot:
//if there is a name on the stack append it.
ExpressionNode before = NodePeek();
if (before != null && before.GetType() == typeof(NameNode))
{
Scan();
if (_token == Tokens.Name)
{
NameNode nameBefore = (NameNode)NodePop();
string newName = nameBefore._name + "." + NameNode.ParseName(_text, _start, _pos);
NodePush(new NameNode(_table, newName));
goto loop;
}
}
// fall through to default
goto default;
default:
throw ExprException.UnknownToken(new string(_text, _start, _pos - _start), _start + 1);
}
}
goto end_loop;
end_loop:
Debug.Assert(_topNode == 1 || _topNode == 0, "Invalid Node Stack");
_expression = _nodeStack[0];
return(_expression);
}
public Task <long> SortedSetCombineAndStoreAsync(SetOperation operation, RedisKey destination, RedisKey[] keys, double[] weights = null, Aggregate aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None)
{
return(this.db.SortedSetCombineAndStoreAsync(operation, destination, keys, weights, aggregate, flags));
}
public void LoadWithInclude()
{
using(GetNewServer())
using (var store = new DocumentStore{Url = "http://localhost:8079"}.Initialize())
{
var aggregate = new Aggregate
{
Name = "First"
};
using (var session = store.OpenSession())
{
session.Advanced.UseOptimisticConcurrency = true;
session.Store(aggregate);
session.SaveChanges();
}
var root = new Root
{
Bridge = new Bridge
{
Aggregates = new List<string>
{
aggregate.Id
}
}
};
using (var session = store.OpenSession())
{
session.Advanced.UseOptimisticConcurrency = true;
session.Store(root); session.SaveChanges();
}
using (var session = store.OpenSession())
{
var item = session.Load<Aggregate>(1);
Assert.NotNull(item);
}
using (var session = store.OpenSession())
{
session.Advanced.UseOptimisticConcurrency = true;
var query = session
.Include("Bridge.Aggregates")
.Load<Root>(1);
Assert.NotNull(query);
}
using (var session = store.OpenSession())
{
session.Advanced.UseOptimisticConcurrency = true;
var query = session
.Include("Bridge.Aggregates")
.Load<Root>("roots/1");
var loaded = session.Load<Aggregate>("aggregates/1");
Assert.NotNull(query);
Assert.Equal(1, session.Advanced.NumberOfRequests);
}
using (var session = store.OpenSession())
{
session.Advanced.UseOptimisticConcurrency = true;
var query = session
.Include("Bridge.Aggregates")
.Load<Root>(1);
var loaded = session.Load<Aggregate>("aggregates/1");
Assert.NotNull(query);
Assert.Equal(1, session.Advanced.NumberOfRequests);
}
}
}
public void SaveChanges(Aggregate aggregate)
{
SaveEvents(new AggregateKey(aggregate.GetType(), aggregate.AggregateId), aggregate.Revision, aggregate.UncommittedChanges());
aggregate.ClearUncommittedEvents();
}
static void Main()
{
string decorationLine = new string('-', Console.WindowWidth);
Console.Write(decorationLine);
Console.WriteLine("***Example for the 'Iterator' design pattern***");
Console.Write(decorationLine);
IAggregate<int> fibonacciNumbersToFifty = new Aggregate<int>();
fibonacciNumbersToFifty.AddItem(0);
fibonacciNumbersToFifty.AddItem(1);
fibonacciNumbersToFifty.AddItem(1);
fibonacciNumbersToFifty.AddItem(2);
fibonacciNumbersToFifty.AddItem(3);
fibonacciNumbersToFifty.AddItem(5);
fibonacciNumbersToFifty.AddItem(8);
fibonacciNumbersToFifty.AddItem(13);
fibonacciNumbersToFifty.AddItem(21);
fibonacciNumbersToFifty.AddItem(34);
Console.WriteLine("Fibonacci numbers to 50:");
foreach (int number in fibonacciNumbersToFifty.GetAll())
{
Console.WriteLine(number);
}
}
