/** * Protected constructor. Instances of this class should be obtained * through the {@link #create(SensorParams)} factory method. * * @param params */ protected CustomFileSensor(SensorParams @params) : base(@params) { string pathStr = (string)@params.Get("PATH"); FileInfo f = new FileInfo(pathStr); if (!f.Exists) { throw new ArgumentException("Passed improperly formed Tuple: invalid PATH: " + @params.Get("PATH")); } try { IStream <string> fileStream = new Stream <string>(YieldingFileReader.ReadAllLines(f.FullName, Encoding.UTF8)); this.stream = BatchedCsvStream <string> .Batch(fileStream, BATCH_SIZE, DEFAULT_PARALLEL_MODE, HEADER_SIZE, s => { return(s.Split('\t')); }); } catch (IOException e) { Console.WriteLine(e); } }
/** * Decorator pattern to construct a new HTMSensor wrapping the specified {@link Sensor}. * * @param sensor */ public HTMSensor(ISensor sensor) { this.@delegate = sensor; sensorParams = sensor.GetSensorParams(); header = new Header(sensor.GetInputStream().GetMeta()); if (header == null || header.Size() < 3) { throw new InvalidOperationException("Header must always be present; and have 3 lines."); } CreateEncoder(); }
/// <summary> /// <p>Creates and returns the <see cref="Sensor"/> subtype indicated by the method reference passed in for the SensorFactory <see cref="Func{SensorParams, Sensor{T}}"/> /// argument. <br/><br/><b>Typical usage is as follows:</b></p> /// <p><pre>Sensor.create(FileSensor.Create, SensorParams); //Can be URISensor, or ObservableSensor</pre></p> /// </summary> /// <param name="factoryMethod">the <see cref="Func{SensorParams, Sensor{T}}"/> or method reference. SensorFactory is a {@link FunctionalInterface}</param> /// <param name="t">the <see cref="SensorParams"/> which hold the configuration and data source details.</param> /// <returns></returns> public static Sensor <T> Create(Func <SensorParams, ISensor> factoryMethod, SensorParams t) { if (factoryMethod == null) { throw new InvalidOperationException("Factory cannot be null"); } if (t == null) { throw new InvalidOperationException("Properties (i.e. \"SensorParams\") cannot be null"); } return(new HTMSensor <T>(factoryMethod(t))); }
/** * Creates a new {@code ObservableSensor} using the specified * {@link SensorParams} * * @param params */ internal ObservableSensor(SensorParams @params) { if ([email protected]("ONSUB")) { throw new ArgumentException("Passed improperly formed Tuple: no key for \"ONSUB\""); } this.@params = @params; IObservable <string> obs = null; object publisher = @params.Get("ONSUB"); if (publisher is Publisher) { obs = ((Publisher)publisher).Observable(); } else if (publisher is PublisherSupplier) { obs = ((PublisherSupplier)publisher).Get().Observable(); } else { obs = (IObservable <string>)@params.Get("ONSUB"); } //IEnumerator<string> observerator = obs.GetEnumerator(); //IEnumerator<string> iterator = new CustomIterator<string>( // () => // { // bool moved = observerator.MoveNext(); // return new System.Tuple<bool, string>(moved, observerator.Current); // }); //Iterator<String> iterator = new Iterator<String>() { // public boolean hasNext() { return observerator.hasNext(); } // public String next() // { // return observerator.next(); // } //}; //int characteristics = Spliterator.SORTED | Spliterator.ORDERED; //Spliterator<string> spliterator = Spliterators.spliteratorUnknownSize(iterator, characteristics); this.stream = BatchedCsvStream <string> .Batch( new Stream <string>(obs), BATCH_SIZE, DEFAULT_PARALLEL_MODE, HEADER_SIZE); }
/** * Protected constructor. Instances of this class should be obtained * through the {@link #create(SensorParams)} factory method. * * @param params */ protected FileSensor(SensorParams @params) { this.@params = @params; if ([email protected]("PATH")) { throw new ArgumentException("Passed improperly formed Tuple: no key for \"PATH\""); } string pathStr = (string)@params.Get("PATH"); if (pathStr.IndexOf("!") != -1) { pathStr = pathStr.Substring("file:".Length); IStream <string> stream = GetZipEntryStream(pathStr); this.stream = BatchedCsvStream <string> .Batch(stream, BATCH_SIZE, DEFAULT_PARALLEL_MODE, HEADER_SIZE); } else { FileInfo f = new FileInfo(pathStr); if (!f.Exists) { throw new ArgumentException("Passed improperly formed Tuple: invalid PATH: " + @params.Get("PATH")); } try { IStream <string> fileStream = new Stream <string>(YieldingFileReader.ReadAllLines(f.FullName, Encoding.UTF8)); this.stream = BatchedCsvStream <string> .Batch(fileStream, BATCH_SIZE, DEFAULT_PARALLEL_MODE, HEADER_SIZE); } catch (IOException e) { Console.WriteLine(e); } } }
/** * Factory method to allow creation through the {@link SensorFactory} in * the {@link Sensor#create(SensorFactory, SensorParams)} method of the * parent {@link Sensor} class. This indirection allows the decoration of * the returned {@code Sensor} type by wrapping it in an {@link HTMSensor} * (which is the current implementation but could be any wrapper). * * @param p the {@link SensorParams} which describe connection or source * data details. * @return the Sensor. */ public static Sensor <FileInfo> Create(SensorParams p) { Sensor <FileInfo> fs = new FileSensor(p); return(fs); }
public static ObservableSensor <T> Create(SensorParams p) { ObservableSensor <string[]> sensor = new ObservableSensor <string[]>(p); return(sensor as ObservableSensor <T>); }