Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
03/10/20 17:17:37 (4 years ago)
Author:
dpiringe
Message:

#3026:

  • refactored inheritance structure of json items, now the default JsonItem is an abstract class without properties Value and Range -> splitted up into new interfaces
  • updated view models for new json item structure
  • updated SingleLineArrayJsonWriter
Location:
branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface
Files:
12 added
1 deleted
30 edited
2 moved

Legend:

Unmodified
Added
Removed

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ConstrainedValueParameterConverter.cs

    r17433 r17473  
    1919          parameter.ActualValue = x;
    2020
    21       if (parameter.ActualValue is IParameterizedItem && cdata.Children != null) {
     21      if (parameter.ActualValue != null && /*parameter.ActualValue is IParameterizedItem &&*/ cdata.Children != null) {
    2222        foreach(var param in cdata.Children) {
    2323          if(param.Name == parameter.ActualValue.ItemName)
    … …  
    3434        Description = value.ItemDescription,
    3535        Value = parameter.ActualValue?.ToString(),
    36         Range = GetValidValues(parameter).Select(x => x.ToString())
     36        ConcreteRestrictedItems = GetValidValues(parameter).Select(x => x.ToString())
    3737      };
    3838      item.AddChildren(GetParameterizedChilds(parameter));

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/EnumTypeConverter.cs

    r17433 r17473  
    2424        Description = value.ItemDescription,
    2525        Value = Enum.GetName(enumType, val),
    26         Range = Enum.GetNames(enumType)
     26        ConcreteRestrictedItems = Enum.GetNames(enumType)
    2727    };
    2828    }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/MultiCheckedOperatorConverter.cs

    r17439 r17473  
    1919        IJsonItem childItem = GetChildItem(op.Name, data);
    2020        if(childItem != null) {
    21           if(childItem.Value is bool b) {
    22             val.Operators.SetItemCheckedState(op, b);
     21          if(childItem is BoolJsonItem boolJsonItem) {
     22            val.Operators.SetItemCheckedState(op, boolJsonItem.Value);
    2323          }
    2424          root.Inject((IItem)op, childItem, root);
    … …  
    3434          Name = op.Name,
    3535          Description = op.Description,
    36           Value = val.Operators.ItemChecked(op),
    37           Range = new bool[] { false, true }
     36          Value = val.Operators.ItemChecked(op)
    3837        };
    3938        IJsonItem c = root.Extract((IItem)op, root);
    … …  
    4948    private bool GetOperatorState(string name, IJsonItem data) {
    5049      foreach(var op in data.Children) {
    51         if (op.Name == name && op.Value is bool) return (bool)op.Value;
     50        if (op.Name == name && op is BoolJsonItem b) return b.Value;
    5251      }
    5352      return false;
    … …  
    5554
    5655    private IJsonItem GetChildItem(string name, IJsonItem parent) {
     56      if (parent.Children == null) return null;
    5757      foreach(var c in parent.Children) {
    5858        if (c.Name == name) return c;

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ParameterizedItemConverter.cs

    r17433 r17473  
    2424      var parameterizedItem = value as IParameterizedItem;
    2525
    26       IJsonItem item = new JsonItem() {
     26      IJsonItem item = new EmptyJsonItem() {
    2727        Name = value.ItemName,
    2828        Description = value.ItemDescription

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/RegressionProblemDataConverter.cs

    r17471 r17473  
    3131      var dataInfo = dataset.GetType().GetField("variableValues", flags);
    3232      dataInfo.SetValue(dataset, dictTmp);
    33       val.TargetVariable = (string)data.Children[3].Value;
    34       val.TrainingPartition.Start = ((IntRangeJsonItem)data.Children[2]).Value.First();
    35       val.TrainingPartition.End = ((IntRangeJsonItem)data.Children[2]).Value.Last();
    36       val.TestPartition.Start = ((IntRangeJsonItem)data.Children[1]).Value.First();
    37       val.TestPartition.End = ((IntRangeJsonItem)data.Children[1]).Value.Last();
     33      val.TargetVariable = ((StringJsonItem)data.Children[3]).Value;
     34      val.TrainingPartition.Start = ((IntRangeJsonItem)data.Children[2]).MinValue;
     35      val.TrainingPartition.End = ((IntRangeJsonItem)data.Children[2]).MaxValue;
     36      val.TestPartition.Start = ((IntRangeJsonItem)data.Children[1]).MinValue;
     37      val.TestPartition.End = ((IntRangeJsonItem)data.Children[1]).MaxValue;
    3838    }
    3939
    4040    public override IJsonItem Extract(IItem value, IJsonItemConverter root) {
    41       IJsonItem item = new JsonItem() {
     41      IJsonItem item = new EmptyJsonItem() {
    4242        Name = value.ItemName,
    4343        Description = value.ItemDescription
    … …  
    7171          Name = "Dataset",
    7272          Value = mat,
    73           RowNames = rowNames
     73          RowNames = rowNames,
     74          Minimum = double.MinValue,
     75          Maximum = double.MaxValue
    7476        });
    7577      }
    … …  
    8082      item.AddChildren(new IntRangeJsonItem() {
    8183        Name = "TestPartition",
    82         Value = new int[] { testPartition.Start, testPartition.End },
    83         Range = new int[] { 0, Math.Max(testPartition.End, trainingPartition.End) }
     84        MinValue = testPartition.Start,
     85        MaxValue = testPartition.End,
     86        Minimum = 0,
     87        Maximum = Math.Max(testPartition.End, trainingPartition.End)
    8488      });
    8589
    … …  
    8791      item.AddChildren(new IntRangeJsonItem() {
    8892        Name = "TrainingPartition",
    89         Value = new int[] { trainingPartition.Start, trainingPartition.End },
    90         Range = new int[] { 0, Math.Max(testPartition.End, trainingPartition.End)}
     93        MinValue = trainingPartition.Start,
     94        MaxValue = trainingPartition.End,
     95        Minimum = 0,
     96        Maximum = Math.Max(testPartition.End, trainingPartition.End)
    9197      });
    9298
    9399      IEnumerable<StringValue> variables = (IEnumerable<StringValue>)val.InputVariables;
    94       item.AddChildren(new JsonItem() {
     100      item.AddChildren(new StringJsonItem() {
    95101        Name = "TargetVariable",
    96         Value = (object)targetVariable,
    97         Range = variables.Select(x => x.Value)
     102        Value = (string)targetVariable,
     103        ConcreteRestrictedItems = variables.Select(x => x.Value)
    98104      });
    99105

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ResultParameterConverter.cs

    r17471 r17473  
    1717      return new ResultJsonItem() {
    1818        Name = res.ActualName,
    19         Value = res.ActualName,
    2019        Description = res.Description
    2120      };
    … …  
    2423    public override void Inject(IItem item, IJsonItem data, IJsonItemConverter root) {
    2524      IResultParameter res = item as IResultParameter;
    26       res.ActualName = (string)data.Value;
     25      res.ActualName = data.Name;
    2726    }
    2827  }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/StringValueConverter.cs

    r17443 r17473  
    1717    public override IJsonItem Extract(IItem value, IJsonItemConverter root) =>
    1818      new StringJsonItem() {
    19         Name = "[OverridableParamName]",
     19        //Name = "[OverridableParamName]",
     20        Name = value.ItemName,
    2021        Description = value.ItemDescription,
    2122        Value = ((StringValue)value).Value

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueLookupParameterConverter.cs

    r17471 r17473  
    1313    public override void Inject(IItem item, IJsonItem data, IJsonItemConverter root) {
    1414      IValueLookupParameter param = item as IValueLookupParameter;
    15       param.ActualName = CastValue<string>(((IValueLookupJsonItem)data).ActualName);
     15      IValueLookupJsonItem lookupItem = data as IValueLookupJsonItem;
     16      param.ActualName = lookupItem.ActualName;
    1617      if (param.Value != null)
    17         root.Inject(param.Value, data, root);
     18        root.Inject(param.Value, lookupItem.JsonItemReference, root);
    1819    }
    1920
    … …  
    2526      if (param.Value != null) {
    2627        IJsonItem tmp = root.Extract(param.Value, root);
    27         item.Value = tmp.Value;
    28         item.Range = tmp.Range;
    29         item.Name = tmp.Name;
    30         item.Description = tmp.Description;
    3128        item.AddChildren(tmp.Children);
    32         item.Active = tmp.Active;
    3329        item.JsonItemReference = tmp;
    34       } else {
    35         var min = GetMinValue(param.DataType);
    36         var max = GetMaxValue(param.DataType);
    37         if (min != null && max != null)
    38           item.Range = new object[] { min, max };
    39         else
    40           item.Range = null;
    4130      }
    4231      item.Name = param.Name;

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueParameterConverter.cs

    r17439 r17473  
    1414      IParameter parameter = value as IParameter;
    1515
    16       if (parameter.ActualValue == null && data.Value != null)
     16      if (parameter.ActualValue == null)
    1717        parameter.ActualValue = Instantiate(parameter.DataType);
    1818
    … …  
    2121            root.Inject(parameter.ActualValue, data, root);
    2222          else
    23             root.Inject(parameter.ActualValue, data.Children?.First(), root);
     23            root.Inject(parameter.ActualValue, /*data.Children?.First()*/ data, root);
    2424         
    2525      }
    … …  
    2929      IParameter parameter = value as IParameter;
    3030
    31       IJsonItem item = new JsonItem() {
     31      IJsonItem item = new EmptyJsonItem() {
    3232        Name = parameter.Name,
    3333        Description = parameter.Description
    … …  
    3737        IJsonItem tmp = root.Extract(parameter.ActualValue, root);
    3838        if (!(tmp is UnsupportedJsonItem)) {
     39          tmp.Name = parameter.Name;
     40          tmp.Description = parameter.Description;
     41          item = tmp;
     42          /*
    3943          if (tmp.Name == "[OverridableParamName]") {
    4044            tmp.Name = parameter.Name;
    … …  
    4448          } else
    4549            item.AddChildren(tmp);
     50            */
    4651        }
    4752      }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueRangeConverter.cs

    r17451 r17473  
    1818      IntRange range = item as IntRange;
    1919      IntRangeJsonItem cdata = data as IntRangeJsonItem;
    20       range.Start = cdata.Value[0];
    21       range.End = cdata.Value[1];
     20      range.Start = cdata.MinValue;
     21      range.End = cdata.MaxValue;
    2222    }
    2323
    … …  
    2525      IntRange range = value as IntRange;
    2626      return new IntRangeJsonItem() {
    27         Name = "[OverridableParamName]",
     27        //Name = "[OverridableParamName]",
     28        Name = value.ItemName,
    2829        Description = value.ItemDescription,
    29         Value = new int[] { range.Start, range.End },
    30         Range = new int[] { int.MinValue, int.MaxValue }
     30        MinValue = range.Start,
     31        MaxValue = range.End,
     32        Minimum = int.MinValue,
     33        Maximum = int.MaxValue
    3134      };
    3235    }
    … …  
    4043      DoubleRange range = item as DoubleRange;
    4144      DoubleRangeJsonItem cdata = data as DoubleRangeJsonItem;
    42       range.Start = cdata.Value[0];
    43       range.End = cdata.Value[1];
     45      range.Start = cdata.MinValue;
     46      range.End = cdata.MaxValue;
    4447    }
    4548
    … …  
    4750      DoubleRange range = value as DoubleRange;
    4851      return new DoubleRangeJsonItem() {
    49         Name = "[OverridableParamName]",
     52        //Name = "[OverridableParamName]",
     53        Name = value.ItemName,
    5054        Description = value.ItemDescription,
    51         Value = new double[] { range.Start, range.End },
    52         Range = new double[] { double.MinValue, double.MaxValue }
     55        MinValue = range.Start,
     56        MaxValue = range.End,
     57        Minimum = double.MinValue,
     58        Maximum = double.MaxValue
    5359      };
    5460    }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueTypeArrayConverter.cs

    r17451 r17473  
    3030        Description = value.ItemDescription,
    3131        Value = ((IntArray)value).CloneAsArray(),
    32         Range = new int[] { int.MinValue, int.MaxValue }
     32        Minimum = int.MinValue,
     33        Maximum = int.MaxValue
    3334      };
    3435  }
    … …  
    5657        Description = value.ItemDescription,
    5758        Value = ((DoubleArray)value).CloneAsArray(),
    58         Range = new double[] { double.MinValue, double.MaxValue }
     59        Minimum = double.MinValue,
     60        Maximum = double.MaxValue
    5961      };
    6062  }
    … …  
    8082        Description = value.ItemDescription,
    8183        Value = ((PercentArray)value).CloneAsArray(),
    82         Range = new double[] { 0.0d, 1.0d }
     84        Minimum = 0.0d,
     85        Maximum = 1.0d
    8386      };
    8487  }
    … …  
    101104    public override IJsonItem Extract(IItem value, IJsonItemConverter root) =>
    102105      new BoolArrayJsonItem() {
    103         Name = "[OverridableParamName]",
     106        //Name = "[OverridableParamName]",
     107        Name = value.ItemName,
    104108        Description = value.ItemDescription,
    105         Value = ((BoolArray)value).CloneAsArray(),
    106         Range = new bool[] { false, true }
     109        Value = ((BoolArray)value).CloneAsArray()
    107110      };
    108111  }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueTypeMatrixConverter.cs

    r17471 r17473  
    2323        Description = value.ItemDescription,
    2424        Value = Transform((IntMatrix)value),
    25         Range = new int[] { int.MinValue, int.MaxValue }
     25        Minimum = int.MinValue,
     26        Maximum = int.MaxValue
    2627      };
    2728  }
    … …  
    4243        Description = value.ItemDescription,
    4344        Value = Transform((DoubleMatrix)value),
    44         Range = new double[] { double.MinValue, double.MaxValue },
     45        Minimum = double.MinValue,
     46        Maximum = double.MaxValue,
    4547        RowNames = ((DoubleMatrix)value).RowNames,
    4648        ColumnNames = ((DoubleMatrix)value).ColumnNames
    … …  
    6365        Description = value.ItemDescription,
    6466        Value = Transform((PercentMatrix)value),
    65         Range = new double[] { 0.0d, 1.0d }
     67        Minimum = 0.0d,
     68        Maximum = 1.0d
    6669      };
    6770  }
    … …  
    7982    public override IJsonItem Extract(IItem value, IJsonItemConverter root) =>
    8083      new BoolMatrixJsonItem() {
    81         Name = "[OverridableParamName]",
     84        //Name = "[OverridableParamName]",
     85        Name = value.ItemName,
    8286        Description = value.ItemDescription,
    83         Value = Transform((BoolMatrix)value),
    84         Range = new bool[] { false, true }
     87        Value = Transform((BoolMatrix)value)
    8588      };
    8689  }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueTypeValueConverter.cs

    r17433 r17473  
    1818    public override IJsonItem Extract(IItem value, IJsonItemConverter root) =>
    1919      new IntJsonItem() {
    20         Name = "[OverridableParamName]",
     20        //Name = "[OverridableParamName]",
     21        Name = value.ItemName,
    2122        Description = value.ItemDescription,
    2223        Value = ((IntValue)value).Value,
    23         Range = new int[] { int.MinValue, int.MaxValue }
     24        Minimum = int.MinValue,
     25        Maximum = int.MaxValue
    2426      };
    2527  }
    … …  
    3436    public override IJsonItem Extract(IItem value, IJsonItemConverter root) =>
    3537      new DoubleJsonItem() {
    36         Name = "[OverridableParamName]",
     38        //Name = "[OverridableParamName]",
     39        Name = value.ItemName,
    3740        Description = value.ItemDescription,
    3841        Value = ((DoubleValue)value).Value,
    39         Range = new double[] { double.MinValue, double.MaxValue }
     42        Minimum = double.MinValue,
     43        Maximum = double.MaxValue
    4044      };
    4145  }
    … …  
    5054    public override IJsonItem Extract(IItem value, IJsonItemConverter root) =>
    5155      new DoubleJsonItem() {
    52         Name = "[OverridableParamName]",
     56        //Name = "[OverridableParamName]",
     57        Name = value.ItemName,
    5358        Description = value.ItemDescription,
    5459        Value = ((PercentValue)value).Value,
    55         Range = new double[] { double.MinValue, double.MaxValue }
     60        Minimum = double.MinValue,
     61        Maximum = double.MaxValue
    5662      };
    5763  }
    … …  
    6672    public override IJsonItem Extract(IItem value, IJsonItemConverter root) =>
    6773      new BoolJsonItem() {
    68         Name = "[OverridableParamName]",
     74        //Name = "[OverridableParamName]",
     75        Name = value.ItemName,
    6976        Description = value.ItemDescription,
    70         Value = ((BoolValue)value).Value,
    71         Range = new bool[] { false, true }
     77        Value = ((BoolValue)value).Value
    7278      };
    7379  }
    … …  
    8288    public override IJsonItem Extract(IItem value, IJsonItemConverter root) =>
    8389      new DateTimeJsonItem() {
    84         Name = "[OverridableParamName]",
     90        //Name = "[OverridableParamName]",
     91        Name = value.ItemName,
    8592        Description = value.ItemDescription,
    8693        Value = ((DateTimeValue)value).Value,
    87         Range = new DateTime[] { DateTime.MinValue, DateTime.MaxValue }
     94        Minimum = DateTime.MinValue,
     95        Maximum = DateTime.MaxValue
    8896      };
    8997  }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/HeuristicLab.JsonInterface.csproj

    r17471 r17473  
    6868    <Compile Include="Converters\ValueRangeConverter.cs" />
    6969    <Compile Include="Interfaces\IArrayJsonItem.cs" />
     70    <Compile Include="Interfaces\IConcreteRestrictedJsonItem.cs" />
     71    <Compile Include="Interfaces\IIntervalRestrictedJsonItem.cs" />
    7072    <Compile Include="Interfaces\IJsonItem.cs" />
    7173    <Compile Include="Interfaces\IJsonItemValidator.cs" />
    7274    <Compile Include="Interfaces\ILookupJsonItem.cs" />
    7375    <Compile Include="Interfaces\IMatrixJsonItem.cs" />
     76    <Compile Include="Interfaces\IRangedJsonItem.cs" />
    7477    <Compile Include="Interfaces\IResultJsonItem.cs" />
     78    <Compile Include="Interfaces\IValueJsonItem.cs" />
    7579    <Compile Include="Interfaces\IValueLookupJsonItem.cs" />
    76     <Compile Include="Models\ArrayJsonItemBase.cs" />
     80    <Compile Include="Models\ArrayJsonItem.cs" />
    7781    <Compile Include="Models\BoolJsonItems.cs" />
     82    <Compile Include="Models\ConcreteRestrictedArrayJsonItem.cs" />
     83    <Compile Include="Models\ConcreteRestrictedValueJsonItem.cs" />
    7884    <Compile Include="Models\DateTimeJsonItem.cs" />
    7985    <Compile Include="Models\DoubleJsonItems.cs" />
    80     <Compile Include="Models\GenericJsonItem.cs" />
     86    <Compile Include="Models\EmptyJsonItem.cs" />
     87    <Compile Include="Models\IntervalRestrictedArrayJsonItem.cs" />
     88    <Compile Include="Models\IntervalRestrictedMatrixJsonItem.cs" />
     89    <Compile Include="Models\IntervalRestrictedValueJsonItem.cs" />
    8190    <Compile Include="Models\IntJsonItems.cs" />
    8291    <Compile Include="Models\JsonItem.cs" />
    8392    <Compile Include="Models\LookupJsonItem.cs" />
    84     <Compile Include="Models\MatrixJsonItemBase.cs" />
     93    <Compile Include="Models\MatrixJsonItem.cs" />
     94    <Compile Include="Models\RangedJsonItem.cs" />
    8595    <Compile Include="Models\ResultJsonItem.cs" />
    8696    <Compile Include="Models\StringJsonItem.cs" />
    8797    <Compile Include="Models\UnsupportedJsonItem.cs" />
     98    <Compile Include="Models\ValueJsonItem.cs" />
    8899    <Compile Include="Models\ValueLookupJsonItem.cs" />
    89100    <Compile Include="SingleLineArrayJsonWriter.cs" />

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Interfaces/IArrayJsonItem.cs

    r17446 r17473  
    66
    77namespace HeuristicLab.JsonInterface {
    8   public interface IArrayJsonItem : IJsonItem {
     8  public interface IArrayJsonItem : IValueJsonItem {
    99    bool Resizable { get; set; }
    1010  }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Interfaces/IJsonItem.cs

    r17471 r17473  
    2424    IJsonItem Parent { get; set; }
    2525
    26     object Value { get; set; }
     26    //object Value { get; set; }
    2727
    28     IEnumerable<object> Range { get; set; }
     28    //IEnumerable<object> Range { get; set; }
    2929   
    3030    IJsonItemValidator GetValidator();

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Interfaces/IMatrixJsonItem.cs

    r17471 r17473  
    66
    77namespace HeuristicLab.JsonInterface {
    8   public interface IMatrixJsonItem : IJsonItem {
     8  public interface IMatrixJsonItem : IValueJsonItem {
    99    bool RowsResizable { get; set; }
    1010    bool ColumnsResizable { get; set; }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/JCGenerator.cs

    r17471 r17473  
    6262      IEnumerable<IJsonItem> children = item.Children;
    6363     
    64       if (item.Active && (item.Value != null || item.Range != null || item is IResultJsonItem || item is ILookupJsonItem)) {
     64      if (item.Active && !(item is EmptyJsonItem)) {
    6565        jsonItems.Add(item);
    6666      }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/JsonTemplateInstantiator.cs

    r17446 r17473  
    105105        instData.Objects.Add(tmp.Path, tmp);
    106106      }
     107      //IList<IJsonItem> faultyItems = new List<IJsonItem>();
     108      //root.GetValidator().Validate(ref faultyItems);
    107109    }
    108110   
    … …  
    113115        // override default value
    114116        if (instData.Objects.TryGetValue(path, out IJsonItem param)) {
    115           // save range from template
    116           IEnumerable<object> tmpRange = param.Range;
     117          // remove fixed template parameter => dont allow to copy them from concrete config
     118          obj.Property(nameof(IIntervalRestrictedJsonItem<int>.Minimum))?.Remove();
     119          obj.Property(nameof(IIntervalRestrictedJsonItem<int>.Maximum))?.Remove();
     120          obj.Property(nameof(IConcreteRestrictedJsonItem<string>.ConcreteRestrictedItems))?.Remove();
     121          // merge
    117122          param.SetFromJObject(obj);
    118           // set range from template
    119           param.Range = tmpRange;
    120123        } else throw new InvalidDataException($"No parameter with path='{path}' defined!");
    121124      }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/ArrayJsonItem.cs

    r17472 r17473  
    77
    88namespace HeuristicLab.JsonInterface {
    9   public class ArrayJsonItemBase<T> : JsonItem<T[], T>, IArrayJsonItem {
     9  public abstract class ArrayJsonItem<T> : ValueJsonItem<T[]>, IArrayJsonItem {
    1010    public virtual bool Resizable { get; set; }
    1111    public override void SetFromJObject(JObject jObject) {

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/BoolJsonItems.cs

    r17446 r17473  
    66
    77namespace HeuristicLab.JsonInterface {
    8   public class BoolJsonItem : JsonItem<bool> { }
     8  public class BoolJsonItem : ValueJsonItem<bool> {
     9    protected override bool Validate() => true;
     10  }
    911
    10   public class BoolArrayJsonItem : ArrayJsonItemBase<bool> { }
     12  public class BoolArrayJsonItem : ArrayJsonItem<bool> {
     13    protected override bool Validate() => true;
     14  }
    1115
    12   public class BoolMatrixJsonItem : MatrixJsonItemBase<bool> { }
     16  public class BoolMatrixJsonItem : MatrixJsonItem<bool> {
     17    protected override bool Validate() => true;
     18  }
    1319}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/DateTimeJsonItem.cs

    r17446 r17473  
    66
    77namespace HeuristicLab.JsonInterface {
    8   public class DateTimeJsonItem : JsonItem<DateTime> { }
     8  public class DateTimeJsonItem : IntervalRestrictedValueJsonItem<DateTime> {
     9    protected override bool Validate() => Minimum.CompareTo(Value) >= 0 && Maximum.CompareTo(Value) <= 0;
     10  }
    911}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/DoubleJsonItems.cs

    r17471 r17473  
    66
    77namespace HeuristicLab.JsonInterface {
    8   public class DoubleJsonItem : JsonItem<double> { }
    9   public class DoubleArrayJsonItem : ArrayJsonItemBase<double> { }
    10   public class DoubleRangeJsonItem : ArrayJsonItemBase<double> {
    11     public override bool Resizable { get => false; set { } }
    12   }
     8  public class DoubleJsonItem : IntervalRestrictedValueJsonItem<double> { }
     9  public class DoubleArrayJsonItem : IntervalRestrictedArrayJsonItem<double> { }
     10  public class DoubleRangeJsonItem : RangedJsonItem<double> { }
    1311
    14   public class DoubleMatrixJsonItem : MatrixJsonItemBase<double> {
     12  public class DoubleMatrixJsonItem : IntervalRestrictedMatrixJsonItem<double> {
     13    /*
    1514    protected override bool IsInRange() {
    1615      for (int c = 0; c < Value.Length; ++c) {
    … …  
    2221      return true;
    2322    }
     23    */
    2424  }
    2525}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/IntJsonItems.cs

    r17471 r17473  
    66
    77namespace HeuristicLab.JsonInterface {
    8   public class IntJsonItem : JsonItem<int> {
    9     //public new IEnumerable<int> Range { get; }
     8  public class IntJsonItem : IntervalRestrictedValueJsonItem<int> { }
     9  public class IntArrayJsonItem : IntervalRestrictedArrayJsonItem<int> { }
     10  public class IntRangeJsonItem : RangedJsonItem<int> { }
     11  public class IntMatrixJsonItem : IntervalRestrictedMatrixJsonItem<int> {
    1012    /*
    11     public int MinValue { get; set; }
    12     public int MaxValue { get; set; }
    13     */
    14   }
    15   public class IntArrayJsonItem : ArrayJsonItemBase<int> { }
    16   public class IntRangeJsonItem : ArrayJsonItemBase<int> {
    17     public override bool Resizable { get => false; set { } }
    18   }
    19   public class IntMatrixJsonItem : MatrixJsonItemBase<int> {
    20 
    2113    protected override bool IsInRange() {
    2214      for (int c = 0; c < Value.Length; ++c) {
    … …  
    2820      return true;
    2921    }
     22    */
    3023  }
    3124}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/JsonItem.cs

    r17471 r17473  
    1111  /// Main data class for json interface.
    1212  /// </summary>
    13   public class JsonItem : IJsonItem {
     13  public abstract class JsonItem : IJsonItem {
    1414
    1515    public class JsonItemValidator : IJsonItemValidator {
    … …  
    2525      }
    2626
     27      // TODO: return ValidationResult ?
    2728      private bool ValidateHelper(JsonItem item, ref IList<IJsonItem> faultyItems) {
    2829        int hash = item.GetHashCode();
    … …  
    3031          return r;
    3132
    32         bool res = true;
    33         if (item.Value != null && item.Range != null)
    34           res = item.IsInRange();
     33        bool res = item.Validate();
    3534        if (!res) faultyItems.Add(item);
    3635        Cache.Add(hash, res);
    37         if(item.Children != null)
     36        if(item.Children != null) {
    3837          foreach (var child in item.Children)
    39             res = res && ValidateHelper(child as JsonItem, ref faultyItems);
     38            if (!ValidateHelper(child as JsonItem, ref faultyItems))
     39              res = false && res;
     40        }
    4041        return res;
    4142      }
    … …  
    6263    }
    6364
    64     public virtual object Value { get; set; }
     65    //public virtual object Value { get; set; }
    6566
    66     public virtual IEnumerable<object> Range { get; set; }
     67    //public virtual IEnumerable<object> Range { get; set; }
    6768   
    6869    // TODO jsonIgnore dataType?
    … …  
    105106
    106107    public virtual void SetFromJObject(JObject jObject) {
    107       Value = jObject[nameof(IJsonItem.Value)]?.ToObject<object>();
    108       Range = jObject[nameof(IJsonItem.Range)]?.ToObject<object[]>();
     108      //Value = jObject[nameof(IJsonItem.Value)]?.ToObject<object>();
     109      //Range = jObject[nameof(IJsonItem.Range)]?.ToObject<object[]>();
    109110    }
    110111    #endregion
    … …  
    114115     * TODO protected abstract bool Validate();
    115116     */
    116      
     117    protected abstract bool Validate();
     118    /*
    117119    protected virtual bool IsInRange() {
    118120      bool b1 = true, b2 = true;
    … …  
    156158        (((T)max).CompareTo(value) == 1 || ((T)max).CompareTo(value) == 0);
    157159    }
     160    */
    158161    #endregion
    159162  }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/LookupJsonItem.cs

    r17471 r17473  
    1414      ActualName = jObject[nameof(ILookupJsonItem.ActualName)]?.ToString();
    1515    }
     16
     17    protected override bool Validate() => true;
    1618  }
    1719}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/MatrixJsonItem.cs

    r17472 r17473  
    77
    88namespace HeuristicLab.JsonInterface {
    9   public class MatrixJsonItemBase<T> : JsonItem<T[][], T>, IMatrixJsonItem {
     9  public abstract class MatrixJsonItem<T> : ValueJsonItem<T[][]>, IMatrixJsonItem {
    1010    public virtual bool RowsResizable { get; set; }
    1111    public virtual bool ColumnsResizable { get; set; }

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/ResultJsonItem.cs

    r17471 r17473  
    77namespace HeuristicLab.JsonInterface {
    88  public class ResultJsonItem : JsonItem, IResultJsonItem {
    9 
     9    protected override bool Validate() => true;
    1010  }
    1111}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/StringJsonItem.cs

    r17451 r17473  
    66
    77namespace HeuristicLab.JsonInterface {
    8   public class StringJsonItem : JsonItem<string> { }
    9   public class StringArrayJsonItem : JsonItem<string[], string> { }
     8  public class StringJsonItem : ConcreteRestrictedValueJsonItem<string> { }
     9  public class StringArrayJsonItem : ConcreteRestrictedArrayJsonItem<string> { }
    1010}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/UnsupportedJsonItem.cs

    r17471 r17473  
    3434    }
    3535
    36     public override object Value {
    37       get => throw new NotSupportedException();
    38       set => throw new NotSupportedException();
    39     }
    40 
    41     public override IEnumerable<object> Range {
    42       get => throw new NotSupportedException();
    43       set => throw new NotSupportedException();
    44     }
     36    protected override bool Validate() => true;
    4537  }
    4638}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Models/ValueLookupJsonItem.cs

    r17471 r17473  
    1010    [JsonIgnore]
    1111    public IJsonItem JsonItemReference { get; set; }
     12
     13    protected override bool Validate() {
     14      if (JsonItemReference == null) return true;
     15      IList<IJsonItem> faultyItems = new List<IJsonItem>();
     16      return JsonItemReference.GetValidator().Validate(ref faultyItems);
     17    }
    1218  }
    1319}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/SingleLineArrayJsonWriter.cs

    r17442 r17473  
    1919      base.Formatting = Formatting.Indented;
    2020      base.WritePropertyName(name);
    21       isRangeArray = name == nameof(IJsonItem.Range) || name == nameof(IJsonItem.Value);
     21      isRangeArray =
     22        name == nameof(IConcreteRestrictedJsonItem<int>.ConcreteRestrictedItems) ||
     23        name == nameof(IValueJsonItem.Value) ||
     24        name == nameof(IMatrixJsonItem.RowNames) ||
     25        name == nameof(IMatrixJsonItem.ColumnNames);
    2226    }
    2327
Note: See TracChangeset for help on using the changeset viewer.