Updated Library.properties to library.json

Distinct -> DistunctUntilChanged
Added Distinct operator

Author: rzeldent

keywords.txt

@@ -0,0 +1,37 @@
+{
+    "$schema": "https://raw.githubusercontent.com/platformio/platformio-core/develop/platformio/assets/schema/library.json",
+    "name": "ReactiveArduino",
+    "description": "ReactiveArduino implements observable-observer pattern on a processor like Arduino",
+    "keywords": [
+        "Reactive",
+        "Arduino",
+        "Observer",
+        "Observable",
+        "Event"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/rzeldent/Arduino-ReactiveArduino"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "platforms": "*",
+    "build": {
+        "srcDir": "src/",
+        "includeDir": "include/"
+    },
+    "version": "2.0.0",
+    "authors": [
+        {
+            "name": "Luis Llamas",
+            "maintainer": true
+        },
+        {
+            "name": "Rene Zeldenthuis",
+            "maintainer": true
+        }
+
+    ],
+    "category": "Other"
+}

library.json

@@ -19,7 +19,7 @@ class OperatorDistinct : public Operator<T, T>
 	void OnNext(T value) override;
 
 private:
-	T _last = T();
+	std::set<T> _seen;
 	bool _any = false;
 };
 
@@ -31,10 +31,12 @@ OperatorDistinct<T>::OperatorDistinct()
 template <typename T>
 void OperatorDistinct<T>::OnNext(T value)
 {
-	if (!_any || (_any && _last != value))
+	if (!_any || (_any && _seen.find(value) == _seen.end()))
+	{
+		_seen.insert(value);
 		this->_childObservers.OnNext(value);
+	}
 
-	_last = value;
 	_any = true;
 }
 

library.properties

@@ -0,0 +1,43 @@
+/***************************************************
+Copyright (c) 2019 Luis Llamas
+(www.luisllamas.es)
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License
+ ****************************************************/
+
+#ifndef _REACTIVEOPERATORDISTINCTUNTILCHANGED_h
+#define _REACTIVEOPERATORDISTINCTUNTILCHANGED_h
+
+template <typename T>
+class OperatorDistinctUntilChanged : public Operator<T, T>
+{
+public:
+	OperatorDistinctUntilChanged();
+
+	void OnNext(T value) override;
+
+private:
+	T _last = T();
+	bool _any = false;
+};
+
+template <typename T>
+OperatorDistinctUntilChanged<T>::OperatorDistinctUntilChanged()
+{
+}
+
+template <typename T>
+void OperatorDistinctUntilChanged<T>::OnNext(T value)
+{
+	if (!_any || (_any && _last != value))
+	{
+		_last = value;
+		this->_childObservers.OnNext(value);
+	}
+	
+	_any = true;
+}
+
+#endif

src/Operators/OperatorDistinct.h

@@ -12,6 +12,7 @@ Unless required by applicable law or agreed to in writing, software distributed
 
 #include "OperatorWhere.h"
 #include "OperatorDistinct.h"
+#include "OperatorDistinctUntilChanged.h"
 
 #include "OperatorLast.h"
 #include "OperatorFirst.h"

src/Operators/OperatorDistinctUntilChanged.h

@@ -50,6 +50,7 @@ template <typename T> class FilterIsZero;
 
 template <typename T> class OperatorWhere;
 template <typename T> class OperatorDistinct;
+template <typename T> class OperatorDistinctUntilChanged;
 template <typename T> class OperatorLast;
 template <typename T> class OperatorFirst;
 template <typename T> class OperatorTake;
@@ -154,6 +155,7 @@ class Observable : IObservable<T>, IResetable<T>
 	// "Fluent" behavior
 	OperatorWhere<T>& Where(ReactivePredicate<T> condition);
 	OperatorDistinct<T>& Distinct();
+	OperatorDistinctUntilChanged<T>& DistinctUntilChanged();
 	OperatorFirst<T>& First();
 	OperatorLast<T>& Last();
 	OperatorSkip<T>& Skip(size_t num);
@@ -266,6 +268,14 @@ auto Observable<T>::Distinct() -> OperatorDistinct<T>&
 	return *newOp;
 }
 
+template <typename T>
+auto Observable<T>::DistinctUntilChanged() -> OperatorDistinctUntilChanged<T>&
+{
+	auto newOp = new OperatorDistinctUntilChanged<T>();
+	Compound(*this, *newOp);
+	return *newOp;
+}
+
 template <typename T>
 auto Observable<T>::First() -> OperatorFirst<T>&
 {

src/Operators/Operators.h

@@ -5,7 +5,7 @@ Copyright (c) 2019 Luis Llamas
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License
- ****************************************************/
+****************************************************/
 
 #ifndef _REACTIVEARDUINOLIB_h
 #define _REACTIVEARDUINOLIB_h
@@ -18,6 +18,8 @@ Unless required by applicable law or agreed to in writing, software distributed
 	#include "WProgram.h"
 #endif
 
+#include <set>
+
 namespace Reactive
 {
 #include "ReactiveArduinoCore.h"
@@ -223,6 +225,12 @@ namespace Reactive
 		return *(new OperatorDistinct<T>());
 	}
 
+	template <typename T>
+	OperatorDistinctUntilChanged<T>& DistinctUntilChanged()
+	{
+		return *(new OperatorDistinctUntilChanged<T>());
+	}
+
 	template <typename T>
 	OperatorFirst<T>& First()
 	{