Example #1
0
        private MetaOperator.InstanceProperties BuildOperatorInstanceProperties(MetaManager metaManager, MetaOperator metaOp, JToken jsonOp)
        {
            var opProperties = new MetaOperator.InstanceProperties();

            opProperties.Name     = jsonOp["Name"].Value <string>();
            opProperties.Position = new Point(jsonOp["PosX"].Value <double>(), jsonOp["PosY"].Value <double>());
            opProperties.Width    = jsonOp["Width"].Value <double>();
            opProperties.Visible  = jsonOp["Visible"].Value <bool>();
            if (jsonOp["Disabled"] != null)
            {
                opProperties.Disabled = jsonOp["Disabled"].Value <bool>();
            }

            var foundMetaInputsList = new List <MetaInput>();

            foreach (var jsonInput in jsonOp["Inputs"])
            {
                var id        = Guid.Parse(jsonInput["ID"].Value <string>());
                var metaInput = (from input in metaOp.Inputs
                                 where input.ID == id
                                 select input).SingleOrDefault();
                if (metaInput == null)
                {
                    Logger.Debug("Skipped obsolete parameter value {0} in meta operator {1}, because it no longer exists.", id.ToString(), metaOp.Name);
                    continue;
                }

                var valueToken = jsonInput["Type"];
                if (valueToken != null)
                {
                    var type  = valueToken.Value <string>();
                    var lines = new List <String>();
                    foreach (var valueLine in jsonInput["Value"])
                    {
                        lines.Add(valueLine.Value <string>());
                    }
                    var value = string.Join("\n", lines);
                    opProperties.InputValues[id] = Utilities.CreateValueFunction(ValueUtilities.CreateValue(type, value));
                }
                else
                {
                    opProperties.InputValues[id] = metaInput.DefaultFunc;
                }

                foundMetaInputsList.Add(metaInput);
            }

            // extract inputs for which no values have been set, e.g. because the input was added later after creating the parent op
            // for these inputs the default func is set
            var inputsWithoutStoredInstanceValues = foundMetaInputsList.Except(metaOp.Inputs);

            foreach (var input in inputsWithoutStoredInstanceValues)
            {
                opProperties.InputValues[input.ID] = input.DefaultFunc;
                Logger.Debug("Added default value for new parameter {0} in Operator {1}", input.Name, input.ID.ToString());
            }

            foreach (var jsonState in jsonOp["States"])
            {
                var opPartId        = Guid.Parse(jsonState.Value <string>("ID"));
                var metaOpPart      = metaOp.OperatorParts.First(opPartEntry => opPartEntry.Item1 == opPartId).Item2;
                var stateType       = metaOpPart.StateType;
                var serializedState = jsonState.Value <JObject>("State");

                var serializer = new JsonSerializer();
                using (var reader = new StringReader(serializedState.ToString()))
                {
                    var state = serializer.Deserialize(reader, stateType) as IOperatorPartState;
                    if (state != null)
                    {
                        opProperties.OperatorPartStates.Add(opPartId, state);
                    }
                }
            }

            return(opProperties);
        }
Example #2
0
        private void WriteOperatorInstanceProperties(MetaOperator parentOp, Guid metaOpInstanceID, MetaOperator metaOp, MetaOperator.InstanceProperties opProperties)
        {
            Writer.WriteStartObject();

            Writer.WriteValue("Name", opProperties.Name);
            Writer.WriteValue("PosX", opProperties.Position.X);
            Writer.WriteValue("PosY", opProperties.Position.Y);
            Writer.WriteValue("Width", opProperties.Width);
            Writer.WriteValue("Visible", opProperties.Visible);
            Writer.WriteValue("Disabled", opProperties.Disabled);

            Writer.WritePropertyName("Inputs");
            Writer.WriteStartArray();
            foreach (var inputValue in opProperties.InputValues)
            {
                var inputID        = inputValue.Key;
                var inputValueFunc = inputValue.Value;

                var metaInput = (from input in metaOp.Inputs
                                 where input.ID == inputValue.Key
                                 select input).SingleOrDefault();

                bool isDefault = ((metaInput != null) && (inputValueFunc == metaInput.DefaultFunc)) ||
                                 parentOp.ExistsConnectionToInput(metaOpInstanceID, metaInput.ID);

                if (!isDefault)
                {
                    Writer.WriteStartObject();
                    Writer.WriteValue("ID", inputID);
                    var inputValueValue = (inputValueFunc as Utilities.ValueFunction).Value;
                    var inputValueType  = inputValueValue.Type;

                    Writer.WriteValue("Type", inputValueType);

                    //write value multi lined
                    var value         = ValueUtilities.GetValueForTypeFromContext(inputValueType, inputValueValue.SetValueInContext(new OperatorPartContext()));
                    var splittedValue = value.Split(new string[] { "\n" }, StringSplitOptions.None);
                    Writer.WritePropertyName("Value");
                    Writer.WriteStartArray();
                    foreach (var valueLine in splittedValue)
                    {
                        Writer.WriteValue(valueLine);
                    }
                    Writer.WriteEndArray();
                    Writer.WriteEndObject();
                }
            }
            Writer.WriteEndArray();

            Writer.WritePropertyName("States");
            Writer.WriteStartArray();
            foreach (var stateEntry in opProperties.OperatorPartStates)
            {
                Writer.WriteStartObject();
                Writer.WriteValue("ID", stateEntry.Key);
                Writer.WritePropertyName("State");
                var s = new JsonSerializer();
                s.Serialize(Writer, stateEntry.Value);
                Writer.WriteEndObject();
            }
            Writer.WriteEndArray();

            Writer.WriteEndObject();
        }