Changeset 17269


Ignore:
Timestamp:
09/25/19 17:18:41 (3 years ago)
Author:
dpiringe
Message:

#3026

  • deleted IItemExtensions.cs
  • fixed a bug in GetInterfaceDistance in TypeExtensions.cs -> generic types were ignored
  • lots of code clean ups
  • added new transformers: ParameterizedItemTransformer, MultiCheckedOperatorTransformer
Location:
branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture
Files:
2 added
1 deleted
10 edited

Legend:

Unmodified
Added
Removed

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Extensions/TypeExtensions.cs

    r17266 r17269  
    44using System.Text;
    55using System.Threading.Tasks;
     6using HeuristicLab.Core;
    67
    78namespace HeuristicLab.Manufacture {
    … …  
    910    public static int GetInterfaceDistance(this Type type, Type interfaceType) {
    1011      if (!interfaceType.IsInterface) return -1;
    11       int distance = 0;
     12      int distance = int.MaxValue;
    1213      Type baseType = type;
    1314      while (baseType != typeof(object)) {
    1415        var interfaces = baseType.GetInterfaces();
    1516        var minimalInterfaces = interfaces.Except(interfaces.SelectMany(i => i.GetInterfaces()));
    16         if (baseType == interfaceType && minimalInterfaces.Any(i => i == interfaceType))
    17           ++distance;
     17        if (minimalInterfaces.Any(i => {
     18          if (i.IsGenericType)
     19            return i.GetGenericTypeDefinition() == interfaceType;
     20          return i == interfaceType;
     21        })) --distance;
    1822        baseType = baseType.BaseType;
    1923      }
    2024      return distance;
    2125    }
     26
    2227    public static bool IsEqualTo(this Type type, Type other) {
    2328      if (other == null) throw new ArgumentNullException("other");
    … …  
    3035            .Any(i => i.GetGenericTypeDefinition() == other);
    3136      else if (other.IsInterface) {
    32         /*
    33         Type baseType = type;
    34         while (baseType != typeof(object)) {
    35           var interfaces = baseType.GetInterfaces();
    36           var minimalInterfaces = interfaces.Except(interfaces.SelectMany(i => i.GetInterfaces()));
    37           if (baseType == other && minimalInterfaces.Any(i => i == other))
    38             return true;
    39           baseType = baseType.BaseType;
    40         }
    41         */
    4237        return type.GetInterfaces().Any(i => i == other);
    4338      }

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

    r17266 r17269  
    5151  </ItemGroup>
    5252  <ItemGroup>
    53     <Compile Include="Extensions\IItemExtensions.cs" />
    5453    <Compile Include="Extensions\ObjectExtensions.cs" />
    5554    <Compile Include="Extensions\TypeExtensions.cs" />
    … …  
    5857    <Compile Include="ParameterTransformer\ConstrainedValueParameterTransformer.cs" />
    5958    <Compile Include="ParameterTransformer\ParameterBaseTransformer.cs" />
     59    <Compile Include="ParameterTransformer\ParameterizedItemTransformer.cs" />
    6060    <Compile Include="ParameterTransformer\ValueParameterTransformer.cs" />
    6161    <Compile Include="TypeTransformer\EnumTypeTransformer.cs" />
    6262    <Compile Include="TypeTransformer\DummyTransformer.cs" />
    6363    <Compile Include="ParameterTransformer\LookupParameterTransformer.cs" />
     64    <Compile Include="TypeTransformer\MultiCheckedOperatorTransformer.cs" />
    6465    <Compile Include="TypeTransformer\StringValueTransformer.cs" />
    6566    <Compile Include="TypeTransformer\ValueTypeArrayTransformer.cs" />

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

    r17266 r17269  
    1616
    1717  public class CustomWriter : JsonTextWriter {
     18    private const int ArrayFlatterLvl = 1;
    1819    private Stack<Formatting> formattings = new Stack<Formatting>();
    1920    private int lvl = 0;
    2021    public override void WriteStartArray() {
    2122      base.WriteStartArray();
    22       if(lvl > 1) {
     23      if(lvl > ArrayFlatterLvl) {
    2324        formattings.Push(base.Formatting);
    2425        base.Formatting = Formatting.None;
    … …  
    3031      base.WriteEndArray();
    3132      lvl--;
    32       if (lvl > 1)
     33      if (lvl > ArrayFlatterLvl)
    3334        base.Formatting = formattings.Pop();
    3435    }
    … …  
    4950
    5051    private JObject template = JObject.Parse(@"{
    51       'Metadata': {},
    52       'FreeParameters': {},
    53       'StaticParameters': {
    54         'Algorithm':{},
    55         'Problem':{},
    56         'TypeList':{}
    57       }
     52      'Metadata': {
     53        'Algorithm':'',
     54        'Problem':''
     55      },
     56      'Objects': []
    5857    }");
    5958
    6059   
    6160    private Dictionary<string, string> TypeList = new Dictionary<string, string>();
    62 
     61   
    6362    public string GenerateTemplate(IAlgorithm algorithm, IProblem problem, params string[] freeParameters) {
    6463      algorithm.Problem = problem;
    65       IList<JCObject> items = BJCO(algorithm);
     64      ParameterData algorithmData = Transformer.Extract(algorithm);
     65      ParameterData problemData = Transformer.Extract(problem);
     66      IList<ParameterData> items = algorithmData.ParameterizedItems;
     67      foreach (var pItem in problemData.ParameterizedItems) items.Add(pItem);
    6668      JArray jsonItems = new JArray();
    6769     
    68       foreach(var item in items) {
     70      foreach(var item in items.Distinct()) {
    6971        JToken token = JObject.FromObject(item, Settings());
    70 
     72        token["StaticParameters"] = token["Parameters"];
     73        token["FreeParameters"] = token["Parameters"];
     74        token.Cast<JObject>().Property("Parameters")?.Remove();
    7175        RefactorFreeParameters(token, freeParameters);
    7276        RefactorStaticParameters(token);
    7377        if(token["StaticParameters"].HasValues || token["FreeParameters"].HasValues)
    7478          jsonItems.Add(token);
    75       }
    76       return CustomWriter.Serialize(jsonItems);
     79      }
     80
     81      template["Metadata"]["Algorithm"] = algorithm.Name;
     82      template["Metadata"]["Problem"] = problem.Name;
     83      template["Objects"] = jsonItems;
     84
     85      return CustomWriter.Serialize(template);
    7786    }
    7887
     88    #region Helper
    7989    private void RefactorFreeParameters(JToken token, string[] freeParameters) {
    8090
    81       token["FreeParameters"] = token["StaticParameters"];
     91      //token["FreeParameters"] = token["StaticParameters"];
    8292
    8393      IList<JObject> objToRemove = new List<JObject>();
    … …  
    98108      }, token["FreeParameters"]);
    99109      foreach (var x in objToRemove) x.Remove();
    100      
     110
    101111    }
    102112
    … …  
    110120      foreach (var x in objToRemove) x.Remove();
    111121    }
    112      
    113    
    114 
    115     #region Helper
    116     private IList<JCObject> BJCO(IParameterizedItem item) {
    117       List<JCObject> list = new List<JCObject>();
    118       JCObject obj = new JCObject();
    119       obj.Name = item.ItemName;
    120       obj.Type = item.GetType().AssemblyQualifiedName;
    121       obj.StaticParameters = new List<ParameterData>();
    122       list.Add(obj);
    123 
    124       foreach (var param in item.Parameters) {
    125         if(!param.Hidden) {
    126           obj.StaticParameters.Add(Transformer.Extract(param));
    127 
    128           if (param is IParameterizedItem)
    129             list.AddRange(BJCO(param.Cast<IParameterizedItem>()));
    130          
    131           if (param.GetType().IsEqualTo(typeof(IConstrainedValueParameter<>)))
    132             foreach (var validValue in param.Cast<dynamic>().ValidValues)
    133               if (validValue is IParameterizedItem &&
    134                 ((IParameterizedItem)validValue).Parameters.Any(p => !p.Hidden))
    135                 list.AddRange(BJCO((IParameterizedItem)validValue));
    136         }
    137       }
    138       return list;
    139     }
    140 
    141122
    142123    private JsonSerializer Settings() => new JsonSerializer() {
    … …  
    152133    }
    153134    #endregion
    154 
    155     /*
    156     private void ExtractOperatorInfo(IItem item, ParameterData obj) {
    157       if (item is IMultiOperator) {
    158         foreach (var op in ((IMultiOperator)item).Operators) {
    159           ParameterData newOperator = BuildJCParameter(op);
    160           if (obj.Operators == null)
    161             obj.Operators = new List<ParameterData>();
    162           obj.Operators.Add(newOperator);
    163           newOperator.Name = op.GetType().Name;
    164 
    165           newOperator.Path = obj.Path + ".Operators." + op.Name;
    166           MultiPermutationManipulator manipulator = new MultiPermutationManipulator();
    167         }
    168       }
    169     }*/
    170135  }
    171136}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCInstantiator.cs

    r17266 r17269  
    1616 
    1717  public class JCInstantiator {
    18     //private Dictionary<string, JCProperty> Properties = new Dictionary<string, JCProperty>();
    19     private Dictionary<string, string> TypeList = new Dictionary<string, string>();
    2018
    21     #region Constants
    22     private const string SParametersID = "StaticParameters";
    23     private const string FParametersID = "FreeParameters";
    24     private const string TListID = "TypeList";
    25     private const string AlgorithmID = "Algorithm";
    26     private const string ProblemID = "Problem";
    27     #endregion
     19    private JToken Config { get; set; }
    2820
    2921    public IAlgorithm Instantiate(string configFile) {
    30       JArray config = JArray.Parse(File.ReadAllText(configFile));
    31       JCObject obj = config[0].ToObject<JCObject>();
    32       IAlgorithm algorithm = CreateObject<IAlgorithm>(obj);
     22      Config = JToken.Parse(File.ReadAllText(configFile));
    3323
    34       foreach(var sp in obj.StaticParameters) {
    35         if(algorithm.Parameters.TryGetValue(sp.Name, out IParameter param)) {
    36           Transformer.Inject(param, sp);
     24      ParameterData algorithmData = GetData(Config["Metadata"]["Algorithm"].ToString());
     25      ResolveReferences(algorithmData);
     26      IAlgorithm algorithm = CreateObject<IAlgorithm>(algorithmData);
     27     
     28      ParameterData problemData = GetData(Config["Metadata"]["Problem"].ToString());
     29      ResolveReferences(problemData);
     30      IProblem problem = CreateObject<IProblem>(problemData);
     31      algorithm.Problem = problem;
     32
     33      Transformer.Inject(algorithm, algorithmData);
     34      Transformer.Inject(algorithm, problemData);
     35
     36      return algorithm;
     37    }
     38
     39    /*
     40     * resolve references
     41     */
     42
     43    private void ResolveReferences(ParameterData data) {
     44      foreach (var p in data.Parameters) {
     45        if (p.Default is string && p.Reference == null) {
     46          p.Reference = GetData(p.Default.Cast<string>());
    3747        }
    3848      }
     49    }
    3950
    40       foreach (var sp in obj.FreeParameters) {
    41         if (algorithm.Parameters.TryGetValue(sp.Name, out IParameter param)) {
    42           if(IsInRangeList(sp.Range, sp.Default) ||
    43             IsInNumericRange<long>(sp.Default, sp.Range[0], sp.Range[1]) ||
    44             IsInNumericRange<double>(sp.Default, sp.Range[0], sp.Range[1]))
    45           Transformer.Inject(param, sp);
    46         }
     51    private ParameterData GetData(string key)
     52    {
     53      foreach(JObject item in Config["Objects"])
     54      {
     55        ParameterData data = BuildDataFromJObject(item);
     56        if (data.Name == key) return data;
     57      }
     58      return null;
     59    }
     60
     61    private ParameterData BuildDataFromJObject(JObject obj) {
     62      ParameterData data = new ParameterData() {
     63        Name = obj["Name"]?.ToString(),
     64        Default = obj["Default"]?.ToObject<object>(),
     65        Range = obj["Range"]?.ToObject<object[]>(),
     66        Type = obj["Type"]?.ToObject<string>()
     67      };
     68
     69      if(obj["StaticParameters"] != null)
     70        foreach (JObject sp in obj["StaticParameters"])
     71          data[sp["Name"].ToString()] = BuildDataFromJObject(sp);
     72
     73      if (obj["FreeParameters"] != null)
     74        foreach (JObject sp in obj["FreeParameters"])
     75          data[sp["Name"].ToString()] = BuildDataFromJObject(sp);
     76
     77      if (obj["Operators"] != null) {
     78        data.Operators = new List<ParameterData>();
     79        foreach (JObject sp in obj["Operators"])
     80          data.Operators.Add(BuildDataFromJObject(sp));
    4781      }
    4882
    49 
    50       return algorithm;
    51 
    52 
    53       /*
    54       TypeList = config[SParametersID][TListID].ToObject<Dictionary<string, string>>();
    55 
    56       JCObject algorithmData = config[SParametersID][AlgorithmID].ToObject<JCObject>();
    57       JCObject problemData = config[SParametersID][ProblemID].ToObject<JCObject>();
    58 
    59       IAlgorithm algorithm = CreateTypeListObject<IAlgorithm>(algorithmData.Name);
    60       algorithm.Problem = CreateTypeListObject<IProblem>(problemData.Name);
    61 
    62       ProcessParameters(algorithmData, algorithm);
    63       ProcessParameters(problemData, algorithm.Problem);
    64 
    65       ParameterData[] freeAlgorithmParameters = config[FParametersID][algorithmData.Name].ToObject<ParameterData[]>();
    66       ParameterData[] freeProblemParameters = config[FParametersID][problemData.Name].ToObject<ParameterData[]>();
    67       UseFreeParams(algorithmData.Name, freeAlgorithmParameters, algorithm);
    68       UseFreeParams(problemData.Name, freeProblemParameters, algorithm.Problem);
    69       return algorithm;
    70       */
     83      return data;
    7184    }
    7285
    73     private T CreateObject<T>(JCObject obj) {
    74       Type type = Type.GetType(obj.Type);
     86    private T CreateObject<T>(ParameterData data) {
     87      Type type = Type.GetType(data.Type);
    7588      return (T)Activator.CreateInstance(type);
    7689    }
    7790
    78     private T CreateTypeListObject<T>(string key) {
    79       if (TypeList.TryGetValue(key, out string value)) {
    80         Type type = Type.GetType(value);
    81         return (T)Activator.CreateInstance(type);
    82       } else throw new TypeLoadException($"The type '{key}' does not exists in TypeList.");
    83     }
    84 
    85     private void ProcessParameters(JCObject obj, IParameterizedItem instance) {
    86       foreach (var param in obj.StaticParameters)
    87         if (param.Default != null)
    88           SetParameterValue(FindPropertyByKey(instance, param.Name), param.Default);
    89     }
    90 
    91     private void SetParameterValue (IParameter parameter, object value) {
    92       if (Util.IsTypeOf(parameter, typeof(IFixedValueParameter<>))) return;
    93       if (Util.IsTypeOf(parameter, typeof(IConstrainedValueParameter<>)))
    94         SetCVParameter(parameter, value);
    95       else if (Util.IsTypeOf(parameter.ActualValue, typeof(ValueTypeMatrix<>)))
    96         SetVTMatrix(parameter, value);
    97       else if (Util.IsTypeOf(parameter.ActualValue, typeof(ValueTypeArray<>)))
    98         SetVTArray(parameter, value);
    99       else if (Util.IsTypeOf(parameter.ActualValue, typeof(EnumValue<>)))
    100         SetEnum(parameter, value);
    101       else if (!(value is string))
    102         SetValue(parameter, value);
    103       else
    104         SetNewInstance(parameter, value);
    105     }
    106     #region Helper for SetParameterValue
    107     private void SetCVParameter(IParameter parameter, object value) {
    108       foreach (var x in ((dynamic)parameter).ValidValues)
    109         if (x.GetType().Name == (string)value)
    110           parameter.ActualValue = x;
    111     }
    112 
    113     private void SetVTMatrix(IParameter parameter, object value) {
    114       var matrixType = ((dynamic)parameter.ActualValue).CloneAsMatrix().GetType();
    115       var data = ((JToken)value).ToObject(matrixType);
    116       parameter.ActualValue = (IItem)Activator.CreateInstance(parameter.ActualValue.GetType(), new object[] { data });
    117     }
    118 
    119     private void SetVTArray(IParameter parameter, object value) {
    120       var arrayType = ((dynamic)parameter.ActualValue).CloneAsArray().GetType();
    121       var data = ((JToken)value).ToObject(arrayType);
    122       parameter.ActualValue = (IItem)Activator.CreateInstance(parameter.ActualValue.GetType(), new object[] { data });
    123     }
    124 
    125     private void SetEnum(IParameter parameter, object value) {
    126       var enumType = ((dynamic)parameter.ActualValue).Value.GetType();
    127       var data = Enum.Parse(enumType, (string)value);
    128       ((dynamic)parameter.ActualValue).Value = data;
    129     }
    130 
    131     private void SetValue(IParameter parameter, object value) {
    132       var x = (dynamic)parameter.ActualValue;
    133       if (value is IConvertible)
    134         x.Value = Convert.ChangeType(value, x.Value.GetType());
    135       else
    136         x.Value = value;
    137     }
    138 
    139     private void SetNewInstance(IParameter parameter, object value) =>
    140       parameter.ActualValue = (IItem)Activator.CreateInstance(Type.GetType(TypeList[(string)value]));
    141     #endregion
    142 
    143     private IParameter FindPropertyByKey(IParameterizedItem item, string key) {
    144       if (item.Parameters.TryGetValue(key, out IParameter param))
    145         return param;
    146       else throw new KeyNotFoundException();
    147     }
    148 
    149 
    150     /*
    151     JCProperty property = FindPropertyByPath(instance, param.Path);
    152     property.Value = param.Default;
    153     Properties.Add(obj.Name + "." + param.Name, property);
    154    
    155     private JCProperty FindPropertyByPath(object start, string path) {
    156       string[] parts = path.Split('.');
    157       object instance = start;
    158       for (int i = 0; i < parts.Length - 1; ++i) {
    159         if (parts[i].StartsWith("Parameters['")) {
    160           IParameterizedItem pItem = (IParameterizedItem)instance;
    161           string tmp = parts[i].Replace("Parameters['", "").Replace("']", "");
    162           if (pItem.Parameters.ContainsKey(tmp))
    163             instance = pItem.Parameters[tmp];
    164         } else {
    165           PropertyInfo propInfo = instance.GetType().GetProperty(parts[i]);
    166           instance = propInfo.GetValue(instance);
    167         }
    168       }
    169       return new JCProperty(instance.GetType().GetProperty(parts[parts.Length - 1]), instance, TypeList);
    170     }
    171     */
    172     private bool IsInRangeList(IEnumerable<object> list, object value) {
    173       foreach (var x in list)
    174         if (x.Equals(value)) return true;
    175       return false;
    176     }
    177 
    178     private void UseFreeParams(string root, ParameterData[] parameters, IParameterizedItem instance) {
    179       foreach (var param in parameters) {
    180         string key = $"{root}.{param.Name}";
    181         if((param.Range == null && param.Default != null) ||
    182           (param.Range != null && IsInRangeList(param.Range, param.Default)) ||
    183           IsInNumericRange<long>(param.Default, param.Range[0], param.Range[1]) ||
    184           IsInNumericRange<double>(param.Default, param.Range[0], param.Range[1]))
    185           SetParameterValue(FindPropertyByKey(instance, param.Name), param.Default);
    186         //Properties[key].Value = param.Default;
    187         else
    188           throw new ArgumentOutOfRangeException(key);
    189       }
    190     }
    191 
    192     private bool IsInNumericRange<T>(object value, object min, object max) where T : IComparable =>
    193       (value != null && min != null && max != null && value is T && min is T && max is T &&
    194         (((T)min).CompareTo(value) == -1 || ((T)min).CompareTo(value) == 0) &&
    195         (((T)max).CompareTo(value) ==  1 || ((T)max).CompareTo(value) == 0));
    19691  }
    19792}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/ParameterTransformer/ConstrainedValueParameterTransformer.cs

    r17266 r17269  
    1212        if (x.GetType().Name == CastValue<string>(data.Default))
    1313          parameter.ActualValue = x;
     14
     15      if (parameter.ActualValue is IParameterizedItem && data.Reference != null)
     16        Transformer.Inject(parameter.ActualValue, data.Reference);
    1417    }
    1518
    1619    public override ParameterData ExtractData(IParameter value) {
     20
    1721      return new ParameterData() {
    1822        Name = value.Name,
    1923        Default = value.ActualValue?.GetType().Name,
    20         Range = GetValidValues(value)
     24        Range = GetValidValues(value),
     25        ParameterizedItems = GetParameterizedChilds(value)
    2126      };
    2227    }
    … …  
    2631      List<object> list = new List<object>();
    2732      var values = value.Cast<dynamic>().ValidValues;
    28       foreach (var x in values) list.Add(x);
    29       return list.Select(x => x.GetType().Name).ToArray();
     33      foreach (var x in values) list.Add(x.GetType().Name);
     34      return list.ToArray();
     35    }
     36
     37    private IList<ParameterData> GetParameterizedChilds(IParameter value) {
     38      List<ParameterData> list = new List<ParameterData>();
     39      var values = value.Cast<dynamic>().ValidValues;
     40      foreach(var x in values) {
     41        if (x is IParameterizedItem &&
     42            ((IParameterizedItem)x).Parameters.Any(p => !p.Hidden)) {
     43          ParameterData tmp = Transformer.Extract(x);
     44          if (tmp.ParameterizedItems != null)
     45            list.AddRange(tmp.ParameterizedItems);
     46          else
     47            list.Add(tmp);
     48        }
     49      }
     50      return list.Count == 0 ? null : list;
    3051    }
    3152    #endregion

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/ParameterTransformer/ValueParameterTransformer.cs

    r17266 r17269  
    1313
    1414    public override ParameterData ExtractData(IParameter value) {
    15       ParameterData data = Transformer.Extract(value.ActualValue);
     15      ParameterData data = null;
     16      if (value.ActualValue == null)
     17        data = new ParameterData();
     18      else
     19        data = Transformer.Extract(value.ActualValue);
    1620      data.Name = value.Name;
    1721      return data;

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Program.cs

    r17266 r17269  
    3131  public class Program {
    3232    static void Main(string[] args) {
    33       //GeneticAlgorithm ga = new GeneticAlgorithm();
    3433      GeneticAlgorithm alg = new GeneticAlgorithm();
    3534      TravelingSalesmanProblem tsp = new TravelingSalesmanProblem();
    3635
    3736      JCGenerator gen = new JCGenerator();
    38       File.WriteAllText(@"C:\Workspace\TemplateProto10.json", gen.GenerateTemplate(alg, tsp));
     37      //File.WriteAllText(@"C:\Workspace\TemplateProto10.json", gen.GenerateTemplate(alg, tsp));
    3938     
    4039      JCInstantiator configurator = new JCInstantiator();
    4140      configurator.Instantiate(@"C:\Workspace\TemplateProto10.json");
    42       //Configure(@"C:\Workspace\TemplateProto9.json");
    43       //Console.WriteLine(Optimizer);
    4441
    4542      //Console.ReadLine();

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Template.cs

    r17266 r17269  
    88
    99namespace HeuristicLab.Manufacture {   
    10   public class JCObject { //Blueprint, Component,  ?
     10  /*
     11  public class ParameterData { //Blueprint, Component,  ?
    1112    public string Name { get; set; }
    1213    public string Type { get; set; }
    … …  
    1415    public IList<ParameterData> StaticParameters { get; set; }
    1516
    16     public override string ToString() {
    17       StringBuilder sb = new StringBuilder();
    18       sb.Append($"{Name}: [");
    19       foreach(var x in StaticParameters) {
    20         sb.Append(x?.ToString());
    21       }
    22       sb.Append($"\n]");
    23       return sb.ToString();
    24     }
    25   }
     17  }*/
    2618
    2719  public class ParameterData {
    2820    public string Name { get; set; }
    29     [JsonIgnore]
    3021    public string Type { get; set; }
    3122    public object Default { get; set; }
    32     //[JsonIgnore]
    3323    public string Path { get; set; }
    3424    public IList<object> Range { get; set; }
     25
    3526    public IList<ParameterData> Parameters { get; set; }
    3627    public IList<ParameterData> Operators { get; set; }
    3728
    38     public ParameterData() { }
    39     /*
    40     public ParameterData(ParameterData original) {
    41       this.Name = original.Name;
    42       this.Type = original.Type;
    43       this.Default = original.Default;
    44       this.Path = original.Path;
    45       this.Name = original.Name;
    46       this.Name = original.Name;
    47     }*/
    48     public override string ToString() {
    49       StringBuilder sb = new StringBuilder();
    50       sb.Append($"\n{Name}, {Default}, Range[");
    51       if(Range != null) {
    52         foreach (var x in Range) {
    53           sb.Append(x.ToString() + ", ");
    54         }
     29    [JsonIgnore]
     30    public ParameterData this[string index] {
     31      get {
     32        if (Parameters == null) return null;
     33        foreach (var p in Parameters)
     34          if (p.Name == index) return p;
     35        return null;
    5536      }
    56       sb.Append($"],");
    57       return sb.ToString();
     37      set {
     38        if (Parameters == null)
     39          Parameters = new List<ParameterData>();
     40        ParameterData data = this[index];
     41        if (data != null && CheckConstraints(value))
     42          Merge(data, value);
     43        else
     44          Parameters.Add(value);
     45      }
    5846    }
     47
     48    public override bool Equals(object obj) {
     49      if (!(obj is ParameterData))
     50        return false;
     51      else
     52        return obj.Cast<ParameterData>().Name == this.Name;
     53    }
     54
     55    public override int GetHashCode() {
     56      return Name.GetHashCode();
     57    }
     58
     59    [JsonIgnore]
     60    public IList<ParameterData> ParameterizedItems { get; set; }
     61
     62    [JsonIgnore]
     63    public ParameterData Reference { get; set; }
     64
     65    #region Helper
     66    public static void Merge(ParameterData target, ParameterData from) {
     67      target.Name = from.Name ?? target.Name;
     68      target.Type = from.Type ?? target.Type;
     69      target.Range = from.Range ?? target.Range;
     70      target.Path = from.Path ?? target.Path;
     71      target.Default = from.Default ?? target.Default;
     72      target.Reference = from.Reference ?? target.Reference;
     73      target.Parameters = from.Parameters ?? target.Parameters;
     74      target.ParameterizedItems = from.ParameterizedItems ?? target.ParameterizedItems;
     75    }
     76
     77    private bool CheckConstraints(ParameterData data) =>
     78      data.Range != null && data.Default != null && (
     79      IsInRangeList(data.Range, data.Default) ||
     80      IsInNumericRange<long>(data.Default, data.Range[0], data.Range[1]) ||
     81      IsInNumericRange<double>(data.Default, data.Range[0], data.Range[1]));
     82
     83    private bool IsInRangeList(IEnumerable<object> list, object value) {
     84      foreach (var x in list)
     85        if (x.Equals(value)) return true;
     86      return false;
     87    }
     88
     89    private bool IsInNumericRange<T>(object value, object min, object max) where T : IComparable =>
     90      (value != null && min != null && max != null && value is T && min is T && max is T &&
     91        (((T)min).CompareTo(value) == -1 || ((T)min).CompareTo(value) == 0) &&
     92        (((T)max).CompareTo(value) == 1 || ((T)max).CompareTo(value) == 0));
     93    #endregion
    5994  }
    60 
    61 
    6295}

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Transformer.cs

    r17266 r17269  
    1919    public static void Register<T>(ITypeTransformer transformer) => Register(typeof(T), transformer);
    2020
    21     public static ITypeTransformer Get(Type type) {
     21    public static IEnumerable<ITypeTransformer> Get(Type type) {
    2222      IList<KeyValuePair<Type, ITypeTransformer>> possibleTransformers = new List<KeyValuePair<Type, ITypeTransformer>>();
     23
     24
    2325      foreach (var x in transformers) {
    2426        if (type.IsEqualTo(x.Key))
    2527          possibleTransformers.Add(x);
    2628      }
     29
    2730
    2831      if(possibleTransformers.Count > 0) {
    … …  
    3639          }
    3740        }
    38         return nearest;
     41        return new ITypeTransformer[] { nearest };
     42        /*
     43        return possibleTransformers.OrderBy(x => {
     44          return type.GetInterfaceDistance(x.Key);
     45        }).Select(x => x.Value);
     46        */
    3947      }
    40       return new DummyTransformer();
     48      return new ITypeTransformer[] { new DummyTransformer() };
    4149    }
    4250
    4351    internal static void Inject(IItem item, ParameterData data) {
    44       Get(item.GetType()).Inject(item, data);
     52      IEnumerable<ITypeTransformer> arr = Get(item.GetType());
     53      foreach (var transformer in arr)
     54        transformer.Inject(item, data);
    4555    }
    4656
    4757    internal static ParameterData Extract(IItem item) {
    48       return Get(item.GetType()).Extract(item);
     58      IEnumerable<ITypeTransformer> arr = Get(item.GetType());
     59      ParameterData data = new ParameterData();
     60      foreach (var transformer in arr)
     61        ParameterData.Merge(data, transformer.Extract(item));
     62      return data;
    4963    }
    5064
    … …  
    7185      Register(typeof(ILookupParameter), new LookupParameterTransformer());
    7286      Register(typeof(IValueParameter), new ValueParameterTransformer());
     87      Register(typeof(IParameterizedItem), new ParameterizedItemTransformer());
     88      Register(typeof(ICheckedMultiOperator<>), new MultiCheckedOperatorTransformer());
    7389    }
    7490

  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/TypeTransformer/DummyTransformer.cs

    r17266 r17269  
    1313    }
    1414
    15     public override ParameterData ExtractData(IItem value) => new ParameterData();
     15    public override ParameterData ExtractData(IItem value) =>
     16      new ParameterData() { Default = value.GetType().Name };
    1617  }
    1718}
Note: See TracChangeset for help on using the changeset viewer.