public void UnsubscribeReceiver(IDataReceiver obj)
{
if (modelTransrom.Contains(obj))
{
modelTransrom.Remove(obj);
}
}
public static void Send(Stream source, IDataReceiver dataReceiver, CancellationToken cancellationToken, int bufferLength = 0)
{
if (cancellationToken.IsCancellationRequested)
{
dataReceiver.Cancel();
return;
}
byte[] buffer = CreateBuffer(bufferLength);
if (source.CanSeek)
{
dataReceiver.SetTotalLength(source.Length);
}
int count = source.Read(buffer, 0, buffer.Length);
while (count > 0)
{
if (cancellationToken.IsCancellationRequested)
{
dataReceiver.Cancel();
break;
}
else
{
dataReceiver.Receive(buffer, 0, count);
count = source.Read(buffer, 0, buffer.Length);
}
}
}
// **********************************************************************
public StopOrders(TermManager tmgr, IDataReceiver dataReceiver)
{
this.tmgr = tmgr;
this.dataReceiver = dataReceiver;
orders = new List <StopOrder>();
}
/// <summary>
/// Calls day reader and abstract datetime manually for test purpose.
/// </summary>
/// <param name="receiver"><see cref="IDataReceiver"/>, which contains HTTP Client</param>
/// <param name="datetime"><see cref="IDateTime"/>, which is possibly fake date.</param>
/// <param name="settings">Injected application Setting.</param>
public DayReader(IDataReceiver receiver, IDateTime datetime, IAppSettings settings)
{
_receiver = receiver;
_datetime = datetime;
_summaryLength = settings.SummaryLength;
_pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
}
/// <summary>
/// Creates a <see cref="IDeviceFactory"/> for UWP Hid devices
/// </summary>
/// <param name="filterDeviceDefinition">Devices must match this</param>
/// <param name="loggerFactory"><see href="https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.iloggerfactory"/></param>
/// <param name="classGuid">Filters by specified class guid</param>
/// <param name="deviceInformationFilter"></param>
/// <param name="dataReceiver"></param>
/// <param name="readBufferSize">Override the input report size</param>
/// <param name="readTransferTransform">Exposes the raw data from the device (including Report Id) on reads and allows you to format the returned <see cref="TransferResult"/></param>
/// <param name="writeTransferTransform">Given the Report Id and data supplied for the write, allow you to format the raw data that is sent to the device</param>
/// <param name="writeReportTransform">Given the data supplied, allow you to divide the data in to a <see cref="Report"/></param>
/// <param name="writeBufferSize">Override the output report size</param>
/// <param name="getConnectedDeviceDefinitionsAsync">Override the default call for getting definitions</param>
/// <param name="getDevice"></param>
/// <param name="readReportTransform">Allows you to manually convert the <see cref="Report"/> in to a <see cref="TransferResult"/> so that the Report Id is not discarded on ReadAsync. By default, this inserts the Report Id at index zero of the array.</param>
/// <returns>A factory which enumerates and instantiates devices</returns>
public static IDeviceFactory CreateUwpHidDeviceFactory(
this FilterDeviceDefinition filterDeviceDefinition,
ILoggerFactory loggerFactory = null,
GetConnectedDeviceDefinitionsAsync getConnectedDeviceDefinitionsAsync = null,
GetDeviceAsync getDevice = null,
Guid?classGuid = null,
Func <wde.DeviceInformation, bool> deviceInformationFilter = null,
IDataReceiver dataReceiver = null,
ushort?writeBufferSize = null,
ushort?readBufferSize = null,
Func <Report, TransferResult> readReportTransform = null,
Func <TransferResult, Report> readTransferTransform = null,
Func <byte[], byte, byte[]> writeTransferTransform = null,
WriteReportTransform writeReportTransform = null) => CreateUwpHidDeviceFactory(
new List <FilterDeviceDefinition> {
filterDeviceDefinition
},
loggerFactory,
getConnectedDeviceDefinitionsAsync,
getDevice,
classGuid,
deviceInformationFilter,
dataReceiver,
writeBufferSize,
readBufferSize,
readReportTransform,
readTransferTransform,
writeTransferTransform,
writeReportTransform);
public void addDataReceiver(IDataReceiver receiver)
{
using (WriteLocker wl = new WriteLocker(ref mReceiversLock))
{
mReceivers.Add(receiver);
}
}
// Use this for initialization
void Start()
{
receive = new DataReceiver();
receive.RegistHook();
//EventHolder.RegisterEvent("add", OnReceive);
text = FindObjectOfType <UnityEngine.UI.Text>();
}
public void Receive(Stream source, int bufferLength = 0)
{
using (IDataReceiver dataReceiver = CreateDataReceiver())
{
StreamSender.Send(source, dataReceiver, bufferLength);
}
}
public void SubscribeReceiver(IDataReceiver obj)
{
if (!modelTransrom.Contains(obj))
{
modelTransrom.Add(obj);
}
}
public Logic(ILogger logger, IDataHelper dataHelper, IDataTransmitter dataTransmitter, IDataReceiver dataReceiver)
{
this.logger = logger;
this.dataHelper = dataHelper;
this.dataTransmitter = dataTransmitter;
this.dataReceiver = dataReceiver;
}
///<summary>默认统计模组</summary>
///<param name="max">最大值</param>
///<param name="min">最小值</param>
///<param name="average">平均值</param>
///<param name="sd">标准差</param>
///<param name="isCV">是否使用标准差系数代替标准差</param>
///<param name="fft">快速傅立叶变换</param>
///<param name="value">数据大小（使用FFT时必须大于等于8且为2的次方）</param>
public DefaultStatisticsModule(IDataReceiver max, IDataReceiver min, IDataReceiver average, IDataReceiver sd = null, bool isCV = false, IDataReceiver fft = null, uint size = 8192u)
{
if (fft != null)
{
if (size < 8u || (size & (size - 1u)) != 0u)
{
throw new ArgumentException();
}
}
else
{
if (size == 0u)
{
throw new ArgumentException();
}
}
m_Max = max;
m_Min = min;
m_Average = average;
m_StandardDeviation = sd;
m_IsCV = isCV;
m_FastFourierTransform = fft;
m_Size = size;
m_Cache = new float[size];
}
public void Receive(Stream source, CancellationToken cancellationToken, int bufferLength = 0)
{
using (IDataReceiver dataReceiver = CreateDataReceiver())
{
StreamSender.Send(source, dataReceiver, cancellationToken, bufferLength);
}
}
// **********************************************************************
public Position(TermManager tmgr, IDataReceiver dataReceiver)
{
this.tmgr = tmgr;
this.dataReceiver = dataReceiver;
byOrdersUpdated = true;
}
public void removeDataReceiver(IDataReceiver receiver)
{
using (WriteLocker wl = new WriteLocker(ref mReceiversLock))
{
mReceivers.Remove(receiver);
}
}
/// <summary>
/// Loads data for selected device.
/// </summary>
/// <param name="request">Request with selected device type.</param>
/// <returns>Data with received values for selected device type.</returns>
public Data LoadData(Data request)
{
IDataReceiver dataReceiver = dataReceiverFactory.GetDataReceiver(request.SelectedDeviceType);
Data response = dataReceiver.ReceiveData();
return(response);
}
///<summary>默认串口数据处理程序</summary>
///<param name="receiver">数据接收器</param>
public DefaultSerialPortDataHandler(IDataReceiver receiver)
{
if (receiver == null)
{
throw new ArgumentNullException();
}
m_Receivers = new IDataReceiver[] { receiver };
}
public SomeModule(IDataReceiver receiver)
{
_worker.DoWork += new DoWorkEventHandler(Worker_DoWork);
_worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Worker_RunWorkerCompleted);
_worker.ProgressChanged += new ProgressChangedEventHandler(Worker_ProgressChanged);
_worker.WorkerReportsProgress = true;
_receiver = receiver;
}
public UDPConnection(int port, IDataReceiver receiver)
{
connection = new UdpClient(port);
this.receiver = receiver;
connection.BeginReceive(OnReceive, null);
}
private CTPDataProvider(IDataReceiver dataReceiver)
{
_dataReceiver = dataReceiver;
// 初始化数据
Initialize();
// 处理实时数据
DoProcessMarketDataQuote();
}
public SomeModule(IDataReceiver receiver)
{
// attach event handlers to the background worker
_worker.DoWork += new DoWorkEventHandler(Worker_DoWork);
_worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Worker_RunWorkerCompleted);
// store a reference to the receiver
_receiver = receiver;
}
public void Dispose()
{
_actions?.Clear();
_engine?.Dispose();
_dataReceiver?.Dispose();
_actions = null;
_engine = null;
_dataReceiver = null;
}
public UwpUsbInterfaceInterruptReadEndpoint(
UsbInterruptInPipe pipe,
IDataReceiver dataReceiver,
ILogger <UwpUsbInterfaceInterruptReadEndpoint> logger = null) : base(pipe, logger)
{
_logger = logger ?? (ILogger)NullLogger.Instance;
UsbInterruptInPipe.DataReceived += UsbInterruptInPipe_DataReceived;
_dataReceiver = dataReceiver;
}
public UDPConnection(IPAddress ip, int port, IDataReceiver receiver)
{
connection = new UdpClient();
connection.Connect(ip, port);
this.receiver = receiver;
connection.BeginReceive(OnReceive, null);
}
public PlanetwarApi(Login login, string url)
{
_dataReceiver = new DataReceiver(url);
string loginData = JsonConvert.SerializeObject(login);
var response = _dataReceiver.SendRequest("login", new Dictionary <string, string>(), loginData);
_accountKey = Decode <string>(response);
}
private ServiceImplementStub(IDataReceiver dataReceiver, Type serviceType, IRpcImplInstnce rpcImpl)
{
rpcImplInstance = rpcImpl;
routingRule = MetaData.GetServiceRoutingRule(serviceType);
serviceMethodDispatcher = MetaData.GetServiceMethodDispatcher(serviceType);
methodSerializer = MetaData.GetMethodSerializer(serviceType);
dataReceiver.RegisterImpl(this, MetaData.GetServiceId(serviceType));
}
// **********************************************************************
public static void SetReceiver(IDataReceiver receiver)
{
int reciverIdxs = MarketProvider.Receiver.Length + 1;
IDataReceiver[] tmpReciver = new IDataReceiver[reciverIdxs];
MarketProvider.Receiver.CopyTo(tmpReciver, 0);
MarketProvider.Receiver = tmpReciver;
MarketProvider.Receiver[reciverIdxs - 1] = receiver;
}
protected UwpDeviceHandler(
string deviceId,
IDataReceiver dataReceiver,
ILoggerFactory loggerFactory)
{
DeviceId = deviceId;
LoggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
Logger = loggerFactory.CreateLogger <UwpDeviceHandler <T> >();
DataReceiver = dataReceiver;
}
public TcpConnectedClient(TcpClient tcpClient, IDataReceiver dataReceiver = null)
{
this.tcpClient = tcpClient;
this.dataReceiver = dataReceiver;
if (TcpNetworkManager.Instance.IsServer)
{
Stream.BeginRead(readBuffer, 0, readBuffer.Length, OnRead, null);
}
}
// **********************************************************************
public Recorder(IDataReceiver receiver)
{
this.Receiver = receiver;
pLock = new object();
tickIds = new Dictionary <int, int>();
diffQuotes = new List <Quote>(DiffListBaseSize);
Status = "Ожидание начала записи...";
}
public void GetSharpSensorsDataReceiverTest()
{
// Given
DataReceiverFactory dataReceiverFactory = new DataReceiverFactory(devicesManager);
SelectedDevice dataReceiverType = SelectedDevice.Sharp;
// When
IDataReceiver dataReceiver = dataReceiverFactory.GetDataReceiver(dataReceiverType);
// Then
Assert.IsTrue(dataReceiver is SharpSensorsDataReceiver);
}
public void GetEncoderDataReceiverTest()
{
// Given
DataReceiverFactory dataReceiverFactory = new DataReceiverFactory(devicesManager);
SelectedDevice dataReceiverType = SelectedDevice.Encoder;
// When
IDataReceiver dataReceiver = dataReceiverFactory.GetDataReceiver(dataReceiverType);
// Then
Assert.IsTrue(dataReceiver is EncoderDataReceiver);
}
public void GetTemperatureDataReceiverTest()
{
// Given
DataReceiverFactory dataReceiverFactory = new DataReceiverFactory(devicesManager);
SelectedDevice dataReceiverType = SelectedDevice.Temperature;
// When
IDataReceiver dataReceiver = dataReceiverFactory.GetDataReceiver(dataReceiverType);
// Then
Assert.IsTrue(dataReceiver is TemperatureDataReceiver);
}
public InternalBus(IMessageSender messageSender, IBusBootstrapper busBootstrapper, IDataReceiver dataReceiver, HandlingProcessorStandard handlingProcessorStandard, HandlingProcessorInfrastructure handlingProcessorInfrastructure, PersistenceSynchronizationProcessor networkProcessor, MessageTargetsHandler messageTargetsHandler, NetworkSender networkSender, IHeartbeatManager heartbeatManager, IQueueConfiguration queueConfiguration)
{
_messageSender = messageSender;
_busBootstrapper = busBootstrapper;
_dataReceiver = dataReceiver;
_handlingProcessorStandard = handlingProcessorStandard;
_handlingProcessorInfrastructure = handlingProcessorInfrastructure;
_networkProcessor = networkProcessor;
_messageTargetsHandler = messageTargetsHandler;
_networkSender = networkSender;
_heartbeatManager = heartbeatManager;
_queueConfiguration = queueConfiguration;
_networkInputDisruptor = new Disruptor<InboundMessageProcessingEntry>(() => new InboundMessageProcessingEntry(),new MultiThreadedClaimStrategy(_queueConfiguration.InboundQueueSize), new SleepingWaitStrategy(), new RoundRobinThreadAffinedTaskScheduler(3));
_outputDisruptor = new Disruptor<OutboundDisruptorEntry>(() => new OutboundDisruptorEntry(), new MultiThreadedClaimStrategy(_queueConfiguration.OutboundQueueSize), new SleepingWaitStrategy(), new RoundRobinThreadAffinedTaskScheduler(2));
}
public HeartbeatManager(IHeartbeatingConfiguration heartbeatingConfiguration, IMessageSender messageSender, IDataReceiver dataReceiver)
{
_heartbeatingConfiguration = heartbeatingConfiguration;
_messageSender = messageSender;
_dataReceiver = dataReceiver;
}
internal override void RepeatAsyncRead(IDataReceiver cb)
{
Debug.Assert(_callback==null); //�P���Ă�ł͂���
_callback = cb;
if(_event!=null) {
_event.Set();
_event.Close();
_event = null;
}
}
/// <summary>
/// Kick off the first asynchronous read
/// </summary>
public void Start(IDataReceiver dataReceiver)
{
m_DataReceiver = dataReceiver;
BeginAsyncRead();
}
private static UnitCollectionsModel GetDataFromService(IDataReceiver dataReceiver, HttpClient client)
{
var data = dataReceiver.GetData(client);
return data;
}
internal override void RepeatAsyncRead(IDataReceiver cb)
{
if(_callback!=null) throw new InvalidOperationException("duplicated AsyncRead() is attempted");
_callback = cb;
GUtil.CreateThread(new ThreadStart(AsyncEntry)).Start();
//_stream.BeginRead(_buf, 0, _buf.Length, new AsyncCallback(RepeatCallback), null);
}
internal abstract void RepeatAsyncRead(IDataReceiver receiver);
internal override void RepeatAsyncRead(IDataReceiver r)
{
}
internal override void RepeatAsyncRead(IDataReceiver cb)
{
if(_callback!=null) throw new InvalidOperationException("duplicated AsyncRead() is attempted");
_callback = cb;
_socket.RepeatAsyncRead(this);
}
internal override void RepeatAsyncRead(IDataReceiver cb)
{
_callback = cb;
if(_buffer!=null) {
lock(this) {
_buffer.Close();
byte[] t = _buffer.ToArray();
if(t.Length>0) _callback.DataArrived(t, 0, t.Length);
_buffer = null;
}
}
}
/// <summary>
/// Sets up an async read listener on this connection. Doesn't actually do anything.
/// </summary>
/// <param name="cb">Async receiver for the data.</param>
public override void RepeatAsyncRead(IDataReceiver cb)
{
}
private static void InitializeHttpClients(out IDataSender dataSender, out IDataReceiver dataReceiver)
{
dataSender = DataSender.GetInstance;
dataReceiver = DataReceiver.GetInstance;
}
public abstract void RepeatAsyncRead(IDataReceiver cb);
internal override void RepeatAsyncRead(IDataReceiver receiver)
{
_callback = receiver;
_socket.BeginReceive(_buf, 0, _buf.Length, SocketFlags.None, new AsyncCallback(RepeatCallback), null);
}
