M/VisualSapfor
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

промежуточный. перевод опций и флагов из джсона в таблицы. надо еще отладить, и доделать клонирование

Browse Source
This commit is contained in:
02090095
2025-03-25 01:56:48 +03:00
parent a60ed8f661
commit 7ef9ee0d5c
24 changed files with 480 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/_VisualDVM/Constants.java
View File

@@ -48,7 +48,7 @@ public class Constants {
//
//7998 отладочный порт. теперь.
public static final int ComponentsServerPort = 7995; //7795
public static final int TestingServerPort = 7996; //7996
public static final int TestingServerPort = 7998; //7996
public static final int SocketTimeout = 0;
//-
public static final String ServerAddress = "alex-freenas.ddns.net";

4
src/_VisualDVM/GlobalData/CompilerEnvironment/Json/EnvironmentJson.java
View File

@@ -10,4 +10,8 @@ public class EnvironmentJson {
name = src.name;
value = src.value;
}
public EnvironmentJson(String name_in,String value_in){
name=name_in;
value=value_in;
}
}

7
src/_VisualDVM/GlobalData/CompilerOption/Json/OptionJson.java
View File

@@ -7,7 +7,10 @@ public class OptionJson {
@Expose
public String value; //значение без кавычек
public OptionJson(CompilerOption src) {
name = src.name + src.parameterSeparator;
value = src.parameterValue;
this(src.name + src.parameterSeparator, src.parameterValue);
}
public OptionJson(String name_in, String value_in){
name=name_in;
value= value_in;
}
}

65
src/_VisualDVM/ServerObjectsCache/DVMSettingsCache.java
View File

@@ -1,62 +1,41 @@
package _VisualDVM.ServerObjectsCache;
import Common.Utils.Utils_;
import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentsJson;
import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentsSetJson;
import _VisualDVM.GlobalData.CompilerOption.Json.OptionsJson;
import _VisualDVM.GlobalData.CompilerOption.Json.OptionsSetJson;
import _VisualDVM.Global;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOption;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSet;
import _VisualDVM.TestingSystem.DVM.DVMEnvironment.DVMEnvironment;
import _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet.DVMEnvironmentsSet;
import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettings;
import javafx.util.Pair;
import java.util.Vector;
public class DVMSettingsCache extends VisualCache {
public OptionsSetJson optionsSetJson = null;
public EnvironmentsSetJson environmentsSetJson = null;
//--
public String optionsSummary = null;
public String environmentsSummary = null;
//--
public DVMSettingsCache(DVMSettings dvmSettings) {
//-->>
if (dvmSettings.packedCompilationOptionsJson.isEmpty())
optionsSetJson = new OptionsSetJson();
else
optionsSetJson = Utils_.gson.fromJson(dvmSettings.packedCompilationOptionsJson, OptionsSetJson.class);
//-->>
if (dvmSettings.packedRunEnvironmentValuesJson.isEmpty())
environmentsSetJson = new EnvironmentsSetJson();
else
environmentsSetJson = Utils_.gson.fromJson(dvmSettings.packedRunEnvironmentValuesJson, EnvironmentsSetJson.class);
//--
Vector<String> optionsSummary_ = new Vector<>();
for (OptionsJson optionsJson : optionsSetJson.values) {
optionsSummary_.add(optionsJson.toLine());
Vector<DVMCompilationOptionsSet> optionsSets = Global.testingServer.db.getVectorByFK(dvmSettings, DVMCompilationOptionsSet.class);
for (DVMCompilationOptionsSet optionsSet: optionsSets){
Vector<String> optionsValues = new Vector<>();
Vector<DVMCompilationOption> options = Global.testingServer.db.getVectorByFK(optionsSet, DVMCompilationOption.class);
for (DVMCompilationOption option: options){
optionsValues.add(option.print());
}
optionsSummary_.add(String.join(" ", optionsValues));
}
optionsSummary = String.join(";\n", optionsSummary_);
//-->>
Vector<String> environmentsSummary_ = new Vector<>();
for (EnvironmentsJson environmentsJson : environmentsSetJson.values) {
environmentsSummary_.add(environmentsJson.toLine());
Vector<DVMEnvironmentsSet> environmentsSets = Global.testingServer.db.getVectorByFK(dvmSettings,DVMEnvironmentsSet.class);
for (DVMEnvironmentsSet environmentsSet: environmentsSets){
Vector<String> environmentsValues = new Vector<>();
Vector<DVMEnvironment> environments = Global.testingServer.db.getVectorByFK(environmentsSet, DVMEnvironment.class);
for (DVMEnvironment environment: environments){
environmentsValues.add(environment.print());
}
environmentsSummary_.add(String.join(" ", environmentsValues));
}
environmentsSummary = String.join(";\n", environmentsSummary_);
}
public Vector<Pair<String, String>> getTasksParameters() {
//уравниваем количество наборов опций и окружений и сопоставляем 1 к 1
Vector<Pair<String, String>> res = new Vector<>();
for (int i = 0; i < optionsSetJson.values.size(); ++i) {
String optionsLine = optionsSetJson.values.get(i).toLine();
String environmentsLine = (i < environmentsSetJson.values.size()) ?
environmentsSetJson.values.get(i).toLine() : "";
res.add(new Pair<>(
optionsLine,
environmentsLine));
}
if (optionsSetJson.values.size() < environmentsSetJson.values.size()) {
for (int i = optionsSetJson.values.size(); i < environmentsSetJson.values.size(); ++i) {
res.add(new Pair<>(
"",
environmentsSetJson.values.get(i).toLine()
));
}
}
return res;
}
}

20
src/_VisualDVM/TestingSystem/Common/TestingServer.java
View File

@@ -32,6 +32,7 @@ import _VisualDVM.TestingSystem.DVM.DVMConfigurationGroup.DVMConfigurationGroup;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationSettings.DVMConfigurationSettings;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationTest.DVMConfigurationTest;
import _VisualDVM.TestingSystem.DVM.DVMPackage.DVMPackage;
import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettings;
import _VisualDVM.TestingSystem.DVM.DVMTestingChecker;
import _VisualDVM.TestingSystem.DVM.PackageCredentials.DVMPackageCredentials;
import _VisualDVM.TestingSystem.SAPFOR.Json.SapforPackage_json;
@@ -143,6 +144,12 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
SapforPackage sapforPackage = (SapforPackage) object;
sapforPackage.init();
db.saveSapforPackageConfigurations(sapforPackage);
}else if (object instanceof DVMSettings) {
DVMSettings dvmSettings= (DVMSettings) object;
db.InsertDVMSettingsOptions(dvmSettings);
db.InsertDVMSettingsEnvironments(dvmSettings);
dvmSettings.packedCompilationOptionsJson = null;
dvmSettings.packedRunEnvironmentValuesJson=null;
}
}
@Override
@@ -192,6 +199,16 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
db.getVectorByFK(sapforConfiguration, SapforConfigurationSettings.class),
sapforConfiguration.settings
);
} else if (object instanceof DVMSettings) {
DVMSettings dvmSettings = (DVMSettings) object;
db.DeleteDVMSettingsOptions(dvmSettings);
db.DeleteDVMSettingsEnvironments(dvmSettings);
//--
db.InsertDVMSettingsOptions(dvmSettings);
db.InsertDVMSettingsEnvironments(dvmSettings);
//--
dvmSettings.packedCompilationOptionsJson=null;
dvmSettings.packedRunEnvironmentValuesJson=null;
}
}
@Override
@@ -232,6 +249,9 @@ public class TestingServer extends RepositoryServer<TestsDatabase> {
//--
File workspace = sapforPackage.getLocalWorkspace();
Utils_.forceDeleteWithCheck(workspace);
} else if (object instanceof DVMSettings) {
DVMSettings dvmSettings = (DVMSettings) object;
db.DeleteDVMSettingsOptions(dvmSettings);
}
//-
}

322
src/_VisualDVM/TestingSystem/Common/TestsDatabase.java
View File

@@ -6,6 +6,12 @@ import _VisualDVM.ComponentsServer.Component.Sapfor.Sapfor;
import _VisualDVM.ComponentsServer.UserAccount.UserAccount;
import _VisualDVM.Constants;
import _VisualDVM.Global;
import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentJson;
import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentsJson;
import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentsSetJson;
import _VisualDVM.GlobalData.CompilerOption.Json.OptionJson;
import _VisualDVM.GlobalData.CompilerOption.Json.OptionsJson;
import _VisualDVM.GlobalData.CompilerOption.Json.OptionsSetJson;
import _VisualDVM.Passes.PassCode;
import _VisualDVM.ServerObjectsCache.VisualCaches;
import _VisualDVM.TestingSystem.Common.Group.Group;
@@ -15,6 +21,10 @@ import _VisualDVM.TestingSystem.Common.Test.TestDBTable;
import _VisualDVM.TestingSystem.Common.TestFile.TestFile;
import _VisualDVM.TestingSystem.Common.TestFile.TestFilesDBTable;
import _VisualDVM.TestingSystem.Common.TestingPackageToKill.TestingPackagesToKillDBTable;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOption;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOptionsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSet;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSetsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMConfiguration.DVMConfiguration;
import _VisualDVM.TestingSystem.DVM.DVMConfiguration.DVMConfigurationDBTable;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationGroup.DVMConfigurationGroup;
@@ -23,10 +33,15 @@ import _VisualDVM.TestingSystem.DVM.DVMConfigurationSettings.DVMConfigurationSet
import _VisualDVM.TestingSystem.DVM.DVMConfigurationSettings.DVMConfigurationSettingsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationTest.DVMConfigurationTest;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationTest.DVMConfigurationTestsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMEnvironment.DVMEnvironment;
import _VisualDVM.TestingSystem.DVM.DVMEnvironment.DVMEnvironmentsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet.DVMEnvironmentsSet;
import _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet.DVMEnvironmentsSetsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMPackage.DVMPackage;
import _VisualDVM.TestingSystem.DVM.DVMPackage.DVMPackageDBTable;
import _VisualDVM.TestingSystem.DVM.DVMPackageConfiguration.DVMPackageConfiguration;
import _VisualDVM.TestingSystem.DVM.DVMPackageConfiguration.DVMPackageConfigurationsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettings;
import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettingsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMTasks.DVMRunTasksSet;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
@@ -61,6 +76,10 @@ public class TestsDatabase extends SQLiteDatabase {
public TestFilesDBTable testsFiles;
//---
public DVMSettingsDBTable dvmSettings;
public DVMCompilationOptionsSetsDBTable dvmCompilationOptionsSets;
public DVMCompilationOptionsDBTable dvmCompilationOptions;
public DVMEnvironmentsSetsDBTable dvmEnvironmentsSets;
public DVMEnvironmentsDBTable dvmEnvironments;
public DVMConfigurationDBTable dvmConfigurations;
public DVMConfigurationGroupsDBTable dvmConfigurationGroups;
public DVMConfigurationTestsDBTable dvmConfigurationTests;
@@ -91,6 +110,12 @@ public class TestsDatabase extends SQLiteDatabase {
addTable(testsFiles = new TestFilesDBTable());
//--
addTable(dvmSettings = new DVMSettingsDBTable());
//--
addTable(dvmCompilationOptionsSets = new DVMCompilationOptionsSetsDBTable());
addTable(dvmCompilationOptions = new DVMCompilationOptionsDBTable());
addTable(dvmEnvironmentsSets =new DVMEnvironmentsSetsDBTable());
addTable(dvmEnvironments = new DVMEnvironmentsDBTable());
//---
addTable(dvmConfigurations = new DVMConfigurationDBTable());
addTable(dvmConfigurationGroups = new DVMConfigurationGroupsDBTable());
addTable(dvmConfigurationTests = new DVMConfigurationTestsDBTable());
@@ -390,141 +415,6 @@ public class TestsDatabase extends SQLiteDatabase {
for (TestFile file : files)
Delete(file);
}
public void Patch() throws Exception {
/*
Vector<DVMPackageConfiguration> dvmPackageConfigurations_ = new Vector<>();
for (DVMPackage dvmPackage: dvmPackages.Data.values()){
if (!dvmPackage.packedConfigurationsJson.isEmpty()) {
ConfigurationsJson configurationsJson = Utils_.gson.fromJson(dvmPackage.packedConfigurationsJson, ConfigurationsJson.class);
for (ConfigurationJson configurationJson : configurationsJson.array) {
DVMPackageConfiguration dvmPackageConfiguration = new DVMPackageConfiguration();
dvmPackageConfiguration.dvmpackage_id = dvmPackage.id;
dvmPackageConfiguration.dvmconfiguration_id = configurationJson.id;
dvmPackageConfiguration.description =configurationJson.description;
dvmPackageConfigurations_.add(dvmPackageConfiguration);
}
}
}
BeginTransaction();
for (DVMPackageConfiguration dvmPackageConfiguration: dvmPackageConfigurations_)
Insert(dvmPackageConfiguration);
Commit();
//--
Vector<SapforPackageConfiguration> sapforPackageConfigurations_ = new Vector<>();
for (SapforPackage sapforPackage: sapforPackages.Data.values()){
if (!sapforPackage.packedConfigurationsJson.isEmpty()) {
ConfigurationsJson configurationsJson = Utils_.gson.fromJson(sapforPackage.packedConfigurationsJson, ConfigurationsJson.class);
for (ConfigurationJson configurationJson : configurationsJson.array) {
SapforPackageConfiguration sapforPackageConfiguration = new SapforPackageConfiguration();
sapforPackageConfiguration.sapforpackage_id = sapforPackage.id;
sapforPackageConfiguration.sapforconfiguration_id = configurationJson.id;
sapforPackageConfiguration.description =configurationJson.description;
sapforPackageConfigurations_.add(sapforPackageConfiguration);
}
}
}
BeginTransaction();
for (SapforPackageConfiguration sapforPackageConfiguration: sapforPackageConfigurations_)
Insert(sapforPackageConfiguration);
Commit();
*/
/*
Vector<DVMConfigurationGroup> DVMConfigurationGroups=new Vector<>();
//группы dvm конфигураций
for (DVMConfiguration dvmConfiguration: dvmConfigurations.Data.values()){
GroupsJson groupsJson = Utils_.gson.fromJson(dvmConfiguration.packedGroupsJson, GroupsJson.class);
for (GroupJson groupJson: groupsJson.array){
DVMConfigurationGroup dvmConfigurationGroup = new DVMConfigurationGroup();
dvmConfigurationGroup.group_id = groupJson.id;
dvmConfigurationGroup.dvmconfiguration_id = dvmConfiguration.id;
DVMConfigurationGroups.add(dvmConfigurationGroup);
}
}
BeginTransaction();
for (DVMConfigurationGroup dvmConfigurationGroup: DVMConfigurationGroups)
Insert(dvmConfigurationGroup);
Commit();
//---
Vector<SapforConfigurationGroup> SapforConfigurationGroups =new Vector<>();
//группы sapfor конфигураций
for (SapforConfiguration sapforConfiguration: sapforConfigurations.Data.values()){
GroupsJson groupsJson = Utils_.gson.fromJson(sapforConfiguration.packedGroupsJson, GroupsJson.class);
for (GroupJson groupJson: groupsJson.array){
SapforConfigurationGroup sapforConfigurationGroup = new SapforConfigurationGroup();
sapforConfigurationGroup.group_id = groupJson.id;
sapforConfigurationGroup.sapforconfiguration_id = sapforConfiguration.id;
SapforConfigurationGroups.add(sapforConfigurationGroup);
}
}
BeginTransaction();
for (SapforConfigurationGroup sapforConfigurationGroup: SapforConfigurationGroups)
Insert(sapforConfigurationGroup);
Commit();
//тесты двм конфигураций
Vector<DVMConfigurationTest> DvmConfigurationTests_ = new Vector<>();
for (DVMConfiguration configuration: dvmConfigurations.Data.values()){
TestsJson testsJson = Utils_.gson.fromJson(configuration.packedTestsJson,TestsJson.class);
for (TestJson testJson: testsJson.array){
DVMConfigurationTest test= new DVMConfigurationTest();
test.test_id=testJson.id;
test.dvmconfiguration_id=configuration.id;
DvmConfigurationTests_.add(test);
}
}
BeginTransaction();
for (DVMConfigurationTest test:DvmConfigurationTests_)
Insert(test);
Commit();
//-
//тесты сапфор конфигураций
Vector<SapforConfigurationTest> SapforConfigurationTests_ = new Vector<>();
for (SapforConfiguration configuration: sapforConfigurations.Data.values()){
TestsJson testsJson = Utils_.gson.fromJson(configuration.packedTestsJson,TestsJson.class);
for (TestJson testJson: testsJson.array){
SapforConfigurationTest test= new SapforConfigurationTest();
test.test_id=testJson.id;
test.sapforconfiguration_id=configuration.id;
SapforConfigurationTests_.add(test);
}
}
BeginTransaction();
for (SapforConfigurationTest test: SapforConfigurationTests_)
Insert(test);
Commit();
//--
Vector<DVMConfigurationSettings> DvmConfigurationSettings_ = new Vector<>();
for (DVMConfiguration configuration: dvmConfigurations.Data.values()){
SettingsArrayJson settingsArrayJson = Utils_.gson.fromJson(configuration.packedSettingsJson,SettingsArrayJson.class);
for (SettingsJson settingsJson: settingsArrayJson.array){
DVMConfigurationSettings Settings= new DVMConfigurationSettings();
Settings.dvmsettings_id=settingsJson.id;
Settings.dvmconfiguration_id=configuration.id;
DvmConfigurationSettings_.add(Settings);
}
}
BeginTransaction();
for (DVMConfigurationSettings Settings:DvmConfigurationSettings_)
Insert(Settings);
Commit();
//-
Vector<SapforConfigurationSettings> SapforConfigurationSettings_ = new Vector<>();
for (SapforConfiguration configuration: sapforConfigurations.Data.values()){
SettingsArrayJson settingsArrayJson = Utils_.gson.fromJson(configuration.packedSettingsJson,SettingsArrayJson.class);
for (SettingsJson settingsJson: settingsArrayJson.array){
SapforConfigurationSettings Settings= new SapforConfigurationSettings();
Settings.sapforsettings_id=settingsJson.id;
Settings.sapforconfiguration_id=configuration.id;
SapforConfigurationSettings_.add(Settings);
}
}
BeginTransaction();
for (SapforConfigurationSettings Settings:SapforConfigurationSettings_)
Insert(Settings);
Commit();
//-
*/
}
public void saveDVMPackageConfigurations(DVMPackage dvmPackage) throws Exception {
for (DVMPackageConfiguration packageConfiguration : dvmPackage.configurations) {
packageConfiguration.dvmpackage_id = dvmPackage.id;
@@ -644,4 +534,166 @@ public class TestsDatabase extends SQLiteDatabase {
}
return res;
}
//--
public OptionsSetJson convertOptionsToJson(DVMSettings dvmSettings_in) {
OptionsSetJson res = new OptionsSetJson();
if (dvmSettings_in.id != CommonConstants.Nan) {
Vector<DVMCompilationOptionsSet> optionsSets = getVectorByFK(dvmSettings_in, DVMCompilationOptionsSet.class);
for (DVMCompilationOptionsSet optionsSet: optionsSets){
Vector<DVMCompilationOption> options = getVectorByFK(optionsSet, DVMCompilationOption.class);
OptionsJson optionsJson = new OptionsJson();
for (DVMCompilationOption option:options){
optionsJson.values.add(new OptionJson(option.name,option.value));
}
res.values.add(optionsJson);
}
}
return res;
}
public void DeleteDVMSettingsOptions(DVMSettings dvmSettings) throws Exception{
Vector<DVMCompilationOptionsSet> optionsSets = getVectorByFK(dvmSettings, DVMCompilationOptionsSet.class);
for (DVMCompilationOptionsSet optionsSet: optionsSets){
DeleteDependencies(optionsSet);
Delete(optionsSet);
}
}
public void InsertDVMSettingsOptions(DVMSettings dvmSettings) throws Exception{
OptionsSetJson optionsSetJson = Utils_.gson.fromJson(dvmSettings.packedCompilationOptionsJson, OptionsSetJson.class);
for (OptionsJson optionsJson: optionsSetJson.values){
DVMCompilationOptionsSet optionsSet = new DVMCompilationOptionsSet(dvmSettings);
Insert(optionsSet);
for (OptionJson optionJson: optionsJson.values){
DVMCompilationOption option = new DVMCompilationOption();
option.dvmcompilationoptionsset_id=optionsSet.id;
option.name = optionJson.name;
option.value = optionJson.value;
Insert(option);
}
}
}
public void DeleteDVMSettingsEnvironments(DVMSettings dvmSettings) throws Exception{
Vector<DVMEnvironmentsSet> environmentsSets = getVectorByFK(dvmSettings, DVMEnvironmentsSet.class);
for (DVMEnvironmentsSet environmentsSet: environmentsSets){
DeleteDependencies(environmentsSet);
Delete(environmentsSet);
}
}
public void InsertDVMSettingsEnvironments(DVMSettings dvmSettings) throws Exception{
EnvironmentsSetJson environmentsSetJson = Utils_.gson.fromJson(dvmSettings.packedRunEnvironmentValuesJson, EnvironmentsSetJson.class);
for (EnvironmentsJson environmentsJson: environmentsSetJson.values){
DVMEnvironmentsSet environmentsSet = new DVMEnvironmentsSet(dvmSettings);
Insert(environmentsSet);
for (EnvironmentJson environmentJson: environmentsJson.values){
DVMEnvironment environment = new DVMEnvironment();
environment.dvmenvironmentsset_id=environmentsSet.id;
environment.name = environmentJson.name;
environment.value = environmentJson.value;
Insert(environment);
}
}
}
//--
public void Patch() throws Exception {
/*
Vector<DVMCompilationOptionsSet> sets = new Vector<>();
for (DVMSettings dvm_settings : dvmSettings.Data.values()) {
OptionsSetJson optionsSetJson = Utils_.gson.fromJson(dvm_settings.packedCompilationOptionsJson, OptionsSetJson.class);
for (OptionsJson optionsJson : optionsSetJson.values) {
DVMCompilationOptionsSet set = new DVMCompilationOptionsSet(dvm_settings);
set.options = new Vector<>();
for (OptionJson optionJson : optionsJson.values) {
set.options.add(new DVMCompilationOption(optionJson.name, optionJson.value));
}
sets.add(set);
}
}
BeginTransaction();
for (DVMCompilationOptionsSet set : sets) {
Insert(set);
for (DVMCompilationOption option : set.options) {
option.dvmcompilationoptionsset_id = set.id;
Insert(option);
}
}
Commit();
*/
/*
Vector<DVMEnvironmentsSet> sets = new Vector<>();
for (DVMSettings dvm_settings : dvmSettings.Data.values()) {
EnvironmentsSetJson environmentsSetJson = Utils_.gson.fromJson(dvm_settings.packedRunEnvironmentValuesJson, EnvironmentsSetJson.class);
for (EnvironmentsJson environmentsJson : environmentsSetJson.values) {
DVMEnvironmentsSet set = new DVMEnvironmentsSet(dvm_settings);
set.environments = new Vector<>();
for (EnvironmentJson environmentJson : environmentsJson.values) {
set.environments.add(new DVMEnvironment(environmentJson.name, environmentJson.value));
}
sets.add(set);
}
}
BeginTransaction();
for (DVMEnvironmentsSet set : sets) {
Insert(set);
for (DVMEnvironment option : set.environments) {
option.dvmenvironmentsset_id = set.id;
Insert(option);
}
}
Commit();
*/
}
public static String printOptionsLine(Vector<DVMCompilationOption> options){
Vector<String> res = new Vector<>();
for (DVMCompilationOption option: options)
res.add(option.print());
return String.join(" ", res);
}
public static String printEnvironmentsLine(Vector<DVMEnvironment> environments){
Vector<String> res = new Vector<>();
for (DVMEnvironment environment: environments)
res.add(environment.print());
return String.join(" ", res);
}
public Vector<Pair<String, String>> getTasksParameters(DVMSettings dvmSettings_in) {
//уравниваем количество наборов опций и окружений и сопоставляем 1 к 1
Vector<Pair<String, String>> res = new Vector<>();
Vector<DVMCompilationOptionsSet> optionsSets = getVectorByFK(dvmSettings_in, DVMCompilationOptionsSet.class);
Vector<DVMEnvironmentsSet> environmentsSets = getVectorByFK(dvmSettings_in, DVMEnvironmentsSet.class);
//--
for (int i = 0; i < optionsSets.size(); ++i) {
Vector<DVMCompilationOption> options = getVectorByFK(optionsSets.get(i), DVMCompilationOption.class);
Vector<DVMEnvironment> environments = getVectorByFK(environmentsSets.get(i), DVMEnvironment.class);
String optionsLine = printOptionsLine(options);
String environmentsLine = (i < environmentsSets.size()) ? printEnvironmentsLine(environments) : "";
res.add(new Pair<>(
optionsLine,
environmentsLine));
}
if (optionsSets.size() < environmentsSets.size()) {
for (int i = optionsSets.size(); i < environmentsSets.size(); ++i) {
res.add(new Pair<>(
"",
printEnvironmentsLine(getVectorByFK(environmentsSets.get(i), DVMEnvironment.class))
));
}
}
return res;
}
public EnvironmentsSetJson convertEnvironmentsToJson(DVMSettings dvmSettings_in) {
EnvironmentsSetJson res = new EnvironmentsSetJson();
if (dvmSettings_in.id != CommonConstants.Nan) {
Vector<DVMEnvironmentsSet> environmentsSets = getVectorByFK(dvmSettings_in, DVMEnvironmentsSet.class);
for (DVMEnvironmentsSet environmentsSet: environmentsSets){
Vector<DVMEnvironment> environments = getVectorByFK(environmentsSet, DVMEnvironment.class);
EnvironmentsJson environmentsJson = new EnvironmentsJson();
for (DVMEnvironment option:environments){
environmentsJson.values.add(new EnvironmentJson(option.name,option.value));
}
res.values.add(environmentsJson);
}
}
return res;
}
}

26
src/_VisualDVM/TestingSystem/DVM/DVMCompilationOption/DVMCompilationOption.java Normal file
View File

@@ -0,0 +1,26 @@
package _VisualDVM.TestingSystem.DVM.DVMCompilationOption;
import Common.CommonConstants;
import Common.Database.Objects.DBObject;
import Common.Database.Objects.iDBObject;
import Common.Utils.Utils_;
public class DVMCompilationOption extends iDBObject {
public String name = "";
public String value= "";
public int dvmcompilationoptionsset_id = CommonConstants.Nan;
public DVMCompilationOption(String name_in, String value_in) {
name = name_in;
value = value_in;
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
DVMCompilationOption src_ = (DVMCompilationOption) src;
name = src_.name;
value=src_.value;
dvmcompilationoptionsset_id = src_.dvmcompilationoptionsset_id;
}
public DVMCompilationOption(){}
public String print(){
return name + (value.contains(" ") ? Utils_.DQuotes(value) : value);
}
}

15
src/_VisualDVM/TestingSystem/DVM/DVMCompilationOption/DVMCompilationOptionsDBTable.java Normal file
View File

@@ -0,0 +1,15 @@
package _VisualDVM.TestingSystem.DVM.DVMCompilationOption;
import Common.Database.Objects.DBObject;
import Common.Database.Tables.FKBehaviour;
import Common.Database.Tables.FKCurrentObjectBehaviuor;
import Common.Database.Tables.FKDataBehaviour;
import Common.Database.Tables.iDBTable;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSet;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationSettings.DVMConfigurationSettings;
import java.util.LinkedHashMap;
public class DVMCompilationOptionsDBTable extends iDBTable<DVMCompilationOption> {
public DVMCompilationOptionsDBTable() {
super(DVMCompilationOption.class);
}
}

25
src/_VisualDVM/TestingSystem/DVM/DVMCompilationOptionsSet/DVMCompilationOptionsSet.java Normal file
View File

@@ -0,0 +1,25 @@
package _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet;
import Common.CommonConstants;
import Common.Database.Objects.DBObject;
import Common.Database.Objects.iDBObject;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOption;
import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettings;
import com.sun.org.glassfish.gmbal.Description;
import java.util.Vector;
public class DVMCompilationOptionsSet extends iDBObject {
public int dvmsettings_id = CommonConstants.Nan;
@Description("IGNORE")
public Vector<DVMCompilationOption> options = null;
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
DVMCompilationOptionsSet src_ = (DVMCompilationOptionsSet) src;
dvmsettings_id = src_.dvmsettings_id;
}
public DVMCompilationOptionsSet() {
}
public DVMCompilationOptionsSet(DVMSettings settings_in) {
dvmsettings_id = settings_in.id;
}
}

22
src/_VisualDVM/TestingSystem/DVM/DVMCompilationOptionsSet/DVMCompilationOptionsSetsDBTable.java Normal file
View File

@@ -0,0 +1,22 @@
package _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet;
import Common.Database.Objects.DBObject;
import Common.Database.Tables.FKBehaviour;
import Common.Database.Tables.FKCurrentObjectBehaviuor;
import Common.Database.Tables.FKDataBehaviour;
import Common.Database.Tables.iDBTable;
import Common.Visual.DataSetControlForm;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOption;
import javax.swing.*;
import java.util.LinkedHashMap;
public class DVMCompilationOptionsSetsDBTable extends iDBTable<DVMCompilationOptionsSet> {
public DVMCompilationOptionsSetsDBTable() {
super(DVMCompilationOptionsSet.class);
}
@Override
public LinkedHashMap<Class<? extends DBObject>, FKBehaviour> getFKDependencies() {
LinkedHashMap<Class<? extends DBObject>, FKBehaviour> res = new LinkedHashMap<>();
res.put(DVMCompilationOption.class, new FKBehaviour(FKDataBehaviour.DELETE, FKCurrentObjectBehaviuor.PASSIVE));
return res;
}
}

3
src/_VisualDVM/TestingSystem/DVM/DVMConfiguration/DVMConfiguration.java
View File

@@ -48,8 +48,7 @@ public class DVMConfiguration extends Configuration {
@Override
public void saveSettings(Vector<Settings> settings_in) {
settings = new Vector<>();
for (Settings dvmSettings : settings_in) {
for (Settings dvmSettings : settings_in)
settings.add(new DVMConfigurationSettings(this, (DVMSettings) dvmSettings));
}
}
}

27
src/_VisualDVM/TestingSystem/DVM/DVMEnvironment/DVMEnvironment.java Normal file
View File

@@ -0,0 +1,27 @@
package _VisualDVM.TestingSystem.DVM.DVMEnvironment;
import Common.CommonConstants;
import Common.Database.Objects.DBObject;
import Common.Database.Objects.iDBObject;
import Common.Utils.Utils_;
public class DVMEnvironment extends iDBObject {
public String name = "";
public String value = "";
public int dvmenvironmentsset_id = CommonConstants.Nan;
public DVMEnvironment(String name_in, String value_in) {
name = name_in;
value = value_in;
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
DVMEnvironment src_ = (DVMEnvironment) src;
name = src_.name;
value = src_.value;
dvmenvironmentsset_id = src_.dvmenvironmentsset_id;
}
public DVMEnvironment() {
}
public String print() {
return name + "=" + Utils_.DQuotes(value);
}
}

14
src/_VisualDVM/TestingSystem/DVM/DVMEnvironment/DVMEnvironmentsDBTable.java Normal file
View File

@@ -0,0 +1,14 @@
package _VisualDVM.TestingSystem.DVM.DVMEnvironment;
import Common.Database.Objects.DBObject;
import Common.Database.Tables.FKBehaviour;
import Common.Database.Tables.FKCurrentObjectBehaviuor;
import Common.Database.Tables.FKDataBehaviour;
import Common.Database.Tables.iDBTable;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOption;
import java.util.LinkedHashMap;
public class DVMEnvironmentsDBTable extends iDBTable<DVMEnvironment> {
public DVMEnvironmentsDBTable() {
super(DVMEnvironment.class);
}
}

26
src/_VisualDVM/TestingSystem/DVM/DVMEnvironmentsSet/DVMEnvironmentsSet.java Normal file
View File

@@ -0,0 +1,26 @@
package _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet;
import Common.CommonConstants;
import Common.Database.Objects.DBObject;
import Common.Database.Objects.iDBObject;
import _VisualDVM.TestingSystem.DVM.DVMEnvironment.DVMEnvironment;
import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettings;
import com.sun.org.glassfish.gmbal.Description;
import java.util.Vector;
public class DVMEnvironmentsSet extends iDBObject {
public int dvmsettings_id=CommonConstants.Nan;
@Description("IGNORE")
public Vector<DVMEnvironment> environments = null;
public DVMEnvironmentsSet(DVMSettings dvmSettings){
dvmsettings_id = dvmSettings.id;
}
public DVMEnvironmentsSet(){
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
DVMEnvironmentsSet src_= (DVMEnvironmentsSet) src;
dvmsettings_id = src_.dvmsettings_id;
}
}

20
src/_VisualDVM/TestingSystem/DVM/DVMEnvironmentsSet/DVMEnvironmentsSetsDBTable.java Normal file
View File

@@ -0,0 +1,20 @@
package _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet;
import Common.Database.Objects.DBObject;
import Common.Database.Tables.FKBehaviour;
import Common.Database.Tables.FKCurrentObjectBehaviuor;
import Common.Database.Tables.FKDataBehaviour;
import Common.Database.Tables.iDBTable;
import _VisualDVM.TestingSystem.DVM.DVMEnvironment.DVMEnvironment;
import java.util.LinkedHashMap;
public class DVMEnvironmentsSetsDBTable extends iDBTable<DVMEnvironmentsSet> {
public DVMEnvironmentsSetsDBTable() {
super(DVMEnvironmentsSet.class);
}
@Override
public LinkedHashMap<Class<? extends DBObject>, FKBehaviour> getFKDependencies() {
LinkedHashMap<Class<? extends DBObject>, FKBehaviour> res = new LinkedHashMap<>();
res.put(DVMEnvironment.class, new FKBehaviour(FKDataBehaviour.DELETE, FKCurrentObjectBehaviuor.PASSIVE));
return res;
}
}

4
src/_VisualDVM/TestingSystem/DVM/DVMPackage/DVMPackage.java
View File

@@ -102,9 +102,7 @@ public class DVMPackage extends TestingPackage<DVMPackage_json> {
//--
for (int settings_id : settingsIds) {
DVMSettings dvmSettings = Global.testingServer.db.dvmSettings.get(settings_id);
//---
DVMSettingsCache settingsCache = (DVMSettingsCache) VisualCaches.GetCache(dvmSettings);
Vector<Pair<String, String>> params = settingsCache.getTasksParameters();
Vector<Pair<String, String>> params = Global.testingServer.db.getTasksParameters(dvmSettings);
//--
for (Pair<String, String> p : params) {
//--

8
src/_VisualDVM/TestingSystem/DVM/DVMPackageConfiguration/DVMPackageConfiguration.java
View File

@@ -1,5 +1,6 @@
package _VisualDVM.TestingSystem.DVM.DVMPackageConfiguration;
import Common.CommonConstants;
import Common.Database.Objects.DBObject;
import Common.Database.Objects.iDBObject;
import _VisualDVM.TestingSystem.DVM.DVMConfiguration.DVMConfiguration;
public class DVMPackageConfiguration extends iDBObject {
@@ -12,4 +13,11 @@ public class DVMPackageConfiguration extends iDBObject {
dvmconfiguration_id = configuration_in.id;
description = configuration_in.description;
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
DVMPackageConfiguration src_ = (DVMPackageConfiguration) src;
dvmconfiguration_id = src_.dvmconfiguration_id;
dvmpackage_id =src_.dvmpackage_id;
}
}

6
src/_VisualDVM/TestingSystem/DVM/DVMSettings/DVMSettings.java
View File

@@ -14,9 +14,9 @@ public class DVMSettings extends Settings {
public int min_dim_proc_count = 1;
public int max_dim_proc_count = 4;
//--
@Description("DEFAULT ''")
@Description("IGNORE")
public String packedCompilationOptionsJson = "";
@Description("DEFAULT ''")
@Description("IGNORE")
public String packedRunEnvironmentValuesJson = "";
public DVMSettings() {
}
@@ -28,8 +28,6 @@ public class DVMSettings extends Settings {
super.SynchronizeFields(src);
DVMSettings c = (DVMSettings) src;
Is_DVM_STAT = c.Is_DVM_STAT;
packedCompilationOptionsJson = ((DVMSettings) src).packedCompilationOptionsJson;
packedRunEnvironmentValuesJson = ((DVMSettings) src).packedRunEnvironmentValuesJson;
//-
cube = c.cube;
max_proc_count = c.max_proc_count;

4
src/_VisualDVM/TestingSystem/DVM/DVMSettings/DVMSettingsDBTable.java
View File

@@ -5,7 +5,9 @@ import Common.Database.Tables.FKCurrentObjectBehaviuor;
import Common.Database.Tables.FKDataBehaviour;
import Common.Database.Tables.iDBTable;
import Common.Visual.DataSetControlForm;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSet;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationSettings.DVMConfigurationSettings;
import _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet.DVMEnvironmentsSet;
import _VisualDVM.TestingSystem.DVM.DVMSettings.UI.DVMSettingsForm;
import javax.swing.*;
@@ -30,6 +32,8 @@ public class DVMSettingsDBTable extends iDBTable<DVMSettings> {
public LinkedHashMap<Class<? extends DBObject>, FKBehaviour> getFKDependencies() {
LinkedHashMap<Class<? extends DBObject>, FKBehaviour> res = new LinkedHashMap<>();
res.put(DVMConfigurationSettings.class, new FKBehaviour(FKDataBehaviour.DELETE, FKCurrentObjectBehaviuor.PASSIVE));
res.put(DVMCompilationOptionsSet.class, new FKBehaviour(FKDataBehaviour.DELETE, FKCurrentObjectBehaviuor.PASSIVE));
res.put(DVMEnvironmentsSet.class, new FKBehaviour(FKDataBehaviour.DELETE, FKCurrentObjectBehaviuor.PASSIVE));
return res;
}
}

5
src/_VisualDVM/TestingSystem/DVM/DVMSettings/UI/DVMSettingsDialog.java
View File

@@ -1,6 +1,7 @@
package _VisualDVM.TestingSystem.DVM.DVMSettings.UI;
import Common.Utils.Utils_;
import Common.Visual.Windows.Dialog.DBObjectDialog;
import _VisualDVM.Global;
import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettings;
public class DVMSettingsDialog extends DBObjectDialog<DVMSettings, DVMSettingsFields> {
public DVMSettingsDialog() {
@@ -36,8 +37,8 @@ public class DVMSettingsDialog extends DBObjectDialog<DVMSettings, DVMSettingsFi
fields.sMaxProc.setValue(Result.max_proc_count);
fields.cbDvmStat.setSelected(Result.Is_DVM_STAT != 0);
//---
fields.fillOptionsLines(Result.packedCompilationOptionsJson);
fields.fillEnvironmentsLines(Result.packedRunEnvironmentValuesJson);
fields.fillOptionsLines(Global.testingServer.db.convertOptionsToJson(Result));
fields.fillEnvironmentsLines(Global.testingServer.db.convertEnvironmentsToJson(Result));
}
@Override
public void ProcessResult() {

15
src/_VisualDVM/TestingSystem/DVM/DVMSettings/UI/DVMSettingsFields.java
View File

@@ -7,6 +7,7 @@ import _VisualDVM.GlobalData.CompilerEnvironment.EnvironmentsLinesSet;
import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentsSetJson;
import _VisualDVM.GlobalData.CompilerOption.Json.OptionsSetJson;
import _VisualDVM.GlobalData.CompilerOption.OptionsLinesSet;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSet;
import javax.swing.*;
import java.awt.*;
@@ -22,9 +23,10 @@ public class DVMSettingsFields implements DialogFields {
public JButton bAddEnvironments;
public JButton bDeleteFlags;
public JButton bDeleteEnvironment;
//
//-------------
public OptionsLinesSet optionsLines;
public EnvironmentsLinesSet environmentsLines;
//-------------
private JPanel content;
private JPanel optionsLinesPanel;
private JPanel environmentsLinesPanel;
@@ -37,20 +39,19 @@ public class DVMSettingsFields implements DialogFields {
//-
}
//
public void fillOptionsLines(String packed) {
OptionsSetJson optionsSetJson = packed.isEmpty() ? new OptionsSetJson() : Utils_.gson.fromJson(packed, OptionsSetJson.class);
optionsLines = new OptionsLinesSet(optionsSetJson);
//-
public void fillOptionsLines(OptionsSetJson optionsSetJson) {
//-Это нужно для того, чтобы старый меню бар был пересоздан. бары создаются один раз в целях экономии памяти.
// В противном случае бар его проходы добавления редактирования и удаления
// привязаны к старому источнику данных и возникает БАГ!!!
if (MainModule_.instance.getUI().menuBars.containsKey(OptionsLinesSet.class))
MainModule_.instance.getUI().menuBars.remove(OptionsLinesSet.class);
optionsLines = new OptionsLinesSet(optionsSetJson);
//-
optionsLines.mountUI(optionsLinesPanel);
optionsLines.ShowUI();
}
public void fillEnvironmentsLines(String packed) {
EnvironmentsSetJson environmentsSetJson = packed.isEmpty() ? new EnvironmentsSetJson() : Utils_.gson.fromJson(packed, EnvironmentsSetJson.class);
public void fillEnvironmentsLines(EnvironmentsSetJson environmentsSetJson) {
environmentsLines = new EnvironmentsLinesSet(environmentsSetJson);
//-
if (MainModule_.instance.getUI().menuBars.containsKey(EnvironmentsLinesSet.class))

8
src/_VisualDVM/TestingSystem/SAPFOR/SapforConfigurationSettings/SapforConfigurationSettings.java
View File

@@ -1,5 +1,6 @@
package _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationSettings;
import Common.CommonConstants;
import Common.Database.Objects.DBObject;
import Common.Database.Objects.iDBObject;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
import _VisualDVM.TestingSystem.SAPFOR.SapforSettings.SapforSettings;
@@ -12,4 +13,11 @@ public class SapforConfigurationSettings extends iDBObject {
sapforconfiguration_id = sapforConfiguration.id;
sapforsettings_id = settings.id;
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
SapforConfigurationSettings src_= (SapforConfigurationSettings) src;
sapforconfiguration_id = src_.sapforconfiguration_id;
sapforsettings_id = src_.sapforsettings_id;
}
}

9
src/_VisualDVM/TestingSystem/SAPFOR/SapforPackageConfiguration/SapforPackageConfiguration.java
View File

@@ -1,6 +1,8 @@
package _VisualDVM.TestingSystem.SAPFOR.SapforPackageConfiguration;
import Common.CommonConstants;
import Common.Database.Objects.DBObject;
import Common.Database.Objects.iDBObject;
import _VisualDVM.TestingSystem.DVM.DVMPackageConfiguration.DVMPackageConfiguration;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
public class SapforPackageConfiguration extends iDBObject {
public int sapforpackage_id = CommonConstants.Nan;
@@ -12,4 +14,11 @@ public class SapforPackageConfiguration extends iDBObject {
sapforconfiguration_id = configuration_in.id;
description = configuration_in.description;
}
@Override
public void SynchronizeFields(DBObject src) {
super.SynchronizeFields(src);
SapforPackageConfiguration src_ = (SapforPackageConfiguration) src;
sapforconfiguration_id = src_.sapforconfiguration_id;
sapforpackage_id =src_.sapforpackage_id;
}
}