C# InputData.NodeConfigurationWithName方法代码示例

        public void PushesDataToEpoch()
        {
            const string UNUSED_NAME = "UNUSED";

            var c = new SingleEpochController();
            var dev = new UnitConvertingExternalDevice(UNUSED_NAME, UNUSED_DEVICE_MANUFACTURER, UNUSED_BACKGROUND);
            c.AddDevice(dev);

            var srate = new Measurement(100, "Hz");
            var samples = Enumerable.Range(0, 100).Select(i => new Measurement(1, "V")).ToList();

            var e = new Epoch("PushesDataToEpoch");
            e.Responses[dev] = new Response();

            e.Stimuli[dev] = new RenderedStimulus((string) "ID1", (IDictionary<string, object>) new Dictionary<string, object>(), (IOutputData) new OutputData(samples, srate, false));

            c.SetCurrentEpoch(e);

            var streamFake = new DAQInputStream("StreamFake");

            var data = new InputData(samples, srate, DateTimeOffset.Now)
                .DataWithStreamConfiguration(streamFake, new Dictionary<string, object>());

            c.PushInputData(dev, data);

            Assert.That(e.Responses[dev].Data, Is.EqualTo(data.Data));
            Assert.That(e.Responses[dev].InputTime, Is.EqualTo(data.InputTime));
            Assert.That(e.Responses[dev].DataConfigurationSpans.First().Nodes.First(),
                Is.EqualTo(data.NodeConfigurationWithName(streamFake.Name)));
        }

        public void InputData_SetsExternalDeviceConfig()
        {
            var config = new Dictionary<string, object>();
            config["key"] = "value";

            IInputData data = new InputData(Data, UNUSED_SRATE, DateTimeOffset.Now);

            data = data.DataWithExternalDeviceConfiguration(devFake, config);

            Assert.That(data.NodeConfigurationWithName(devFake.Name).Configuration, Is.EqualTo(config));
        }

        public void InputDataConversion()
        {
            IDictionary<string, object> config = new Dictionary<string, object>(2);
            config["param1"] = 10;
            config["param2"] = 1;

            IMeasurement srate = new Measurement(1000, "Hz");

            IInputData data = new InputData(this.Data,
                srate,
                DateTimeOffset.Now,
                new PipelineNodeConfiguration(IOData.STREAM_CONFIGURATION_NAME, new Dictionary<string, object>()))
                .DataWithExternalDeviceConfiguration(devFake, new Dictionary<string, object>());

            Converters.Clear();
            ConvertProc fooConversion = (m) => new Measurement(m.QuantityInBaseUnits * 10, 1, "foo");
            Converters.Register("V", "foo", fooConversion);

            IInputData expected = new InputData(data,
                data.Data.Select(m => new Measurement(m.QuantityInBaseUnits * 10, 1, "foo")).ToList());

            Assert.NotNull(expected.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME));
            IInputData actual = data.DataWithUnits("foo");

            Assert.AreEqual(expected.Data, actual.Data);
            Assert.That(actual.NodeConfigurationWithName(IOData.EXTERNAL_DEVICE_CONFIGURATION_NAME),
                Is.EqualTo(expected.NodeConfigurationWithName(IOData.EXTERNAL_DEVICE_CONFIGURATION_NAME)));
            Assert.That(actual.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME),
                Is.EqualTo(expected.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME)));
            Assert.AreEqual(expected.InputTime, actual.InputTime);
        }

        public void InputDataCreation()
        {
            IDictionary<string, object> config = new Dictionary<string, object>(2);
            config["param1"] = 10;
            config["param2"] = 1;

            IMeasurement srate = new Measurement(1000, "Hz");

            DateTimeOffset expectedTime = DateTimeOffset.UtcNow;

            var nodeName = "test-node";

            IInputData inData = new InputData(this.Data,
                new Measurement(1000, "Hz"),
                expectedTime,
                new PipelineNodeConfiguration(nodeName, config));

            Assert.IsNotNull(inData);
            Assert.AreEqual(this.Data, inData.Data);
            Assert.IsNull(inData.NodeConfigurationWithName(nodeName+"x"));
            Assert.That(inData.NodeConfigurationWithName(nodeName).Configuration, Is.EqualTo(config));
            Assert.AreEqual(srate, inData.SampleRate);
            Assert.AreEqual(expectedTime, inData.InputTime);
        }

        public void PushesDataToEpoch()
        {
            const string UNUSED_NAME = "UNUSED";

            var daq = new SimpleDAQController();
            var c = new NonValidatingController { DAQController = daq };
            var dev = new UnitConvertingExternalDevice(UNUSED_NAME, UNUSED_DEVICE_MANUFACTURER, c, UNUSED_BACKGROUND);
            var outStream = new DAQOutputStream("out");
            var inStream = new DAQInputStream("in");

            dev.BindStream(outStream).BindStream(inStream);

            var srate = new Measurement(100, "Hz");
            var samples = Enumerable.Range(0, 100).Select(i => new Measurement(1, "V")).ToList();

            var e = new Epoch("PushesDataToEpoch");
            e.Responses[dev] = new Response();

            e.Stimuli[dev] = new RenderedStimulus((string) "ID1", (IDictionary<string, object>) new Dictionary<string, object>(), (IOutputData) new OutputData(samples, srate, false));

            var data = new InputData(samples, srate, DateTimeOffset.Now).DataWithStreamConfiguration(inStream, new Dictionary<string, object>());
            bool pushed = false;

            daq.Started += (evt, args) =>
                {
                    c.PushInputData(dev, data);
                    pushed = true;

                    c.RequestStop();
                };

            c.EnqueueEpoch(e);
            c.StartAsync(null);

            while (!pushed)
            {
                Thread.Sleep(1);
            }

            Assert.That(e.Responses[dev].Data, Is.EqualTo(data.Data));
            Assert.That(e.Responses[dev].InputTime, Is.EqualTo(data.InputTime));
            Assert.That(e.Responses[dev].DataConfigurationSpans.First().Nodes.First(),
                Is.EqualTo(data.NodeConfigurationWithName(inStream.Name)));
        }