public static TDestination Project <TSource, TDestination>(
this TSource source, IProjector <TSource, TDestination> projector)
where TSource : class
where TDestination : class
{
return(projector.Project(source));
}
public bool Contains(Vector2 position, IProjector projector)
{
using (new ProjectorScope(projector, GetProjection()))
{
return(Value.Contains(position, projector));
}
}
public static IEnumerable <TDestination> Project <TSource, TDestination>(
this IEnumerable <TSource> source, IProjector <TSource, TDestination> projector)
where TSource : class
where TDestination : class
{
return(source.Select(projector.Project));
}
public void Draw(GameTime gameTime, SpriteBatch spriteBatch, IProjector projector)
{
using (new ProjectorScope(projector, GetProjection()))
{
Value.Draw(gameTime, spriteBatch, projector);
}
}
private void Awake()
{
m_renderer = GetComponent <Renderer>();
if (m_renderer == null)
{
if (Debug.isDebugBuild || Application.isEditor)
{
Debug.LogError("No renderer was found!", this);
}
return;
}
m_renderer.material.EnableKeyword("FSR_RECEIVER");
if (m_projectorComponent != null)
{
if (m_projectorComponent is IProjector)
{
m_projector = m_projectorComponent as IProjector;
}
else if (m_projectorComponent is Projector)
{
m_projector = new UnityProjector(m_projectorComponent as Projector);
}
}
#if (UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7) // support Unity 4.3 or later
m_transform = transform;
#endif
m_propertyBlock = new MaterialPropertyBlock();
}
public HomeTheaterFacade(IProjector projector, IAmplifier amplifier, IDvdPlayer dvdPlayer, ICdPlayer cdPlayer)
{
_projector = projector;
_amplifier = amplifier;
_dvdPlayer = dvdPlayer;
_cdPlayer = cdPlayer;
}
public void Add(IProjector pj)
{
lock (lst )
{
lst.Add(pj);
}
}
public void Draw(GameTime gameTime, SpriteBatch spriteBatch, IProjector projector)
{
foreach (var card in Cards)
{
card.Draw(gameTime, spriteBatch, projector);
}
}
internal projectInvoke(StreamSpan <byte[]> span, string _stream, FSharpAsyncBuilder builder, IProjector projectorHandler)
{
this.span = span;
this._stream = _stream;
this.builder = builder;
_projectorHandler = projectorHandler;
}
public bool Equals(ref IProjector other)
{
if (other == null)
{
return(false);
}
var otherhost = other.getHost();
if (otherhost == null)
{
return(false);
}
var thisHost = this.getHost();
if (thisHost == null)
{
return(false);
}
bool match = thisHost.Equals(otherhost);
thisHost = null;
otherhost = null;
return(match);
}
public ProjectionEngine(IProjector projector,
IFilterableDatabase database,
ITransactionalDatabase transactionalDatabase,
IServiceProvider serviceProvider,
ILogger <ProjectionEngine> logger = default)
{
if (projector == null)
{
throw new ArgumentNullException(nameof(projector));
}
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
if (transactionalDatabase == null)
{
throw new ArgumentNullException(nameof(transactionalDatabase));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
_projector = projector;
_database = database;
_transactionalDatabase = transactionalDatabase;
_serviceProvider = serviceProvider;
_logger = logger;
}
public DebugCanvas(Size displaySize, Point drawPadding, IProjector projector)
{
this.drawPadding = drawPadding;
this.projector = projector;
PaddedSize = new Size(displaySize.Width + 2 * drawPadding.X, displaySize.Height + 2 * drawPadding.Y);
bitmap = new Bitmap(PaddedSize.Width, PaddedSize.Height);
}
public GetMeterMeasurementTypesQueryHandler(
IResolver resolver
) : base(resolver)
{
Repository = GetRepository <MeterMeasurementType>();
Projector = new Projector.ToFlat <MeterMeasurementType, GetMeterMeasurementTypesResponse>();
}
/// <inheritdoc />
public override void Draw(GameTime gameTime, SpriteBatch spriteBatch, IProjector projector)
{
if (Effect != null && Effect.Duration < gameTime.TotalGameTime - Effect.CreationTime)
{
Effect = null;
}
if (Effect is GlowEffect glowEffect)
{
var effectLocalSize = projector.ScaleToLocal(new Vector2(glowEffect.PixelSize, glowEffect.PixelSize));
spriteBatch.ProjectionDraw(projector, CommonTextures.CardBorder, effectLocalSize * -1, (_size + 2 * effectLocalSize) / _size, Color.Yellow * 0.5f);
}
else if (Effect is PulsingGlowEffect pulsingGlowEffect)
{
var elapsedTime = gameTime.TotalGameTime - pulsingGlowEffect.CreationTime;
var singleDuration = Effect.Duration.Ticks / pulsingGlowEffect.Times;
var ratio = (elapsedTime.Ticks % singleDuration) / (float)singleDuration;
var opacity = (1 - ratio) * pulsingGlowEffect.MaxOpacity;
var effectSize = ratio * pulsingGlowEffect.PixelSize;
var effectLocalSize = projector.ScaleToLocal(new Vector2(effectSize, effectSize));
spriteBatch.ProjectionDraw(projector, CommonTextures.CardBorder, effectLocalSize * -1, (_size + 2 * effectLocalSize) / _size, Color.Red * opacity);
}
spriteBatch.ProjectionDraw(projector, CommonTextures.CardBorder, Vector2.Zero, Color.Black);
spriteBatch.ProjectionDraw(projector, Image, _textureOffset);
}
/// <inheritdoc />
public override bool Contains(Vector2 position, IProjector projector)
{
var local = projector.ProjectToLocal(position);
return(local.X >= 0 && local.X <= _size.X &&
local.Y >= 0 && local.Y <= _size.Y);
}
public void Add(IProjector pj)
{
lock (lst )
{
lst.Add(pj);
}
}
public GetMailMessageLogsQueryHandler(
IResolver resolver
) : base(resolver)
{
Repository = GetRepository <MailMessageLogItem>();
Projector = new Projector.ToFlat <MailMessageLogItem, GetMailMessageLogsQueryResult>();
}
/// <summary>Отрисовывает объект в указанном контексте рисования</summary>
/// <param name="dc">Контекст рисования</param>
/// <param name="Projector">Индекс масштаба рисования</param>
protected override void Draw(DrawingContext dc, IProjector <TX, TY> Projector)
{
Point p1 = Projector.Project(Segment.Start, Y1);
Point p2 = Projector.Project(Segment.End, Y2);
dc.DrawLine(_pen, p1, p2);
}
public void Update(GameTime gameTime, ref bool captureEvents, IProjector projector)
{
using (new ProjectorScope(projector, GetProjection()))
{
Value.Update(gameTime, ref captureEvents, projector);
}
}
public static IEnumerable <TDestination> Project <TEntity, TDestination>(
this IQueryable <TEntity> source, IProjector <TEntity, TDestination> projector)
where TEntity : Entity
where TDestination : class
{
return(source.Select(projector.Project));
}
public string RenderProjector()
{
IProjector button = CreateProjector();
var result = button.getCCData();
return(result);
}
public IEtlPipelineStep <TOut, TNextOut> Project <TNextOut>(IProjector <TOut, TNextOut> projector)
{
if (projector == null)
{
throw new ArgumentNullException(nameof(projector));
}
return(Project(projector.ProjectTo));
}
public void SetUp()
{
_projector = Substitute.For <IProjector <TestEvent> >();
_testCommandConsumer = new TestEventConsumer(_projector);
_consumeContext = Substitute.For <ConsumeContext <TestEvent> >();
_testEvent = new TestEvent();
_consumeContext.Message.Returns(_testEvent);
}
public static IQueryable <TDest> ApplyProjectApplyAgainWithoutOrderBy <TSource, TDest>(
this IQueryable <TSource> queryable, IProjector projector, object spec)
where TSource : class
where TDest : class
=> queryable
.MaybeWhere(spec)
.Project <TDest>(projector)
.MaybeWhere(spec);
public TypiconXmlImportManager(IProjector <TypiconVersionProjection, TypiconEntity> projector
, TypiconDBContext dbContext
, ITypiconSerializer serializer)
{
_projector = projector ?? throw new ArgumentNullException(nameof(projector));
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
public DebugMultiCanvasHost(Size canvasSize, Point canvasPadding, IProjector projector = null)
{
this.canvasSize = canvasSize;
this.canvasPadding = canvasPadding;
this.projector = projector ?? OrthographicXYProjector.Instance;
var paddedSize = new Size(canvasSize.Width + 2 * canvasPadding.X, canvasSize.Height + 2 * canvasPadding.Y);
var displaySize = new Size((int)(paddedSize.Width * scale), (int)(paddedSize.Height * scale));
form = new Form {
ClientSize = new Size(displaySize.Width, displaySize.Height + 40),
StartPosition = FormStartPosition.CenterScreen
};
pb = new PictureBox {
Location = Point.Empty,
Size = displaySize,
SizeMode = PictureBoxSizeMode.Zoom
};
slider = new TrackBar {
Orientation = Orientation.Horizontal,
Location = new Point(0, displaySize.Height),
Size = new Size(displaySize.Width, 40)
};
slider.ValueChanged += HandleSliderValueChanged;
form.Controls.Add(pb);
form.Controls.Add(slider);
slider.KeyUp += (s, e) => {
if (e.KeyCode != Keys.Space)
{
return;
}
var speedup = 1;
if (e.Shift)
{
new Thread(() => {
var v = slider.Value;
while (slider.Value == v && v != 0)
{
v = Math.Max(v - 5 * speedup, 0);
slider.Invoke(new Action(() => { slider.Value = v; }));
Thread.Sleep(12);
}
}).Start();
}
else
{
new Thread(() => {
var v = slider.Value;
while (slider.Value == v && v != slider.Maximum)
{
v = Math.Min(v + 2 * speedup, (int)slider.Maximum);
slider.Invoke(new Action(() => { slider.Value = v; }));
Thread.Sleep(12);
}
}).Start();
}
};
}
protected override ConfigureOptions CreateConfigureOptions([NotNull] GlobalContext globalContext,
[CanBeNull] string configureOptionsString, bool forceReload)
{
var localVars = new ValuesFrame();
var options = new ConfigureOptions();
ProjectionSet orderedProjections = null;
_projector = null;
Option.Parse(globalContext, configureOptionsString,
MatcherStrategyOption.Action((args, j) => {
string strategy = Option.ExtractRequiredOptionValue(args, ref j, "missing strategy");
switch (strategy)
{
case "S":
_createProjector = (p, i) => new SimpleProjector(p, name: "default projector");
break;
case "PT":
_createProjector = (p, i) => new SelfOptimizingPrefixTrieProjector(p, i, 10000, name: "PT projector");
break;
case "FL":
_createProjector = (p, i) => new SelfOptimizingFirstLetterProjector(p, i, 10000, name: "FL projector");
break;
default:
Log.WriteWarning($"Unrecognized matcher optimization strategy {strategy} - using default");
break;
}
return(j);
}), ProjectionFileOption.Action((args, j) => {
string fullSourceName =
Path.GetFullPath(Option.ExtractRequiredOptionValue(args, ref j, "missing projections filename"));
orderedProjections = GetOrReadChildConfiguration(globalContext, () => new StreamReader(fullSourceName),
fullSourceName, globalContext.IgnoreCase, "????", forceReload, localVars);
return(j);
}), ProjectionsOption.Action((args, j) => {
orderedProjections = GetOrReadChildConfiguration(globalContext,
() => new StringReader(string.Join(Environment.NewLine, args.Skip(j + 1))),
ProjectionsOption.ShortName, globalContext.IgnoreCase, "????", forceReload: true, localVars: localVars);
// ... and all args are read in, so the next arg index is past every argument.
return(int.MaxValue);
}));
if (orderedProjections == null || !orderedProjections.AllProjections.Any())
{
Log.WriteWarning("No projections defined");
_projector = new SimpleProjector(new Projection[0], name: "empty");
_allProjectionsForMatchCountLoggingOnly = new Projection[0];
}
else
{
_projector = _createProjector(orderedProjections.AllProjections, globalContext.IgnoreCase);
_allProjectionsForMatchCountLoggingOnly = orderedProjections.AllProjections;
}
return(options);
}
/// <inheritdoc />
public void Draw(GameTime gameTime, SpriteBatch spriteBatch, IProjector projector)
{
spriteBatch.ProjectionDraw(projector, CommonTextures.BoardBackground, Vector2.Zero, 8f);
foreach (var boardItem in Items)
{
boardItem.Draw(gameTime, spriteBatch, projector);
}
}
public override void Draw(Graphics g, IProjector projector, CartesianToGdi GdiTrans)
{
PointF start2d = projector.Project(Start);
PointF end2d = projector.Project(End);
PenPicker picker = new PenPicker();
Pen pen = picker.PickPen(Color, isDashedLine);
g.DrawLine(pen, GdiTrans.ToGdi(start2d), GdiTrans.ToGdi(end2d));
}
public ProjectionController(IProjector <TProjection> projector)
{
if (projector == null)
{
throw new ArgumentNullException(nameof(projector));
}
_projector = projector;
}
public CartesianTierPlotter(int tierLevel, IProjector projector, string fieldPrefix)
{
_tierLevel = tierLevel;
_fieldPrefix = fieldPrefix;
_projector = projector;
SetTierLength();
SetTierBoxes();
SetTierVerticalPosDivider();
}
public CartesianTierPlotter(int tierLevel, IProjector projector, string fieldPrefix)
{
_tierLevel = tierLevel;
_fieldPrefix = fieldPrefix;
_projector = projector;
SetTierLength();
SetTierBoxes();
SetTierVerticalPosDivider();
}
public IQuery GetQueryFor(Type message, Type entity, IProjector projector, int rows)
{
if (_queries.ContainsKey((message.ToString()))) return _store.CreateQuery(_queries[message.ToString()]);
var queryBuilder = new StringBuilder();
BuildSelectClause(queryBuilder, projector.Parameters, projector.References);
BuildFromClause(entity, queryBuilder, projector.References);
BuildWhereClause(queryBuilder, projector.Citerion);
BuildOrderClause(queryBuilder, projector.Ordering);
var queryText = queryBuilder.ToString();
_queries.Add(message.ToString(), queryText);
var query = _store.CreateQuery(queryBuilder.ToString());
if (rows != 0)
query.SetMaxResults(rows);
return query;
}
public bool Equals(ref IProjector other)
{
if (other == null) return false ;
var otherhost = other.getHost();
if (otherhost == null) return false;
var thisHost = this.getHost();
if (thisHost == null) return false;
bool match = thisHost.Equals(otherhost);
thisHost = null;
otherhost = null;
return match;
}
