Beispiel #1
0
        /// <summary>
        /// Executed upon existing the param_expr rule
        /// </summary>
        /// <param name="context">the param_expr context</param>
        public override void ExitParam_expr([NotNull] ParamExprGrammarParser.Param_exprContext context)
        {
            base.ExitParam_expr(context);
            NodeProperty paramExprNodeProp = GetNodePropertyValue(context.expr());
            object       parValue          = paramExprNodeProp.nodePropertyValue;

            // Unique parameter value can only be "enforced" for a string datatype by appending a running number: <parValue> (#), starting with 2
            if (isUnique && parValue is string)
            {
                Tuple <string, object> key = new Tuple <string, object>(RevitParameterName, parValue);
                int counter = 0;
                if (UniqueParameterValue.TryGetValue(key, out counter))
                {
                    counter++;
                    parValue = parValue.ToString() + " (" + counter.ToString() + ")";
                    UniqueParameterValue[key] = counter;
                }
                else
                {
                    UniqueParameterValue.Add(key, 1);
                }
            }
            FinalParameterValue = parValue;
            UnitType            = paramExprNodeProp.uomTypeId;
            if (paramExprNodeProp.uomTypeId != null)
            {
                if (FinalParameterValue is double)
                {
                    double?paramValueDouble = FinalParameterValue as double?;
                    formattedValue      = UnitFormatUtils.Format(RevitElement.Document.GetUnits(), paramExprNodeProp.uomTypeId, paramValueDouble.Value, false);
                    FinalParameterValue = UnitUtils.ConvertToInternalUnits(paramValueDouble.Value, paramExprNodeProp.uomTypeId);
                }
            }
        }
Beispiel #2
0
        /// <summary>
        /// Resolve "(expr)^power"
        /// </summary>
        /// <param name="expr">the expr NodeProperty</param>
        /// <param name="powerOp">the power operator</param>
        /// <returns>NodeProperty</returns>
        public static NodeProperty ResolveExprPowerOp(NodeProperty expr, int powerOp)
        {
            NodeProperty ret = new NodeProperty();

            ret.originalNodePropertyValue = "(" + expr.originalNodePropertyValue + ")^" + powerOp.ToString();
            if (expr.nodePropertyValue is double || expr.nodePropertyValue is int)
            {
                ret.nodePropertyValue = Math.Pow((double)expr.nodePropertyValue, (double)powerOp);
            }
            return(ret);
        }
Beispiel #3
0
        /// <summary>
        /// Executed upon exiting value rule
        /// </summary>
        /// <param name="context">the value context</param>
        public override void ExitValue([NotNull] ParamExprGrammarParser.ValueContext context)
        {
            base.ExitValue(context);
            object value = null;

            string valueStr = context.GetChild(0).GetText();

            if (context.GetChild(0) is ParamExprGrammarParser.StringliteralContext)
            {
                valueStr = valueStr.Trim().Replace("\'", "").Replace("\"", "");
                value    = (string)valueStr;
            }
            else if (context.GetChild(0) is ParamExprGrammarParser.RealliteralContext)
            {
                UnitType convertUnit = UnitType.UT_Length;
                bool     hasUnit     = false;

                ParamExprGrammarParser.RealliteralContext realCtx = context.GetChild(0) as ParamExprGrammarParser.RealliteralContext;
                if (realCtx.UNITTYPEENUM() != null)
                {
                    hasUnit = Enum.TryParse <UnitType>(realCtx.UNITTYPEENUM().GetText(), true, out convertUnit);
                }

                valueStr = realCtx.signed_number().GetText();
                int valueInt;
                if (Int32.TryParse(valueStr, out valueInt))
                {
                    value = (int)valueInt;
                }
                else
                {
                    double valueDbl;
                    if (Double.TryParse(valueStr, out valueDbl))
                    {
                        if (hasUnit)
                        {
                            value = (double)valueDbl / UnitUtil.ScaleDouble(convertUnit, 1.0);
                        }
                        else
                        {
                            value = (double)valueDbl;
                        }
                    }
                }
            }
            NodeProperty nodeP = new NodeProperty();

            nodeP.originalNodePropertyValue = valueStr;
            nodeP.nodePropertyValue         = value;

            SetNodePropertyValue(context, nodeP);
        }
Beispiel #4
0
        /// <summary>
        /// Executed upon exiting expr rule
        /// </summary>
        /// <param name="context">the expr context</param>
        public override void ExitExpr([NotNull] ParamExprGrammarParser.ExprContext context)
        {
            base.ExitExpr(context);
            NodeProperty retExpr = new NodeProperty();

            // value
            if (context.GetChild(0) is ParamExprGrammarParser.ValueContext && context.children.Count == 1)
            {
                retExpr = GetNodePropertyValue(context.GetChild(0));
            }
            // | atomic_param
            else if (context.GetChild(0) is ParamExprGrammarParser.Atomic_paramContext && context.children.Count == 1)
            {
                retExpr = GetNodePropertyValue(context.GetChild(0));
            }
            // | unary_operator expr
            else if (context.GetChild(0) is ParamExprGrammarParser.Unary_operatorContext && context.ChildCount == 2)
            {
                retExpr = ParamExprResolver.ResolveExprUnaryOperator(context.GetChild(0).GetText(), GetNodePropertyValue(context.GetChild(1)));
            }
            // | expr ops expr
            else if (context.GetChild(1) is ParamExprGrammarParser.OpsContext && context.ChildCount == 3)
            {
                retExpr = ParamExprResolver.ResolveExprOpsExpr(context.GetChild(0) as ParamExprGrammarParser.ExprContext, GetNodePropertyValue(context.GetChild(0)),
                                                               context.GetChild(1) as ParamExprGrammarParser.OpsContext, GetNodePropertyValue(context.GetChild(2)));
            }
            // | '(' expr ')' (power_op)?
            else if (context.GetChild(0) is ITerminalNode && context.GetChild(2) is ITerminalNode)
            {
                int powerOp = +1;
                if (context.ChildCount == 4)
                {
                    powerOp = ParamExprResolver.GetPowerOp(context.GetChild(3) as ParamExprGrammarParser.Power_opContext);
                }
                retExpr = ParamExprResolver.ResolveExprPowerOp(GetNodePropertyValue(context.GetChild(1) as ParamExprGrammarParser.ExprContext), powerOp);
            }
            else
            {
                // Not valid rule, return nothing? or the original text?
            }

            SetNodePropertyValue(context, retExpr);
        }
Beispiel #5
0
        /// <summary>
        /// Resolve unary operator for expr
        /// </summary>
        /// <param name="unaryOp">the unary operator</param>
        /// <param name="expr">the expr</param>
        /// <returns>NodeProperty</returns>
        public static NodeProperty ResolveExprUnaryOperator(string unaryOp, NodeProperty expr)
        {
            NodeProperty ret = new NodeProperty();

            ret.originalNodePropertyValue = unaryOp + " " + ret.originalNodePropertyValue;
            if (expr.nodePropertyValue == null)
            {
                return(ret);
            }

            if (expr.nodePropertyValue is Int32)
            {
                if (unaryOp.Equals("-"))
                {
                    ret.nodePropertyValue = -1 * ((int)expr.nodePropertyValue);
                }
                else
                {
                    ret.nodePropertyValue = (int)expr.nodePropertyValue;
                }
            }
            else if (expr.nodePropertyValue is double)
            {
                if (unaryOp.Equals("-"))
                {
                    ret.nodePropertyValue = -1 * ((double)expr.nodePropertyValue);
                }
                else
                {
                    ret.nodePropertyValue = (double)expr.nodePropertyValue;
                }
            }
            else
            {
                ret.nodePropertyValue = unaryOp + " " + expr.nodePropertyValue.ToString();
            }

            return(ret);
        }
Beispiel #6
0
        /// <summary>
        /// Executed upon exiting atomic_param rule
        /// </summary>
        /// <param name="context">the atomic_param context</param>
        public override void ExitAtomic_param([NotNull] ParamExprGrammarParser.Atomic_paramContext context)
        {
            base.ExitAtomic_param(context);
            NodeProperty nodeP = new NodeProperty();

            nodeP.originalNodePropertyValue = context.GetText();

            // Handle special_param
            if (context.GetChild(0) is ParamExprGrammarParser.Special_paramContext)
            {
                var spParCtx = context.GetChild(0) as ParamExprGrammarParser.Special_paramContext;
                if (spParCtx.ELEMENTID() != null)
                {
                    nodeP.nodePropertyValue = RevitElement.Id.IntegerValue;
                }
                else if (spParCtx.RUNNINGNUMBER() != null)
                {
                    var key = new Tuple <string, string>(RevitElement.Category.Name, RevitParameterName);
                    int lastNumber;
                    if (LastRunningNumberCollection.ContainsKey(key))
                    {
                        lastNumber = ++LastRunningNumberCollection[key];
                    }
                    else
                    {
                        lastNumber = 1;
                        LastRunningNumberCollection.Add(key, lastNumber);
                    }
                    nodeP.nodePropertyValue = lastNumber;
                }
                else if (spParCtx.RUNNINGNUMBERINSTANCE() != null)
                {
                    var key = new Tuple <string, string>(RevitElement.Id.ToString(), RevitParameterName);
                    int lastNumber;
                    if (LastRunningNumberCollection.ContainsKey(key))
                    {
                        lastNumber = ++LastRunningNumberCollection[key];
                    }
                    else
                    {
                        lastNumber = 1;
                        LastRunningNumberCollection.Add(key, lastNumber);
                    }
                    nodeP.nodePropertyValue = lastNumber;
                }
                //else if (spParCtx.AUTOCALCULATE() != null)
                //{

                //}
                else
                {
                    // Not supported
                }
            }
            //  handle objref param_name (',' param_name)
            else
            {
                object parValue   = null;
                var    thisObj    = context.GetChild(0) as ParamExprGrammarParser.ObjrefContext;
                var    paramNames = context.param_name();
                if (paramNames.Count() >= 1)
                {
                    // This is the first level reference
                    if (thisObj.THIS() != null)
                    {
                        parValue = GetValueFromParam_nameContext(RevitElement, paramNames[0]);
                    }
                    else if (thisObj.TYPE() != null)
                    {
                        parValue = GetValueFromParam_nameContext(RevitElement.Document.GetElement(RevitElement.GetTypeId()), paramNames[0]);
                    }
                }

                if (paramNames.Count() > 1 && parValue != null && parValue is ElementId)
                {
                    // Parameter should be obtained from the second level reference if the parameter is of ElementId type
                    parValue = GetValueFromParam_nameContext(RevitElement.Document.GetElement(parValue as ElementId), paramNames[1]);
                }
                nodeP.nodePropertyValue = parValue;
            }
            SetNodePropertyValue(context, nodeP);
        }
Beispiel #7
0
 /// <summary>
 /// Set NodeProperty
 /// </summary>
 /// <param name="node">the node</param>
 /// <param name="value">value</param>
 public void SetNodePropertyValue(Antlr4.Runtime.Tree.IParseTree node, NodeProperty value)
 {
     nodeProp.Put(node, value);
 }
Beispiel #8
0
        /// <summary>
        /// Executed upon exiting value rule
        /// </summary>
        /// <param name="context">the value context</param>
        public override void ExitValue([NotNull] ParamExprGrammarParser.ValueContext context)
        {
            base.ExitValue(context);
            object      value       = null;
            ForgeTypeId convertUnit = SpecTypeId.Number;

            string valueStr = context.GetChild(0).GetText();

            if (context.GetChild(0) is ParamExprGrammarParser.StringliteralContext)
            {
                valueStr = valueStr.Trim().Replace("\'", "").Replace("\"", "");
                value    = (string)valueStr;
            }
            else if (context.GetChild(0) is ParamExprGrammarParser.RealliteralContext)
            {
                ParamExprGrammarParser.RealliteralContext realCtx = context.GetChild(0) as ParamExprGrammarParser.RealliteralContext;

                valueStr = realCtx.signed_number().GetText();
                int valueInt;
                if (Int32.TryParse(valueStr, out valueInt))
                {
                    value = (int)valueInt;
                }
                else
                {
                    double valueDbl;
                    if (Double.TryParse(valueStr, out valueDbl))
                    {
                        value = (double)valueDbl;
                    }
                }
            }
            else if (context.GetChild(0) is ParamExprGrammarParser.Value_with_unitContext)
            {
                ParamExprGrammarParser.Value_with_unitContext vwunitCtx = context.GetChild(0) as ParamExprGrammarParser.Value_with_unitContext;
                if (vwunitCtx.UNITTYPE() != null)
                {
                    try
                    {
                        if (vwunitCtx.GetChild(2) is ParamExprGrammarParser.Atomic_paramContext)
                        {
                            NodeProperty val = GetNodePropertyValue(vwunitCtx.GetChild(2));
                            if (val.nodePropertyValue is double)
                            {
                                value = (double)val.nodePropertyValue;
                            }
                        }
                        else if (vwunitCtx.GetChild(2) is ParamExprGrammarParser.Signed_numberContext)
                        {
                            ParamExprGrammarParser.Signed_numberContext signedNum = vwunitCtx.GetChild(2) as ParamExprGrammarParser.Signed_numberContext;
                            valueStr = signedNum.GetText();
                            double valueDbl;
                            if (Double.TryParse(valueStr, out valueDbl))
                            {
                                value = (double)valueDbl;
                            }
                        }

                        string unitTypeName = vwunitCtx.UNITTYPE().GetText();
                        System.Reflection.PropertyInfo unitType = typeof(Autodesk.Revit.DB.SpecTypeId).GetProperty(unitTypeName);
                        if (unitType != null)
                        {
                            convertUnit = unitType.GetValue(null, null) as ForgeTypeId;
                        }
                    }
                    catch { }
                }
            }
            NodeProperty nodeP = new NodeProperty();

            nodeP.originalNodePropertyValue = valueStr;
            nodeP.nodePropertyValue         = value;
            nodeP.uomTypeId = convertUnit;

            SetNodePropertyValue(context, nodeP);
        }
Beispiel #9
0
        /// <summary>
        /// Resolve "expr operator expr"
        /// </summary>
        /// <param name="expr1Ctx">context of expr 1</param>
        /// <param name="expr1">NodeProperty of expr 1</param>
        /// <param name="ops">operator</param>
        /// <param name="expr2">NodeProperty of expr 2</param>
        /// <returns>NodeProperty</returns>
        public static NodeProperty ResolveExprOpsExpr(ParamExprGrammarParser.ExprContext expr1Ctx, NodeProperty expr1,
                                                      ParamExprGrammarParser.OpsContext ops, NodeProperty expr2)
        {
            NodeProperty ret = new NodeProperty();

            ret.originalNodePropertyValue = expr1.originalNodePropertyValue + " " + ops.GetText() + " " + expr2.originalNodePropertyValue;

            if (expr1.nodePropertyValue == null && expr2.nodePropertyValue == null)
            {
                return(ret);
            }

            if (expr1.nodePropertyValue == null)
            {
                // expr1 is null, the ops is undefined, returns only expr2 as it is
                ret.nodePropertyValue = expr2.nodePropertyValue;
                return(ret);
            }

            if (expr2.nodePropertyValue == null)
            {
                // expr2 is null, ops is undefined, returns only expr1 as it is
                ret.nodePropertyValue = expr1.nodePropertyValue;
                return(ret);
            }

            if (expr1.nodePropertyValue is ElementId || expr2.nodePropertyValue is ElementId)
            {
                // For ElementId to be in this oper, the Name of the Element will be used and the rest will be converted to strings
                string expr1Str = null;
                if (expr1.nodePropertyValue is ElementId)
                {
                    expr1Str = _element.Document.GetElement((ElementId)expr1.nodePropertyValue).Name;
                }
                else
                {
                    expr1Str = expr1.nodePropertyValue.ToString();
                }

                string expr2Str = null;
                if (expr2.nodePropertyValue is ElementId)
                {
                    expr2Str = _element.Document.GetElement((ElementId)expr2.nodePropertyValue).Name;
                }
                else
                {
                    expr2Str = expr2.nodePropertyValue.ToString();
                }

                //ret.nodePropertyValue = expr1Str + " " + ops.GetText() + " " + expr2Str;
                ret.nodePropertyValue = expr1Str + expr2Str;
            }
            else if (expr1.nodePropertyValue is string || expr2.nodePropertyValue is string)
            {
                // one of the expr is a string, and therefore the entire expr will returns string
                //ret.nodePropertyValue = expr1.nodePropertyValue.ToString() + " " + ops.GetText() + " " + expr2.nodePropertyValue.ToString();
                ret.nodePropertyValue = expr1.nodePropertyValue.ToString() + expr2.nodePropertyValue.ToString();
            }
            else if (expr1.nodePropertyValue is double || expr2.nodePropertyValue is double)
            {
                if (ops.MULTIPLY() != null)
                {
                    ret.nodePropertyValue = (double)expr1.nodePropertyValue * (double)expr2.nodePropertyValue;
                }
                if (ops.DIVIDE() != null)
                {
                    ret.nodePropertyValue = (double)expr1.nodePropertyValue / (double)expr2.nodePropertyValue;
                }
                if (ops.ADDITION() != null)
                {
                    ret.nodePropertyValue = (double)expr1.nodePropertyValue + (double)expr2.nodePropertyValue;
                }
                if (ops.SUBTRACT() != null)
                {
                    ret.nodePropertyValue = (double)expr1.nodePropertyValue - (double)expr2.nodePropertyValue;
                }
            }
            else
            {
                if (ops.MULTIPLY() != null)
                {
                    ret.nodePropertyValue = (int)expr1.nodePropertyValue * (int)expr2.nodePropertyValue;
                }
                if (ops.DIVIDE() != null)
                {
                    ret.nodePropertyValue = (double)((int)expr1.nodePropertyValue / (int)expr2.nodePropertyValue);
                }
                if (ops.ADDITION() != null)
                {
                    ret.nodePropertyValue = (int)expr1.nodePropertyValue + (int)expr2.nodePropertyValue;
                }
                if (ops.SUBTRACT() != null)
                {
                    ret.nodePropertyValue = (int)expr1.nodePropertyValue - (int)expr2.nodePropertyValue;
                }
            }

            return(ret);
        }