logic: added C/C++ project setup from Code::Blocks

* also changed xml elements in sourcegroup settings that specify the used language standard, so that one sourcegroup can maintain multiple language standards
* added migration and migrated sample projects

src/lib/CMakeLists.txt

@@ -316,8 +316,14 @@ add_files(
 	settings/SourceGroupSettings.h
 	settings/SourceGroupSettingsCxx.cpp
 	settings/SourceGroupSettingsCxx.h
+	settings/SourceGroupSettingsCEmpty.cpp
+	settings/SourceGroupSettingsCEmpty.h
+	settings/SourceGroupSettingsCppEmpty.cpp
+	settings/SourceGroupSettingsCppEmpty.h
 	settings/SourceGroupSettingsCxxCdb.cpp
 	settings/SourceGroupSettingsCxxCdb.h
+	settings/SourceGroupSettingsCxxCodeblocks.cpp
+	settings/SourceGroupSettingsCxxCodeblocks.h
 	settings/SourceGroupSettingsCxxEmpty.cpp
 	settings/SourceGroupSettingsCxxEmpty.h
 	settings/SourceGroupSettingsCxxSonargraph.cpp
@@ -334,12 +340,20 @@ add_files(
 	settings/SourceGroupSettingsJavaSonargraph.h
 	settings/SourceGroupSettingsWithClasspath.cpp
 	settings/SourceGroupSettingsWithClasspath.h
+	settings/SourceGroupSettingsWithCppStandard.cpp
+	settings/SourceGroupSettingsWithCppStandard.h
+	settings/SourceGroupSettingsWithCStandard.cpp
+	settings/SourceGroupSettingsWithCStandard.h
 	settings/SourceGroupSettingsWithExcludeFilters.cpp
 	settings/SourceGroupSettingsWithExcludeFilters.h
 	settings/SourceGroupSettingsWithIndexedHeaderPaths.cpp
 	settings/SourceGroupSettingsWithIndexedHeaderPaths.h
+	settings/SourceGroupSettingsWithJavaStandard.cpp
+	settings/SourceGroupSettingsWithJavaStandard.h
 	settings/SourceGroupSettingsWithSonargraphProjectPath.cpp
 	settings/SourceGroupSettingsWithSonargraphProjectPath.h
+	settings/SourceGroupSettingsWithSourceExtensions.cpp
+	settings/SourceGroupSettingsWithSourceExtensions.h
 	settings/SourceGroupSettingsWithSourcePaths.cpp
 	settings/SourceGroupSettingsWithSourcePaths.h
 	settings/SourceGroupStatusType.cpp

src/lib/settings/LanguageType.cpp

@@ -43,6 +43,8 @@ LanguageType getLanguageTypeForSourceGroupType(SourceGroupType t)
 		return LANGUAGE_CPP;
 	case SOURCE_GROUP_CXX_CDB:
 		return LANGUAGE_CPP;
+	case SOURCE_GROUP_CXX_CODEBLOCKS:
+		return LANGUAGE_CPP;
 	case SOURCE_GROUP_CXX_SONARGRAPH:
 		return LANGUAGE_CPP;
 	case SOURCE_GROUP_CXX_VS:

src/lib/settings/ProjectSettings.cpp

@@ -3,8 +3,10 @@
 #include "settings/migration/SettingsMigrationDeleteKey.h"
 #include "settings/migration/SettingsMigrationLambda.h"
 #include "settings/migration/SettingsMigrationMoveKey.h"
+#include "settings/SourceGroupSettingsCEmpty.h"
+#include "settings/SourceGroupSettingsCppEmpty.h"
 #include "settings/SourceGroupSettingsCxxCdb.h"
-#include "settings/SourceGroupSettingsCxxEmpty.h"
+#include "settings/SourceGroupSettingsCxxCodeblocks.h"
 #include "settings/SourceGroupSettingsCxxSonargraph.h"
 #include "settings/SourceGroupSettingsJavaEmpty.h"
 #include "settings/SourceGroupSettingsJavaMaven.h"
@@ -14,7 +16,7 @@
 #include "utility/utilityString.h"
 #include "utility/utilityUuid.h"
 
-const size_t ProjectSettings::VERSION = 6;
+const size_t ProjectSettings::VERSION = 7;
 const wchar_t PROJECT_FILE_EXTENSION[] = L".srctrlprj";
 
 LanguageType ProjectSettings::getLanguageOfProject(const FilePath& filePath)
@@ -144,14 +146,17 @@ std::vector<std::shared_ptr<SourceGroupSettings>> ProjectSettings::getAllSourceG
 		switch (type)
 		{
 		case SOURCE_GROUP_C_EMPTY:
-			settings = std::make_shared<SourceGroupSettingsCxxEmpty>(id, SOURCE_GROUP_C_EMPTY, this);
+			settings = std::make_shared<SourceGroupSettingsCEmpty>(id, this);
 			break;
 		case SOURCE_GROUP_CPP_EMPTY:
-			settings = std::make_shared<SourceGroupSettingsCxxEmpty>(id, SOURCE_GROUP_CPP_EMPTY, this);
+			settings = std::make_shared<SourceGroupSettingsCppEmpty>(id, this);
 			break;
 		case SOURCE_GROUP_CXX_CDB:
 			settings = std::make_shared<SourceGroupSettingsCxxCdb>(id, this);
 			break;
+		case SOURCE_GROUP_CXX_CODEBLOCKS:
+			settings = std::make_shared<SourceGroupSettingsCxxCodeblocks>(id, this);
+			break;
 		case SOURCE_GROUP_CXX_SONARGRAPH:
 			settings = std::make_shared<SourceGroupSettingsCxxSonargraph>(id, this);
 			break;
@@ -337,6 +342,26 @@ SettingsMigrator ProjectSettings::getMigrations() const
 		}
 	}
 
+	for (std::shared_ptr<SourceGroupSettings> sourceGroupSettings : getAllSourceGroupSettings())
+	{
+		std::string languageName;
+		switch (getLanguageTypeForSourceGroupType(sourceGroupSettings->getType()))
+		{
+		case LANGUAGE_C:
+			languageName = "c";
+			break;
+		case LANGUAGE_CPP:
+			languageName = "cpp";
+			break;
+		case LANGUAGE_JAVA:
+			languageName = "java";
+			break;
+		}
+
+		std::string key = SourceGroupSettings::s_keyPrefix + sourceGroupSettings->getId();
+		migrator.addMigration(7, std::make_shared<SettingsMigrationMoveKey>(key + "/standard", key + "/" + languageName + "_standard"));
+	}
+
 	return migrator;
 }
 

src/lib/settings/SourceGroupSettings.cpp

@@ -14,7 +14,6 @@ SourceGroupSettings::SourceGroupSettings(
 	, m_name(sourceGroupTypeToString(type))
 	, m_type(type)
 	, m_status(SOURCE_GROUP_STATUS_ENABLED)
-	, m_standard("")
 {
 }
 
@@ -29,7 +28,6 @@ void SourceGroupSettings::load(std::shared_ptr<const ConfigManager> config)
 	}
 
 	setStatus(stringToSourceGroupStatusType(config->getValueOrDefault(key + "/status", sourceGroupStatusTypeToString(SOURCE_GROUP_STATUS_ENABLED))));
-	setStandard(config->getValueOrDefault<std::string>(key + "/standard", ""));
 }
 
 void SourceGroupSettings::save(std::shared_ptr<ConfigManager> config)
@@ -38,7 +36,6 @@ void SourceGroupSettings::save(std::shared_ptr<ConfigManager> config)
 
 	config->setValue(key + "/status", sourceGroupStatusTypeToString(getStatus()));
 	config->setValue(key + "/name", getName());
-	config->setValue(key + "/standard", getStandard());
 }
 
 bool SourceGroupSettings::equals(std::shared_ptr<SourceGroupSettings> other) const
@@ -47,8 +44,7 @@ bool SourceGroupSettings::equals(std::shared_ptr<SourceGroupSettings> other) con
 		m_id == other->m_id &&
 		m_name == other->m_name &&
 		m_type == other->m_type &&
-		m_status == other->m_status &&
-		m_standard == other->m_standard
+		m_status == other->m_status
 	);
 }
 
@@ -106,17 +102,3 @@ std::vector<FilePath> SourceGroupSettings::makePathsExpandedAndAbsolute(const st
 {
 	return m_projectSettings->makePathsExpandedAndAbsolute(paths);
 }
-
-std::string SourceGroupSettings::getStandard() const
-{
-	if (m_standard.empty())
-	{
-		return getDefaultStandard();
-	}
-	return m_standard;
-}
-
-void SourceGroupSettings::setStandard(const std::string& standard)
-{
-	m_standard = standard;
-}

src/lib/settings/SourceGroupSettings.h

@@ -42,23 +42,14 @@ public:
 	FilePath makePathExpandedAndAbsolute(const FilePath& path) const;
 	std::vector<FilePath> makePathsExpandedAndAbsolute(const std::vector<FilePath>& paths) const;
 
-	virtual std::vector<std::string> getAvailableLanguageStandards() const = 0;
-
-	std::string getStandard() const;
-	void setStandard(const std::string& standard);
-
 protected:
 	const ProjectSettings* m_projectSettings;
 
 private:
-	virtual std::string getDefaultStandard() const = 0;
-
 	std::string m_id;
 	std::string m_name;
 	const SourceGroupType m_type;
 	SourceGroupStatusType m_status;
-
-	std::string m_standard;
 };
 
 #endif // SOURCE_GROUP_SETTINGS_H

src/lib/settings/SourceGroupSettingsCEmpty.cpp

@@ -0,0 +1,45 @@
+#include "settings/SourceGroupSettingsCEmpty.h"
+
+SourceGroupSettingsCEmpty::SourceGroupSettingsCEmpty(const std::string& id, const ProjectSettings* projectSettings)
+	: SourceGroupSettingsCxxEmpty(id, SOURCE_GROUP_C_EMPTY, projectSettings)
+{
+}
+
+void SourceGroupSettingsCEmpty::load(std::shared_ptr<const ConfigManager> config)
+{
+	SourceGroupSettingsCxxEmpty::load(config);
+
+	const std::string key = s_keyPrefix + getId();
+
+	SourceGroupSettingsWithCStandard::load(config, key);
+}
+
+void SourceGroupSettingsCEmpty::save(std::shared_ptr<ConfigManager> config)
+{
+	SourceGroupSettingsCxxEmpty::save(config);
+
+	const std::string key = s_keyPrefix + getId();
+
+	SourceGroupSettingsWithCStandard::save(config, key);
+}
+
+bool SourceGroupSettingsCEmpty::equals(std::shared_ptr<SourceGroupSettings> other) const
+{
+	std::shared_ptr<SourceGroupSettingsCEmpty> otherCxxEmpty = std::dynamic_pointer_cast<SourceGroupSettingsCEmpty>(other);
+
+	return (
+		otherCxxEmpty &&
+		SourceGroupSettingsCxxEmpty::equals(other) &&
+		SourceGroupSettingsWithCStandard::equals(otherCxxEmpty)
+	);
+}
+
+const ProjectSettings* SourceGroupSettingsCEmpty::getProjectSettings() const
+{
+	return m_projectSettings;
+}
+
+std::vector<std::wstring> SourceGroupSettingsCEmpty::getDefaultSourceExtensions() const
+{
+	return { L".c" };
+}

src/lib/settings/SourceGroupSettingsCEmpty.h

@@ -0,0 +1,24 @@
+#ifndef SOURCE_GROUP_SETTINGS_C_EMPTY_H
+#define SOURCE_GROUP_SETTINGS_C_EMPTY_H
+
+#include "settings/SourceGroupSettingsCxxEmpty.h"
+#include "settings/SourceGroupSettingsWithCStandard.h"
+
+class SourceGroupSettingsCEmpty
+	: public SourceGroupSettingsCxxEmpty
+	, public SourceGroupSettingsWithCStandard
+{
+public:
+	SourceGroupSettingsCEmpty(const std::string& id, const ProjectSettings* projectSettings);
+
+	void load(std::shared_ptr<const ConfigManager> config) override;
+	void save(std::shared_ptr<ConfigManager> config) override;
+
+	bool equals(std::shared_ptr<SourceGroupSettings> other) const override;
+
+private:
+	const ProjectSettings* getProjectSettings() const override;
+	std::vector<std::wstring> getDefaultSourceExtensions() const override;
+};
+
+#endif // SOURCE_GROUP_SETTINGS_C_EMPTY_H

src/lib/settings/SourceGroupSettingsCppEmpty.cpp

@@ -0,0 +1,49 @@
+#include "settings/SourceGroupSettingsCppEmpty.h"
+
+SourceGroupSettingsCppEmpty::SourceGroupSettingsCppEmpty(const std::string& id, const ProjectSettings* projectSettings)
+	: SourceGroupSettingsCxxEmpty(id, SOURCE_GROUP_CPP_EMPTY, projectSettings)
+{
+}
+
+void SourceGroupSettingsCppEmpty::load(std::shared_ptr<const ConfigManager> config)
+{
+	SourceGroupSettingsCxxEmpty::load(config);
+
+	const std::string key = s_keyPrefix + getId();
+
+	SourceGroupSettingsWithCppStandard::load(config, key);
+}
+
+void SourceGroupSettingsCppEmpty::save(std::shared_ptr<ConfigManager> config)
+{
+	SourceGroupSettingsCxxEmpty::save(config);
+
+	const std::string key = s_keyPrefix + getId();
+
+	SourceGroupSettingsWithCppStandard::save(config, key);
+}
+
+bool SourceGroupSettingsCppEmpty::equals(std::shared_ptr<SourceGroupSettings> other) const
+{
+	std::shared_ptr<SourceGroupSettingsCppEmpty> otherCxxEmpty = std::dynamic_pointer_cast<SourceGroupSettingsCppEmpty>(other);
+
+	return (
+		otherCxxEmpty &&
+		SourceGroupSettingsCxxEmpty::equals(other) &&
+		SourceGroupSettingsWithCppStandard::equals(otherCxxEmpty)
+	);
+}
+
+const ProjectSettings* SourceGroupSettingsCppEmpty::getProjectSettings() const
+{
+	return m_projectSettings;
+}
+
+std::vector<std::wstring> SourceGroupSettingsCppEmpty::getDefaultSourceExtensions() const
+{
+	return { 
+		L".cpp",
+		L".cxx",
+		L".cc"
+	};
+}

src/lib/settings/SourceGroupSettingsCppEmpty.h

@@ -0,0 +1,24 @@
+#ifndef SOURCE_GROUP_SETTINGS_CPP_EMPTY_H
+#define SOURCE_GROUP_SETTINGS_CPP_EMPTY_H
+
+#include "settings/SourceGroupSettingsCxxEmpty.h"
+#include "settings/SourceGroupSettingsWithCppStandard.h"
+
+class SourceGroupSettingsCppEmpty
+	: public SourceGroupSettingsCxxEmpty
+	, public SourceGroupSettingsWithCppStandard
+{
+public:
+	SourceGroupSettingsCppEmpty(const std::string& id, const ProjectSettings* projectSettings);
+
+	void load(std::shared_ptr<const ConfigManager> config) override;
+	void save(std::shared_ptr<ConfigManager> config) override;
+
+	bool equals(std::shared_ptr<SourceGroupSettings> other) const override;
+
+private:
+	const ProjectSettings* getProjectSettings() const override;
+	std::vector<std::wstring> getDefaultSourceExtensions() const override;
+};
+
+#endif // SOURCE_GROUP_SETTINGS_CPP_EMPTY_H

src/lib/settings/SourceGroupSettingsCxx.cpp

@@ -47,60 +47,6 @@ bool SourceGroupSettingsCxx::equals(std::shared_ptr<SourceGroupSettings> other)
 	);
 }
 
-std::vector<std::string> SourceGroupSettingsCxx::getAvailableLanguageStandards() const
-{
-	std::vector<std::string> standards;
-
-	switch (getType())
-	{
-	case SOURCE_GROUP_CPP_EMPTY:
-	case SOURCE_GROUP_CXX_CDB:
-	case SOURCE_GROUP_CXX_SONARGRAPH:
-		standards.push_back("c++2a");
-		standards.push_back("gnu++2a");
-
-		standards.push_back("c++17");
-		standards.push_back("gnu++17");
-
-		standards.push_back("c++14");
-		standards.push_back("gnu++14");
-
-		standards.push_back("c++11");
-		standards.push_back("gnu++11");
-
-		standards.push_back("c++03");
-		standards.push_back("gnu++03");
-
-		standards.push_back("c++98");
-		standards.push_back("gnu++98");
-		break;
-
-	case SOURCE_GROUP_C_EMPTY:
-		standards.push_back("c11");
-		standards.push_back("gnu11");
-		standards.push_back("iso9899:2011");
-
-		standards.push_back("c99");
-		standards.push_back("gnu99");
-		standards.push_back("iso9899:1999");
-
-		standards.push_back("iso9899:199409");
-
-		standards.push_back("c90");
-		standards.push_back("gnu90");
-		standards.push_back("iso9899:1990");
-
-		standards.push_back("c89");
-		standards.push_back("gnu89");
-		break;
-
-	default:
-		break;
-	}
-
-	return standards;
-}
-
 std::vector<FilePath> SourceGroupSettingsCxx::getHeaderSearchPaths() const
 {
 	return m_headerSearchPaths;
@@ -140,20 +86,3 @@ void SourceGroupSettingsCxx::setCompilerFlags(const std::vector<std::wstring>& c
 {
 	m_compilerFlags = compilerFlags;
 }
-
-std::string SourceGroupSettingsCxx::getDefaultStandard() const
-{
-	switch (getType())
-	{
-	case SOURCE_GROUP_CPP_EMPTY:
-	case SOURCE_GROUP_CXX_SONARGRAPH:
-		return "c++17";
-	case SOURCE_GROUP_C_EMPTY:
-		return "c11";
-	case SOURCE_GROUP_CXX_CDB:
-	default:
-		break;
-	}
-
-	return "";
-}

src/lib/settings/SourceGroupSettingsCxx.h

@@ -3,6 +3,8 @@
 
 #include "settings/SourceGroupSettings.h"
 
+#include "utility/file/FilePath.h"
+
 class SourceGroupSettingsCxx
 	: public SourceGroupSettings
 {
@@ -14,8 +16,6 @@ public:
 
 	bool equals(std::shared_ptr<SourceGroupSettings> other) const override;
 
-	std::vector<std::string> getAvailableLanguageStandards() const override;
-
 	std::vector<FilePath> getHeaderSearchPaths() const;
 	std::vector<FilePath> getHeaderSearchPathsExpandedAndAbsolute() const;
 	void setHeaderSearchPaths(const std::vector<FilePath>& headerSearchPaths);
@@ -28,8 +28,6 @@ public:
 	void setCompilerFlags(const std::vector<std::wstring>& compilerFlags);
 
 private:
-	std::string getDefaultStandard() const override;
-
 	std::vector<FilePath> m_headerSearchPaths;
 	std::vector<FilePath> m_frameworkSearchPaths;
 	std::vector<std::wstring> m_compilerFlags;

src/lib/settings/SourceGroupSettingsCxxCodeblocks.cpp

@@ -0,0 +1,82 @@
+#include "settings/SourceGroupSettingsCxxCodeblocks.h"
+
+#include "settings/ProjectSettings.h"
+#include "utility/ConfigManager.h"
+
+SourceGroupSettingsCxxCodeblocks::SourceGroupSettingsCxxCodeblocks(const std::string& id, const ProjectSettings* projectSettings)
+	: SourceGroupSettingsCxx(id, SOURCE_GROUP_CXX_CODEBLOCKS, projectSettings)
+{
+}
+
+void SourceGroupSettingsCxxCodeblocks::load(std::shared_ptr<const ConfigManager> config)
+{
+	SourceGroupSettingsCxx::load(config);
+
+	const std::string key = s_keyPrefix + getId();
+
+	SourceGroupSettingsWithCppStandard::load(config, key);
+	SourceGroupSettingsWithCStandard::load(config, key);
+	SourceGroupSettingsWithIndexedHeaderPaths::load(config, key);
+	SourceGroupSettingsWithSourceExtensions::load(config, key);
+	
+	setCodeblocksProjectPath(config->getValueOrDefault(key + "/codeblocks_project_path", FilePath(L"")));
+}
+
+void SourceGroupSettingsCxxCodeblocks::save(std::shared_ptr<ConfigManager> config)
+{
+	SourceGroupSettingsCxx::save(config);
+
+	const std::string key = s_keyPrefix + getId();
+
+	SourceGroupSettingsWithCppStandard::save(config, key);
+	SourceGroupSettingsWithCStandard::save(config, key);
+	SourceGroupSettingsWithIndexedHeaderPaths::save(config, key);
+	SourceGroupSettingsWithSourceExtensions::save(config, key);
+
+	config->setValue(key + "/codeblocks_project_path", getCodeblocksProjectPath().wstr());
+}
+
+bool SourceGroupSettingsCxxCodeblocks::equals(std::shared_ptr<SourceGroupSettings> other) const
+{
+	std::shared_ptr<SourceGroupSettingsCxxCodeblocks> otherCxxCodeblocks = std::dynamic_pointer_cast<SourceGroupSettingsCxxCodeblocks>(other);
+
+	return (
+		otherCxxCodeblocks &&
+		SourceGroupSettingsCxx::equals(other) &&
+		SourceGroupSettingsWithCppStandard::equals(otherCxxCodeblocks) &&
+		SourceGroupSettingsWithCStandard::equals(otherCxxCodeblocks) &&
+		SourceGroupSettingsWithIndexedHeaderPaths::equals(otherCxxCodeblocks) &&
+		SourceGroupSettingsWithSourceExtensions::equals(otherCxxCodeblocks) &&
+		m_codeblocksProjectPath == otherCxxCodeblocks->m_codeblocksProjectPath
+	);
+}
+
+FilePath SourceGroupSettingsCxxCodeblocks::getCodeblocksProjectPath() const
+{
+	return m_codeblocksProjectPath;
+}
+
+FilePath SourceGroupSettingsCxxCodeblocks::getCodeblocksProjectPathExpandedAndAbsolute() const
+{
+	return m_projectSettings->makePathExpandedAndAbsolute(getCodeblocksProjectPath());
+}
+
+void SourceGroupSettingsCxxCodeblocks::setCodeblocksProjectPath(const FilePath& compilationDatabasePath)
+{
+	m_codeblocksProjectPath = compilationDatabasePath;
+}
+
+const ProjectSettings* SourceGroupSettingsCxxCodeblocks::getProjectSettings() const
+{
+	return m_projectSettings;
+}
+
+std::vector<std::wstring> SourceGroupSettingsCxxCodeblocks::getDefaultSourceExtensions() const
+{
+	return {
+		L".c",
+		L".cpp",
+		L".cxx",
+		L".cc"
+	};
+}

src/lib/settings/SourceGroupSettingsCxxCodeblocks.h

@@ -0,0 +1,36 @@
+#ifndef SOURCE_GROUP_SETTINGS_CXX_CODEBLOCKS_H
+#define SOURCE_GROUP_SETTINGS_CXX_CODEBLOCKS_H
+
+#include "settings/SourceGroupSettingsCxx.h"
+#include "settings/SourceGroupSettingsWithCppStandard.h"
+#include "settings/SourceGroupSettingsWithCStandard.h"
+#include "settings/SourceGroupSettingsWithIndexedHeaderPaths.h"
+#include "settings/SourceGroupSettingsWithSourceExtensions.h"
+
+class SourceGroupSettingsCxxCodeblocks
+	: public SourceGroupSettingsCxx
+	, public SourceGroupSettingsWithCppStandard
+	, public SourceGroupSettingsWithCStandard
+	, public SourceGroupSettingsWithIndexedHeaderPaths
+	, public SourceGroupSettingsWithSourceExtensions
+{
+public:
+	SourceGroupSettingsCxxCodeblocks(const std::string& id, const ProjectSettings* projectSettings);
+
+	void load(std::shared_ptr<const ConfigManager> config) override;
+	void save(std::shared_ptr<ConfigManager> config) override;
+
+	bool equals(std::shared_ptr<SourceGroupSettings> other) const override;
+
+	FilePath getCodeblocksProjectPath() const;
+	FilePath getCodeblocksProjectPathExpandedAndAbsolute() const;
+	void setCodeblocksProjectPath(const FilePath& compilationDatabasePath);
+
+private:
+	const ProjectSettings* getProjectSettings() const override;
+	std::vector<std::wstring> getDefaultSourceExtensions() const override;
+
+	FilePath m_codeblocksProjectPath;
+};
+
+#endif // SOURCE_GROUP_SETTINGS_CXX_CODEBLOCKS_H

src/lib/settings/SourceGroupSettingsCxxEmpty.cpp

@@ -157,6 +157,7 @@ void SourceGroupSettingsCxxEmpty::load(std::shared_ptr<const ConfigManager> conf
 
 	const std::string key = s_keyPrefix + getId();
 
+	SourceGroupSettingsWithSourceExtensions::load(config, key);
 	SourceGroupSettingsWithSourcePaths::load(config, key);
 	SourceGroupSettingsWithExcludeFilters::load(config, key);
 
@@ -173,6 +174,7 @@ void SourceGroupSettingsCxxEmpty::save(std::shared_ptr<ConfigManager> config)
 
 	const std::string key = s_keyPrefix + getId();
 
+	SourceGroupSettingsWithSourceExtensions::save(config, key);
 	SourceGroupSettingsWithSourcePaths::save(config, key);
 	SourceGroupSettingsWithExcludeFilters::save(config, key);
 
@@ -190,6 +192,7 @@ bool SourceGroupSettingsCxxEmpty::equals(std::shared_ptr<SourceGroupSettings> ot
 	return (
 		otherCxxEmpty &&
 		SourceGroupSettingsCxx::equals(other) &&
+		SourceGroupSettingsWithSourceExtensions::equals(otherCxxEmpty) &&
 		SourceGroupSettingsWithSourcePaths::equals(otherCxxEmpty) &&
 		SourceGroupSettingsWithExcludeFilters::equals(otherCxxEmpty) &&
 		getTargetFlag() == otherCxxEmpty->getTargetFlag()
@@ -258,30 +261,4 @@ std::wstring SourceGroupSettingsCxxEmpty::getTargetFlag() const
 		targetFlag += L"-" + (m_targetAbi.empty() ? L"unknown" : m_targetAbi);
 	}
 	return targetFlag;
-}
-
-const ProjectSettings* SourceGroupSettingsCxxEmpty::getProjectSettings() const
-{
-	return m_projectSettings;
-}
-
-std::vector<std::wstring> SourceGroupSettingsCxxEmpty::getDefaultSourceExtensions() const
-{
-	std::vector<std::wstring> defaultValues;
-
-	switch (getType())
-	{
-	case SOURCE_GROUP_CPP_EMPTY:
-		defaultValues.push_back(L".cpp");
-		defaultValues.push_back(L".cxx");
-		defaultValues.push_back(L".cc");
-		break;
-	case SOURCE_GROUP_C_EMPTY:
-		defaultValues.push_back(L".c");
-		break;
-	default:
-		break;
-	}
-
-	return defaultValues;
-}
+}

src/lib/settings/SourceGroupSettingsCxxEmpty.h

@@ -3,11 +3,13 @@
 
 #include "settings/SourceGroupSettingsCxx.h"
 #include "settings/SourceGroupSettingsWithExcludeFilters.h"
+#include "settings/SourceGroupSettingsWithSourceExtensions.h"
 #include "settings/SourceGroupSettingsWithSourcePaths.h"
 
 class SourceGroupSettingsCxxEmpty
 	: public SourceGroupSettingsCxx
 	, public SourceGroupSettingsWithExcludeFilters
+	, public SourceGroupSettingsWithSourceExtensions
 	, public SourceGroupSettingsWithSourcePaths
 {
 public:
@@ -41,9 +43,6 @@ public:
 	std::wstring getTargetFlag() const;
 
 private:
-	const ProjectSettings* getProjectSettings() const override;
-	std::vector<std::wstring> getDefaultSourceExtensions() const override;
-
 	bool m_targetOptionsEnabled;
 	std::wstring m_targetArch;
 	std::wstring m_targetVendor;

src/lib/settings/SourceGroupSettingsCxxSonargraph.cpp

@@ -11,6 +11,7 @@ void SourceGroupSettingsCxxSonargraph::load(std::shared_ptr<const ConfigManager>
 
 	const std::string key = s_keyPrefix + getId();
 
+	SourceGroupSettingsWithCppStandard::load(config, key);
 	SourceGroupSettingsWithIndexedHeaderPaths::load(config, key);
 	SourceGroupSettingsWithSonargraphProjectPath::load(config, key);
 }
@@ -21,6 +22,7 @@ void SourceGroupSettingsCxxSonargraph::save(std::shared_ptr<ConfigManager> confi
 
 	const std::string key = s_keyPrefix + getId();
 
+	SourceGroupSettingsWithCppStandard::save(config, key);
 	SourceGroupSettingsWithIndexedHeaderPaths::save(config, key);
 	SourceGroupSettingsWithSonargraphProjectPath::save(config, key);
 }
@@ -32,7 +34,8 @@ bool SourceGroupSettingsCxxSonargraph::equals(std::shared_ptr<SourceGroupSetting
 	return (
 		otherCxxSonargraph &&
 		SourceGroupSettingsCxx::equals(other) &&
-		SourceGroupSettingsWithIndexedHeaderPaths::equals(otherCxxSonargraph) && 
+		SourceGroupSettingsWithCppStandard::equals(otherCxxSonargraph) &&
+		SourceGroupSettingsWithIndexedHeaderPaths::equals(otherCxxSonargraph) &&
 		SourceGroupSettingsWithSonargraphProjectPath::equals(otherCxxSonargraph)
 	);
 }

src/lib/settings/SourceGroupSettingsCxxSonargraph.h

@@ -2,11 +2,13 @@
 #define SOURCE_GROUP_SETTINGS_CXX_SONARGRAPH_H
 
 #include "settings/SourceGroupSettingsCxx.h"
+#include "settings/SourceGroupSettingsWithCppStandard.h"
 #include "settings/SourceGroupSettingsWithIndexedHeaderPaths.h"
 #include "settings/SourceGroupSettingsWithSonargraphProjectPath.h"
 
 class SourceGroupSettingsCxxSonargraph
 	: public SourceGroupSettingsCxx
+	, public SourceGroupSettingsWithCppStandard
 	, public SourceGroupSettingsWithIndexedHeaderPaths
 	, public SourceGroupSettingsWithSonargraphProjectPath
 {

src/lib/settings/SourceGroupSettingsJava.cpp

@@ -10,9 +10,11 @@ void SourceGroupSettingsJava::load(std::shared_ptr<const ConfigManager> config)
 	SourceGroupSettings::load(config);
 
 	const std::string key = s_keyPrefix + getId();
-
+	
+	SourceGroupSettingsWithSourceExtensions::load(config, key);
 	SourceGroupSettingsWithSourcePaths::load(config, key);
 	SourceGroupSettingsWithExcludeFilters::load(config, key);
+	SourceGroupSettingsWithJavaStandard::load(config, key);
 	SourceGroupSettingsWithClasspath::load(config, key);
 }
 
@@ -22,8 +24,10 @@ void SourceGroupSettingsJava::save(std::shared_ptr<ConfigManager> config)
 
 	const std::string key = s_keyPrefix + getId();
 
+	SourceGroupSettingsWithSourceExtensions::save(config, key);
 	SourceGroupSettingsWithSourcePaths::save(config, key);
 	SourceGroupSettingsWithExcludeFilters::save(config, key);
+	SourceGroupSettingsWithJavaStandard::save(config, key);
 	SourceGroupSettingsWithClasspath::save(config, key);
 }
 
@@ -34,17 +38,14 @@ bool SourceGroupSettingsJava::equals(std::shared_ptr<SourceGroupSettings> other)
 	return (
 		otherJava &&
 		SourceGroupSettings::equals(other) &&
+		SourceGroupSettingsWithSourceExtensions::equals(otherJava) &&
 		SourceGroupSettingsWithSourcePaths::equals(otherJava) &&
 		SourceGroupSettingsWithExcludeFilters::equals(otherJava) &&
+		SourceGroupSettingsWithJavaStandard::equals(otherJava) &&
 		SourceGroupSettingsWithClasspath::equals(otherJava)
 	);
 }
 
-std::vector<std::string> SourceGroupSettingsJava::getAvailableLanguageStandards() const
-{
-	return std::vector<std::string>{"1", "2", "3", "4", "5", "6", "7", "8"};
-}
-
 const ProjectSettings* SourceGroupSettingsJava::getProjectSettings() const
 {
 	return m_projectSettings;
@@ -54,8 +55,3 @@ std::vector<std::wstring> SourceGroupSettingsJava::getDefaultSourceExtensions()
 {
 	return { L".java" };
 }
-
-std::string SourceGroupSettingsJava::getDefaultStandard() const
-{
-	return "8";
-}

src/lib/settings/SourceGroupSettingsJava.h

@@ -7,12 +7,16 @@
 #include "settings/SourceGroupSettings.h"
 #include "settings/SourceGroupSettingsWithClasspath.h"
 #include "settings/SourceGroupSettingsWithExcludeFilters.h"
+#include "settings/SourceGroupSettingsWithJavaStandard.h"
+#include "settings/SourceGroupSettingsWithSourceExtensions.h"
 #include "settings/SourceGroupSettingsWithSourcePaths.h"
 
 class SourceGroupSettingsJava
 	: public SourceGroupSettings
+	, public SourceGroupSettingsWithSourceExtensions
 	, public SourceGroupSettingsWithSourcePaths
 	, public SourceGroupSettingsWithExcludeFilters
+	, public SourceGroupSettingsWithJavaStandard
 	, public SourceGroupSettingsWithClasspath
 {
 public:
@@ -23,12 +27,9 @@ public:
 
 	bool equals(std::shared_ptr<SourceGroupSettings> other) const override;
 
-	std::vector<std::string> getAvailableLanguageStandards() const override;
-
 private:
 	const ProjectSettings* getProjectSettings() const override;
 	std::vector<std::wstring> getDefaultSourceExtensions() const override;
-	std::string getDefaultStandard() const override;
 };
 
 #endif // SOURCE_GROUP_SETTINGS_JAVA_H

src/lib/settings/SourceGroupSettingsJavaSonargraph.cpp

@@ -12,6 +12,7 @@ void SourceGroupSettingsJavaSonargraph::load(std::shared_ptr<const ConfigManager
 	const std::string key = s_keyPrefix + getId();
 
 	SourceGroupSettingsWithClasspath::load(config, key);
+	SourceGroupSettingsWithJavaStandard::load(config, key);
 	SourceGroupSettingsWithSonargraphProjectPath::load(config, key);
 }
 
@@ -22,6 +23,7 @@ void SourceGroupSettingsJavaSonargraph::save(std::shared_ptr<ConfigManager> conf
 	const std::string key = s_keyPrefix + getId();
 
 	SourceGroupSettingsWithClasspath::save(config, key);
+	SourceGroupSettingsWithJavaStandard::save(config, key);
 	SourceGroupSettingsWithSonargraphProjectPath::save(config, key);
 }
 
@@ -33,20 +35,11 @@ bool SourceGroupSettingsJavaSonargraph::equals(std::shared_ptr<SourceGroupSettin
 		otherJavaSonargraph &&
 		SourceGroupSettings::equals(other) &&
 		SourceGroupSettingsWithClasspath::equals(otherJavaSonargraph) &&
+		SourceGroupSettingsWithJavaStandard::equals(otherJavaSonargraph) &&
 		SourceGroupSettingsWithSonargraphProjectPath::equals(otherJavaSonargraph)
 	);
 }
 
-std::vector<std::string> SourceGroupSettingsJavaSonargraph::getAvailableLanguageStandards() const
-{
-	return std::vector<std::string>{"1", "2", "3", "4", "5", "6", "7", "8"};
-}
-
-std::string SourceGroupSettingsJavaSonargraph::getDefaultStandard() const
-{
-	return "8";
-}
-
 const ProjectSettings* SourceGroupSettingsJavaSonargraph::getProjectSettings() const
 {
 	return m_projectSettings;

src/lib/settings/SourceGroupSettingsJavaSonargraph.h

@@ -3,11 +3,13 @@
 
 #include "settings/SourceGroupSettings.h"
 #include "settings/SourceGroupSettingsWithClasspath.h"
+#include "settings/SourceGroupSettingsWithJavaStandard.h"
 #include "settings/SourceGroupSettingsWithSonargraphProjectPath.h"
 
 class SourceGroupSettingsJavaSonargraph
 	: public SourceGroupSettings
 	, public SourceGroupSettingsWithClasspath
+	, public SourceGroupSettingsWithJavaStandard
 	, public SourceGroupSettingsWithSonargraphProjectPath
 {
 public:
@@ -18,10 +20,7 @@ public:
 
 	bool equals(std::shared_ptr<SourceGroupSettings> other) const override;
 
-	std::vector<std::string> getAvailableLanguageStandards() const override;
-
 private:
-	std::string getDefaultStandard() const override;
 	const ProjectSettings* getProjectSettings() const override;
 };
 

src/lib/settings/SourceGroupSettingsWithCStandard.cpp

@@ -0,0 +1,63 @@
+#include "settings/SourceGroupSettingsWithCStandard.h"
+
+#include "settings/ProjectSettings.h"
+
+std::string SourceGroupSettingsWithCStandard::getDefaultCStandardStatic()
+{
+	return "c11";
+}
+
+bool SourceGroupSettingsWithCStandard::equals(std::shared_ptr<SourceGroupSettingsWithCStandard> other) const
+{
+	return (
+		other &&
+		m_cStandard == other->m_cStandard
+	);
+}
+
+void SourceGroupSettingsWithCStandard::load(std::shared_ptr<const ConfigManager> config, const std::string& key)
+{
+	setCStandard(config->getValueOrDefault<std::string>(key + "/c_standard", ""));
+}
+
+void SourceGroupSettingsWithCStandard::save(std::shared_ptr<ConfigManager> config, const std::string& key)
+{
+	config->setValue(key + "/c_standard", getCStandard());
+}
+
+std::string SourceGroupSettingsWithCStandard::getCStandard() const
+{
+	if (m_cStandard.empty())
+	{
+		return getDefaultCStandard();
+	}
+	return m_cStandard;
+}
+
+void SourceGroupSettingsWithCStandard::setCStandard(const std::string& standard)
+{
+	m_cStandard = standard;
+}
+
+std::vector<std::string> SourceGroupSettingsWithCStandard::getAvailableCStandards() const
+{
+	return {
+		"c11",
+		"gnu11",
+		"iso9899:2011",
+		"c99",
+		"gnu99",
+		"iso9899:1999",
+		"iso9899:199409",
+		"c90",
+		"gnu90",
+		"iso9899:1990",
+		"c89",
+		"gnu89"
+	};
+}
+
+std::string SourceGroupSettingsWithCStandard::getDefaultCStandard() const
+{
+	return getDefaultCStandardStatic();
+}

src/lib/settings/SourceGroupSettingsWithCStandard.h

@@ -0,0 +1,37 @@
+#ifndef SOURCE_GROUP_SETTINGS_WITH_C_STANDARD_H
+#define SOURCE_GROUP_SETTINGS_WITH_C_STANDARD_H
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class ConfigManager;
+class ProjectSettings;
+
+class SourceGroupSettingsWithCStandard
+{
+public:
+	static std::string getDefaultCStandardStatic();
+
+	SourceGroupSettingsWithCStandard() = default;
+	virtual ~SourceGroupSettingsWithCStandard() = default;
+
+	bool equals(std::shared_ptr<SourceGroupSettingsWithCStandard> other) const;
+
+	std::string getCStandard() const;
+	void setCStandard(const std::string& standard);
+
+	std::vector<std::string> getAvailableCStandards() const;
+
+protected:
+	void load(std::shared_ptr<const ConfigManager> config, const std::string& key);
+	void save(std::shared_ptr<ConfigManager> config, const std::string& key);
+
+private:
+	virtual const ProjectSettings* getProjectSettings() const = 0;
+	std::string getDefaultCStandard() const;
+
+	std::string m_cStandard;
+};
+
+#endif // SOURCE_GROUP_SETTINGS_WITH_C_STANDARD_H

src/lib/settings/SourceGroupSettingsWithCppStandard.cpp

@@ -0,0 +1,63 @@
+#include "settings/SourceGroupSettingsWithCppStandard.h"
+
+#include "settings/ProjectSettings.h"
+
+std::string SourceGroupSettingsWithCppStandard::getDefaultCppStandardStatic()
+{
+	return "c++17";
+}
+
+bool SourceGroupSettingsWithCppStandard::equals(std::shared_ptr<SourceGroupSettingsWithCppStandard> other) const
+{
+	return (
+		other &&
+		m_cppStandard == other->m_cppStandard
+	);
+}
+
+void SourceGroupSettingsWithCppStandard::load(std::shared_ptr<const ConfigManager> config, const std::string& key)
+{
+	setCppStandard(config->getValueOrDefault<std::string>(key + "/cpp_standard", ""));
+}
+
+void SourceGroupSettingsWithCppStandard::save(std::shared_ptr<ConfigManager> config, const std::string& key)
+{
+	config->setValue(key + "/cpp_standard", getCppStandard());
+}
+
+std::string SourceGroupSettingsWithCppStandard::getCppStandard() const
+{
+	if (m_cppStandard.empty())
+	{
+		return getDefaultCppStandard();
+	}
+	return m_cppStandard;
+}
+
+void SourceGroupSettingsWithCppStandard::setCppStandard(const std::string& standard)
+{
+	m_cppStandard = standard;
+}
+
+std::vector<std::string> SourceGroupSettingsWithCppStandard::getAvailableCppStandards() const
+{
+	return {
+		"c++2a",
+		"gnu++2a",
+		"c++17",
+		"gnu++17",
+		"c++14",
+		"gnu++14",
+		"c++11",
+		"gnu++11",
+		"c++03",
+		"gnu++03",
+		"c++98",
+		"gnu++98"
+	};
+}
+
+std::string SourceGroupSettingsWithCppStandard::getDefaultCppStandard() const
+{
+	return getDefaultCppStandardStatic();
+}

src/lib/settings/SourceGroupSettingsWithCppStandard.h

@@ -0,0 +1,37 @@
+#ifndef SOURCE_GROUP_SETTINGS_WITH_CPP_STANDARD_H
+#define SOURCE_GROUP_SETTINGS_WITH_CPP_STANDARD_H
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class ConfigManager;
+class ProjectSettings;
+
+class SourceGroupSettingsWithCppStandard
+{
+public:
+	static std::string getDefaultCppStandardStatic();
+
+	SourceGroupSettingsWithCppStandard() = default;
+	virtual ~SourceGroupSettingsWithCppStandard() = default;
+
+	bool equals(std::shared_ptr<SourceGroupSettingsWithCppStandard> other) const;
+
+	std::string getCppStandard() const;
+	void setCppStandard(const std::string& standard);
+
+	std::vector<std::string> getAvailableCppStandards() const;
+
+protected:
+	void load(std::shared_ptr<const ConfigManager> config, const std::string& key);
+	void save(std::shared_ptr<ConfigManager> config, const std::string& key);
+
+private:
+	virtual const ProjectSettings* getProjectSettings() const = 0;
+	std::string getDefaultCppStandard() const;
+
+	std::string m_cppStandard;
+};
+
+#endif // SOURCE_GROUP_SETTINGS_WITH_CPP_STANDARD_H

src/lib/settings/SourceGroupSettingsWithJavaStandard.cpp

@@ -0,0 +1,50 @@
+#include "settings/SourceGroupSettingsWithJavaStandard.h"
+
+#include "settings/ProjectSettings.h"
+
+std::string SourceGroupSettingsWithJavaStandard::getDefaultJavaStandardStatic()
+{
+	return "8";
+}
+
+bool SourceGroupSettingsWithJavaStandard::equals(std::shared_ptr<SourceGroupSettingsWithJavaStandard> other) const
+{
+	return (
+		other &&
+		m_javaStandard == other->m_javaStandard
+	);
+}
+
+void SourceGroupSettingsWithJavaStandard::load(std::shared_ptr<const ConfigManager> config, const std::string& key)
+{
+	setJavaStandard(config->getValueOrDefault<std::string>(key + "/java_standard", ""));
+}
+
+void SourceGroupSettingsWithJavaStandard::save(std::shared_ptr<ConfigManager> config, const std::string& key)
+{
+	config->setValue(key + "/java_standard", getJavaStandard());
+}
+
+std::string SourceGroupSettingsWithJavaStandard::getJavaStandard() const
+{
+	if (m_javaStandard.empty())
+	{
+		return getDefaultJavaStandard();
+	}
+	return m_javaStandard;
+}
+
+void SourceGroupSettingsWithJavaStandard::setJavaStandard(const std::string& standard)
+{
+	m_javaStandard = standard;
+}
+
+std::vector<std::string> SourceGroupSettingsWithJavaStandard::getAvailableJavaStandards() const
+{
+	return {"1", "2", "3", "4", "5", "6", "7", "8"};
+}
+
+std::string SourceGroupSettingsWithJavaStandard::getDefaultJavaStandard() const
+{
+	return getDefaultJavaStandardStatic();
+}

src/lib/settings/SourceGroupSettingsWithJavaStandard.h

@@ -0,0 +1,37 @@
+#ifndef SOURCE_GROUP_SETTINGS_WITH_JAVA_STANDARD_H
+#define SOURCE_GROUP_SETTINGS_WITH_JAVA_STANDARD_H
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class ConfigManager;
+class ProjectSettings;
+
+class SourceGroupSettingsWithJavaStandard
+{
+public:
+	static std::string getDefaultJavaStandardStatic();
+
+	SourceGroupSettingsWithJavaStandard() = default;
+	virtual ~SourceGroupSettingsWithJavaStandard() = default;
+
+	bool equals(std::shared_ptr<SourceGroupSettingsWithJavaStandard> other) const;
+
+	std::string getJavaStandard() const;
+	void setJavaStandard(const std::string& standard);
+
+	std::vector<std::string> getAvailableJavaStandards() const;
+
+protected:
+	void load(std::shared_ptr<const ConfigManager> config, const std::string& key);
+	void save(std::shared_ptr<ConfigManager> config, const std::string& key);
+
+private:
+	virtual const ProjectSettings* getProjectSettings() const = 0;
+	std::string getDefaultJavaStandard() const;
+
+	std::string m_javaStandard;
+};
+
+#endif // SOURCE_GROUP_SETTINGS_WITH_JAVA_STANDARD_H

src/lib/settings/SourceGroupSettingsWithSourceExtensions.cpp

@@ -0,0 +1,38 @@
+#include "settings/SourceGroupSettingsWithSourceExtensions.h"
+
+#include "settings/ProjectSettings.h"
+#include "utility/utility.h"
+
+SourceGroupSettingsWithSourceExtensions::SourceGroupSettingsWithSourceExtensions()
+	: m_sourceExtensions(std::vector<std::wstring>())
+{
+}
+
+bool SourceGroupSettingsWithSourceExtensions::equals(std::shared_ptr<SourceGroupSettingsWithSourceExtensions> other) const
+{
+	return utility::isPermutation(m_sourceExtensions, other->m_sourceExtensions);
+}
+
+void SourceGroupSettingsWithSourceExtensions::load(std::shared_ptr<const ConfigManager> config, const std::string& key)
+{
+	setSourceExtensions(config->getValuesOrDefaults(key + "/source_extensions/source_extension", std::vector<std::wstring>()));
+}
+
+void SourceGroupSettingsWithSourceExtensions::save(std::shared_ptr<ConfigManager> config, const std::string& key)
+{
+	config->setValues(key + "/source_extensions/source_extension", getSourceExtensions());
+}
+
+std::vector<std::wstring> SourceGroupSettingsWithSourceExtensions::getSourceExtensions() const
+{
+	if (m_sourceExtensions.empty())
+	{
+		return getDefaultSourceExtensions();
+	}
+	return m_sourceExtensions;
+}
+
+void SourceGroupSettingsWithSourceExtensions::setSourceExtensions(const std::vector<std::wstring>& sourceExtensions)
+{
+	m_sourceExtensions = sourceExtensions;
+}

src/lib/settings/SourceGroupSettingsWithSourceExtensions.h

@@ -0,0 +1,34 @@
+#ifndef SOURCE_GROUP_SETTINGS_WITH_SOURCE_EXTENSIONS_H
+#define SOURCE_GROUP_SETTINGS_WITH_SOURCE_EXTENSIONS_H
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class ConfigManager;
+class FilePath;
+class ProjectSettings;
+
+class SourceGroupSettingsWithSourceExtensions
+{
+public:
+	SourceGroupSettingsWithSourceExtensions();
+	virtual ~SourceGroupSettingsWithSourceExtensions() = default;
+	
+	bool equals(std::shared_ptr<SourceGroupSettingsWithSourceExtensions> other) const;
+
+	std::vector<std::wstring> getSourceExtensions() const;
+	void setSourceExtensions(const std::vector<std::wstring>& sourceExtensions);
+	
+protected:
+	void load(std::shared_ptr<const ConfigManager> config, const std::string& key);
+	void save(std::shared_ptr<ConfigManager> config, const std::string& key);
+
+private:
+	virtual const ProjectSettings* getProjectSettings() const = 0;
+	virtual std::vector<std::wstring> getDefaultSourceExtensions() const = 0;
+
+	std::vector<std::wstring> m_sourceExtensions;
+};
+
+#endif // SOURCE_GROUP_SETTINGS_WITH_SOURCE_EXTENSIONS_H

src/lib/settings/SourceGroupSettingsWithSourcePaths.cpp

@@ -5,28 +5,22 @@
 
 SourceGroupSettingsWithSourcePaths::SourceGroupSettingsWithSourcePaths()
 	: m_sourcePaths(std::vector<FilePath>())
-	, m_sourceExtensions(std::vector<std::wstring>())
 {
 }
 
 bool SourceGroupSettingsWithSourcePaths::equals(std::shared_ptr<SourceGroupSettingsWithSourcePaths> other) const
 {
-	return (
-		utility::isPermutation(m_sourcePaths, other->m_sourcePaths) &&
-		utility::isPermutation(m_sourceExtensions, other->m_sourceExtensions)
-	);
+	return utility::isPermutation(m_sourcePaths, other->m_sourcePaths);
 }
 
 void SourceGroupSettingsWithSourcePaths::load(std::shared_ptr<const ConfigManager> config, const std::string& key)
 {
 	setSourcePaths(config->getValuesOrDefaults(key + "/source_paths/source_path", std::vector<FilePath>()));
-	setSourceExtensions(config->getValuesOrDefaults(key + "/source_extensions/source_extension", std::vector<std::wstring>()));
 }
 
 void SourceGroupSettingsWithSourcePaths::save(std::shared_ptr<ConfigManager> config, const std::string& key)
 {
 	config->setValues(key + "/source_paths/source_path", getSourcePaths());
-	config->setValues(key + "/source_extensions/source_extension", getSourceExtensions());
 }
 
 std::vector<FilePath> SourceGroupSettingsWithSourcePaths::getSourcePaths() const
@@ -43,17 +37,3 @@ void SourceGroupSettingsWithSourcePaths::setSourcePaths(const std::vector<FilePa
 {
 	m_sourcePaths = sourcePaths;
 }
-
-std::vector<std::wstring> SourceGroupSettingsWithSourcePaths::getSourceExtensions() const
-{
-	if (m_sourceExtensions.empty())
-	{
-		return getDefaultSourceExtensions();
-	}
-	return m_sourceExtensions;
-}
-
-void SourceGroupSettingsWithSourcePaths::setSourceExtensions(const std::vector<std::wstring>& sourceExtensions)
-{
-	m_sourceExtensions = sourceExtensions;
-}

src/lib/settings/SourceGroupSettingsWithSourcePaths.h

@@ -21,19 +21,14 @@ public:
 	std::vector<FilePath> getSourcePathsExpandedAndAbsolute() const;
 	void setSourcePaths(const std::vector<FilePath>& sourcePaths);
 
-	std::vector<std::wstring> getSourceExtensions() const;
-	void setSourceExtensions(const std::vector<std::wstring>& sourceExtensions);
-	
 protected:
 	void load(std::shared_ptr<const ConfigManager> config, const std::string& key);
 	void save(std::shared_ptr<ConfigManager> config, const std::string& key);
 
 private:
 	virtual const ProjectSettings* getProjectSettings() const = 0;
-	virtual std::vector<std::wstring> getDefaultSourceExtensions() const = 0;
 
 	std::vector<FilePath> m_sourcePaths;
-	std::vector<std::wstring> m_sourceExtensions;
 };
 
 #endif // SOURCE_GROUP_SETTINGS_WITH_SOURCE_PATHS_H

src/lib/settings/SourceGroupType.cpp

@@ -10,6 +10,8 @@ std::string sourceGroupTypeToString(SourceGroupType v)
 		return "C++ Source Group";
 	case SOURCE_GROUP_CXX_CDB:
 		return "C/C++ from Compilation Database";
+	case SOURCE_GROUP_CXX_CODEBLOCKS:
+		return "C/C++ from Code::Blocks";
 	case SOURCE_GROUP_CXX_SONARGRAPH:
 		return "C/C++ from Sonargraph";
 	case SOURCE_GROUP_CXX_VS:
@@ -38,6 +40,8 @@ std::string sourceGroupTypeToProjectSetupString(SourceGroupType v)
 		return "Empty C++ Source Group";
 	case SOURCE_GROUP_CXX_CDB:
 		return "C/C++ from Compilation Database";
+	case SOURCE_GROUP_CXX_CODEBLOCKS:
+		return "C/C++ from Code::Blocks";
 	case SOURCE_GROUP_CXX_SONARGRAPH:
 		return "C/C++ from Sonargraph";
 	case SOURCE_GROUP_CXX_VS:
@@ -70,6 +74,10 @@ SourceGroupType stringToSourceGroupType(const std::string& v)
 	{
 		return SOURCE_GROUP_CXX_CDB;
 	}
+	else if (v == sourceGroupTypeToString(SOURCE_GROUP_CXX_CODEBLOCKS))
+	{
+		return SOURCE_GROUP_CXX_CODEBLOCKS;
+	}
 	else if (v == sourceGroupTypeToString(SOURCE_GROUP_CXX_SONARGRAPH))
 	{
 		return SOURCE_GROUP_CXX_SONARGRAPH;

src/lib/settings/SourceGroupType.h

@@ -8,6 +8,7 @@ enum SourceGroupType
 	SOURCE_GROUP_C_EMPTY,
 	SOURCE_GROUP_CPP_EMPTY,
 	SOURCE_GROUP_CXX_CDB,
+	SOURCE_GROUP_CXX_CODEBLOCKS,
 	SOURCE_GROUP_CXX_SONARGRAPH,
 	SOURCE_GROUP_CXX_VS,
 	SOURCE_GROUP_JAVA_EMPTY,

src/lib/utility/file/FilePath.cpp

@@ -344,7 +344,7 @@ FilePath FilePath::getLowerCase() const
 
 bool FilePath::contains(const FilePath& other) const
 {
-	if (!isDirectory())
+	if (exists() && !isDirectory())
 	{
 		return false;
 	}

src/lib/utility/sonargraph/SonargraphProject.cpp

@@ -60,11 +60,6 @@ namespace Sonargraph
 		return m_softwareSystem->getModules().size();
 	}
 
-	std::set<FilePath> Project::getAllSourcePaths() const
-	{
-		return m_softwareSystem->getAllSourcePaths();
-	}
-
 	std::set<FilePath> Project::getAllSourceFilePathsCanonical() const
 	{
 		return m_softwareSystem->getAllSourceFilePathsCanonical();
@@ -75,11 +70,6 @@ namespace Sonargraph
 		return m_softwareSystem->getAllCxxHeaderSearchPathsCanonical();
 	}
 
-	std::set<FilePath> Project::filterToContainedFilePaths(const std::set<FilePath>& filePaths) const
-	{
-		return m_softwareSystem->filterToContainedFilePaths(filePaths);
-	}
-
 	std::vector<std::shared_ptr<IndexerCommand>> Project::getIndexerCommands(
 		std::shared_ptr<const SourceGroupSettings> sourceGroupSettings, 
 		std::shared_ptr<const ApplicationSettings> appSettings) const

src/lib/utility/sonargraph/SonargraphProject.h

@@ -32,10 +32,8 @@ namespace Sonargraph
 
 		int getLoadedModuleCount() const;
 
-		std::set<FilePath> getAllSourcePaths() const;
 		std::set<FilePath> getAllSourceFilePathsCanonical() const;
 		std::set<FilePath> getAllCxxHeaderSearchPathsCanonical() const;
-		std::set<FilePath> filterToContainedFilePaths(const std::set<FilePath>& filePaths) const;
 
 		std::vector<std::shared_ptr<IndexerCommand>> getIndexerCommands(
 			std::shared_ptr<const SourceGroupSettings> sourceGroupSettings,

src/lib/utility/sonargraph/SonargraphSoftwareSystem.cpp

@@ -90,16 +90,6 @@ namespace Sonargraph
 		return sourceFilePaths;
 	}
 
-	std::set<FilePath> SoftwareSystem::filterToContainedFilePaths(const std::set<FilePath>& filePaths) const
-	{
-		std::set<FilePath> containedFilePaths;
-		for (std::shared_ptr<XsdAbstractModule> module : m_modules)
-		{
-			utility::append(containedFilePaths, module->filterToContainedFilePaths(filePaths));
-		}
-		return containedFilePaths;
-	}
-
 	std::vector<std::shared_ptr<IndexerCommand>> SoftwareSystem::getIndexerCommands(
 		std::shared_ptr<const SourceGroupSettings> sourceGroupSettings,
 		std::shared_ptr<const ApplicationSettings> appSettings) const

src/lib/utility/sonargraph/SonargraphSoftwareSystem.h

@@ -32,7 +32,6 @@ namespace Sonargraph
 		std::set<FilePath> getAllSourcePaths() const;
 		std::set<FilePath> getAllSourceFilePathsCanonical() const;
 		std::set<FilePath> getAllCxxHeaderSearchPathsCanonical() const;
-		std::set<FilePath> filterToContainedFilePaths(const std::set<FilePath>& filePaths) const;
 
 		template <typename ExtensionType>
 		std::vector<std::shared_ptr<ExtensionType>> getSpecificSystemExtensions() const;

src/lib/utility/sonargraph/SonargraphXsdAbstractModule.h

@@ -37,7 +37,6 @@ namespace Sonargraph
 		virtual std::set<FilePath> getAllSourcePaths() const = 0;
 		virtual std::set<FilePath> getAllSourceFilePathsCanonical() const = 0;
 		virtual std::set<FilePath> getAllCxxHeaderSearchPathsCanonical() const = 0;
-		virtual std::set<FilePath> filterToContainedFilePaths(const std::set<FilePath>& filePaths) const = 0;
 
 		std::shared_ptr<const SoftwareSystem> getSoftwareSystem() const;
 		std::vector<FilePathFilter> getDerivedExcludeFilters() const;

src/lib/utility/sonargraph/SonargraphXsdCmakeJsonModule.cpp

@@ -7,6 +7,8 @@
 #include "settings/LanguageType.h"
 #include "settings/SourceGroupSettings.h"
 #include "settings/SourceGroupSettingsCxxSonargraph.h"
+#include "settings/SourceGroupSettingsWithCppStandard.h"
+#include "settings/SourceGroupSettingsWithCStandard.h"
 #include "utility/file/FileSystem.h"
 #include "utility/logging/logging.h"
 #include "utility/sonargraph/SonargraphSoftwareSystem.h"
@@ -177,75 +179,45 @@ namespace Sonargraph
 		return headerSearchPaths;
 	}
 
-	std::set<FilePath> XsdCmakeJsonModule::filterToContainedFilePaths(const std::set<FilePath>& filePaths) const
-	{
-		const std::set<FilePath> indexedPaths = getAllSourcePaths();
-		const std::vector<FilePathFilter> excludeFilters = getDerivedExcludeFilters();
-		const std::vector<FilePathFilter> includeFilters = getDerivedIncludeFilters();
-
-		std::set<FilePath> containedFilePaths;
-		for (const FilePath& filePath : filePaths)
-		{
-			bool isInIndexedPaths = false;
-			for (const FilePath& indexedPath : indexedPaths)
-			{
-				if (indexedPath == filePath || indexedPath.contains(filePath))
-				{
-					isInIndexedPaths = true;
-					break;
-				}
-			}
-
-			if (isInIndexedPaths)
-			{
-				for (const FilePathFilter& excludeFilter : excludeFilters)
-				{
-					if (excludeFilter.isMatching(filePath))
-					{
-						isInIndexedPaths = false;
-						break;
-					}
-				}
-
-				if (!isInIndexedPaths)
-				{
-					for (const FilePathFilter& includeFilter : includeFilters)
-					{
-						if (includeFilter.isMatching(filePath))
-						{
-							isInIndexedPaths = true;
-							break;
-						}
-					}
-				}
-			}
-
-			if (isInIndexedPaths)
-			{
-				containedFilePaths.insert(filePath);
-			}
-		}
-
-		return containedFilePaths;
-	}
-
 	std::vector<std::shared_ptr<IndexerCommand>> XsdCmakeJsonModule::getIndexerCommands(
 		std::shared_ptr<const SourceGroupSettings> sourceGroupSettings,
 		std::shared_ptr<const ApplicationSettings> appSettings) const
 	{
 		std::vector<std::shared_ptr<IndexerCommand>> indexerCommands;
 
+		std::set<FilePath> indexedHeaderPaths;
+		std::string languageStandard = SourceGroupSettingsWithCppStandard::getDefaultCppStandardStatic();
+
+		if (std::shared_ptr<const SourceGroupSettingsCxxSonargraph> sonargraphSettings =
+			std::dynamic_pointer_cast<const SourceGroupSettingsCxxSonargraph>(sourceGroupSettings))
+		{
+			indexedHeaderPaths = utility::toSet(sonargraphSettings->getIndexedHeaderPathsExpandedAndAbsolute());
+			languageStandard = sonargraphSettings->getCppStandard();
+		}
+		else
+		{
+			LOG_ERROR("Source group doesn't specify language standard. Falling back to \"" + languageStandard + "\".");
+			LOG_ERROR("Source group doesn't specify any indexed header paths");
+		}
+
+		const std::vector<FilePath> systemHeaderSearchPaths = (appSettings ? appSettings->getHeaderSearchPathsExpanded() : std::vector<FilePath>());
+		const std::vector<FilePath> frameworkSearchPaths = (appSettings ? appSettings->getFrameworkSearchPathsExpanded() : std::vector<FilePath>());
+
 		for (std::shared_ptr<XsdRootPath> rootPath : getRootPaths())
 		{
 			if (std::shared_ptr<XsdRootPathWithFiles> rootPathWithFiles = std::dynamic_pointer_cast<XsdRootPathWithFiles>(rootPath))
 			{
-				utility::append(indexerCommands, getIndexerCommandsForRootPath(rootPathWithFiles, sourceGroupSettings, appSettings));
+				utility::append(indexerCommands, getIndexerCommandsForRootPath(
+					rootPathWithFiles, indexedHeaderPaths, languageStandard, systemHeaderSearchPaths, frameworkSearchPaths
+				));
 			}
 		}
 
 		for (std::shared_ptr<XsdRootPathWithFiles> rootPath : m_rootPathWithFiles)
 		{
-			utility::append(indexerCommands, getIndexerCommandsForRootPath(rootPath, sourceGroupSettings, appSettings));
+			utility::append(indexerCommands, getIndexerCommandsForRootPath(
+				rootPath, indexedHeaderPaths ,languageStandard, systemHeaderSearchPaths, frameworkSearchPaths
+			));
 		}
 
 		return indexerCommands;
@@ -321,8 +293,10 @@ namespace Sonargraph
 
 	std::vector<std::shared_ptr<IndexerCommand>> XsdCmakeJsonModule::getIndexerCommandsForRootPath(
 		std::shared_ptr<XsdRootPathWithFiles> rootPath,
-		std::shared_ptr<const SourceGroupSettings> sourceGroupSettings,
-		std::shared_ptr<const ApplicationSettings> appSettings) const
+		const std::set<FilePath> indexedHeaderPaths,
+		const std::string& languageStandard,
+		const std::vector<FilePath> systemHeaderSearchPaths,
+		const std::vector<FilePath> frameworkSearchPaths) const
 	{
 		std::vector<std::shared_ptr<IndexerCommand>> indexerCommands;
 		if (rootPath)
@@ -335,17 +309,8 @@ namespace Sonargraph
 
 			const FilePath baseDir = rootPath->getFilePath(softwareSystem->getBaseDirectory());
 
-			std::set<FilePath> indexedHeaderPaths;
-			if (std::shared_ptr<const SourceGroupSettingsCxxSonargraph> sonargraphSettings = std::dynamic_pointer_cast<const SourceGroupSettingsCxxSonargraph>(sourceGroupSettings))
-			{
-				indexedHeaderPaths = utility::toSet(sonargraphSettings->getIndexedHeaderPathsExpandedAndAbsolute());
-			}
-
 			const std::set<FilePathFilter> excludeFilters = utility::toSet(getDerivedExcludeFilters());
 			const std::set<FilePathFilter> includeFilters = utility::toSet(getDerivedIncludeFilters());
-			const std::string languageStandard = sourceGroupSettings->getStandard();
-			const std::vector<FilePath> systemHeaderSearchPaths = (appSettings ? appSettings->getHeaderSearchPathsExpanded() : std::vector<FilePath>());
-			const std::vector<FilePath> frameworkSearchPaths = (appSettings ? appSettings->getFrameworkSearchPathsExpanded() : std::vector<FilePath>());
 
 			OrderedCache<Id, std::vector<std::wstring>> compilerOptionCache([&](const Id& id) {
 				if (std::shared_ptr<const SoftwareSystem> softwareSystem = getSoftwareSystem())

src/lib/utility/sonargraph/SonargraphXsdCmakeJsonModule.h

@@ -17,7 +17,6 @@ namespace Sonargraph
 		std::set<FilePath> getAllSourcePaths() const override;
 		std::set<FilePath> getAllSourceFilePathsCanonical() const override;
 		std::set<FilePath> getAllCxxHeaderSearchPathsCanonical() const override;
-		std::set<FilePath> filterToContainedFilePaths(const std::set<FilePath>& filePaths) const override;
 		std::vector<std::shared_ptr<IndexerCommand>> getIndexerCommands(
 			std::shared_ptr<const SourceGroupSettings> sourceGroupSettings,
 			std::shared_ptr<const ApplicationSettings> appSettings) const override;
@@ -33,9 +32,11 @@ namespace Sonargraph
 			const std::set<FilePathFilter>& includeFilters) const;
 
 		std::vector<std::shared_ptr<IndexerCommand>> getIndexerCommandsForRootPath(
-			std::shared_ptr<XsdRootPathWithFiles> rootPath, 
-			std::shared_ptr<const SourceGroupSettings> sourceGroupSettings,
-			std::shared_ptr<const ApplicationSettings> appSettings) const;
+			std::shared_ptr<XsdRootPathWithFiles> rootPath,
+			const std::set<FilePath> indexedHeaderPaths,
+			const std::string& languageStandard,
+			const std::vector<FilePath> systemHeaderSearchPaths,
+			const std::vector<FilePath> frameworkSearchPaths) const;
 
 		std::vector<std::shared_ptr<XsdRootPathWithFiles>> m_rootPathWithFiles;
 	};

src/lib/utility/sonargraph/SonargraphXsdJavaModule.cpp

@@ -102,58 +102,6 @@ namespace Sonargraph
 		return std::set<FilePath>();
 	}
 	
-	std::set<FilePath> XsdJavaModule::filterToContainedFilePaths(const std::set<FilePath>& filePaths) const
-	{
-		const std::set<FilePath> indexedPaths = getAllSourcePaths();
-		const std::vector<FilePathFilter> excludeFilters = getDerivedExcludeFilters();
-		const std::vector<FilePathFilter> includeFilters = getDerivedIncludeFilters();
-
-		std::set<FilePath> containedFilePaths;
-		for (const FilePath& filePath : filePaths)
-		{
-			bool isInIndexedPaths = false;
-			for (const FilePath& indexedPath : indexedPaths)
-			{
-				if (indexedPath == filePath || indexedPath.contains(filePath))
-				{
-					isInIndexedPaths = true;
-					break;
-				}
-			}
-
-			if (isInIndexedPaths)
-			{
-				for (const FilePathFilter& excludeFilter : excludeFilters)
-				{
-					if (excludeFilter.isMatching(filePath))
-					{
-						isInIndexedPaths = false;
-						break;
-					}
-				}
-
-				if (!isInIndexedPaths)
-				{
-					for (const FilePathFilter& includeFilter : includeFilters)
-					{
-						if (includeFilter.isMatching(filePath))
-						{
-							isInIndexedPaths = true;
-							break;
-						}
-					}
-				}
-			}
-
-			if (isInIndexedPaths)
-			{
-				containedFilePaths.insert(filePath);
-			}
-		}
-
-		return containedFilePaths;
-	}
-
 	std::vector<std::shared_ptr<IndexerCommand>> XsdJavaModule::getIndexerCommands(
 		std::shared_ptr<const SourceGroupSettings> sourceGroupSettings,
 		std::shared_ptr<const ApplicationSettings> appSettings) const
@@ -161,7 +109,16 @@ namespace Sonargraph
 		std::vector<std::shared_ptr<IndexerCommand>> indexerCommands;
 
 		{
-			const std::string languageStandard = sourceGroupSettings->getStandard();
+			std::string languageStandard = SourceGroupSettingsWithJavaStandard::getDefaultJavaStandardStatic();
+			if (std::shared_ptr<const SourceGroupSettingsJavaSonargraph> settings = 
+				std::dynamic_pointer_cast<const SourceGroupSettingsJavaSonargraph>(sourceGroupSettings))
+			{
+				languageStandard = settings->getJavaStandard();
+			}
+			else
+			{
+				LOG_ERROR("Source group doesn't specify language standard. Falling back to \"" + languageStandard + "\".");
+			}
 
 			for (const FilePath& sourceFilePath : getAllSourceFilePathsCanonical())
 			{

src/lib/utility/sonargraph/SonargraphXsdJavaModule.h

@@ -18,7 +18,6 @@ namespace Sonargraph
 		std::set<FilePath> getAllSourcePaths() const override;
 		std::set<FilePath> getAllSourceFilePathsCanonical() const override;
 		std::set<FilePath> getAllCxxHeaderSearchPathsCanonical() const override;
-		std::set<FilePath> filterToContainedFilePaths(const std::set<FilePath>& filePaths) const override;
 		std::vector<std::shared_ptr<IndexerCommand>> getIndexerCommands(
 			std::shared_ptr<const SourceGroupSettings> sourceGroupSettings,
 			std::shared_ptr<const ApplicationSettings> appSettings) const override;