public GtkGameObjectFactory(DrawingArea area, IKeyMapper playerKeyMapper)
{
_playerKeyMapper = playerKeyMapper;
_queueFactory = new GameObjectQueueFactory(this);
_queueFactory.Initialise();
_area = area;
}
private async Task GetClusterMap(IConnection connection, IPEndPoint endPoint)
{
var completionSource = new TaskCompletionSource <byte[]>();
var configOp = new Config
{
CurrentHost = endPoint,
Converter = new DefaultConverter(),
Transcoder = new DefaultTranscoder(new DefaultConverter()),
Opaque = SequenceGenerator.GetNext(),
EndPoint = endPoint,
Completed = s =>
{
//Status will be Success if bucket select was bueno
completionSource.SetResult(s.Data.ToArray());
return(completionSource.Task);
}
};
await connection.SendAsync(configOp.Write(), configOp.Completed).ConfigureAwait(false);
var clusterMapBytes = await completionSource.Task.ConfigureAwait(false);
await configOp.ReadAsync(clusterMapBytes).ConfigureAwait(false);
var configResult = configOp.GetResultWithValue();
_bucketConfig = configResult.Content; //the cluster map
_keyMapper = new VBucketKeyMapper(_bucketConfig); //for vbucket key mapping
}
public DataTable Sort(IKeyMapper keyMapper, DataTable data, DataSource source)
{
var cols = source == DataSource.Left
? keyMapper.LeftColumns
: keyMapper.RightColumns;
var view = data.DefaultView;
var sb = new StringBuilder();
bool first = true;
foreach (var col in cols)
{
if (!first)
{
sb.Append(", ");
}
sb.Append(col.ColumnName);
sb.Append(" ASC");
first = !first;
}
view.Sort = sb.ToString();
var res = view.ToTable(source.ToString());
return(res);
}
public CompareResult Compare(DataTable left, DataTable right)
{
if (left == null)
{
throw new ArgumentNullException(nameof(left));
}
if (right == null)
{
throw new ArgumentNullException(nameof(right));
}
_keyMapper = _keyMapperFactory.Create(Config, left, right);
_valueMapper = _valueMapperFactory.Create(Config, _keyMapper, left, right);
_stopwatch.Restart();
var sorted = Config.IsSorted;
var leftSorted = sorted != DataSource.Left && sorted != DataSource.Both
? _sorter.Sort(_keyMapper, left, DataSource.Left)
: left;
var rightSorted = sorted != DataSource.Right && sorted != DataSource.Both
? _sorter.Sort(_keyMapper, right, DataSource.Right)
: right;
_stopwatch.Stop();
TimeTakenForSorting = _stopwatch.Elapsed;
return(CompareSorted(leftSorted, rightSorted));
}
public void ConfigUpdated(object sender, BucketConfigEventArgs e)
{
_bucketConfig = e.Config;
_keyMapper = new VBucketKeyMapper(_bucketConfig);
LoadManifest();
LoadClusterMap().ConfigureAwait(false).GetAwaiter().GetResult();
}
public void KeyMapper_MapMouseKey_ProperlyMapped(ButtonCode input, UserInputKey result)
{
IKeyMapper keyMapper = CreateKeyMapper();
UserInputKey mappedKey = keyMapper.MapToUserInputKey(input);
Assert.Equal(mappedKey, result);
}
public JoinCustomizer(string splitGroupId, IModelExplicitDeclarationsHolder explicitDeclarationsHolder, ICustomizersHolder customizersHolder)
: base(explicitDeclarationsHolder, customizersHolder, null)
{
if (explicitDeclarationsHolder == null)
{
throw new ArgumentNullException("explicitDeclarationsHolder");
}
this.splitGroupId = splitGroupId;
keyMapper = new JoinKeyCustomizer <TEntity>(customizersHolder);
}
/// <summary>
/// This is the default constructor.
/// </summary>
protected ApiProviderAsyncV2(
IKeyMapper <K> keyMapper = null
, TransportSerializer <E> primaryTransport = null
, IEnumerable <IApiProviderAuthBase> authHandlers = null
, bool useDefaultJsonSerializer = true
) : base(authHandlers)
{
mKeyMapper = keyMapper ?? ResolveKeyMapper();
ResolveTransport(primaryTransport, useDefaultJsonSerializer);
}
public UserInputHandler
(
IHotkeyConditionService hotkeyConditionService,
IKeyMapper keyMapper,
IKeyHandler keyHandler
)
{
_hotkeyConditionService = hotkeyConditionService;
_keyMapper = keyMapper;
_keyHandler = keyHandler;
}
public void WhenCallKeyMapperMoreThanOnceThenKeyMapperIsTheSame()
{
var mapdoc = new HbmMapping();
var hbmJoin = new HbmJoin();
var mapper = new JoinMapper(typeof(MyClass), "AA", hbmJoin, mapdoc);
IKeyMapper firstCallInstance = null;
IKeyMapper secondCallInstance = null;
mapper.Key(km => firstCallInstance = km);
mapper.Key(km => secondCallInstance = km);
firstCallInstance.Should().Be.SameInstanceAs(secondCallInstance);
}
public JoinedSubclassCustomizer(IModelExplicitDeclarationsHolder explicitDeclarationsHolder, ICustomizersHolder customizersHolder)
: base(explicitDeclarationsHolder, customizersHolder, null)
{
if (explicitDeclarationsHolder == null)
{
throw new ArgumentNullException("explicitDeclarationsHolder");
}
explicitDeclarationsHolder.AddAsTablePerClassEntity(typeof(TEntity));
// Add an empty customizer as a way to register the class as explicity declared
CustomizersHolder.AddCustomizer(typeof(TEntity), (IJoinedSubclassAttributesMapper m) => { });
keyMapper = new JoinedSubclassKeyCustomizer <TEntity>(customizersHolder);
}
/// <summary>
/// This is the default constructor.
/// </summary>
public ApiProviderAsyncV2(Uri rootUri
, IKeyMapper <K> keyMapper = null
, TransportSerializer <E> primaryTransport = null
, IEnumerable <IApiProviderAuthBase> authHandlers = null
, bool useDefaultJsonSerializer = true)
: this(keyMapper, primaryTransport, authHandlers, useDefaultJsonSerializer)
{
if (rootUri == null)
{
throw new ArgumentNullException("You must set rootUri for the API");
}
mUriMapper = CreateUriMapper(rootUri);
}
async Task IBucketInternal.Bootstrap(params ClusterNode[] bootstrapNodes)
{
//should never happen
if (bootstrapNodes == null)
{
throw new ArgumentNullException(nameof(bootstrapNodes));
}
foreach (var bootstrapNode in bootstrapNodes)
{
bootstrapNode.Owner = this;
//reuse the bootstrapNode
_bucketNodes.AddOrUpdate(bootstrapNode.EndPoint, bootstrapNode, (key, node) => bootstrapNode);
bootstrapNode.Configuration = _configuration;
//the initial bootstrapping endpoint;
await bootstrapNode.SelectBucket(Name).ConfigureAwait(false);
_manifest = await bootstrapNode.GetManifest().ConfigureAwait(false);
_supportsCollections = bootstrapNode.Supports(ServerFeatures.Collections);
if (_bucketConfig == null)
{
_bucketConfig = await bootstrapNode.GetClusterMap().ConfigureAwait(false);
_keyMapper = new VBucketKeyMapper(_bucketConfig);
}
if (_bucketConfig.NodesExt.Count == 1)
{
var nodesExt = _bucketConfig.NodesExt.First();
if (nodesExt.hostname == null)
{
nodesExt.hostname = bootstrapNode.BootstrapUri.Host;
}
bootstrapNode.NodesExt = nodesExt;
}
else
{
bootstrapNode.NodesExt =
_bucketConfig.NodesExt.Find(x => x.hostname == bootstrapNode.BootstrapUri.Host);
}
}
LoadManifest();
LoadClusterMap(_bucketConfig).ConfigureAwait(false).GetAwaiter().GetResult();
}
/// <summary>
/// This is the default constructor.
/// </summary>
public ApiProviderAsyncV2(TransportUriMapper <K> uriMapper = null
, IKeyMapper <K> keyMapper = null
, TransportSerializer <E> primaryTransport = null
, IEnumerable <IApiProviderAuthBase> authHandlers = null
, bool useDefaultJsonSerializer = true)
: this(keyMapper, primaryTransport, authHandlers, useDefaultJsonSerializer)
{
if (uriMapper == null)
{
throw new ArgumentNullException("You must set uriMapper");
}
mUriMapper = uriMapper;
}
public MainForm(ISNESSystem system, IRenderer renderer, IFPS fps, IKeyMapper keyMapper, OpenSaveFilesDialog dialog)
{
Load += FrmMainLoad;
KeyDown += FrmMainKeyDown;
KeyUp += FrmMainKeyUp;
Closed += AppExit;
Closing += OnClosing;
_fps = fps;
_system = system;
_system.FrameRendered += LockFPS;
_renderer = renderer;
_keyMapper = keyMapper;
_dialog = dialog;
DoubleBuffered = true;
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
}
/// <summary>
/// This constructors sets the underlying respository.
/// </summary>
/// <param name="respository">The aynsc repository.</param>
protected ApiPersistenceControllerAsyncBase(IRepositoryAsync <K, E> respository)
{
mRespository = respository;
mSerializers = TransportSerializer.GetSerializers <E>(GetType())
.ToDictionary((p) => p.MediaType.ToLowerInvariant());
//If we have no serializers set on this controller, check the entity.
if (mSerializers == null || mSerializers.Count == 0)
{
mSerializers = TransportSerializer.GetSerializers <E>(typeof(E))
.ToDictionary((p) => p.MediaType.ToLowerInvariant());
}
mKeyMapper = (KeyMapper <K>)KeyMapper.Resolve <K>();
mODataValidate = ODataValidationSettingsCreate();
}
public InputChangerForm(IKeyMapper keyMapper)
{
InitializeComponent();
_keyMapper = keyMapper;
Prep(ATextBox, _keyMapper.ReverseMap(SNESButton.A), Keys.A);
Prep(BTextBox, _keyMapper.ReverseMap(SNESButton.B), Keys.B);
Prep(XTextBox, _keyMapper.ReverseMap(SNESButton.X), Keys.X);
Prep(YTextBox, _keyMapper.ReverseMap(SNESButton.Y), Keys.Y);
Prep(LTextBox, _keyMapper.ReverseMap(SNESButton.L), Keys.L);
Prep(RTextBox, _keyMapper.ReverseMap(SNESButton.R), Keys.R);
Prep(StartTextBox, _keyMapper.ReverseMap(SNESButton.Start), Keys.End);
Prep(SelectTextBox, _keyMapper.ReverseMap(SNESButton.Sel), Keys.Tab);
Prep(LeftTextBox, _keyMapper.ReverseMap(SNESButton.Left), Keys.Left);
Prep(RightTextBox, _keyMapper.ReverseMap(SNESButton.Right), Keys.Right);
Prep(UpTextBox, _keyMapper.ReverseMap(SNESButton.Up), Keys.Up);
Prep(DownTextBox, _keyMapper.ReverseMap(SNESButton.Down), Keys.Down);
}
public void ConfigUpdated(object sender, BucketConfigEventArgs e)
{
if (e.Config.Rev > _bucketConfig.Rev)
{
_bucketConfig = e.Config;
if (_bucketConfig.VBucketMapChanged)
{
_keyMapper = new VBucketKeyMapper(_bucketConfig);
}
if (_bucketConfig.ClusterNodesChanged)
{
LoadClusterMap(_bucketConfig).ConfigureAwait(false).GetAwaiter().GetResult();
Prune(_bucketConfig);
}
}
}
/// <summary>
/// This is the default constructor.
/// </summary>
public ApiProviderAsyncBase(TransportUriMapper <K> uriMapper = null
, bool useHttps = true, string entityName = null
, IKeyMapper <K> keyMapper = null
, TransportSerializer <E> primaryTransport = null)
{
// Get the types assembly version to add to the request headers
mAssemblyVersion = GetType().Assembly.GetName().Version.ToString();
mKeyMapper = keyMapper ?? ResolveKeyMapper();
mUriMapper = uriMapper ?? ResolveUriMapper(uriMapper, entityName);
if (entityName != null)
{
EntityName = entityName;
}
mPrimaryTransport = primaryTransport ?? ResolveSerializer();
UseHttps = useHttps;
}
public IColumnMapper Create(DataComparerConfig config, IKeyMapper keyMap, DataTable left, DataTable right)
{
var mapper = new ColumnMapper();
var leftCols = left.Columns.Cast <DataColumn>().ToDictionary(x => x.ColumnName);
var rightCols = right.Columns.Cast <DataColumn>().ToDictionary(x => x.ColumnName);
foreach (DataColumn leftCol in left.Columns)
{
var name = leftCol.ColumnName;
if (config.Keys.Contains(name))
{
continue;
}
if (config.Skip.Contains(name))
{
continue;
}
if (!rightCols.TryGetValue(name, out var rightCol))
{
continue;
}
mapper.Add(leftCol, rightCol);
break;
}
if (mapper.LeftColumns.Count == 0)
{
// TODO: 5-Improve no matching Value Columns message exception
throw new InvalidOperationException("Could not find any mathcing Value Columns");
}
return(mapper);
}
/// <param name="spawnPosition">Initial position on-screen of this object.</param>
/// <param name="renderer">Used to draw a visual representation of this object to a drawing surface.</param>
/// <param name="initialDirection">The direction this object faces when first created.</param>
/// <param name="speed">The distance this object can travel when moved.</param>
/// <param name="keyMapper">Used to map keypressed events to movement commands.</param>
public Player(Position spawnPosition, IRenderer renderer, Direction initialDirection, int speed, IKeyMapper keyMapper, IWinCondition[] winConditions) : base(spawnPosition, renderer, initialDirection, speed, winConditions)
{
if (keyMapper != null)
{
keyMapper.OnMoveUpEvent += base.MoveUp;
keyMapper.OnMoveDownEvent += base.MoveDown;
keyMapper.OnMoveLeftEvent += base.MoveLeft;
keyMapper.OnMoveRightEvent += base.MoveRight;
}
}
public void SetKeyMapper(IKeyMapper mapper)
{
keyMapper = mapper;
}
public KeyAwaiter(IKeyMapper keyMapper)
{
_keyMapper = keyMapper;
}
public UserInputHandlerFactory(IHotkeyConditionServiceFactory hotkeyConditionServiceFactory, IKeyMapper keyMapper)
{
_hotkeyConditionServiceFactory = hotkeyConditionServiceFactory;
_keyMapper = keyMapper;
}
public CollectionPropertiesCustomizer(PropertyPath propertyPath, ICustomizersHolder customizersHolder)
{
PropertyPath = propertyPath;
CustomizersHolder = customizersHolder;
keyMapper = new CollectionKeyCustomizer <TEntity>(propertyPath, customizersHolder);
}
private CompareResult CompareSorted(DataTable left, DataTable right)
{
_stopwatch.Restart();
var result = new CompareResult();
_keyMapper = _keyMapperFactory.Create(Config, left, right);
_valueMapper = _valueMapperFactory.Create(Config, _keyMapper, left, right);
_valueComparer = _rowComparerFactory.CreateValueComparer(_valueMapper, left, right);
_keyComparer = _rowComparerFactory.CreateKeyComparer(_keyMapper, left, right);
var leftIx = 0;
var rightIx = 0;
// Go Through All Left Comparing to Right
while (leftIx < left.Rows.Count && rightIx < right.Rows.Count)
{
var leftRow = left.Rows[leftIx];
var rightRow = right.Rows[rightIx];
var keyResult = _keyComparer.Compare(leftRow, rightRow);
if (keyResult == 0)
{
var valueResult = _valueComparer.Compare(leftRow, rightRow);
if (valueResult == 0)
{
result.Same.Add(new CompareResult.Entry(leftRow, rightRow));
}
else
{
result.Different.Add(new CompareResult.Entry(leftRow, rightRow));
}
leftIx++;
rightIx++;
}
else if (keyResult < 0)
{
result.LeftOnly.Add(leftRow);
leftIx++;
}
else
{
result.RightOnly.Add(rightRow);
rightIx++;
}
}
while (leftIx < left.Rows.Count)
{
var leftRow = left.Rows[leftIx];
result.LeftOnly.Add(leftRow);
leftIx++;
}
while (rightIx < right.Rows.Count)
{
var rightRow = right.Rows[rightIx];
result.RightOnly.Add(rightRow);
rightIx++;
}
_stopwatch.Stop();
TimeTakenForComparing = _stopwatch.Elapsed;
return(result);
}
public IRowComparer CreateKeyComparer(IKeyMapper colMap, DataTable left, DataTable right)
{
return(new RowComparer(colMap.LeftColumns, colMap.RightColumns));
}
public CollectionPropertiesCustomizer(IModelExplicitDeclarationsHolder explicitDeclarationsHolder, PropertyPath propertyPath, ICustomizersHolder customizersHolder)
{
PropertyPath = propertyPath;
CustomizersHolder = customizersHolder;
keyMapper = new CollectionKeyCustomizer <TEntity>(explicitDeclarationsHolder, propertyPath, customizersHolder);
}
public JoinedSubclassCustomizer(ICustomizersHolder customizersHolder) : base(customizersHolder, null)
{
keyMapper = new JoinedSubclassKeyCustomizer <TEntity>(customizersHolder);
}
public static void Column <TEntity, TOther>(this IKeyMapper <TEntity> mapper,
Expression <Func <TOther, object> > expression) where TEntity : class where TOther : class
{
mapper.Column(expression.GetPropertyName());
}
