private LinkRouterBase <T> GetLinkFromProducerType <T>(ProducerType type)
{
switch (type)
{
case ProducerType.Broadcaster:
return(new LinkBroadcasterRouter <T>());
case ProducerType.Dispatcher:
return(new LinkDispatcherRouter <T>());
default:
throw new Exception("Unknown producer type specified. Cannot create router.");
}
}
public static Factories.AbstractFactory GetFactory(ProducerType producerType)
{
switch (producerType)
{
case ProducerType.Shape:
return(new ShapeFactory());
case ProducerType.Color:
return(new ColorFactory());
default:
throw new ArgumentOutOfRangeException(nameof(producerType), producerType, null);
}
}
/// <summary>
/// Create a new Ring Buffer with the specified producer type (SINGLE or MULTI)
/// </summary>
/// <param name="producerType">producer type to use <see cref="ProducerType" /></param>
/// <param name="factory">used to create the events within the ring buffer.</param>
/// <param name="bufferSize">number of elements to create within the ring buffer.</param>
/// <param name="waitStrategy">used to determine how to wait for new elements to become available.</param>
/// <returns>a constructed ring buffer.</returns>
/// <exception cref="ArgumentOutOfRangeException">if the producer type is invalid</exception>
/// <exception cref="ArgumentException">if bufferSize is less than 1 or not a power of 2</exception>
public static RingBuffer <T> Create(ProducerType producerType, Func <T> factory, int bufferSize, IWaitStrategy waitStrategy)
{
switch (producerType)
{
case ProducerType.Single:
return(CreateSingleProducer(factory, bufferSize, waitStrategy));
case ProducerType.Multi:
return(CreateMultiProducer(factory, bufferSize, waitStrategy));
default:
throw new ArgumentOutOfRangeException(producerType.ToString());
}
}
private ISequencer newProducer(ProducerType producerType, int bufferSize, IWaitStrategy waitStrategy)
{
switch (producerType)
{
case ProducerType.SINGLE:
return(new SingleProducerSequencer(bufferSize, waitStrategy));
case ProducerType.MULTI:
return(new MultiProducerSequencer(bufferSize, waitStrategy));
default:
throw new ArgumentException(producerType.ToString());
}
}
private ISequencer NewProducer(ProducerType producerType, int bufferSize, IWaitStrategy waitStrategy)
{
switch (producerType)
{
case ProducerType.Single:
return(new SingleProducerSequencer(bufferSize, waitStrategy));
case ProducerType.Multi:
return(new MultiProducerSequencer(bufferSize, waitStrategy));
default:
throw new ArgumentOutOfRangeException(nameof(producerType), producerType, null);
}
}
/// <summary>
/// Create a new sequencer with the specified producer type.
/// </summary>
/// <param name="producerType">producer type to use <see cref="ProducerType" /></param>
/// <param name="bufferSize">number of elements to create within the ring buffer.</param>
/// <param name="waitStrategy">used to determine how to wait for new elements to become available.</param>
/// <returns>a constructed ring buffer.</returns>
/// <exception cref="ArgumentOutOfRangeException">if the producer type is invalid</exception>
/// <exception cref="ArgumentException">if bufferSize is less than 1 or not a power of 2</exception>
public static ISequencer Create(ProducerType producerType, int bufferSize, IWaitStrategy waitStrategy)
{
switch (producerType)
{
case ProducerType.Single:
return(new SingleProducerSequencer(bufferSize, waitStrategy));
case ProducerType.Multi:
return(new MultiProducerSequencer(bufferSize, waitStrategy));
default:
throw new ArgumentOutOfRangeException(producerType.ToString());
}
}
public static void UpdateProducerType(this ProducerType computerType, ProducerTypeViewModel computerTypeVm)
{
computerType.ProducerTypeId = computerTypeVm.ProducerTypeId;
computerType.ProducerTypeCode = computerTypeVm.ProducerTypeCode;
computerType.ProducerTypeName = computerTypeVm.ProducerTypeName;
computerType.ProducerTypeDescription = computerTypeVm.ProducerTypeDescription;
computerType.CreatedDate = computerTypeVm.CreatedDate;
computerType.CreatedBy = computerTypeVm.CreatedBy;
computerType.UpdatedDate = computerTypeVm.UpdatedDate;
computerType.UpdatedBy = computerTypeVm.UpdatedBy;
computerType.MetaKeyword = computerTypeVm.MetaKeyword;
computerType.MetaDescription = computerTypeVm.MetaDescription;
computerType.Status = computerTypeVm.Status;
}
/// <summary>
/// Create a new Ring Buffer with the specified producer type (SINGLE or MULTI).
/// </summary>
/// <param name="producerType">producer type to use <see cref="ProducerType"/>.</param>
/// <param name="factory">used to create events within the ring buffer.</param>
/// <param name="bufferSize">number of elements to create within the ring buffer.</param>
/// <param name="waitStrategy">used to determine how to wait for new elements to become available.</param>
/// <returns>a constructed ring buffer.</returns>
/// <exception cref="ArgumentException">if bufferSize is less than 1 or not a power of 2</exception>
public static RingBuffer <TEvent> Create(
ProducerType producerType,
IEventFactory <TEvent> factory,
int bufferSize,
IWaitStrategy waitStrategy)
{
switch (producerType)
{
case ProducerType.Single:
return(CreateSingleProducer(factory, bufferSize, waitStrategy));
case ProducerType.Multi:
return(CreateMultiProducer(factory, bufferSize, waitStrategy));
default:
throw new IllegalStateException(producerType.ToString());
}
}
// Input parameter configuration (with default value)
// Please refer to OpenPose documentation for parameter explanation
public static void OPConfigureInput(
ProducerType producerType = ProducerType.None, string producerString = "-1",
ulong frameFirst = 0, ulong frameStep = 1, ulong frameLast = ulong.MaxValue,
bool realTimeProcessing = false, bool frameFlip = false,
int frameRotate = 0, bool framesRepeat = false,
Vector2Int?cameraResolution = null, string cameraParameterPath = null,
bool undistortImage = false, int numberViews = -1)
{
// Other default values
Vector2Int _cameraResolution = cameraResolution ?? new Vector2Int(-1, -1);
cameraParameterPath = cameraParameterPath ?? Environment.CurrentDirectory + "/models/cameraParameters/";
Bind._OPConfigureInput(
(byte)producerType, producerString, // ProducerType and string
frameFirst, frameStep, frameLast,
realTimeProcessing, frameFlip, frameRotate, framesRepeat,
_cameraResolution.x, _cameraResolution.y, // Point
cameraParameterPath, undistortImage, numberViews
);
}
public static StdSharedPtr <Producer> CreateProducer(ProducerType type,
Point <int> cameraResolution,
string producerString = "",
string cameraParameterPath = "models/cameraParameters/",
bool undistortImage = true,
int numberViews = -1)
{
var producerStringBytes = Encoding.UTF8.GetBytes(producerString ?? "");
var cameraParameterPathBytes = Encoding.UTF8.GetBytes(cameraParameterPath ?? "");
using (var resolution = cameraResolution.ToNative())
{
var ret = Native.op_createProducer(type,
producerStringBytes,
resolution.NativePtr,
cameraParameterPathBytes,
undistortImage,
numberViews);
return(new StdSharedPtr <Producer>(ret));
}
}
public HttpResponseMessage Post(HttpRequestMessage request, ProducerTypeViewModel producerTypeVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState.Values.FirstOrDefault()?.Errors.FirstOrDefault()?.ErrorMessage);
}
else
{
var newProducerType = new ProducerType();
newProducerType.UpdateProducerType(producerTypeVm);
var producerType = _producerTypeService.Add(newProducerType);
_producerTypeService.Save();
response = request.CreateResponse(HttpStatusCode.Created, producerType);
}
return response;
}));
}
public WrapperStructInput(ProducerType producerType = ProducerType.None,
string producerString = "",
ulong frameFirst = 0,
ulong frameStep = 1,
ulong frameLast = ulong.MaxValue,
bool realTimeProcessing = false,
bool frameFlip = false,
int frameRotate = 0,
bool framesRepeat = false,
Point <int> cameraResolution = default(Point <int>),
string cameraParameterPath = "models/cameraParameters/",
bool undistortImage = true,
int numberViews = -1)
{
if (cameraParameterPath == null)
{
throw new ArgumentNullException(nameof(cameraParameterPath));
}
var producerStringBytes = Encoding.UTF8.GetBytes(producerString ?? "");
var cameraParameterPathBytes = Encoding.UTF8.GetBytes(cameraParameterPath);
using (var native = cameraResolution.ToNative())
this.NativePtr = Native.op_wrapperStructInput_new(producerType,
producerStringBytes,
frameFirst,
frameStep,
frameLast,
realTimeProcessing,
frameFlip,
frameRotate,
framesRepeat,
native.NativePtr,
cameraParameterPathBytes,
undistortImage,
numberViews);
}
public SequencerTests(ProducerType producerType)
{
_producerType = producerType;
}
private static IValueRingBuffer <StubValueEvent> CreateRingBuffer(int size, ProducerType producerType)
{
return(new ValueRingBuffer <StubValueEvent>(() => new StubValueEvent(-1), SequencerFactory.Create(producerType, size)));
}
/// <summary>
/// Create a new ValueDisruptor.
/// </summary>
/// <param name="eventFactory">the factory to create events in the ring buffer</param>
/// <param name="ringBufferSize">the size of the ring buffer, must be power of 2</param>
/// <param name="taskScheduler">a <see cref="TaskScheduler"/> to create threads for processors</param>
/// <param name="producerType">the claim strategy to use for the ring buffer</param>
/// <param name="waitStrategy">the wait strategy to use for the ring buffer</param>
public ValueDisruptor(Func <T> eventFactory, int ringBufferSize, TaskScheduler taskScheduler, ProducerType producerType, IWaitStrategy waitStrategy)
: this(new ValueRingBuffer <T>(eventFactory, SequencerFactory.Create(producerType, ringBufferSize, waitStrategy)), taskScheduler)
{
}
protected abstract IValueRingBuffer <T> CreateRingBuffer(int size, ProducerType producerType);
public SequencerTests(ProducerType producerType)
{
_producerType = producerType;
}
public Producer(GameObject _object, ProducerType _type)
{
Object = _object;
Type = _type;
}
public void Update(ProducerType producerType)
{
producerType.UpdatedDate = DateTime.Now;
//producerType.UpdatedBy = ad //Todo: Add CreatedBy
_producerTypeRepository.Update(producerType);
}
/// <summary>
/// Create a new UnmanagedDisruptor.
///
/// The <see cref="UnmanagedRingBufferMemory"/> is not owned by the disruptor and should be disposed after shutdown.
/// </summary>
/// <param name="memory">block of memory that will store the events</param>
/// <param name="producerType">the claim strategy to use for the ring buffer</param>
/// <param name="waitStrategy">the wait strategy to use for the ring buffer</param>
public UnmanagedDisruptor(UnmanagedRingBufferMemory memory, ProducerType producerType, IWaitStrategy waitStrategy)
: this(new UnmanagedRingBuffer <T>(memory, producerType, waitStrategy), TaskScheduler.Default)
{
}
/// <summary>
/// Create a new sequencer with the specified producer type and <see cref="BlockingWaitStrategy"/>.
/// </summary>
/// <param name="producerType">producer type to use <see cref="ProducerType" /></param>
/// <param name="bufferSize">number of elements to create within the ring buffer.</param>
/// <returns>a constructed ring buffer.</returns>
/// <exception cref="ArgumentOutOfRangeException">if the producer type is invalid</exception>
/// <exception cref="ArgumentException">if bufferSize is less than 1 or not a power of 2</exception>
public static ISequencer Create(ProducerType producerType, int bufferSize)
{
return(Create(producerType, bufferSize, DefaultWaitStrategy()));
}
public FlowBatcherSettings(ProducerType producerType, int maxBatchSize, TimeSpan maxBatchTimeout, int capacity, object context = null, uint parallelismInstances = 1) : base(capacity, context, parallelismInstances)
{
ProducerType = producerType;
MaxBatchSize = maxBatchSize;
MaxBatchTimeout = maxBatchTimeout;
}
public FlowWaiterSettings(ProducerType producerType, int capacity, object context = null, uint parallelismInstances = 1) : base(capacity, context, parallelismInstances)
{
ProducerType = producerType;
}
internal FluentWaiterDefinition(ProducerType producerType)
{
_producerType = producerType;
}
public SequencerTest(ProducerType producerType /*, IWaitStrategy waitStrategy*/)
{
this.producerType = producerType;
}
public FlowProducerSettings(ProducerType producerType, object context = null, uint parallelismInstances = 1)
: base(context, parallelismInstances)
{
ProducerType = producerType;
}
public Batching_Test(ProducerType producerType)
{
_producerType = producerType;
}
/// <summary>
/// Construct an UnmanagedRingBuffer with the full option set.
/// The <see cref="UnmanagedRingBufferMemory"/> is not owned by the ring buffer and should be disposed after shutdown.
/// </summary>
/// <param name="memory">block of memory that will store the events</param>
/// <param name="producerType">producer type to use <see cref="ProducerType" /></param>
/// <param name="waitStrategy">used to determine how to wait for new elements to become available.</param>
/// <exception cref="ArgumentException">if bufferSize is less than 1 or not a power of 2</exception>
public UnmanagedRingBuffer(UnmanagedRingBufferMemory memory, ProducerType producerType, IWaitStrategy waitStrategy)
: base(SequencerFactory.Create(producerType, memory.EventCount, waitStrategy), memory.PointerToFirstEvent, memory.EventSize)
{
}
public static extern IntPtr op_createProducer(ProducerType type,
byte[] producerString,
IntPtr cameraResolution,
byte[] cameraParameterPath,
bool undistortImage,
int mNumberViews);
private Sequencer NewProducer(ProducerType producerType, int bufferSize, IWaitStrategy waitStrategy)
{
switch (producerType)
{
case ProducerType.Single:
return new SingleProducerSequencer(bufferSize, waitStrategy);
case ProducerType.Multi:
return new MultiProducerSequencer(bufferSize, waitStrategy);
default:
throw new ArgumentOutOfRangeException(nameof(producerType), producerType, null);
}
}
/// <summary>
/// Create a new UnmanagedDisruptor.
/// </summary>
/// <param name="pointer">pointer to the first event of the buffer</param>
/// <param name="eventSize">size of each event</param>
/// <param name="ringBufferSize">the number of events of the ring buffer, must be power of 2</param>
/// <param name="taskScheduler">a <see cref="TaskScheduler"/> to create threads for processors</param>
/// <param name="producerType">the claim strategy to use for the ring buffer</param>
/// <param name="waitStrategy">the wait strategy to use for the ring buffer</param>
public UnmanagedDisruptor(IntPtr pointer, int eventSize, int ringBufferSize, TaskScheduler taskScheduler, ProducerType producerType, IWaitStrategy waitStrategy)
: this(new UnmanagedRingBuffer <T>(pointer, eventSize, SequencerFactory.Create(producerType, ringBufferSize, waitStrategy)), taskScheduler)
{
}
public SequencerTest(ProducerType producerType/*, IWaitStrategy waitStrategy*/)
{
this.producerType = producerType;
}
/// <summary>
/// Create a new ValueDisruptor.
/// </summary>
/// <param name="eventFactory">the factory to create events in the ring buffer</param>
/// <param name="ringBufferSize">the size of the ring buffer, must be power of 2</param>
/// <param name="taskScheduler">a <see cref="TaskScheduler"/> to create threads for processors</param>
/// <param name="producerType">the claim strategy to use for the ring buffer</param>
/// <param name="waitStrategy">the wait strategy to use for the ring buffer</param>
public ValueDisruptor(Func <T> eventFactory, int ringBufferSize, TaskScheduler taskScheduler, ProducerType producerType, IWaitStrategy waitStrategy)
: this(ValueRingBuffer <T> .Create(producerType, eventFactory, ringBufferSize, waitStrategy), new BasicExecutor(taskScheduler))
{
}
private ISequencer newProducer(ProducerType producerType, int bufferSize, IWaitStrategy waitStrategy)
{
switch (producerType)
{
case ProducerType.SINGLE:
return new SingleProducerSequencer(bufferSize, waitStrategy);
case ProducerType.MULTI:
return new MultiProducerSequencer(bufferSize, waitStrategy);
default:
throw new ArgumentException(producerType.ToString());
}
}
