예제 #1
0
        private bool ResolveOrdinalParameter(InputNode node, int index)
        {
            // locate ordinal index

            ParameterDef param = CommandDefinition.Parameters.FirstOrDefault(p => p.OrdinalPosition == index);

            if (param == null) // ordinal parameter is not defined for current defintion
            {
                Nodes.Add(new CommandResolverNode()
                {
                    Type            = CRNodeType.OrdinalParameter,
                    IsComplete      = false,
                    InputNode       = node,
                    ResolutionError = string.Format("An ordinal parameter at position {0} could not be found for ordinal parameter value '{1}'", index, node.Value)
                });

                return(false);
            }
            else
            {
                Nodes.Add(new CommandResolverNode()
                {
                    Type       = CRNodeType.OrdinalParameter,
                    IsComplete = true,
                    InputNode  = node,
                    Parameter  = param
                });

                return(true);
            }
        }
예제 #2
0
        /// <summary>
        /// Returns information about the parameters found on the given type
        /// </summary>
        /// <param name="type">The type to find Parameter attributes for</param>
        /// <returns>A list of ParameterDef objects which describe the InputCommandNamed arameters
        /// found on in the type</returns>
        private static List <ParameterDef> GetParameterDefinitions(Type type)
        {
            List <ParameterDef> infoList = new List <ParameterDef>();

            PropertyInfo[] propertiesList = type.GetProperties();
            foreach (var property in propertiesList)
            {
                Parameter parameterAttribute = GetAttributes <Parameter>(property).FirstOrDefault();
                Synopsis  synopsisAttribute  = GetAttributes <Synopsis>(property).FirstOrDefault();

                if (parameterAttribute != null)
                {
                    ParameterDef info = new ParameterDef();
                    info.PropertyInfo = property;
                    info.Name         = parameterAttribute.ParameterName ?? property.Name;
                    info.AddAliases(GetAttributes <Alias>(property).Select(a => a.Value));
                    info.IsRequired                   = parameterAttribute.IsRequired;
                    info.OrdinalPosition              = parameterAttribute.OrdinalPosition;
                    info.Synopsis                     = synopsisAttribute == null ? null : synopsisAttribute.Value;
                    info.ParameterSet                 = parameterAttribute.ParameterSet;
                    info.AutoCompleteValuesFunction   = parameterAttribute.AutoCompleteValuesFunction;
                    info.UseAutoCompleteForValidation = parameterAttribute.UseAutoCompleteForValidation;
                    info.ValidationFunction           = parameterAttribute.ValidationFunction;

                    infoList.Add(info);
                }
            }

            return(infoList);
        }
예제 #3
0
        protected override MathNode OnCreateClone(MathNode parent)
        {
            ParameterDef[] ps = null;
            if (_methodRef.Parameters != null)
            {
                ps = new ParameterDef[_methodRef.Parameters.Length];
                for (int i = 0; i < _methodRef.Parameters.Length; i++)
                {
                    ps[i] = (ParameterDef)_methodRef.Parameters[i].Clone();
                }
            }
            ObjectRef ow = null;

            if (_methodRef.MethodOwner != null)
            {
                ow = (ObjectRef)_methodRef.MethodOwner.Clone();
            }
            RaisDataType ret;

            if (_methodRef.ReturnType != null)
            {
                ret = (RaisDataType)_methodRef.ReturnType.Clone();
            }
            else
            {
                ret = new RaisDataType(typeof(void));
            }
            return(new MathNodeMethodInvoke(parent, ow, _methodRef.MethodName, _methodRef.MethodID, ret, ps));
        }
예제 #4
0
 public void addParameter(ParameterDef paramDef, ParamCommand paramCmd)
 {
     OgrePINVOKE.ParamDictionary_addParameter(swigCPtr, ParameterDef.getCPtr(paramDef), ParamCommand.getCPtr(paramCmd));
     if (OgrePINVOKE.SWIGPendingException.Pending)
     {
         throw OgrePINVOKE.SWIGPendingException.Retrieve();
     }
 }
예제 #5
0
        public void ConstructorTests()
        {
            ParameterDef pd = new ParameterDef("key", UrlDefinitionDataTypes.Data, "value");

            Assert.AreEqual <string>(pd.Name, "key");
            Assert.AreEqual <string>(pd.Type.ToString(), UrlDefinitionDataTypes.Data.ToString());
            Assert.AreEqual <string>(pd.Value, "value");
        }
예제 #6
0
        private ParameterDef ParseParameter(ParameterSyntax parameter, SemanticModel semanticModel)
        {
            var parameterDef = new ParameterDef();

            parameterDef.Name = parameter.Identifier.ValueText;
            parameterDef.Type = ParseTypeSpecifier(parameter.Type, semanticModel);

            return(parameterDef);
        }
예제 #7
0
        public void AddParameterDef(ParameterDef parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException("parameter");
            }

            if (_parameters.ContainsKey(parameter.Name))
            {
                throw new InvalidOperationException(String.Format("A parameter named {0} is already defined in this scope.", parameter.Name));
            }

            _parameters.Add(parameter.Name, parameter);
        }
        private XmlMapElement FindParameterElement(ParameterDef symbol)
        {
            var method = symbol.Method;

            if (method.IsDefinition)
            {
                XmlMapElement elMethod = FindMethodElement((MethodDef)method);
                if (elMethod != null)
                {
                    var elParameters = GetParameters(elMethod);
                    if (symbol.Index < elParameters.Length)
                    {
                        return(elParameters[symbol.Index]);
                    }
                }
            }
            return(null);
        }
예제 #9
0
        public void Visit(ParameterDef parameterDef, object[] args)
        {
            if (reader.MoveToAttribute("type"))
            {
                parameterDef.ParameterType = (ParameterDef.ParameterTypeEnum)Enum.Parse(typeof(ParameterDef.ParameterTypeEnum), reader.Value);
            }
            else
            {
                parameterDef.ParameterType = ParameterDef.ParameterTypeEnum.Auto;
            }

            if (reader.MoveToAttribute("default"))
            {
                Location loc = new Location(file, reader.LineNumber, reader.LinePosition).Offset(9);    //TODO: Position
                switch (parameterDef.ParameterType)
                {
                case ParameterDef.ParameterTypeEnum.Auto:
                    parameterDef.Default = exprParser.ParseValue(reader.Value, loc);
                    break;

                case ParameterDef.ParameterTypeEnum.String:
                    parameterDef.Default = exprParser.ParseValue(reader.Value, Expr.DataType.String, loc);
                    break;

                case ParameterDef.ParameterTypeEnum.Expression:
                    parameterDef.Default = exprParser.ParseValue(reader.Value, loc);
                    break;

                case ParameterDef.ParameterTypeEnum.Int:
                    parameterDef.Default = exprParser.ParseValue(reader.Value, Expr.DataType.Int, loc);
                    break;

                case ParameterDef.ParameterTypeEnum.Float:
                    parameterDef.Default = exprParser.ParseValue(reader.Value, Expr.DataType.Float, loc);
                    break;

                case ParameterDef.ParameterTypeEnum.Bool:
                    parameterDef.Default = exprParser.ParseValue(reader.Value, Expr.DataType.Bool, loc);
                    break;
                }
            }
        }
        private List <string> GetParameterAutoComplete(CommandResolver resolver, InputNode currentNode)
        {
            CommandResolverNode resolverNode = resolver.GetNode(currentNode);
            ParameterDef        def          = resolverNode != null ? resolverNode.Parameter : null;

            string validationFunctionName = null;

            // try to find ordinal parameter definition for an empty element

            if (def == null && currentNode.ElementType == InputNodeType.Empty)
            {
                int ordinalIndex = resolver.Input.InputNodes
                                   .Where(n => n.Index < currentNode.Index && n.ElementType == InputNodeType.OrdinalParameterValue).Count() + 1;

                def = new CommandParameterAnalysis(resolver).AvailableParameters
                      .Where(p => p.OrdinalPosition == ordinalIndex).FirstOrDefault();
            }

            // find validation function for a valid resolver node

            if (def != null)
            {
                validationFunctionName = def.AutoCompleteValuesFunction;
            }

            // execute validation values function

            try
            {
                if (validationFunctionName != null)
                {
                    return(Util.GetParameterAutoCompleteValues(resolver, def, _hostInterface)
                           .Where(v => v.StartsWith(currentNode.Value, StringComparison.OrdinalIgnoreCase)).ToList());
                }
            }
            catch (Exception ex)
            {
                // TODO: Do something with this exception
            }

            return(null);
        }
예제 #11
0
        private void ResolveNamedParameter(InputNode node)
        {
            // get parameter definition - add resolution error and exit if not found

            ParameterDef param = GetParameterDefinition(node.Value);

            if (param == null) // parameter is not defined in defintion
            {
                Nodes.Add(new CommandResolverNode()
                {
                    Type            = CRNodeType.NamedParameter,
                    IsComplete      = false,
                    InputNode       = node,
                    ResolutionError = string.Format("Parameter '{0}' is undefined", node.Value)
                });
            }
            else if (Nodes.Exists(n => n.Parameter == param)) // parameter is already specified in input
            {
                Nodes.Add(new CommandResolverNode()
                {
                    Type            = CRNodeType.NamedParameter,
                    IsComplete      = false,
                    InputNode       = node,
                    ResolutionError = string.Format("Parameter '{0}' is already defined", node.Value)
                });
            }
            else // resolve node
            {
                Nodes.Add(new CommandResolverNode()
                {
                    Type       = CRNodeType.NamedParameter,
                    IsComplete = node.IsPairedWith != null,
                    InputNode  = node,
                    Parameter  = param,
                });
            }
        }
예제 #12
0
        private static void Collect(HashSet<XNamespace> result, ParameterDef element)
        {
            result.AddXNamespaceOfXName(element.Name);

            foreach (var p in element.Properties)
            {
                Collect(result, p);
            }
        }
예제 #13
0
        public static List <string> GetParameterAutoCompleteValues(CommandResolver resolver, ParameterDef paramDef, IHostInterface host)
        {
            if (string.IsNullOrWhiteSpace(paramDef.AutoCompleteValuesFunction))
            {
                throw new ArgumentException(string.Format("Parameter definition for parameter {0} does not define an auto complete values function"
                                                          , paramDef.Name));
            }

            var cmd = new CommandActivator().Create(resolver, host);

            var methodInfo = cmd.GetType().GetMethod(paramDef.AutoCompleteValuesFunction);

            if (methodInfo == null)
            {
                throw new ArgumentException(string.Format("Auto complete values function '{0}' cannot be found for parameter {0}"
                                                          , paramDef.AutoCompleteValuesFunction, paramDef.Name));
            }

            var context = new AutoCompleteValuesFunctionContext();

            methodInfo.Invoke(cmd, new object[] { context });

            return(context.Values);
        }
        private static DeclarationList CreateCurrentDeclarations()
        {
            DeclarationList declarationList = new DeclarationList();
            int             num             = 1;

            declarationList[num++] = IDOwner.GetDeclaration();
            declarationList[num++] = ReportItem.GetDeclaration();
            num++;
            declarationList[num++] = Report.GetDeclaration();
            declarationList[num++] = PageSection.GetDeclaration();
            declarationList[num++] = Line.GetDeclaration();
            declarationList[num++] = Rectangle.GetDeclaration();
            declarationList[num++] = Image.GetDeclaration();
            num++;
            declarationList[num++] = CheckBox.GetDeclaration();
            declarationList[num++] = TextBox.GetDeclaration();
            declarationList[num++] = SubReport.GetDeclaration();
            declarationList[num++] = ActiveXControl.GetDeclaration();
            declarationList[num++] = DataRegion.GetDeclaration();
            num++;
            declarationList[num++] = ReportHierarchyNode.GetDeclaration();
            declarationList[num++] = Grouping.GetDeclaration();
            declarationList[num++] = Sorting.GetDeclaration();
            declarationList[num++] = List.GetDeclaration();
            declarationList[num++] = Pivot.GetDeclaration();
            declarationList[num++] = Matrix.GetDeclaration();
            declarationList[num++] = PivotHeading.GetDeclaration();
            declarationList[num++] = MatrixHeading.GetDeclaration();
            declarationList[num++] = MatrixColumn.GetDeclaration();
            num++;
            declarationList[num++] = MatrixRow.GetDeclaration();
            num++;
            declarationList[num++] = Subtotal.GetDeclaration();
            declarationList[num++] = Table.GetDeclaration();
            declarationList[num++] = TableColumn.GetDeclaration();
            num++;
            declarationList[num++] = TableGroup.GetDeclaration();
            declarationList[num++] = TableRow.GetDeclaration();
            num++;
            declarationList[num++] = OWCChart.GetDeclaration();
            declarationList[num++] = ChartColumn.GetDeclaration();
            num++;
            declarationList[num++] = ReportItemCollection.GetDeclaration();
            declarationList[num++] = ReportItemIndexer.GetDeclaration();
            num++;
            declarationList[num++] = Style.GetDeclaration();
            num++;
            declarationList[num++] = AttributeInfo.GetDeclaration();
            declarationList[num++] = Visibility.GetDeclaration();
            declarationList[num++] = ExpressionInfo.GetDeclaration();
            num++;
            declarationList[num++] = DataAggregateInfo.GetDeclaration();
            num++;
            declarationList[num++] = RunningValueInfo.GetDeclaration();
            num++;
            num++;
            declarationList[num++] = Filter.GetDeclaration();
            num++;
            declarationList[num++] = DataSource.GetDeclaration();
            num++;
            declarationList[num++] = DataSet.GetDeclaration();
            num++;
            declarationList[num++] = ReportQuery.GetDeclaration();
            declarationList[num++] = Field.GetDeclaration();
            num++;
            declarationList[num++] = ParameterValue.GetDeclaration();
            num++;
            num++;
            num++;
            num++;
            declarationList[num++] = ReportSnapshot.GetDeclaration();
            declarationList[num++] = SenderInformation.GetDeclaration();
            declarationList[num++] = InstanceInfo.GetDeclaration();
            declarationList[num++] = ReceiverInformation.GetDeclaration();
            declarationList[num++] = InstanceInfo.GetDeclaration();
            declarationList[num++] = DocumentMapNode.GetDeclaration();
            declarationList[num++] = InfoBase.GetDeclaration();
            declarationList[num++] = OffsetInfo.GetDeclaration();
            declarationList[num++] = InstanceInfo.GetDeclaration();
            declarationList[num++] = ReportItemInstanceInfo.GetDeclaration();
            declarationList[num++] = ReportInstanceInfo.GetDeclaration();
            declarationList[num++] = ReportItemColInstanceInfo.GetDeclaration();
            declarationList[num++] = LineInstanceInfo.GetDeclaration();
            declarationList[num++] = TextBoxInstanceInfo.GetDeclaration();
            declarationList[num++] = RectangleInstanceInfo.GetDeclaration();
            declarationList[num++] = CheckBoxInstanceInfo.GetDeclaration();
            declarationList[num++] = ImageInstanceInfo.GetDeclaration();
            declarationList[num++] = SubReportInstanceInfo.GetDeclaration();
            declarationList[num++] = ActiveXControlInstanceInfo.GetDeclaration();
            declarationList[num++] = ListInstanceInfo.GetDeclaration();
            declarationList[num++] = ListContentInstanceInfo.GetDeclaration();
            declarationList[num++] = MatrixInstanceInfo.GetDeclaration();
            declarationList[num++] = MatrixHeadingInstanceInfo.GetDeclaration();
            declarationList[num++] = MatrixCellInstanceInfo.GetDeclaration();
            declarationList[num++] = TableInstanceInfo.GetDeclaration();
            declarationList[num++] = TableGroupInstanceInfo.GetDeclaration();
            declarationList[num++] = TableRowInstanceInfo.GetDeclaration();
            declarationList[num++] = OWCChartInstanceInfo.GetDeclaration();
            declarationList[num++] = ChartInstanceInfo.GetDeclaration();
            declarationList[num++] = NonComputedUniqueNames.GetDeclaration();
            declarationList[num++] = InstanceInfoOwner.GetDeclaration();
            declarationList[num++] = ReportItemInstance.GetDeclaration();
            num++;
            declarationList[num++] = ReportInstance.GetDeclaration();
            declarationList[num++] = ReportItemColInstance.GetDeclaration();
            declarationList[num++] = LineInstance.GetDeclaration();
            declarationList[num++] = TextBoxInstance.GetDeclaration();
            declarationList[num++] = RectangleInstance.GetDeclaration();
            declarationList[num++] = CheckBoxInstance.GetDeclaration();
            declarationList[num++] = ImageInstance.GetDeclaration();
            declarationList[num++] = SubReportInstance.GetDeclaration();
            declarationList[num++] = ActiveXControlInstance.GetDeclaration();
            declarationList[num++] = ListInstance.GetDeclaration();
            declarationList[num++] = ListContentInstance.GetDeclaration();
            num++;
            declarationList[num++] = MatrixInstance.GetDeclaration();
            declarationList[num++] = MatrixHeadingInstance.GetDeclaration();
            num++;
            declarationList[num++] = MatrixCellInstance.GetDeclaration();
            num++;
            num++;
            declarationList[num++] = TableInstance.GetDeclaration();
            declarationList[num++] = TableRowInstance.GetDeclaration();
            declarationList[num++] = TableColumnInstance.GetDeclaration();
            declarationList[num++] = TableGroupInstance.GetDeclaration();
            num++;
            declarationList[num++] = OWCChartInstance.GetDeclaration();
            declarationList[num++] = ParameterInfo.GetDeclaration();
            num++;
            num++;
            num++;
            declarationList[num++] = InstanceInfo.GetDeclaration();
            num++;
            declarationList[num++] = RecordSetInfo.GetDeclaration();
            declarationList[num++] = RecordRow.GetDeclaration();
            declarationList[num++] = RecordField.GetDeclaration();
            declarationList[num++] = ValidValue.GetDeclaration();
            num++;
            declarationList[num++] = ParameterDataSource.GetDeclaration();
            declarationList[num++] = ParameterDef.GetDeclaration();
            num++;
            declarationList[num++] = ParameterBase.GetDeclaration();
            num++;
            declarationList[num++] = ProcessingMessage.GetDeclaration();
            declarationList[num++] = MatrixSubtotalHeadingInstanceInfo.GetDeclaration();
            declarationList[num++] = MatrixSubtotalCellInstance.GetDeclaration();
            declarationList[num++] = CodeClass.GetDeclaration();
            num++;
            declarationList[num++] = TableDetail.GetDeclaration();
            declarationList[num++] = TableDetailInstance.GetDeclaration();
            num++;
            declarationList[num++] = TableDetailInstanceInfo.GetDeclaration();
            num++;
            declarationList[num++] = Action.GetDeclaration();
            declarationList[num++] = ActionInstance.GetDeclaration();
            declarationList[num++] = Chart.GetDeclaration();
            declarationList[num++] = ChartHeading.GetDeclaration();
            declarationList[num++] = ChartDataPoint.GetDeclaration();
            num++;
            declarationList[num++] = MultiChart.GetDeclaration();
            declarationList[num++] = MultiChartInstance.GetDeclaration();
            num++;
            declarationList[num++] = Axis.GetDeclaration();
            declarationList[num++] = AxisInstance.GetDeclaration();
            declarationList[num++] = ChartTitle.GetDeclaration();
            declarationList[num++] = ChartTitleInstance.GetDeclaration();
            declarationList[num++] = ThreeDProperties.GetDeclaration();
            declarationList[num++] = PlotArea.GetDeclaration();
            declarationList[num++] = Legend.GetDeclaration();
            declarationList[num++] = GridLines.GetDeclaration();
            declarationList[num++] = ChartDataLabel.GetDeclaration();
            declarationList[num++] = ChartInstance.GetDeclaration();
            declarationList[num++] = ChartHeadingInstance.GetDeclaration();
            declarationList[num++] = ChartHeadingInstanceInfo.GetDeclaration();
            num++;
            declarationList[num++] = ChartDataPointInstance.GetDeclaration();
            declarationList[num++] = ChartDataPointInstanceInfo.GetDeclaration();
            num++;
            num++;
            declarationList[num++] = RenderingPagesRanges.GetDeclaration();
            num++;
            declarationList[num++] = IntermediateFormatVersion.GetDeclaration();
            declarationList[num++] = ImageInfo.GetDeclaration();
            declarationList[num++] = ActionItem.GetDeclaration();
            declarationList[num++] = ActionItemInstance.GetDeclaration();
            num++;
            num++;
            declarationList[num++] = DataValue.GetDeclaration();
            declarationList[num++] = DataValueInstance.GetDeclaration();
            num++;
            num++;
            declarationList[num++] = Tablix.GetDeclaration();
            declarationList[num++] = TablixHeading.GetDeclaration();
            declarationList[num++] = CustomReportItem.GetDeclaration();
            declarationList[num++] = CustomReportItemInstance.GetDeclaration();
            declarationList[num++] = CustomReportItemHeading.GetDeclaration();
            declarationList[num++] = CustomReportItemHeadingInstance.GetDeclaration();
            num++;
            num++;
            num++;
            num++;
            declarationList[num++] = CustomReportItemCellInstance.GetDeclaration();
            num++;
            num++;
            declarationList[num++] = DataValueCRIList.GetDeclaration();
            declarationList[num++] = BookmarkInformation.GetDeclaration();
            declarationList[num++] = InstanceInfo.GetDeclaration();
            declarationList[num++] = DrillthroughInformation.GetDeclaration();
            declarationList[num++] = InstanceInfo.GetDeclaration();
            num++;
            declarationList[num++] = CustomReportItemInstanceInfo.GetDeclaration();
            declarationList[num++] = ImageMapAreaInstanceList.GetDeclaration();
            declarationList[num++] = ImageMapAreaInstance.GetDeclaration();
            num++;
            declarationList[num++] = InstanceInfo.GetDeclaration();
            declarationList[num++] = SortFilterEventInfo.GetDeclaration();
            declarationList[num++] = EndUserSort.GetDeclaration();
            num++;
            num++;
            declarationList[num++] = RecordSetPropertyNames.GetDeclaration();
            num++;
            num++;
            num++;
            declarationList[num++] = PageSectionInstance.GetDeclaration();
            num++;
            declarationList[num++] = PageSectionInstanceInfo.GetDeclaration();
            declarationList[num++] = SimpleTextBoxInstanceInfo.GetDeclaration();
            declarationList[num++] = ScopeLookupTable.GetDeclaration();
            num++;
            declarationList[num++] = ReportDrillthroughInfo.GetDeclaration();
            declarationList[num++] = InstanceInfo.GetDeclaration();
            Global.Tracer.Assert(declarationList.Count == num, "(current.Count == index)");
            return(declarationList);
        }
예제 #15
0
 public void Visit(ParameterDef parameterDef, object[] args)
 {
 }
 internal LegacyReportParameterDataSetCache(ProcessReportParameters aParamProcessor, ParameterInfo aParameter, ParameterDef aParamDef, bool aProcessValidValues, bool aProcessDefaultValues)
     : base(aParamProcessor, aParameter, aParamDef, aProcessValidValues, aProcessDefaultValues)
 {
 }
예제 #17
0
        private void VerifyResponseBindings(VerificationContext context, Node node, Dictionary <string, ParameterDef> containers)
        {
            // foreach action
            // If DeclareResponseAction
            // Create a parameter with that name
            // If CollectInformationAction
            // Create a property on the appropriate parameter with the correct type
            // Name = responseBinding.property
            // Type = responseCardinality = Single ? responseDataType : List<responseDataType>

            try
            {
                switch (node.NodeType.GetLocalName())
                {
                case "DeclareResponseAction":
                {
                    var containerName = node.GetAttribute <string>("name");
                    var container     = new ParameterDef {
                        Name = containerName, ParameterType = new ObjectType(containerName + "Type", new List <PropertyDef> {
                            })
                    };
                    containers.Add(container.Name, container);
                }
                break;

                case "CollectInformationAction":
                {
                    var responseBinding = node.Children.FirstOrDefault(c => c.Name == "responseBinding");
                    if (responseBinding != null)
                    {
                        var containerName = responseBinding.GetAttribute <string>("container");
                        if (String.IsNullOrEmpty(containerName))
                        {
                            containerName = "Responses";
                        }

                        if (!containers.ContainsKey(containerName))
                        {
                            throw new InvalidOperationException(String.Format("Could not resolve response container name {0}.", containerName));
                        }

                        var container     = containers[containerName];
                        var containerType = (ObjectType)container.ParameterType;

                        DataType responseType         = null;
                        var      responseName         = responseBinding.GetAttribute <string>("property");
                        var      documentationConcept = node.Children.FirstOrDefault(c => c.Name == "documentationConcept");
                        if (documentationConcept != null)
                        {
                            var responseDataType = documentationConcept.Children.FirstOrDefault(c => c.Name == "responseDataType");
                            if (responseDataType != null)
                            {
                                responseType = context.ResolveType(responseDataType.GetAttribute <string>("value"));
                            }
                            else
                            {
                                responseType = DataTypes.String;
                            }

                            var responseCardinality = documentationConcept.Children.FirstOrDefault(c => c.Name == "responseCardinality");
                            if (responseCardinality != null)
                            {
                                if (responseCardinality.GetAttribute <string>("value") == "Multiple")
                                {
                                    responseType = new ListType(responseType);
                                }
                            }
                        }

                        if (responseType == null)
                        {
                            responseType = DataTypes.String;
                        }

                        if (containerType.Properties.FirstOrDefault(pd => pd.Name == responseName) != null)
                        {
                            throw new InvalidOperationException(String.Format("The response container {0} already has a response named {1}.", container.Name, responseName));
                        }

                        containerType.Properties.Add(new PropertyDef(responseName, responseType));
                    }
                }
                break;
                }
            }
            catch (Exception e)
            {
                context.ReportMessage(e, node);
            }

            foreach (var child in node.Children)
            {
                VerifyResponseBindings(context, child, containers);
            }
        }
 public void Visit(ParameterDef parameterDef, object[] args)
 {
     throw new NotImplementedException();
 }
예제 #19
0
        public override void Visit(FunctionCallStmt funcCallStmt, object[] args)
        {
            if (!root.FuncDefMap.ContainsKey(funcCallStmt.Name))
            {
                kernel.IssueError(ErrorType.FunctionNotExist, funcCallStmt.Location, funcCallStmt.Name);
                return;
            }

            FunctionDef def = root.FuncDefMap[funcCallStmt.Name];

            //解析ParaStr
            if (funcCallStmt.ParaStr != null)
            {
                int count = funcCallStmt.ParaStr.Length;
                if (def.ParaStrMap.ContainsKey(count))
                {
                    for (int i = 0; i < funcCallStmt.ParaStr.Length; i++)
                    {
                        string varName = def.ParaStrMap[count][i];
                        string content = funcCallStmt.ParaStr[i];
                        if (funcCallStmt.ParamMap.ContainsKey(varName))
                        {
                            kernel.IssueError(ErrorType.DuplicatedParaAndParaStr, funcCallStmt.Location, varName);
                        }
                        else
                        {
                            funcCallStmt.ParamMap.Add(varName, exprParser.CreateStringConst(content, funcCallStmt.Location));
                        }
                    }
                }
                else
                {
                    kernel.IssueError(ErrorType.NoMatchedParaStrDef, funcCallStmt.Location);
                }
            }

            //解析实参
            List <KeyValuePair <string, Expression> > toModify = new List <KeyValuePair <string, Expression> >();

            foreach (KeyValuePair <string, Expression> actual in funcCallStmt.ParamMap)
            {
                ParameterDef paramDef  = def.ParaMap[actual.Key];
                string       actualStr = ((actual.Value as RightValueExpr).RightValue as StringConst).Value;
                Location     loc       = actual.Value.Location;

                RightValue     parsedValue    = null;
                RightValueExpr rightValueExpr = new RightValueExpr();

                switch (paramDef.ParameterType)
                {
                case ParameterDef.ParameterTypeEnum.Auto:
                    parsedValue = exprParser.ParseValue(actualStr, loc);
                    break;

                case ParameterDef.ParameterTypeEnum.String:
                    continue;

                case ParameterDef.ParameterTypeEnum.Expression:
                    toModify.Add(new KeyValuePair <string, Expression>(actual.Key, exprParser.ParseExpr(actualStr, loc)));
                    continue;

                case ParameterDef.ParameterTypeEnum.Int:
                    parsedValue = exprParser.ParseValue(actualStr, DataType.Int, loc);
                    break;

                case ParameterDef.ParameterTypeEnum.Float:
                    parsedValue = exprParser.ParseValue(actualStr, DataType.Float, loc);
                    break;

                case ParameterDef.ParameterTypeEnum.Bool:
                    parsedValue = exprParser.ParseValue(actualStr, DataType.Bool, loc);
                    break;
                }

                rightValueExpr.RightValue = parsedValue;
                rightValueExpr.Location   = loc;
                toModify.Add(new KeyValuePair <string, Expression>(actual.Key, rightValueExpr));
            }

            foreach (KeyValuePair <string, Expression> elem in toModify)
            {
                funcCallStmt.ParamMap[elem.Key] = elem.Value;
            }

            //添加默认值
            foreach (KeyValuePair <string, ParameterDef> pDef in def.ParaMap)
            {
                if (!funcCallStmt.ParamMap.ContainsKey(pDef.Key) && pDef.Value.Default != null)
                {
                    RightValueExpr expr = new RightValueExpr();
                    expr.RightValue = pDef.Value.Default;
                    funcCallStmt.ParamMap.Add(pDef.Key, expr);
                }
            }

            //参数完整性检查
            foreach (KeyValuePair <string, ParameterDef> pDef in def.ParaMap)
            {
                if (!funcCallStmt.ParamMap.ContainsKey(pDef.Key))
                {
                    kernel.IssueError(ErrorType.ParameterNotDefined, funcCallStmt.Location, pDef.Key);
                }
            }

            base.Visit(funcCallStmt, args);

            //TODO: 刷新Expression的DataType
        }
예제 #20
0
        private static void Write(XmlWriter writer, ParameterDef element)
        {
            writer.WriteStartElement(Psf.ParameterDef.LocalName, Psf.Namespace.NamespaceName);
            writer.WriteAttributeString("name", element.Name.ToQName(writer));

            foreach (var p in element.Properties)
            {
                Write(writer, p);
            }

            writer.WriteEndElement();
        }
예제 #21
0
 internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ParameterDef obj)
 {
     return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
 }
예제 #22
0
        public void Visit(FunctionDef functionDef, object[] args)
        {
            Location location = new Location(file, reader.LineNumber, reader.LinePosition);

            functionDef.ParaMap        = new Dictionary <string, ParameterDef>();
            functionDef.FuncDefContent = new List <Statement>();
            //funcParaStrMap.Add(functionDef.Name, new List<string>());
            functionDef.ParaStrMap = new Dictionary <int, string[]>();

            while (reader.Read())
            {
                reader.MoveToContent();
                switch (reader.NodeType)
                {
                case XmlNodeType.Element:
                    switch (dic[reader.Name])
                    {
                    case "para":
                        reader.MoveToAttribute("name");
                        string parName = reader.Value;
                        parName = parName.Substring(1, parName.Length - 1);         //去掉$符
                        if (functionDef.ParaMap.ContainsKey(parName))
                        {
                            kernel.IssueError(ErrorType.DuplicatedParameter,
                                              new Location(file, reader.LineNumber, reader.LinePosition),
                                              parName,
                                              functionDef.Name
                                              );
                            continue;
                        }

                        ParameterDef parDef = new ParameterDef();
                        parDef.Location = location;
                        parDef.Parent   = functionDef;
                        functionDef.ParaMap.Add(parName, parDef);

                        parDef.Accept(this);

                        break;

                    case "parastr":
                        //funcParaStrMap[functionDef.Name].Add(reader.ReadString());
                        string   paraStrDef = reader.ReadString();
                        string[] paraStr    = ParaStrProcessor.ReadDefVarList(paraStrDef);
                        if (paraStr == null)
                        {
                            kernel.IssueError(ErrorType.ParaStrDefFormatError, getCurrentLoc(), paraStrDef);
                        }
                        else if (functionDef.ParaStrMap.ContainsKey(paraStr.Length))
                        {
                            kernel.IssueError(ErrorType.SameNumberInParaStr, getCurrentLoc());
                        }
                        else
                        {
                            foreach (string varName in paraStr)
                            {
                                if (!functionDef.ParaMap.ContainsKey(varName))
                                {
                                    kernel.IssueError(ErrorType.ParameterNotDefined, getCurrentLoc(), varName);
                                }
                            }
                            functionDef.ParaStrMap.Add(paraStr.Length, paraStr);
                        }
                        break;

                    case "funcdef":
                        if (reader.IsEmptyElement)
                        {
                            break;
                        }

                        visitMainContent(functionDef, functionDef.FuncDefContent);
                        break;

                    default:
                        break;
                    }
                    break;

                case XmlNodeType.EndElement:
                    reader.Read();
                    return;
                }
            }
        }
예제 #23
0
        public IPersistable CreateRIFObject(ObjectType objectType, ref IntermediateFormatReader context)
        {
            IPersistable persistable = null;

            if (objectType == ObjectType.Null)
            {
                return(null);
            }
            IDOwner    parentIDOwner    = this.m_parentIDOwner;
            ReportItem parentReportItem = this.m_parentReportItem;

            switch (objectType)
            {
            case ObjectType.PageSection:
                persistable             = new PageSection(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.Line:
                persistable             = new Line(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.Rectangle:
                persistable             = new Rectangle(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.Image:
                persistable             = new Image(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.TextBox:
                persistable             = new TextBox(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.SubReport:
                persistable             = new SubReport(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.Grouping:
                persistable = new Grouping(ConstructionPhase.Deserializing);
                break;

            case ObjectType.Sorting:
                persistable = new Sorting(ConstructionPhase.Deserializing);
                break;

            case ObjectType.ReportItemCollection:
                persistable = new ReportItemCollection();
                break;

            case ObjectType.ReportItemIndexer:
                persistable = (IPersistable)(object)default(ReportItemIndexer);
                break;

            case ObjectType.Style:
                persistable = new Style(ConstructionPhase.Deserializing);
                break;

            case ObjectType.AttributeInfo:
                persistable = new AttributeInfo();
                break;

            case ObjectType.Visibility:
                persistable = new Visibility();
                break;

            case ObjectType.ExpressionInfo:
                persistable = new ExpressionInfo();
                break;

            case ObjectType.ExpressionInfoTypeValuePair:
                persistable = new ExpressionInfoTypeValuePair();
                break;

            case ObjectType.DataAggregateInfo:
                persistable = new DataAggregateInfo();
                break;

            case ObjectType.RunningValueInfo:
                persistable = new RunningValueInfo();
                break;

            case ObjectType.Filter:
                persistable = new Filter();
                break;

            case ObjectType.DataSource:
                persistable = new DataSource();
                break;

            case ObjectType.DataSet:
                persistable = new DataSet();
                break;

            case ObjectType.ReportQuery:
                persistable = new ReportQuery();
                break;

            case ObjectType.Field:
                persistable = new Field();
                break;

            case ObjectType.ParameterValue:
                persistable = new ParameterValue();
                break;

            case ObjectType.ReportSnapshot:
                persistable = new ReportSnapshot();
                break;

            case ObjectType.DocumentMapNode:
                persistable = new DocumentMapNode();
                break;

            case ObjectType.DocumentMapBeginContainer:
                persistable = DocumentMapBeginContainer.Instance;
                break;

            case ObjectType.DocumentMapEndContainer:
                persistable = DocumentMapEndContainer.Instance;
                break;

            case ObjectType.ReportInstance:
                persistable = new ReportInstance();
                break;

            case ObjectType.ParameterInfo:
                persistable = new ParameterInfo();
                break;

            case ObjectType.ValidValue:
                persistable = new ValidValue();
                break;

            case ObjectType.ParameterDataSource:
                persistable = new ParameterDataSource();
                break;

            case ObjectType.ParameterDef:
                persistable = new ParameterDef();
                break;

            case ObjectType.ProcessingMessage:
                persistable = new ProcessingMessage();
                break;

            case ObjectType.CodeClass:
                persistable = (IPersistable)(object)default(CodeClass);
                break;

            case ObjectType.Action:
                persistable = new Action();
                break;

            case ObjectType.RenderingPagesRanges:
                persistable = (IPersistable)(object)default(RenderingPagesRanges);
                break;

            case ObjectType.IntermediateFormatVersion:
                persistable = new IntermediateFormatVersion();
                break;

            case ObjectType.ImageInfo:
                persistable = new ImageInfo();
                break;

            case ObjectType.ActionItem:
                persistable = new ActionItem();
                break;

            case ObjectType.DataValue:
                persistable = new DataValue();
                break;

            case ObjectType.CustomReportItem:
                persistable             = new CustomReportItem(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.SortFilterEventInfoMap:
                persistable = new SortFilterEventInfoMap();
                break;

            case ObjectType.SortFilterEventInfo:
                persistable = new SortFilterEventInfo();
                break;

            case ObjectType.EndUserSort:
                persistable = new EndUserSort();
                break;

            case ObjectType.ScopeLookupTable:
                persistable = new ScopeLookupTable();
                break;

            case ObjectType.Tablix:
                persistable             = new Tablix(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.TablixHeader:
                persistable = new TablixHeader();
                break;

            case ObjectType.TablixMember:
                persistable = new TablixMember();
                break;

            case ObjectType.TablixColumn:
                persistable = new TablixColumn();
                break;

            case ObjectType.TablixRow:
                persistable = new TablixRow();
                break;

            case ObjectType.TablixCornerCell:
                persistable = new TablixCornerCell();
                break;

            case ObjectType.TablixCell:
                persistable = new TablixCell();
                break;

            case ObjectType.Chart:
                persistable             = new Chart(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.ChartMember:
                persistable = new ChartMember();
                break;

            case ObjectType.ChartSeries:
                persistable = new ChartSeries();
                break;

            case ObjectType.ChartDataPoint:
                persistable = new ChartDataPoint();
                break;

            case ObjectType.ChartDataPointValues:
                persistable = new ChartDataPointValues();
                break;

            case ObjectType.ChartArea:
                persistable = new ChartArea();
                break;

            case ObjectType.ChartLegend:
                persistable = new ChartLegend();
                break;

            case ObjectType.ChartLegendTitle:
                persistable = new ChartLegendTitle();
                break;

            case ObjectType.ChartAxis:
                persistable = new ChartAxis();
                break;

            case ObjectType.ThreeDProperties:
                persistable = new ChartThreeDProperties();
                break;

            case ObjectType.ChartDataLabel:
                persistable = new ChartDataLabel();
                break;

            case ObjectType.ChartMarker:
                persistable = new ChartMarker();
                break;

            case ObjectType.ChartTitle:
                persistable = new ChartTitle();
                break;

            case ObjectType.ChartAxisScaleBreak:
                persistable = new ChartAxisScaleBreak();
                break;

            case ObjectType.ChartDerivedSeries:
                persistable = new ChartDerivedSeries();
                break;

            case ObjectType.ChartBorderSkin:
                persistable = new ChartBorderSkin();
                break;

            case ObjectType.ChartNoDataMessage:
                persistable = new ChartNoDataMessage();
                break;

            case ObjectType.ChartItemInLegend:
                persistable = new ChartItemInLegend();
                break;

            case ObjectType.ChartEmptyPoints:
                persistable = new ChartEmptyPoints();
                break;

            case ObjectType.ChartNoMoveDirections:
                persistable = new ChartNoMoveDirections();
                break;

            case ObjectType.ChartFormulaParameter:
                persistable = new ChartFormulaParameter();
                break;

            case ObjectType.ChartLegendColumn:
                persistable = new ChartLegendColumn();
                break;

            case ObjectType.ChartLegendColumnHeader:
                persistable = new ChartLegendColumnHeader();
                break;

            case ObjectType.ChartLegendCustomItem:
                persistable = new ChartLegendCustomItem();
                break;

            case ObjectType.ChartLegendCustomItemCell:
                persistable = new ChartLegendCustomItemCell();
                break;

            case ObjectType.ChartAlignType:
                persistable = new ChartAlignType();
                break;

            case ObjectType.ChartElementPosition:
                persistable = new ChartElementPosition();
                break;

            case ObjectType.ChartSmartLabel:
                persistable = new ChartSmartLabel();
                break;

            case ObjectType.ChartStripLine:
                persistable = new ChartStripLine();
                break;

            case ObjectType.ChartAxisTitle:
                persistable = new ChartAxisTitle();
                break;

            case ObjectType.ChartCustomPaletteColor:
                persistable = new ChartCustomPaletteColor();
                break;

            case ObjectType.GridLines:
                persistable = new ChartGridLines();
                break;

            case ObjectType.ChartTickMarks:
                persistable = new ChartTickMarks();
                break;

            case ObjectType.DataMember:
                persistable = new DataMember();
                break;

            case ObjectType.CustomDataRow:
                persistable = new CustomDataRow();
                break;

            case ObjectType.DataCell:
                persistable = new DataCell();
                break;

            case ObjectType.Variable:
                persistable = new Variable();
                break;

            case ObjectType.Page:
                persistable = new Page();
                break;

            case ObjectType.Paragraph:
                persistable = new Paragraph();
                break;

            case ObjectType.TextRun:
                persistable = new TextRun();
                break;

            case ObjectType.Report:
                persistable             = new Report(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.GaugePanel:
                persistable             = new GaugePanel(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.GaugeMember:
                persistable = new GaugeMember();
                break;

            case ObjectType.GaugeRow:
                persistable = new GaugeRow();
                break;

            case ObjectType.GaugeCell:
                persistable = new GaugeCell();
                break;

            case ObjectType.BackFrame:
                persistable = new BackFrame();
                break;

            case ObjectType.CapImage:
                persistable = new CapImage();
                break;

            case ObjectType.FrameBackground:
                persistable = new FrameBackground();
                break;

            case ObjectType.FrameImage:
                persistable = new FrameImage();
                break;

            case ObjectType.CustomLabel:
                persistable = new CustomLabel();
                break;

            case ObjectType.GaugeImage:
                persistable = new GaugeImage();
                break;

            case ObjectType.GaugeInputValue:
                persistable = new GaugeInputValue();
                break;

            case ObjectType.GaugeLabel:
                persistable = new GaugeLabel();
                break;

            case ObjectType.GaugePanelItem:
                persistable = new GaugePanelItem();
                break;

            case ObjectType.GaugeTickMarks:
                persistable = new GaugeTickMarks();
                break;

            case ObjectType.LinearGauge:
                persistable = new LinearGauge();
                break;

            case ObjectType.LinearPointer:
                persistable = new LinearPointer();
                break;

            case ObjectType.LinearScale:
                persistable = new LinearScale();
                break;

            case ObjectType.NumericIndicator:
                persistable = new NumericIndicator();
                break;

            case ObjectType.PinLabel:
                persistable = new PinLabel();
                break;

            case ObjectType.PointerCap:
                persistable = new PointerCap();
                break;

            case ObjectType.PointerImage:
                persistable = new PointerImage();
                break;

            case ObjectType.RadialGauge:
                persistable = new RadialGauge();
                break;

            case ObjectType.RadialPointer:
                persistable = new RadialPointer();
                break;

            case ObjectType.RadialScale:
                persistable = new RadialScale();
                break;

            case ObjectType.ScaleLabels:
                persistable = new ScaleLabels();
                break;

            case ObjectType.ScalePin:
                persistable = new ScalePin();
                break;

            case ObjectType.ScaleRange:
                persistable = new ScaleRange();
                break;

            case ObjectType.IndicatorImage:
                persistable = new IndicatorImage();
                break;

            case ObjectType.StateIndicator:
                persistable = new StateIndicator();
                break;

            case ObjectType.Thermometer:
                persistable = new Thermometer();
                break;

            case ObjectType.TickMarkStyle:
                persistable = new TickMarkStyle();
                break;

            case ObjectType.TopImage:
                persistable = new TopImage();
                break;

            case ObjectType.LookupInfo:
                persistable = new LookupInfo();
                break;

            case ObjectType.LookupDestinationInfo:
                persistable = new LookupDestinationInfo();
                break;

            case ObjectType.ReportSection:
                persistable = new ReportSection();
                break;

            case ObjectType.MapFieldDefinition:
                persistable = new MapFieldDefinition();
                break;

            case ObjectType.MapFieldName:
                persistable = new MapFieldName();
                break;

            case ObjectType.MapLineLayer:
                persistable = new MapLineLayer();
                break;

            case ObjectType.MapShapefile:
                persistable = new MapShapefile();
                break;

            case ObjectType.MapPolygonLayer:
                persistable = new MapPolygonLayer();
                break;

            case ObjectType.MapSpatialDataRegion:
                persistable = new MapSpatialDataRegion();
                break;

            case ObjectType.MapSpatialDataSet:
                persistable = new MapSpatialDataSet();
                break;

            case ObjectType.MapPointLayer:
                persistable = new MapPointLayer();
                break;

            case ObjectType.MapTile:
                persistable = new MapTile();
                break;

            case ObjectType.MapTileLayer:
                persistable = new MapTileLayer();
                break;

            case ObjectType.MapField:
                persistable = new MapField();
                break;

            case ObjectType.MapLine:
                persistable = new MapLine();
                break;

            case ObjectType.MapPolygon:
                persistable = new MapPolygon();
                break;

            case ObjectType.MapPoint:
                persistable = new MapPoint();
                break;

            case ObjectType.MapLineTemplate:
                persistable = new MapLineTemplate();
                break;

            case ObjectType.MapPolygonTemplate:
                persistable = new MapPolygonTemplate();
                break;

            case ObjectType.MapMarkerTemplate:
                persistable = new MapMarkerTemplate();
                break;

            case ObjectType.Map:
                persistable             = new Map(this.m_parentReportItem);
                this.m_parentReportItem = (ReportItem)persistable;
                break;

            case ObjectType.MapBorderSkin:
                persistable = new MapBorderSkin();
                break;

            case ObjectType.MapDataRegion:
                persistable = new MapDataRegion(this.m_parentReportItem);
                break;

            case ObjectType.MapMember:
                persistable = new MapMember();
                break;

            case ObjectType.MapRow:
                persistable = new MapRow();
                break;

            case ObjectType.MapCell:
                persistable = new MapCell();
                break;

            case ObjectType.MapLocation:
                persistable = new MapLocation();
                break;

            case ObjectType.MapSize:
                persistable = new MapSize();
                break;

            case ObjectType.MapGridLines:
                persistable = new MapGridLines();
                break;

            case ObjectType.MapBindingFieldPair:
                persistable = new MapBindingFieldPair();
                break;

            case ObjectType.MapCustomView:
                persistable = new MapCustomView();
                break;

            case ObjectType.MapDataBoundView:
                persistable = new MapDataBoundView();
                break;

            case ObjectType.MapElementView:
                persistable = new MapElementView();
                break;

            case ObjectType.MapViewport:
                persistable = new MapViewport();
                break;

            case ObjectType.MapLimits:
                persistable = new MapLimits();
                break;

            case ObjectType.MapColorScale:
                persistable = new MapColorScale();
                break;

            case ObjectType.MapColorScaleTitle:
                persistable = new MapColorScaleTitle();
                break;

            case ObjectType.MapDistanceScale:
                persistable = new MapDistanceScale();
                break;

            case ObjectType.MapTitle:
                persistable = new MapTitle();
                break;

            case ObjectType.MapLegend:
                persistable = new MapLegend();
                break;

            case ObjectType.MapLegendTitle:
                persistable = new MapLegendTitle();
                break;

            case ObjectType.MapBucket:
                persistable = new MapBucket();
                break;

            case ObjectType.MapColorPaletteRule:
                persistable = new MapColorPaletteRule();
                break;

            case ObjectType.MapColorRangeRule:
                persistable = new MapColorRangeRule();
                break;

            case ObjectType.MapCustomColorRule:
                persistable = new MapCustomColorRule();
                break;

            case ObjectType.MapCustomColor:
                persistable = new MapCustomColor();
                break;

            case ObjectType.MapLineRules:
                persistable = new MapLineRules();
                break;

            case ObjectType.MapPolygonRules:
                persistable = new MapPolygonRules();
                break;

            case ObjectType.MapSizeRule:
                persistable = new MapSizeRule();
                break;

            case ObjectType.MapMarkerImage:
                persistable = new MapMarkerImage();
                break;

            case ObjectType.MapMarker:
                persistable = new MapMarker();
                break;

            case ObjectType.MapMarkerRule:
                persistable = new MapMarkerRule();
                break;

            case ObjectType.MapPointRules:
                persistable = new MapPointRules();
                break;

            case ObjectType.PageBreak:
                persistable = new PageBreak();
                break;

            case ObjectType.DataScopeInfo:
                persistable = new DataScopeInfo();
                break;

            case ObjectType.LinearJoinInfo:
                persistable = new LinearJoinInfo();
                break;

            case ObjectType.IntersectJoinInfo:
                persistable = new IntersectJoinInfo();
                break;

            case ObjectType.BucketedDataAggregateInfos:
                persistable = new BucketedDataAggregateInfos();
                break;

            case ObjectType.DataAggregateInfoBucket:
                persistable = new DataAggregateInfoBucket();
                break;

            case ObjectType.NumericIndicatorRange:
                persistable = new NumericIndicatorRange();
                break;

            case ObjectType.IndicatorState:
                persistable = new IndicatorState();
                break;

            case ObjectType.SharedDataSetQuery:
                persistable = new SharedDataSetQuery();
                break;

            case ObjectType.DataSetCore:
                persistable = new DataSetCore();
                break;

            case ObjectType.DataSetParameterValue:
                persistable = new DataSetParameterValue();
                break;

            case ObjectType.RIFVariantContainer:
                persistable = new RIFVariantContainer();
                break;

            case ObjectType.IdcRelationship:
                persistable = new IdcRelationship();
                break;

            case ObjectType.DefaultRelationship:
                persistable = new DefaultRelationship();
                break;

            case ObjectType.JoinCondition:
                persistable = new Relationship.JoinCondition();
                break;

            case ObjectType.BandLayoutOptions:
                persistable = new BandLayoutOptions();
                break;

            case ObjectType.LabelData:
                persistable = new LabelData();
                break;

            case ObjectType.Slider:
                persistable = new Slider();
                break;

            case ObjectType.Coverflow:
                persistable = new Coverflow();
                break;

            case ObjectType.PlayAxis:
                persistable = new PlayAxis();
                break;

            case ObjectType.BandNavigationCell:
                persistable = new BandNavigationCell();
                break;

            case ObjectType.Tabstrip:
                persistable = new Tabstrip();
                break;

            case ObjectType.NavigationItem:
                persistable = new NavigationItem();
                break;

            case ObjectType.ScopedFieldInfo:
                persistable = new ScopedFieldInfo();
                break;

            default:
                Global.Tracer.Assert(false, "Unsupported object type: " + objectType.ToString());
                break;
            }
            IDOwner iDOwner = persistable as IDOwner;

            if (iDOwner != null)
            {
                iDOwner.ParentInstancePath = this.m_parentIDOwner;
                this.m_parentIDOwner       = iDOwner;
            }
            persistable.Deserialize(context);
            this.m_parentIDOwner    = parentIDOwner;
            this.m_parentReportItem = parentReportItem;
            return(persistable);
        }