removed curl from header file

Author: gf712

src/shogun/io/OpenMLFlow.cpp

@@ -5,16 +5,16 @@
  */
 
 #include <shogun/io/OpenMLFlow.h>
-#include <shogun/lib/type_case.h>
 #include <shogun/util/factory.h>
 
 #include <rapidjson/document.h>
+#ifdef HAVE_CURL
+#include <curl/curl.h>
+#endif // HAVE_CURL
 
 using namespace shogun;
 using namespace rapidjson;
 
-#ifdef HAVE_CURL
-
 /**
  * The writer callback function used to write the packets to a C++ string.
  * @param data the data received in CURL request
@@ -25,16 +25,14 @@ using namespace rapidjson;
  */
 size_t writer(char* data, size_t size, size_t nmemb, std::string* buffer_in)
 {
-	// adapted from https://stackoverflow.com/a/5780603
-	// Is there anything in the buffer?
-	if (buffer_in->empty())
+	// check that the buffer string points to something
+	if (buffer_in != nullptr)
 	{
 		// Append the data to the buffer
 		buffer_in->append(data, size * nmemb);
 
 		return size * nmemb;
 	}
-
 	return 0;
 }
 
@@ -55,7 +53,7 @@ const char* OpenMLReader::flow_file = "/flow/{}";
 /* TASK API */
 const char* OpenMLReader::task_file = "/task/{}";
 /* SPLIT API */
-const char* OpenMLReader::get_split = "/split/{}";
+const char* OpenMLReader::get_split = "/get/{}";
 
 const std::unordered_map<std::string, std::string>
     OpenMLReader::m_format_options = {{"xml", xml_server},
@@ -72,12 +70,9 @@ const std::unordered_map<std::string, std::string>
         {"flow_file", flow_file},
         {"task_file", task_file}};
 
-OpenMLReader::OpenMLReader(const std::string& api_key) : m_api_key(api_key)
-{
-}
-
 void OpenMLReader::openml_curl_request_helper(const std::string& url)
 {
+#ifdef HAVE_CURL
 	CURL* curl_handle = nullptr;
 
 	curl_handle = curl_easy_init();
@@ -95,18 +90,11 @@ void OpenMLReader::openml_curl_request_helper(const std::string& url)
 
 	CURLcode res = curl_easy_perform(curl_handle);
 
-	openml_curl_error_helper(curl_handle, res);
+	if (res != CURLE_OK)
+		SG_SERROR("Connection error: %s.\n", curl_easy_strerror(res))
 
 	curl_easy_cleanup(curl_handle);
-}
-
-void OpenMLReader::openml_curl_error_helper(CURL* curl_handle, CURLcode code)
-{
-	if (code != CURLE_OK)
-	{
-		// TODO: call curl_easy_cleanup(curl_handle) ?
-		SG_SERROR("Connection error: %s.\n", curl_easy_strerror(code))
-	}
+#endif // HAVE_CURL
 }
 
 /**
@@ -298,7 +286,7 @@ void OpenMLFlow::upload_flow(const std::shared_ptr<OpenMLFlow>& flow)
 	SG_SNOTIMPLEMENTED;
 }
 
-void OpenMLFlow::dump()
+void OpenMLFlow::dump() const
 {
 	SG_SNOTIMPLEMENTED;
 }
@@ -543,13 +531,13 @@ OpenMLTask::get_task_from_string(const std::string& task_type)
 	SG_SERROR("OpenMLTask does not support \"%s\"", task_type.c_str())
 }
 
-SGMatrix<int32_t> OpenMLTask::get_train_indices()
+SGMatrix<int32_t> OpenMLTask::get_train_indices() const
 {
 	SG_SNOTIMPLEMENTED
 	return SGMatrix<int32_t>();
 }
 
-SGMatrix<int32_t> OpenMLTask::get_test_indices()
+SGMatrix<int32_t> OpenMLTask::get_test_indices() const
 {
 	SG_SNOTIMPLEMENTED
 	return SGMatrix<int32_t>();
@@ -685,18 +673,18 @@ class StringToShogun : public AnyVisitor
 	 * In OpenML "null" is an empty parameter value field.
 	 * @return whether the field is "null"
 	 */
-	SG_FORCED_INLINE bool is_null()
+	SG_FORCED_INLINE bool is_null() const noexcept
 	{
 		bool result = strcmp(m_string_val.c_str(), "null") == 0;
 		return result;
 	}
 
-	SG_FORCED_INLINE void set_parameter_name(const std::string& name)
+	SG_FORCED_INLINE void set_parameter_name(const std::string& name) noexcept
 	{
 		m_parameter = name;
 	}
 
-	SG_FORCED_INLINE void set_string_value(const std::string& value)
+	SG_FORCED_INLINE void set_string_value(const std::string& value) noexcept
 	{
 		m_string_val = value;
 	}
@@ -774,7 +762,7 @@ std::shared_ptr<CSGObject> ShogunOpenML::flow_to_model(
 	auto obj = instantiate_model_from_factory(module_name, algo_name);
 	auto obj_param = obj->get_params();
 
-	std::unique_ptr<StringToShogun> visitor(new StringToShogun(obj));
+	auto visitor = std::make_unique<StringToShogun>(obj);
 
 	if (initialize_with_defaults)
 	{
@@ -859,7 +847,7 @@ CLabels* ShogunOpenML::run_model_on_fold(
 			return machine->apply(X_test);
 		}
 		else
-			SG_SERROR("The provided model is not trainable!\n")
+			SG_SERROR("The provided model is not a trainable machine!\n")
 	}
 	break;
 	case OpenMLTask::TaskType::LEARNING_CURVE:
@@ -909,5 +897,3 @@ void OpenMLRun::publish() const
 {
 	SG_SNOTIMPLEMENTED
 }
-
-#endif // HAVE_CURL

src/shogun/io/OpenMLFlow.h

@@ -9,13 +9,9 @@
 
 #include <shogun/lib/config.h>
 
-#ifdef HAVE_CURL
-
 #include <shogun/base/SGObject.h>
 #include <shogun/io/SGIO.h>
 
-#include <curl/curl.h>
-
 #include <memory>
 #include <numeric>
 #include <string>
@@ -32,7 +28,9 @@ namespace shogun
 	{
 
 	public:
-		explicit OpenMLReader(const std::string& api_key);
+		explicit OpenMLReader(const std::string& api_key) : m_api_key(api_key)
+		{
+		}
 
 		/**
 		 * Returns a string returned by the server given a request.
@@ -50,7 +48,9 @@ namespace shogun
 		std::string
 		get(const std::string& request, const std::string& format, Args... args)
 		{
+#ifdef HAVE_CURL
 			std::string request_path;
+			// clear the buffer before request
 			m_curl_response_buffer.clear();
 			auto find_format = m_format_options.find(format);
 			if (find_format == m_format_options.end())
@@ -63,8 +63,8 @@ namespace shogun
 			if (format == "split")
 			{
 				REQUIRE(
-						request == "get_split",
-						"Split server can only handle \"get_split\" request.\n")
+				    request == "get_split",
+				    "Split server can only handle \"get_split\" request.\n")
 				request_path = get_split;
 			}
 			else
@@ -73,8 +73,8 @@ namespace shogun
 				if (find_request == m_request_options.end())
 				{
 					SG_SERROR(
-							"Could not find a way to solve the request \"%s\"\n",
-							request.c_str())
+					    "Could not find a way to solve the request \"%s\"\n",
+					    request.c_str())
 				}
 				request_path = find_request->second;
 			}
@@ -110,6 +110,9 @@ namespace shogun
 			openml_curl_request_helper(url);
 
 			return m_curl_response_buffer;
+#else
+			SG_SERROR("This function is only available witht the CURL library!\n")
+#endif // HAVE_CURL
 		}
 
 	private:
@@ -124,14 +127,6 @@ namespace shogun
 		 */
 		void openml_curl_request_helper(const std::string& url);
 
-		/**
-		 * Handles all possible codes
-		 *
-		 * @param curl_handle curl handle used in the request
-		 * @param code the code returned by the query
-		 */
-		void openml_curl_error_helper(CURL* curl_handle, CURLcode code);
-
 		/** the user API key, not required for all requests */
 		std::string m_api_key;
 
@@ -214,7 +209,8 @@ namespace shogun
 		    const std::string& model, components_type components,
 		    parameters_type parameters)
 		    : m_name(name), m_description(description), m_class_name(model),
-		      m_parameters(parameters), m_components(components)
+		      m_parameters(std::move(parameters)),
+		      m_components(std::move(components))
 		{
 		}
 
@@ -247,7 +243,7 @@ namespace shogun
 		/**
 		 * Dumps the OpenMLFlow to disk.
 		 */
-		void dump();
+		void dump() const;
 
 		/**
 		 * Gets a subflow, i.e. a kernel in a machine
@@ -266,17 +262,17 @@ namespace shogun
 		}
 
 #ifndef SWIG
-		SG_FORCED_INLINE parameters_type get_parameters()
+		SG_FORCED_INLINE parameters_type get_parameters() const noexcept
 		{
 			return m_parameters;
 		}
 
-		SG_FORCED_INLINE components_type get_components()
+		SG_FORCED_INLINE components_type get_components() const noexcept
 		{
 			return m_components;
 		}
 
-		SG_FORCED_INLINE std::string get_class_name()
+		SG_FORCED_INLINE std::string get_class_name() const noexcept
 		{
 			return m_class_name;
 		}
@@ -320,7 +316,6 @@ namespace shogun
 		        param_descriptors,
 		    std::vector<std::unordered_map<std::string, std::string>>
 		        param_qualities)
-
 		    : m_name(name), m_description(description),
 		      m_data_format(data_format), m_dataset_id(dataset_id),
 		      m_version(version), m_creator(creator),
@@ -441,8 +436,8 @@ namespace shogun
 		    std::shared_ptr<OpenMLData> data)
 		    : m_task_id(task_id), m_task_name(task_name),
 		      m_task_type(task_type), m_task_type_id(task_type_id),
-		      m_evaluation_measures(evaluation_measures), m_split(split),
-		      m_data(data)
+		      m_evaluation_measures(std::move(evaluation_measures)),
+		      m_split(std::move(split)), m_data(std::move(data))
 		{
 		}
 
@@ -459,9 +454,9 @@ namespace shogun
 			return m_split;
 		}
 
-		SGMatrix<int32_t> get_train_indices();
+		SGMatrix<int32_t> get_train_indices() const;
 
-		SGMatrix<int32_t> get_test_indices();
+		SGMatrix<int32_t> get_test_indices() const;
 
 #ifndef SWIG
 		SG_FORCED_INLINE TaskType get_task_type() const noexcept
@@ -553,9 +548,10 @@ namespace shogun
 		      m_fold_evaluations(std::move(fold_evaluations)),
 		      m_sample_evaluations(std::move(sample_evaluations)),
 		      m_data_content(data_content),
-		      m_output_files(std::move(output_files)), m_task(task),
-		      m_flow(flow), m_run_id(run_id), m_model(model), m_tags(tags),
-		      m_predictions_url(predictions_url)
+		      m_output_files(std::move(output_files)), m_task(std::move(task)),
+		      m_flow(std::move(flow)), m_run_id(run_id),
+		      m_model(std::move(model)), m_tags(std::move(tags)),
+		      m_predictions_url(std::move(predictions_url))
 		{
 		}
 
@@ -591,6 +587,5 @@ namespace shogun
 		std::string m_predictions_url;
 	};
 } // namespace shogun
-#endif // HAVE_CURL
 
 #endif // SHOGUN_OPENMLFLOW_H