/// <summary>
/// Attempts to read from this operator's underlying input stream(s) until the next set of
/// bindings is found which can be outputted by this operator.
/// </summary>
/// <returns>
/// <c>true</c> if a next binding set is found available to output; otherwise, <c>false</c>.
/// </returns>
internal override bool TryReadNext()
{
//
// first creat the sorted temporary file, if it doesn't already exist
if (!m_tmpFileCreated)
{
CreateTmpFile();
}
//
// one the temporary file is in place, we simply read triples from it in order
if (m_reader.BaseStream.Position < m_reader.BaseStream.Length)
{
m_next = new BindingSet();
for (int i = 0; i < m_sortOrder.Length; i++)
{
var a = new Atom(m_reader.ReadInt64());
m_next.Add(new Binding(m_sortOrder[i], a));
}
m_hasNext = true;
return(true);
}
else
{
m_hasNext = false;
return(false);
}
}
public IEnumerable <BindingSet> GetBindings()
{
if (_query.QueryType == SparqlQueryType.Select)
{
List <BindingSet> result = new List <BindingSet>();
foreach (var x in _resultHandler.SparqlResultSet)
{
BindingSet r = new BindingSet();
foreach (var y in x)
{
if (y.Value != null)
{
r.Add(y.Key, ParseCellValue(y.Value));
}
}
result.Add(r);
}
return(result);
}
else
{
throw new QueryTypeNotSupportedException(_query.QueryType);
}
}
protected override IList NonGenericIListFactory(int count)
{
BindingSet <string> collection = new BindingSet <string>();
int seed = 9600;
while (collection.Count < count)
{
object toAdd = CreateT(seed++);
collection.Add((string)toAdd);
}
return(collection);
}
internal CompositeItemBindingBuilder(
[NotNull] SourceItemBinding <TSourceItem, TSourceItemValue> sourceItemBinding,
[NotNull] TargetItemBinding <TTargetItem, TTargetItemValue> targetItemBinding,
[NotNull] BindingSet <TSourceItem> bindingSet)
{
_compositeItemBinding = new CompositeItemBinding <TSourceItem, TSourceItemValue, TTargetItem, TTargetItemValue>(
sourceItemBinding,
targetItemBinding,
BindingMode.TwoWay,
new CompositeItemBindingValueConverter <DefaultValueConverter>());
bindingSet.Add(_compositeItemBinding);
}
/// <summary>
/// Reads a single binding set from the given binary input stream.
/// </summary>
/// <param name="input">The input stream.</param>
/// <returns>
/// A binding set.
/// </returns>
public static BindingSet Read(BinaryReader input)
{
var count = input.ReadInt32();
var values = new BindingSet();
for (int i = 0; i < count; i++)
{
var v = new Variable(input.ReadInt64());
var a = new Atom(input.ReadInt64());
values.Add(new Binding(v, a));
}
return(values);
}
/// <summary>
/// Merges the two specified binding sets together, returning a new binding set which
/// contains bindings from the two given sets.
/// </summary>
/// <param name="left">The left binding set.</param>
/// <param name="right">The right binding set.</param>
/// <returns>
/// A new binding set merging the two given sets.
/// </returns>
private BindingSet Merge(BindingSet left, BindingSet right)
{
#if DEBUG
m_planOperator.StartCPUWork();
#endif
var b = new BindingSet();
//
// binding sets internally disregard (v : a) if they already have some (v : a')
foreach (var item in left.Bindings)
{
b.Add(item);
}
foreach (var item in right.Bindings)
{
b.Add(item);
}
#if DEBUG
m_planOperator.StopCPUWork();
#endif
return(b);
}
internal CompositeItemCommandBindingBuilder(
[NotNull] SourceItemCommandBinding <TSourceItem, TSourceItemValue> sourceItemBinding,
[NotNull] TargetItemBinding <TTargetItem, TTargetItemValue> targetItemBinding,
[NotNull] BindingSet <TSourceItem> bindingSet)
{
_compositeItemBinding = new CompositeItemCommandBinding <TSourceItem, TSourceItemValue, TTargetItem, TTargetItemValue>(
sourceItemBinding,
targetItemBinding,
BindingMode.OneWayToSource,
new CompositeItemBindingValueConverter <TSourceItem>(typeof(DefaultValueConverter)));
_bindingSet = bindingSet;
_bindingSet.Add(_compositeItemBinding);
}
internal CompositeItemCommandBindingBuilder(
[NotNull] SourceItemCommandBinding <TSourceItem, TSourceItemValue> sourceItemBinding,
[NotNull] TargetItemBinding <TTargetItem, TTargetItemValue> targetItemBinding,
[NotNull] BindingSet <TSourceItem> bindingSet,
[NotNull] ICompositeItemBinding <TSourceItem> oldCompositeItemBinding)
{
_compositeItemBinding = new CompositeItemCommandBinding <TSourceItem, TSourceItemValue, TTargetItem, TTargetItemValue>(
sourceItemBinding,
targetItemBinding,
oldCompositeItemBinding.RequestedBindingMode,
oldCompositeItemBinding.ValueConverter);
_bindingSet = bindingSet;
_bindingSet.Remove(oldCompositeItemBinding);
_bindingSet.Add(_compositeItemBinding);
}
public InputBinder(InputConfig config)
{
On <InputEvent>(OnInput);
On <LoadMapEvent>(e => _mapId = e.MapId);
foreach (var rawMode in config.Bindings)
{
if (!_bindings.ContainsKey(rawMode.Key))
{
_bindings.Add(rawMode.Key, new Dictionary <KeyBinding, string>());
}
var mode = _bindings[rawMode.Key];
foreach (var rawBinding in rawMode.Value)
{
var parts = rawBinding.Key.Split('+').Select(x => x.Trim().ToLower()).ToArray();
Key key = Key.LastKey;
var modifiers = ModifierKeys.None;
for (int i = 0; i < parts.Length; i++)
{
if (i == parts.Length - 1)
{
if (int.TryParse(parts[i], out var numeric))
{
key = Key.Number0 + numeric;
}
else
{
key = Enum.Parse <Key>(parts[i], true);
}
}
else
{
modifiers |= Enum.Parse <ModifierKeys>(parts[i], true);
}
}
if (key != Key.LastKey)
{
mode[new KeyBinding(key, modifiers)] = rawBinding.Value;
}
}
}
}
public IEnumerable <BindingSet> GetBindings()
{
List <BindingSet> result = new List <BindingSet>();
if (_query.QueryType == SparqlQueryType.Select)
{
foreach (var x in _resultSet)
{
BindingSet r = new BindingSet();
foreach (var y in x)
{
if (y.Value != null)
{
r.Add(y.Key, ParseCellValue(y.Value));
}
}
result.Add(r);
}
}
return(result);
}
public IEnumerable <BindingSet> GetBindings()
{
if (_query.QueryType == SparqlQueryType.Select)
{
foreach (SparqlResult result in _queryResults)
{
BindingSet b = new BindingSet();
foreach (var r in result)
{
if (r.Value != null)
{
b.Add(r.Key, ParseCellValue(r.Value));
}
}
yield return(b);
}
}
else
{
throw new ArgumentException("Cannot return bindings for queries of type " + _query.QueryType.ToString());
}
}
/// <summary>
/// Attempts to read from this operator's underlying input stream(s) until the next set of
/// bindings is found which can be outputted by this operator.
/// </summary>
/// <returns>
/// <c>true</c> if a next binding set is found available to output; otherwise, <c>false</c>.
/// </returns>
internal override bool TryReadNext()
{
while (m_cursor.HasNext && (!m_isMiniBucket || m_count > 0))
{
#if DEBUG
m_planOperator.StartIOWork();
#endif
var next = m_cursor.Next();
#if DEBUG
m_planOperator.StopIOWork();
m_planOperator.StartCPUWork();
#endif
if (m_isMiniBucket)
{
m_count--;
}
if (IsMatch(next))
{
//
// if a triple has been found which matches the given SAP, prepare a binding
// set and add the atoms in positions where the SAP has a variable to the set
m_next = new BindingSet();
if (!m_patternAtoms.HasFlag(TriplePosition.S))
{
var b = new Binding(m_pattern.S as Variable, next.S);
m_next.Add(b);
}
if (!m_patternAtoms.HasFlag(TriplePosition.P))
{
var b = new Binding(m_pattern.P as Variable, next.P);
m_next.Add(b);
}
if (!m_patternAtoms.HasFlag(TriplePosition.O))
{
var b = new Binding(m_pattern.O as Variable, next.O);
m_next.Add(b);
}
m_hasNext = true;
#if DEBUG
m_planOperator.StopCPUWork();
m_planOperator.AddResult();
#endif
return(true);
}
else if (!PossibleMatchesAfter(next))
{
//
// if the current triple does not match the SAP, see if it is possible that
// there are still matches some time after this triple. if there are no more
// matches possible, we are done here.
#if DEBUG
m_planOperator.StopCPUWork();
#endif
break;
}
#if DEBUG
m_planOperator.StopCPUWork();
#endif
}
m_hasNext = false;
return(false);
}
