コード例 #1
0
 private void ClassNameReadCallback(ClassName arg)
 {
     if (!DataTypes.ContainsKey(arg.InternalId))
     {
         DataTypes.Add(arg.InternalId, arg.Name);
     }
 }
コード例 #2
0
        public void RegisterMembers(DataTable table, ColumnCreator creator, string schema = "TABLE_SCHEMA", string name = "TABLE_NAME")
        {
            var query = SupportSchema ?
                        from a in table.AsEnumerable()
                        group a by a.Field <string>(schema) + "." + a.Field <string>(name) into g
                        select new { g.Key, Columns = g } :
            from a in table.AsEnumerable()
            group a by a.Field <string>(name) into g
            select new { g.Key, Columns = g };

            foreach (var item in query)
            {
                if (Objects.TryGetValue(item.Key, out ObjectElement obj))
                {
                    foreach (var data in item.Columns)
                    {
                        var typename = Convert.ToString(data[Names.DataType]);
                        if (DataTypes.ContainsKey(typename))
                        {
                            var clrtype = DataTypes[typename];
                            var column  = creator.CreateColumn(data, clrtype);
                            obj.Columns.Add(column.Name, column);
                        }
                    }
                }
            }
        }
コード例 #3
0
 public static DataType ByName(string dataTypeName)
 {
     if (DataTypes.ContainsKey(dataTypeName))
     {
         return(DataTypes[dataTypeName]);
     }
     Exceptions.LogException(
         new UnknownDataTypeException(string.Format("DataType \"{0}\" is not installed.", dataTypeName)));
     return(DataTypes[DataTypeNames.UDT_DataType_String]);
 }
コード例 #4
0
        /*public IODataPathHandler GetODataPathHandler() {
         *  return new TypeNameODataPathHandler(TypeNameResolver);
         * }*/

        public IsRepository GetRepositoryForType(Type type)
        {
            if (DataTypes.ContainsKey(type))
            {
                var repositoryType = DataTypes[type];

                if (ContextResolver != null)
                {
                    return((IsRepository)ContextResolver.Get(repositoryType, repositoryType.Name));
                }

                return(repositoryType.New <IsRepository>());
            }

            return(null);
        }
コード例 #5
0
        /// <summary>
        ///     Implements Validate method from <see cref="IValidatableObject" /> interface
        /// </summary>
        /// <param name="validationContext">Context the validation runs in</param>
        /// <returns>List of validation results if any</returns>
        IEnumerable <ValidationResult> IValidatableObject.Validate(ValidationContext validationContext)
        {
            var validationResults = new List <ValidationResult>();

            foreach (var nodeTypeKeyValue in NodeTypes)
            {
                nodeTypeKeyValue.Value.SetDerivedFromToRoot(nodeTypeKeyValue.Key);

                foreach (var requirementKeyValue in nodeTypeKeyValue.Value.Requirements.SelectMany(r => r).ToArray())
                {
                    if (!string.IsNullOrEmpty(requirementKeyValue.Value.Node) &&
                        !NodeTypes.ContainsKey(requirementKeyValue.Value.Node))
                    {
                        validationResults.Add(CreateRequirementValidationResult(requirementKeyValue, nodeTypeKeyValue));
                    }
                }

                foreach (var capabilityKeyValue in nodeTypeKeyValue.Value.Capabilities)
                {
                    if (!CapabilityTypes.ContainsKey(capabilityKeyValue.Value.Type))
                    {
                        validationResults.Add(CreateCapabilityTypeValidationResult(nodeTypeKeyValue.Key,
                                                                                   capabilityKeyValue.Value.Type, capabilityKeyValue.Key));
                    }
                }

                foreach (var complexDataTypeKeyValue in DataTypes)
                {
                    foreach (var basicDatatypeKeyValue in complexDataTypeKeyValue.Value.Properties)
                    {
                        var basicType = basicDatatypeKeyValue.Value.Type;
                        if (!DataTypes.ContainsKey(basicType))
                        {
                            validationResults.Add(new ValidationResult(
                                                      string.Format("Data type '{0}' specified as part of data type '{1}' not found.",
                                                                    basicType,
                                                                    complexDataTypeKeyValue.Key)));
                        }
                    }
                }

                var circularDependencyValidationResults = nodeTypeKeyValue.Value.ValidateCircularDependency().ToList();
                if (circularDependencyValidationResults.Any())
                {
                    return(validationResults.Concat(circularDependencyValidationResults));
                }
            }

            var importCircularValidationResults = ValidateImportsCircularDependency();

            if (importCircularValidationResults.Any())
            {
                return(validationResults.Concat(importCircularValidationResults));
            }

            if (!validationResults.Any())
            {
                var requirementsGraph = new ToscaNodeTypeRequirementsGraph(this);
                if (requirementsGraph.ContainsCyclicLoop())
                {
                    validationResults.Add(new ValidationResult("Circular dependency detected by requirements on node type"));
                }
            }
            return(validationResults);
        }