/// <summary>
/// Registers an aggregate factory.
/// </summary>
/// <param name="aggregateId">The id of the aggregate function.</param>
/// <param name="aggregateName">The id of the aggregate name.</param>
/// <param name="factory">The factory used to create calculators.</param>
public void RegisterFactory(NodeId aggregateId, string aggregateName, AggregatorFactory factory)
{
lock (m_lock)
{
m_factories[aggregateId] = factory;
}
}
/// <summary>
/// Registers an aggregate factory.
/// </summary>
/// <param name="aggregateId">The id of the aggregate function.</param>
/// <param name="aggregateName">The id of the aggregate name.</param>
/// <param name="factory">The factory used to create calculators.</param>
public void RegisterFactory(NodeId aggregateId, string aggregateName, AggregatorFactory factory)
{
System.Diagnostics.Contracts.Contract.Assume(aggregateName != null);
lock (_lock) {
_factories[aggregateId] = factory;
}
}
private async Task <GremlinResponse <T> > ReceiveAsync <T>()
{
ResponseStatus status;
IAggregator aggregator = null;
var isAggregatingSideEffects = false;
var result = new List <T>();
List <int> statusCodes = new List <int>();
List <Dictionary <string, object> > attributes = new List <Dictionary <string, object> >();
do
{
var received = await _webSocketConnection.ReceiveMessageAsync().ConfigureAwait(false);
var receivedMsg = _messageSerializer.DeserializeMessage <ResponseMessage <JToken> >(received);
status = receivedMsg.Status;
status.ThrowIfStatusIndicatesError();
if (status.Code == ResponseStatusCode.Authenticate)
{
await AuthenticateAsync().ConfigureAwait(false);
}
else
{
statusCodes.Add((int)status.Code);
attributes.Add(status.Attributes);
if (status.Code != ResponseStatusCode.NoContent)
{
var receivedData = _graphSONReader.ToObject(receivedMsg.Result.Data);
foreach (var d in receivedData)
{
if (receivedMsg.Result.Meta.ContainsKey(Tokens.ArgsSideEffectKey))
{
if (aggregator == null)
{
aggregator =
new AggregatorFactory().GetAggregatorFor(
(string)receivedMsg.Result.Meta[Tokens.ArgsAggregateTo]);
}
aggregator.Add(d);
isAggregatingSideEffects = true;
}
else
{
result.Add(d);
}
}
}
}
} while (status.Code == ResponseStatusCode.PartialContent || status.Code == ResponseStatusCode.Authenticate);
List <T> resultsToReturn = isAggregatingSideEffects
? new List <T> {
(T)aggregator.GetAggregatedResult()
}
: result;
return(new GremlinResponse <T>(resultsToReturn, attributes, statusCodes));
}
/// <summary>
/// Registers an aggregate factory.
/// </summary>
/// <param name="aggregateId">The id of the aggregate function.</param>
/// <param name="aggregateName">The id of the aggregate name.</param>
/// <param name="factory">The factory used to create calculators.</param>
public void RegisterFactory(NodeId aggregateId, string aggregateName, AggregatorFactory factory)
{
lock (m_lock) {
m_factories[aggregateId] = factory;
}
if (m_server != null)
{
m_server.DiagnosticsNodeManager.AddAggregateFunction(aggregateId, aggregateName, true);
}
}
private async Task <IReadOnlyCollection <T> > ReceiveAsync <T>()
{
ResponseStatus status;
IAggregator aggregator = null;
var isAggregatingSideEffects = false;
var result = new List <T>();
do
{
var received = await _webSocketConnection.ReceiveMessageAsync().ConfigureAwait(false);
var receivedMsg = _messageSerializer.DeserializeMessage <ResponseMessage <JToken> >(received);
status = receivedMsg.Status;
status.ThrowIfStatusIndicatesError();
if (status.Code == ResponseStatusCode.Authenticate)
{
await AuthenticateAsync().ConfigureAwait(false);
}
else if (status.Code != ResponseStatusCode.NoContent)
{
var receivedData = _graphSONReader.ToObject(receivedMsg.Result.Data);
foreach (var d in receivedData)
{
if (receivedMsg.Result.Meta.ContainsKey(Tokens.ArgsSideEffectKey))
{
if (aggregator == null)
{
aggregator =
new AggregatorFactory().GetAggregatorFor(
(string)receivedMsg.Result.Meta[Tokens.ArgsAggregateTo]);
}
aggregator.Add(d);
isAggregatingSideEffects = true;
}
else
{
result.Add(d);
}
}
}
} while (status.Code == ResponseStatusCode.PartialContent || status.Code == ResponseStatusCode.Authenticate);
if (isAggregatingSideEffects)
{
return new List <T> {
(T)aggregator.GetAggregatedResult()
}
}
;
return(result);
}
/// <summary>
/// Create and AggregateCalculator for a ReadProcessed service call.
/// </summary>
/// <param name="filter"></param>
/// <param name="steppedVariable"></param>
/// <returns></returns>
public static AggregateCalculatorImpl CreateAggregator(NewAggregateFilter filter, bool steppedVariable)
{
AggregatorFactory aci = null;
if (Lookup.TryGetValue(filter.AggregateType, out aci))
{
AggregateCalculatorImpl retval = aci();
retval.StartTime = filter.StartTime;
retval.EndTime = filter.EndTime;
retval.ProcessingInterval = filter.ProcessingInterval;
retval.Configuration = filter.AggregateConfiguration;
retval.SteppedVariable = steppedVariable;
return(retval);
}
return(null);
}
public CompareDefinition DeserializeCompareDefinition(XElement xCompareDef)
{
try
{
var compareDef = new CompareDefinition();
if (xCompareDef == null)
{
return(compareDef);
}
// CompareFields
foreach (XElement xField in xCompareDef.Element("comparefields").Elements())
{
// Name
CompareField compareField = new CompareField();
compareField.Name1 = xField.Attribute(XName.Get("name1")).Value;
// Weight
compareField.Weight = (float)xField.Attribute(XName.Get("weight"));
// Comparer
string comparerName = xField.Attribute(XName.Get("comparer")).Value;
if (!string.IsNullOrEmpty(comparerName))
{
compareField.FuzzyComparer = StringFuzzyComparerFactory.GetInstance(comparerName);
}
compareDef.CompareFields.Add(compareField);
}
// Aggregator
string aggregatorName = xCompareDef.Element("aggregator")
.Attribute(XName.Get("name"))
.Value;
compareDef.Aggregator = AggregatorFactory.GetInstance(aggregatorName);
return(compareDef);
}
catch (Exception ex)
{
throw new ArgumentException("Fehler in " + this.GetType().FullName + " Method: [" + System.Reflection.MethodBase.GetCurrentMethod() + "] Data: " + xCompareDef.ToString(), ex);
}
}
/// <summary>
/// Restores PivotData from specified state object.
/// </summary>
/// <remarks>This method assumes that PivotData configuration (dimensions, aggregator factory) matches specified state object.</remarks>
/// <param name="state">state object</param>
public void SetState(PivotDataState state)
{
if (state.DimCount != Dimensions.Length)
{
throw new ArgumentException("Incompatible number of dimensions", "state");
}
Clear();
values = new Dictionary <object[], IAggregator>(state.Values.Length, new ValueKeyEqualityComparer());
var revKeyIdx = new object[state.KeyValues.Length];
for (var i = 0; i < revKeyIdx.Length; i++)
{
revKeyIdx[i] = state.KeyValues[i];
}
var dimLen = Dimensions.Length;
uint d;
IAggregator aggr;
for (var i = 0; i < state.ValueKeys.Length; i++)
{
var vkIdx = state.ValueKeys[i];
var vkDimKeys = new object[dimLen];
for (d = 0; d < dimLen; d++)
{
vkDimKeys[d] = revKeyIdx[vkIdx[d]];
}
if (values.TryGetValue(vkDimKeys, out aggr))
{
aggr.Merge(AggregatorFactory.Create(state.Values[i]));
}
else
{
values[vkDimKeys] = AggregatorFactory.Create(state.Values[i]);
}
}
if (!lazyTotals)
{
BatchCalcTotals();
}
}
/// <summary>
/// Modifies the current <see cref="PivotData"/> object to merge values from itself and specified <see cref="PivotData"/>.
/// </summary>
/// <remarks>
/// Only compatible <see cref="PivotData"/> objects could be merged: they should have the same AggregatorFactory and Dimensions configuration.
/// This method is also useful for organizing parallel data aggregation algorithm.
/// </remarks>
/// <param name="pvtData">multidimensional dataset to merge</param>
public virtual void Merge(IPivotData pvtData)
{
if (!AggregatorFactory.Equals(pvtData.AggregatorFactory))
{
throw new ArgumentException("AggregatorFactory mismatch");
}
if (Dimensions.Length != pvtData.Dimensions.Length)
{
throw new ArgumentException("Dimensions mismatch");
}
for (int i = 0; i < Dimensions.Length; i++)
{
if (!Dimensions[i].SequenceEqual(pvtData.Dimensions[i]))
{
throw new ArgumentException(String.Format("Dimension {0} elements mismatch", i));
}
}
// remove all totals
totalValues.Clear();
valuesArr = null;
IAggregator aggr;
foreach (var dp in pvtData)
{
if (!values.TryGetValue(dp.Key, out aggr))
{
aggr = aggregatorFactory.Create();
values[dp.Key] = aggr;
}
aggr.Merge(dp.Value);
}
if (!lazyTotals)
{
BatchCalcTotals();
}
}
/// <summary>
/// Creates a new aggregate calculator.
/// </summary>
/// <param name="aggregateId">The id of the aggregate function.</param>
/// <param name="startTime">When to start processing.</param>
/// <param name="endTime">When to stop processing.</param>
/// <param name="processingInterval">The processing interval.</param>
/// <param name="stepped">Whether stepped interpolation should be used.</param>
/// <param name="configuration">The configuaration to use.</param>
/// <returns></returns>
public IAggregateCalculator CreateCalculator(
NodeId aggregateId,
DateTime startTime,
DateTime endTime,
double processingInterval,
bool stepped,
AggregateConfiguration configuration)
{
if (NodeId.IsNull(aggregateId))
{
return(null);
}
AggregatorFactory factory = null;
lock (m_lock)
{
if (!m_factories.TryGetValue(aggregateId, out factory))
{
return(null);
}
}
if (configuration.UseServerCapabilitiesDefaults)
{
// ensure the configuration is initialized
configuration = GetDefaultConfiguration(null);
}
IAggregateCalculator calculator = factory(aggregateId, startTime, endTime, processingInterval, stepped, configuration);
if (calculator == null)
{
return(null);
}
return(calculator);
}
/// <summary>
/// Creates a new aggregate calculator.
/// </summary>
/// <param name="aggregateId">The id of the aggregate function.</param>
/// <param name="startTime">When to start processing.</param>
/// <param name="endTime">When to stop processing.</param>
/// <param name="processingInterval">The processing interval.</param>
/// <param name="configuration">The configuaration to use.</param>
/// <returns></returns>
public IAggregateCalculator CreateCalculator(
NodeId aggregateId,
DateTime startTime,
DateTime endTime,
double processingInterval,
AggregateConfiguration configuration)
{
if (NodeId.IsNull(aggregateId))
{
return(null);
}
AggregatorFactory factory = null;
lock (m_lock)
{
if (!m_factories.TryGetValue(aggregateId, out factory))
{
return(null);
}
}
AggregateCalculatorImpl calculator = factory();
if (calculator == null)
{
return(null);
}
calculator.StartTime = startTime;
calculator.EndTime = endTime;
calculator.ProcessingInterval = processingInterval;
calculator.Configuration = configuration;
calculator.SteppedVariable = configuration.UseSlopedExtrapolation;
return(calculator);
}
/// <summary>
/// Registers an aggregate factory.
/// </summary>
/// <param name="aggregateId">The id of the aggregate function.</param>
/// <param name="aggregateName">The id of the aggregate name.</param>
/// <param name="factory">The factory used to create calculators.</param>
public void RegisterFactory(NodeId aggregateId, string aggregateName, AggregatorFactory factory)
{
lock (m_lock)
{
m_factories[aggregateId] = factory;
}
if (m_server != null)
{
m_server.DiagnosticsNodeManager.AddAggregateFunction(aggregateId, aggregateName, true);
}
}
/// <summary>
/// Use this to register the AggregatorFactory for a custom or vendor-defined
/// Aggregator. This method assumes that the AggregateType node has been created
/// and placed in the appropriate place in the namespace already.
/// </summary>
/// <param name="key">NodeId of the Aggregatetype node</param>
/// <param name="factory">AggregatorFactory delegate</param>
public static void RegisterAggregatorFactory(NodeId key, AggregatorFactory factory)
{
Lookup[key] = factory;
}
public OlapCube Count <T>(Func <IOlapDataVector, bool> aggregatePred = null, string title = "Count")
{
Aggregators.Add(AggregatorFactory.CreateCount <T>(aggregatePred));
ValueTitles.Add(title);
return(this);
}
/// <summary>
/// Use this to register the AggregatorFactory for a custom or vendor-defined
/// Aggregator. This method assumes that the AggregateType node has been created
/// and placed in the appropriate place in the namespace already.
/// </summary>
/// <param name="key">NodeId of the Aggregatetype node</param>
/// <param name="factory">AggregatorFactory delegate</param>
public static void RegisterAggregatorFactory(NodeId key, AggregatorFactory factory)
{
Lookup[key] = factory;
}
public OlapCube Min <T>(Func <IOlapDataVector, object> valueSelector, Func <IOlapDataVector, bool> aggregatePred = null, string title = "Min")
{
Aggregators.Add(AggregatorFactory.CreateMin <T>(valueSelector, aggregatePred));
ValueTitles.Add(title);
return(this);
}
/// <summary>
/// Registers an aggregate factory.
/// </summary>
/// <param name="aggregateId">The id of the aggregate function.</param>
/// <param name="aggregateName">The id of the aggregate name.</param>
/// <param name="factory">The factory used to create calculators.</param>
public void RegisterFactory(NodeId aggregateId, string aggregateName, AggregatorFactory factory)
{
lock (m_lock)
{
m_factories[aggregateId] = factory;
}
}
