コード例 #1
0
        /// <summary>
        /// Set the output value of ShadowedOutputNode.  This is the same as for
        /// the super class methodd, except that it updates the shadowing inputs 
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        /// <param name="t"></param>
        /// <param name="send"></param>
        /// <returns></returns>
        public override DXTypeVals setOutputValue(int index, String value, DXTypeVals t, bool send)
        {
            DXTypeVals type;

            Debug.Assert(value != null);

            // Defer visual notification in case, we do more then one set*Value().
            deferVisualNotification();

            // When data-driven, outputs that have shadowing inputs are not sent and
            // instead their shadows are sent..
            int shadow_input = getShadowingInput(index);
            if (shadow_input > 0)
            {
                type = base.setOutputValue(index, value, t, false);
                if (type != DXTypeVals.UndefinedType)
                {
                    value = getOutputValueString(index);
                    setInputValue(shadow_input, value, type, false);
                    if (send)
                        sendValues(false);
                }
            }
            else
            {
                type = base.setOutputValue(index, value, t, send);
            }

            undeferVisualNotification();
            return type;
        }
コード例 #2
0
        /// <summary>
        /// // We implement this for FileSelector node so that we can keep the
        /// 2nd output (the basename of the full file name) up to date.
        /// One should never use this method to set the 2nd output, only the 1st.
        /// Well, this is used when we parse a .net file.
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        /// <param name="t"></param>
        /// <param name="send"></param>
        /// <returns></returns>
        public override DXTypeVals setOutputValue(int index, String value, DXTypeVals t, bool send)
        {
            Regex regex = new Regex(@"\\");
            String localValue = regex.Replace(value, "/");

            if (index == 2)
                return base.setOutputValue(2, localValue, t, send);

            DXTypeVals type = base.setOutputValue(1, localValue, t, false);
            if (type != DXTypeVals.UndefinedType)
            {
                String basename = getOutputValueString(1);
                basename = regex.Replace(basename, "/");

                if (!basename.Contains("/"))
                    type = base.setOutputValue(2, value, type, send);
                else
                {
                    // Not quite sure what the code is trying to do here.
                    throw new Exception("Not Yet Implemented");
                }
            }
            return type;
        }
コード例 #3
0
        /// <summary>
        /// Update any inputs that are being updated by the server (i.e. the
        /// module that is doing the data-driven operations).
        /// We update the values internally, and send the shadowing input
        /// value back to the executive with an Executive() call.
        /// We use the Executive call instead of a direct assignment, because if
        /// we are currently in execute-on-change  mode, the assignment would cause
        /// extra executions.  
        /// The Executive() call (a dictionary update) avoids that.
        /// </summary>
        /// <param name="output_index"></param>
        /// <param name="val"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        protected DXTypeVals setShadowedOutputSentFromServer(int output_index, String val,
            DXTypeVals t)
        {
            // Set the values internally
            // Set the output quietly instead of just setting it and not sending it
            // for the following scenario with out the quietly:
            //
            //   1) Interactor->Echo,	Execute echos 0
            //		(references GLOBAL main_Interactor_1_out_1)
            //   2) Set Interactor:min value to 5, Execute echos 5
            //		(references LOCAL  main_Interactor_1_out_1)
            //   3) Tab up Interactor:min, Execute echos 0
            //		(references GLOBAL main_Interactor_1_out_1)
            //
            // So, setting the output quietly makes sure that the global value
            // is up to date.

            int input_index = getShadowingInput(output_index);
            DXTypeVals type = setOutputValueQuietly(output_index, val, t);
            if (type != DXTypeVals.UndefinedType)
            {
                clearOutputDirty(output_index);
                setInputValueQuietly(input_index, val, type);
            }
            return type;
        }
コード例 #4
0
ファイル: ImageNode.cs プロジェクト: BackupTheBerlios/opendx2
 public ParamClass(int pIndex, int opIndex, DXTypeVals pType, ParamCats pcat)
 {
     paramIndex = pIndex;
     oldParamIndex = opIndex;
     paramType = pType;
     category = pcat;
 }
コード例 #5
0
ファイル: ImageNode.cs プロジェクト: BackupTheBerlios/opendx2
        public override DXTypeVals setInputValue(int index, string value, 
            DXTypeVals type, bool send)
        {
            DXTypeVals result;

            bool trans = translating;
            translating = false;

            switch (index)
            {
                case (int)Params.usevector:
                    if (trans)
                    {
                        if (value.StartsWith("1"))
                            value = "0";
                        else if (value.StartsWith("2"))
                            value = "1";
                    }
                    if (value == "NULL")
                        value = "0";
                    notifyUseVectorChange(!value.StartsWith("0"));
                    break;

                case (int)Params.aaenabled:
                    if (trans)
                    {
                        if (value.StartsWith("1"))
                            value = "0";
                        else if (value.StartsWith("2"))
                            value = "1";
                    }
                    break;

                case (int)Params.recenable:
                    if (trans)
                    {
                        if (value.StartsWith("1"))
                            value = "0";
                        else if (value.StartsWith("2"))
                            value = "1";
                    }
                    break;

                case (int)Params.projection:
                    notifyProjectionChange(!value.StartsWith("0"));
                    break;

                case (int)Params.render_mode:
                    if (value == "\"hardware\"" ||
                    value == "hardware")
                        value = "1";
                    else if (value == "\"software\"" ||
                        value == "software")
                        value = "0";
                    else if (trans)
                    {
                        if (value.StartsWith("1"))
                            value = "0";
                        else if (value.StartsWith("2"))
                            value = "1";
                    }
                    if (type == DXTypeVals.StringType)
                        type = DXTypeVals.FlagType;
                    break;
                case (int)Params.button_up_approx:
                case (int)Params.button_down_approx:
                    if (value == "\"flat\"")
                        value = "\"none\"";
                    break;
            }

            result = base.setInputValue(index, value, type, send);
            translating = trans;
            return result;
        }
コード例 #6
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
        /// <summary>
        /// For the given type, try and augment the given string value with
        /// syntactic sugar to coerce the given value to the given type.
        /// The types we can coerce are StringType, ListType, VectorType and 
        /// TensorType.
        /// If the value is coerceable return a new string that does not need to
        /// be coerced to the given value, otherwise return NULL.
        /// On success, the returned string must be freed by the caller.
        /// </summary>
        /// <param name="val"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static String CoerceValue(String val, DXTypeVals type)
        {
            String s;
            bool failed = true;

            if (type == DXTypeVals.ValueType)
            {
                s = DXValue.CoerceValue(val, DXTypeVals.VectorType);
            }
            else
            {
                if (val == null)
                    s = "";
                else
                    s = val.Trim();

                if ((type == DXTypeVals.StringType) || (type == DXTypeVals.WhereType))
                {
                    s = "\"" + s + "\"";
                }
                else if (type == DXTypeVals.ListType)
                {
                    s = "{" + s + "}";
                }
                else if (type == DXTypeVals.TensorType || type == DXTypeVals.VectorType)
                {
                    s = "[" + s + "]";
                }

                if (!DXValue.IsValidValue(s, type))
                    failed = true;
                else
                    failed = false;

                // Try and coerce a list with a single element (i.e. coerce both the
                // element and the overall value.
                if (failed && (long)(type & DXTypeVals.ListType) > 0)
                {
                    DXTypeVals basetype = type & DXTypeVals.ListTypeMask;
                    String p = DXValue.CoerceValue(val, basetype);
                    if (p != null)
                    {
                        String p2 = DXValue.CoerceValue(p, type);
                        if (p2 != null)
                        {
                            s = p2;
                            failed = false;
                        }
                    }
                }
                if (failed)
                {
                    s = null;
                }
            }
            return s;
        }
コード例 #7
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// Make sure all values (Scalar[List], Integer[List] and Vector[List] 
 /// components) are within the given ranges for each component.  
 /// 'val' is the given string value representing the Scalar, Integer or 
 /// Vector and 'valtype' is expected to be its type.  
 /// mins/maxs are arrays of minimum and maximum values for the 
 /// corresponding components (scalar and integer only have a single 
 /// component).  
 /// TRUE is returned if the value needs to be clamped to be within the 
 /// given ranges, FALSE otherwise.  If clampedval is provided, then a 
 /// string is passed back which represents the clamped value. 
 /// </summary>
 /// <param name="val"></param>
 /// <param name="valtype"></param>
 /// <param name="mins"></param>
 /// <param name="maxs"></param>
 /// <param name="clampedval"></param>
 /// <returns></returns>
 public static bool ClampVSIValue(String val, DXTypeVals valtype, ref double mins,
     ref double maxs, ref String clampedval)
 {
     throw new Exception("Not yet implemented");
 }
コード例 #8
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// Replace a list item in a list value.
 /// null is returned on failure.  Positions begin at 1.
 /// This works on the same list types that NextListItem() does.
 /// </summary>
 /// <param name="list"></param>
 /// <param name="item"></param>
 /// <param name="listtype"></param>
 /// <param name="position"></param>
 /// <returns></returns>
 public static String ReplaceListItem(String list, String item,
     DXTypeVals listtype, int position)
 {
     throw new Exception("Not yet implemented");
 }
コード例 #9
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// Get the next item from a list of the given type.
 /// Currently, only ScalarListType, IntegerListType, VectorListType and
 /// StringListType are supported.
 /// Search for the item is started a s[*index], and upon a successfull,
 /// return *index is updated to point to the character not parsed as a list.
 /// item. If *index is less than zero then we parse the initial list 
 /// delimiter '{'.  If buf is provided (!NULL), then the list item is copied 
 /// into it otherwise a new string is allocated to hold the list item.  In 
 /// either case a pointer to the string holding the list item is returned .
 /// upon success.
 /// </summary>
 /// <param name="s"></param>
 /// <param name="index"></param>
 /// <param name="listtype"></param>
 /// <param name="buf"></param>
 /// <returns></returns>
 public static String NextListItem(String s, ref int index, DXTypeVals listtype,
     ref String buf)
 {
     throw new Exception("Not yet implemented");
 }
コード例 #10
0
ファイル: Parameter.cs プロジェクト: BackupTheBerlios/opendx2
        public bool setValue(String value, DXTypeVals type, bool coerce)
        {
            bool success = false;
            if (this.value == null)
                this.value = new DXValue();

            if (type == DXTypeVals.UndefinedType && value == null)
            {
                this.value = null;
                success = true;
            }
            else
            {
                ParameterDefinition pd = this.Definition;
                bool typeMatch = false;
                foreach (DXType dxt in pd.getTypes())
                {
                    if (DXType.MatchType(type, dxt.getType()))
                    {
                        typeMatch = true;
                        break;
                    }
                }
                if (typeMatch && (
                       this.value.setValue(value, type) ||
                       (coerce && this.coerceAndSetValue(value, type))))
                    success = true;
                else
                    success = false;
            }
            if (success)
            {
                setDirty();
                if (type == DXTypeVals.UndefinedType && value == null)
                    setUnconnectedDefaultingStatus(true);
                else
                    setUnconnectedDefaultingStatus(false);
            }
            return success;
        }
コード例 #11
0
ファイル: Parameter.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// Set the value of this parameter to the value represented by v which 
 /// must match the given type.  If coerce is TRUE, then try and add
 /// syntactic sugar to make the value match the type.
 /// </summary>
 /// <param name="v"></param>
 /// <param name="t"></param>
 /// <param name="coerce"></param>
 /// <returns></returns>
 public bool setValue(String value, DXTypeVals type)
 {
     return setValue(value, type, true);
 }
コード例 #12
0
ファイル: Parameter.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// Uset setValue(v,t,c) to set the stored value.
 /// If the parameter is not defaulting, this is
 /// the same as setValue, but if it is defaulting, then we set the
 /// value but leave the parameter clean and defaulting.
 /// </summary>
 /// <param name="value"></param>
 /// <param name="type"></param>
 /// <returns></returns>
 public bool setSetValue(String value, DXTypeVals type)
 {
     throw new Exception("Not Yet Implemented");
 }
コード例 #13
0
 public ToggleNode(NodeDefinition nd, Network net, int instnc)
     : base(nd, net, instnc)
 {
     outputType = DXTypeVals.UndefinedType;
     is_set = false;
 }
コード例 #14
0
 /// <summary>
 /// Make sure the given output's current value complies with any attributes.
 /// This is called by InteractorInstance::setOutputValue() which is
 /// intern intended to be called by the Interactors.
 /// If verification fails (returns FALSE), then a reason is expected to
 /// placed in reason.
 /// At this level we always return TRUE (assuming that there are no
 /// attributes) and set *reason to NULL.
 /// </summary>
 /// <param name="output"></param>
 /// <param name="val"></param>
 /// <param name="t"></param>
 /// <param name="reason"></param>
 /// <returns></returns>
 protected virtual bool verifyValueAgainstAttributes(int output,
     String val, DXTypeVals t, ref String[] reason)
 {
     throw new Exception("Not Yet Implemented");
 }
コード例 #15
0
 /// <summary>
 /// Make sure the given value complies with any attributes and if so
 /// set the value in the Node.  This should generally be called from
 /// interactors that can't directly enforce  attributes.  For example,
 /// the Text style versus the Stepper style Vector interactor.  The
 /// Stepper style enforces its attributes itself, but the Text style
 /// accepts any value and then must have the value checked for type
 /// and attribute compliance.
 /// If we fail because attribute verification fails, then *reason contains
 /// the reason (as passed back by verifyValueAgainstAttributes()) for
 /// failure.  
 /// </summary>
 /// <param name="index"></param>
 /// <param name="val"></param>
 /// <param name="type"></param>
 /// <param name="send"></param>
 /// <param name="reason"></param>
 /// <returns></returns>
 public bool setAndVerifyOutput(int index, String val, DXTypeVals type, 
     bool send, ref String reason)
 {
     throw new Exception("Not Yet Implemented");
 }
コード例 #16
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
        public static bool IsValidValue(String str, DXTypeVals type)
        {
            bool result = false;
            int tuple = 0;

            if (str == null)
                return false;

            str = str.Trim();

            if (str == "" || str.ToLower() == "null")
                result = true;

            else if (type == DXTypeVals.FlagType)
            {
                Regex r = new Regex(@"^(true|false|\d+)$");
                result = r.IsMatch(str);
            }
            else if (type == DXTypeVals.IntegerType)
            {
                Regex r = new Regex(Scanning.Scanner.IntegerOnlyPattern);
                result = r.IsMatch(str);
            }
            else if (type == DXTypeVals.ScalarType)
            {
                Regex r = new Regex(Scanning.Scanner.DoubleOnlyPattern);
                result = r.IsMatch(str);
            }
            else if (type == DXTypeVals.VectorType)
            {
                result = DXTensor.IsVector(str, ref tuple);
            }
            else if (type == DXTypeVals.TensorType)
            {
                result = DXTensor.IsTensor(str);
            }
            else if (type == DXTypeVals.ValueType)
            {
                DXTypeVals value_type = DXTypeVals.UndefinedType;
                result = IsValue(str, ref value_type);
            }
            else if (type == DXTypeVals.StringType)
            {
                Regex r = new Regex(@"^""[^""]*""$");
                result = r.IsMatch(str);
            }
            else if (type == DXTypeVals.ObjectType)
            {
                result = IsObject(str);
            }
            else if ((type & DXTypeVals.ListType) > 0)
            {
                DXTypeVals list_type = type & DXTypeVals.ListTypeMask;

                result = IsList(str, list_type);
            }
            else if ((type & DXTypeVals.WhereType) > 0)
            {
                Regex r = new Regex(@"^""[^""]*""$");
                result = r.IsMatch(str);
            }
            else if (type == DXTypeVals.UserType1 ||
               type == DXTypeVals.UserType2 ||
               type == DXTypeVals.UserType4 ||
               type == DXTypeVals.UserType5 ||
               type == DXTypeVals.UserType6 ||
               type == DXTypeVals.DescriptionType)
            {
                return true;
            }
            return result;
        }
コード例 #17
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
        public static bool IsValue(String str, ref DXTypeVals type)
        {
            int tuple = 0;

            if (str == null)
                return false;

            Regex r = new Regex(Scanning.Scanner.DoubleOnlyPattern);
            switch (type)
            {
                case DXTypeVals.ScalarType:
                    return r.IsMatch(str);
                    break;
                case DXTypeVals.VectorType:
                    return DXTensor.IsVector(str, ref tuple);
                    break;
                case DXTypeVals.TensorType:
                    return DXTensor.IsTensor(str);
                    break;
                default:
                    if (r.IsMatch(str))
                    {
                        type = DXTypeVals.ScalarType;
                        return true;
                    }
                    if (DXTensor.IsVector(str, ref tuple))
                    {
                        type = DXTypeVals.VectorType;
                        return true;
                    }
                    if (DXTensor.IsTensor(str))
                    {
                        type = DXTypeVals.TensorType;
                        return true;
                    }
                    break;
            }
            return false;
        }
コード例 #18
0
ファイル: Parameter.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// For the given type, try and augment the given string value with
 /// syntactic sugar to coerce the given value to the given type.
 /// The types we can coerce are StringType, ListType, VectorType and 
 /// TensorType.
 /// </summary>
 /// <param name="value"></param>
 /// <param name="type"></param>
 /// <returns>t/f indicating whether the value was successfully set</returns>
 protected bool coerceAndSetValue(String value, DXTypeVals type)
 {
     String s = DXValue.CoerceValue(value, type);
     bool r = false;
     if (s != null)
     {
         r = this.value.setValue(s, type);
     }
     return r;
 }
コード例 #19
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
 public static String NextListItem(String s, ref int index, DXTypeVals listtype)
 {
     String tmp = null;
     return NextListItem(s, ref index, listtype, ref tmp);
 }
コード例 #20
0
        protected DXTypeVals setInputAttributeFromServer(int index, String val, DXTypeVals t)
        {
            Parameter p = getInputParameter(index);
            Debug.Assert(p is AttributeParameter);

            bool was_dirty = p.IsDirty;

            bool r = setInputAttributeParameter(index, val);

            if (!was_dirty)
                clearInputDirty(index);
            Debug.Assert(r);
            if (t == DXTypeVals.UndefinedType)
            {
                AttributeParameter ap = (AttributeParameter)p;
                t = ap.getAttributeValueType();
            }
            return t;
        }
コード例 #21
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
        /// <summary>
        /// Assigns a string value of the specified type (DXType constant).
        /// Returns TRUE if the new value has been assigned;
        /// returns FALSE otherwise.
        /// </summary>
        /// <param name="str"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public bool setValue(String strp, DXTypeVals typep)
        {
            bool result = false;

            if (DXValue.IsValidValue(strp, typep))
            {
                this.clear();
                this.type.setType(typep);

                this.str = strp;
                if (String.Compare(str, "NULL", true) == 0)
                {
                    this.type.setType(typep);
                }
                else
                {
                    // Convert the string to internal, native form according to type
                    double d; int v;
                    switch (typep)
                    {
                        case DXTypeVals.FlagType:
                            // The executive dow not recognize 'true' or 'false', so
                            // we convert them to integer values.
                            if (String.Compare(strp, "false", true) == 0)
                            {
                                this.integer = 0; this.scalar = 0;
                                this.str = "0";
                            }
                            else if (String.Compare(strp, "true", true) == 0)
                            {
                                this.integer = 1; this.scalar = 1;
                                this.str = "1";
                            }
                            else
                            {
                                v = int.Parse(strp); this.integer = v;
                                d = double.Parse(strp); this.scalar = d;
                            }
                            break;

                        case DXTypeVals.IntegerType:
                            v = int.Parse(strp); this.integer = v;
                            d = double.Parse(strp); this.scalar = d;
                            break;

                        case DXTypeVals.ScalarType:
                            d = double.Parse(strp); this.scalar = d;
                            if (strp.Contains("."))
                                this.str = this.scalar.ToString();
                            break;

                        case DXTypeVals.VectorType:
                            tensor = new DXTensor();
                            result = tensor.setValue(strp);
                            Debug.Assert(result);
                            break;

                        case DXTypeVals.TensorType:
                        case DXTypeVals.ValueType:
                        case DXTypeVals.StringType:
                        case DXTypeVals.ObjectType:
                        case DXTypeVals.WhereType:
                        case DXTypeVals.DescriptionType:
                            break;

                        default:
                            if ((typep & DXTypeVals.ListType) > 0)
                            {
                                List<String> toks;
                                String buf;
                                switch (typep & DXTypeVals.ListTypeMask)
                                {
                                    case DXTypeVals.ScalarType:
                                        // Convert '{ 1 2.0000 3.3 }' into '{ 1.0 2.0 3.3 }'
                                        // Ignore lists specified with the elipsis '{ 1..2: 3}'
                                        if (this.str.Contains(":") || this.str.Contains(".."))
                                            break;
                                        toks = Utils.StringTokenizer(strp, " ,\t{}", null);
                                        buf = "{ ";
                                        foreach (String tok in toks)
                                        {
                                            buf += double.Parse(tok).ToString("0.0") + " ";
                                        }
                                        buf += "}";
                                        this.str = buf;
                                        break;

                                    case DXTypeVals.IntegerType:
                                        // Ignore lists specified with the ellipsis '{ 1..2:3 }'
                                        if (this.str.Contains(":") || this.str.Contains(".."))
                                            break;
                                        toks = Utils.StringTokenizer(strp, " ,\t{}", null);
                                        buf = "{ ";
                                        foreach (String tok in toks)
                                        {
                                            buf += int.Parse(tok).ToString() + " ";
                                        }
                                        buf += "}";
                                        this.str = buf;
                                        break;

                                    case DXTypeVals.StringType:
                                        toks = Utils.StringTokenizer(strp, " ,\t{}", null);
                                        buf = "{ ";
                                        foreach (String tok in toks)
                                        {
                                            buf += tok + " ";
                                        }
                                        buf += "}";
                                        this.str = buf;
                                        break;

                                    case DXTypeVals.FlagType:
                                    case DXTypeVals.VectorType:
                                    case DXTypeVals.TensorType:
                                    case DXTypeVals.ValueType:
                                        break;
                                }
                            }
                            else if ((long)(typep & DXTypeVals.UserType1) > 0 ||
                                (long)(typep & DXTypeVals.UserType2) > 0 ||
                                (long)(typep & DXTypeVals.UserType4) > 0 ||
                                (long)(typep & DXTypeVals.UserType5) > 0 ||
                                (long)(typep & DXTypeVals.UserType6) > 0)
                            { }
                            else
                                Debug.Assert(false);
                            break;
                    }
                }
                return true;
            }
            else
                return false;
        }
コード例 #22
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// Parse the floating point numbers out of either a ScalarList or a
 /// VectorList.  Numbers are parsed into an array created from within.
 /// The values are placed into the array in the order they are encountered
 /// in the list.  In the case of VectorLists, all vectors in the list must
 /// be of the same dimensionality.
 /// The return value is the number of list items parsed out of the list.  
 /// *data is the allocated array of values.
 /// *tuple is the dimensionality of the VectorList items (1 for ScalarList).
 /// '*tuple * return-val' is the number of items in the *data array.
 /// </summary>
 /// <param name="list"></param>
 /// <param name="listtype"></param>
 /// <param name="data"></param>
 /// <param name="tuple"></param>
 /// <returns></returns>
 public static int GetDoublesFromList(String list, DXTypeVals listtype,
     ref double[] data, ref int tuple)
 {
     throw new Exception("Not yet implemented");
 }
コード例 #23
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// Does the given string represent the given type?
 /// </summary>
 /// <param name="str"></param>
 /// <param name="type"></param>
 /// <returns></returns>
 public bool Valid(String str, DXTypeVals type)
 {
     throw new Exception("Not Yet Implemented");
 }
コード例 #24
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// Get the index'th list item from the given string which
 /// is expected to be a list. 
 /// null is returned if the item was not found or if the listtype is wrong.
 /// </summary>
 /// <param name="list"></param>
 /// <param name="index"></param>
 /// <param name="listtype"></param>
 /// <returns></returns>
 public static String GetListItem(String list, int index, DXTypeVals listtype)
 {
     throw new Exception("Not yet implemented");
 }
コード例 #25
0
        /// <summary>
        /// Calls setOutputAndOtherInteractorValues to update all interactor
        /// instances.
        /// </summary>
        /// <param name="index"></param>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <param name="send"></param>
        /// <returns></returns>
        public override DXTypeVals setOutputValue(int index, string value, DXTypeVals type, bool send)
        {
            // Set the output value of an interactor.  This is the same as for
            // Node::setOutputValue(), except that it also updates the interactors
            // in this->instanceList with
            //  InteractorInstance->Interactor->updateDisplayedInteractorValue().

            DXTypeVals dxtype;

            dxtype = base.setOutputValue(index, value, type, send);

            if ((dxtype != DXTypeVals.UndefinedType) &&
                !isVisualNotificationDeferred())
            {
                foreach (InteractorInstance ii in instanceList)
                {
                    Interactor interactor = ii.getInteractor();
                    if (interactor != null)
                        interactor.updateDisplayedInteractorValue();
                }
            }
            return dxtype;
        }
コード例 #26
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
 /// <summary>
 /// Get the number of items in the list.
 /// </summary>
 /// <param name="list"></param>
 /// <param name="listtype"></param>
 /// <returns></returns>
 public static int GetListItemCount(String list, DXTypeVals listtype)
 {
     throw new Exception("Not yet implemented");
 }
コード例 #27
0
ファイル: ImageNode.cs プロジェクト: BackupTheBerlios/opendx2
 public ParamClass(int pIndex, int opIndex, DXTypeVals pType)
 {
     paramIndex = pIndex;
     oldParamIndex = opIndex;
     paramType = pType;
     category = ParamCats.unknown;
 }
コード例 #28
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
 public static bool IsList(String str, DXTypeVals type)
 {
     bool r = IsListExplicit(str, type);
     if (!r && ((type & DXTypeVals.ValueType) > 0))
         r = IsListConstructor(str);
     return r;
 }
コード例 #29
0
ファイル: DXValue.cs プロジェクト: BackupTheBerlios/opendx2
        public static bool IsListExplicit(String str, DXTypeVals type)
        {
            bool lexed;
            int tuple = 0, first_tuple = -1;

            if (str == null)
                return false;

            str = str.Trim();
            if (!str.StartsWith("{") ||
                !str.EndsWith("}"))
                return false;

            str = str.Substring(1);
            str = str.Substring(0, str.Length -1);

            DXTypeVals value_type = DXTypeVals.UndefinedType;

            List<String> toks = Utils.StringTokenizer(str, " ,\t", new String[] { "\"", "[]" });
            Regex r;

            int elements = 0;
            foreach (String tok in toks)
            {
                switch (type)
                {
                    case DXTypeVals.FlagType:
                        r = new Regex(@"^(true|false|\d+)$");
                        lexed = r.IsMatch(tok);
                        break;
                    case DXTypeVals.IntegerType:
                        r = new Regex(Scanning.Scanner.IntegerOnlyPattern);
                        lexed = r.IsMatch(tok);
                        break;
                    case DXTypeVals.ScalarType:
                        r = new Regex(Scanning.Scanner.DoubleOnlyPattern);
                        lexed = r.IsMatch(tok);
                        break;
                    case DXTypeVals.VectorType:
                        lexed = DXTensor.IsVector(tok, ref tuple);
                        if (elements == 0)
                            first_tuple = tuple;
                        else if (tuple != first_tuple)
                            return false;
                        break;
                    case DXTypeVals.TensorType:
                        lexed = DXTensor.IsTensor(tok);
                        break;
                    case DXTypeVals.ValueType:
                        lexed = IsValue(str, ref value_type);
                        break;
                    case DXTypeVals.StringType:
                        r = new Regex(@"^""[^""]*""$");
                        lexed = r.IsMatch(tok);
                        break;
                    default:
                        return false;
                }
                if (lexed)
                    elements++;
                else
                    return false;
            }
            return true;
        }
コード例 #30
0
ファイル: Node.cs プロジェクト: BackupTheBerlios/opendx2
 private DXTypeVals setIOValueQuietly(ref List<Parameter> io, int index,
     String value, DXTypeVals t)
 {
     throw new Exception("Not Yet Implemented");
 }