api: cpp: replace multiple Indigo*Iterator classes to single template one; add Bingo.Part test

api/cpp/CMakeLists.txt

@@ -18,5 +18,5 @@ if (NOT EMSCRIPTEN)
     target_include_directories(${PROJECT_NAME}
             PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src)
     target_link_libraries(${PROJECT_NAME}
-            PRIVATE indigo indigo-inchi indigo-renderer bingo-nosql)
+            PUBLIC indigo indigo-inchi indigo-renderer bingo-nosql)
 endif ()

api/cpp/src/BingoNoSQL.cpp

@@ -21,7 +21,7 @@
 #include <bingo-nosql.h>
 
 #include "IndigoException.h"
-#include "IndigoSDFileIterator.h"
+#include "IndigoIterator.h"
 
 using namespace indigo_cpp;
 
@@ -95,7 +95,7 @@ int BingoNoSQL<target_t, query_t>::insertRecord(const target_t& entity)
 }
 
 template <typename target_t, typename query_t>
-int BingoNoSQL<target_t, query_t>::insertIterator(const IndigoSDFileIterator& iterator)
+int BingoNoSQL<target_t, query_t>::insertIterator(const IndigoIterator<target_t>& iterator)
 {
     session->setSessionId();
     return session->_checkResult(bingoInsertIteratorObj(id, iterator.id()));
@@ -123,11 +123,26 @@ BingoResultIterator<target_t> BingoNoSQL<target_t, query_t>::searchSim(const tar
     return {session->_checkResult(bingoSearchSim(id, query.id(), min, max, to_string(metric))), session};
 }
 
+template <typename target_t, typename query_t>
+BingoResultIterator<target_t> BingoNoSQL<target_t, query_t>::searchSim(const target_t& query, const double min, const double max,
+                                                                       const std::string& options) const
+{
+    session->setSessionId();
+    return {session->_checkResult(bingoSearchSim(id, query.id(), min, max, options.c_str())), session};
+}
+
 template <typename target_t, typename query_t>
 std::string BingoNoSQL<target_t, query_t>::getStatistics(bool for_session) const
 {
     session->setSessionId();
     return session->_checkResultString(bingoProfilingGetStatistics(static_cast<int>(for_session)));
 }
 
+template <typename target_t, typename query_t>
+BingoResultIterator<target_t> BingoNoSQL<target_t, query_t>::searchExact(const target_t& query, const std::string& options) const
+{
+    session->setSessionId();
+    return {session->_checkResult(bingoSearchExact(id, query.id(), options.c_str())), session};
+}
+
 template class indigo_cpp::BingoNoSQL<IndigoMolecule, IndigoQueryMolecule>;

api/cpp/src/BingoNoSQL.h

@@ -49,12 +49,14 @@ namespace indigo_cpp
         void close();
 
         int insertRecord(const target_t& entity);
-        int insertIterator(const IndigoSDFileIterator& iterator);
+        int insertIterator(const IndigoIterator<target_t>& iterator);
         void deleteRecord(int recordId);
 
         BingoResultIterator<target_t> searchSub(const query_t& query, const std::string& options = "") const;
+        BingoResultIterator<target_t> searchExact(const target_t& query, const std::string& options = "") const;
         BingoResultIterator<target_t> searchSim(const target_t& query, double min, double max = 1.0,
                                                 IndigoSimilarityMetric metric = IndigoSimilarityMetric::TANIMOTO) const;
+        BingoResultIterator<target_t> searchSim(const target_t& query, const double min, const double max, const std::string& options = "") const;
 
         IndigoSessionPtr session;
 

api/cpp/src/IndigoIterator.h

@@ -0,0 +1,115 @@
+/****************************************************************************
+ * Copyright (C) from 2009 to Present EPAM Systems.
+ *
+ * This file is part of Indigo toolkit.
+ *
+ * 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.
+ ***************************************************************************/
+
+#pragma once
+
+#include <memory>
+
+#include <indigo.h>
+
+#include "IndigoObject.h"
+
+namespace indigo_cpp
+{
+    class IndigoSession;
+
+    template <class T>
+    class IndigoIterator : public IndigoObject
+    {
+    private:
+        std::shared_ptr<T> _current = nullptr;
+
+    public:
+        class iterator
+        {
+        private:
+            IndigoIterator* _obj;
+
+        public:
+            using value_type = std::shared_ptr<T>;
+            using reference = value_type&;
+            using pointer = const value_type*;
+
+            explicit iterator(IndigoIterator* obj) : _obj{obj}
+            {
+            }
+
+            reference operator*()
+            {
+                return _obj->_current;
+            }
+
+            iterator& operator++()
+            {
+                increment();
+                return *this;
+            }
+
+            bool operator!=(iterator rhs) const
+            {
+                return this->_obj != rhs._obj;
+            }
+
+        protected:
+            void increment()
+            {
+                _obj->next();
+                if (!_obj->valid())
+                {
+                    _obj = nullptr;
+                }
+            }
+        };
+
+        IndigoIterator(int id, IndigoSessionPtr session) : IndigoObject(id, std::move(session))
+        {
+        }
+
+        friend class IndigoSession;
+
+    public:
+        iterator begin()
+        {
+            return ++iterator{this};
+        }
+
+        static iterator end()
+        {
+            return iterator{nullptr};
+        }
+
+        void next()
+        {
+            session()->setSessionId();
+            auto nextId = session()->_checkResult(indigoNext(id()));
+            if (nextId == 0)
+            {
+                _current = nullptr;
+            }
+            else
+            {
+                _current = std::make_shared<T>(nextId, session());
+            }
+        }
+
+        bool valid() const
+        {
+            return _current != nullptr;
+        }
+    };
+}