Beispiel #1
0
        private static ItemDefinitionMeta FindDefMeta(Dictionary <string, ItemDefinitionMeta> itemDefMetaDict, ItemDefinitionMeta currMeta, string typeName)
        {
            ItemDefinitionMeta itemMeta = null;

            if (currMeta != null)
            {
                currMeta.ItemComponents.TryGetValue(typeName, out var currMetaFnd);
                itemMeta = currMetaFnd;
                if (currMetaFnd == null)
                {
                    itemDefMetaDict.TryGetValue(typeName, out var mainMetaFnd);
                    itemMeta = mainMetaFnd;
                }
            }
            else
            {
                itemDefMetaDict.TryGetValue(typeName, out var mainMetaFnd);
                itemMeta = mainMetaFnd;
            }

            if (itemMeta == null)
            {
                return(null);
            }

            if (itemMeta.TypeName == null || VariableHelper.IsBaseTypes(itemMeta.TypeName))
            {
                return(itemMeta);
            }

            return(FindDefMeta(itemDefMetaDict, itemMeta, itemMeta.TypeName));
        }
Beispiel #2
0
        private Dictionary <string, ItemDefinitionMeta> BuildItemDefinitionsMeta(TDefinitions definitions)
        {
            var itemDefMetaDict = new Dictionary <string, ItemDefinitionMeta> ();

            foreach (var item in definitions.ItemDefinition)
            {
                var itemDefMeta = new ItemDefinitionMeta {
                    AllowedValues = item.AllowedValues,
                    Name          = item.Name,
                    TypeName      = item.TypeRef,
                    TypeLanguage  = item.TypeLanguage,
                    IsCollection  = item.IsCollection
                };
                CreateItemDefinitionMeta(item.ItemComponent, ref itemDefMeta);
                itemDefMetaDict.Add(item.Name, itemDefMeta);
            }
            return(itemDefMetaDict);
        }
Beispiel #3
0
        private void CreateItemDefinitionMeta(Collection <TItemDefinition> itemDefs, ref ItemDefinitionMeta itemMeta)
        {
            var dict = new Dictionary <string, ItemDefinitionMeta> ();

            foreach (var item in itemDefs)
            {
                var itemDefMeta = new ItemDefinitionMeta {
                    AllowedValues = item.AllowedValues,
                    Name          = item.Name,
                    TypeName      = item.TypeRef,
                    TypeLanguage  = item.TypeLanguage,
                    IsCollection  = item.IsCollection
                };
                CreateItemDefinitionMeta(item.ItemComponent, ref itemDefMeta);
                dict.Add(item.Name, itemDefMeta);
            }
            if (itemDefs.Count > 0)
            {
                itemMeta.ItemComponents = dict;
            }
        }
Beispiel #4
0
        private static ContextInputs MakeContextInputs(string name, Collection <ValueTypeComponent> component, ItemDefinitionMeta curItemDefMeta, Dictionary <string, ItemDefinitionMeta> itemDefMetaDict)
        {
            var ctx = new ContextInputs(name);

            ctx.IsItemDefinition = true;

            foreach (var item in component)
            {
                var itemComponent = FindDefMeta(itemDefMetaDict, curItemDefMeta, item.Name);

                if (item.ComponentSpecified)
                {
                    var nestedCtx = MakeContextInputs(item.Name, item.Component, itemComponent, itemDefMetaDict);
                    ctx.Add(item.Name, nestedCtx);
                }

                if (item.ListSpecified)
                {
                    var nestedList = MakeList(item.Name, item.List, itemComponent, itemDefMetaDict);
                    ctx.Add(item.Name, nestedList);
                }

                if (itemComponent.TypeName == null)
                {
                    throw new TCKException($"Missing type name for for component:{item.Name}");
                }

                ctx.Add(item.Name, VariableHelper.MakeVariable(GetValueType(item.Value), itemComponent.TypeName));
            }

            return(ctx);
        }
Beispiel #5
0
        private static Variable MakeList(string name, Collection <ValueType> listItems, ItemDefinitionMeta curItemDefMeta, Dictionary <string, ItemDefinitionMeta> itemDefMetaDict)
        {
            var iL = new List <Variable> ();

            var nested = false;

            foreach (var item in listItems)
            {
                if (item.ComponentSpecified)
                {
                    var nestedCtx = MakeContextInputs(name, item.Component, curItemDefMeta, itemDefMetaDict);
                    iL.Add(nestedCtx);
                    nested = true;
                    continue;
                }

                if (item.ListSpecified)
                {
                    var nestedList = MakeList(name, item.List, curItemDefMeta, itemDefMetaDict);
                    iL.Add(nestedList);
                    nested = true;
                    continue;
                }

                if (curItemDefMeta.TypeName == null)
                {
                    throw new TCKException($"Missing type name for for item definition:{item.Value}");
                }

                iL.Add(VariableHelper.MakeVariable(GetValueType(item.Value), curItemDefMeta.TypeName));
            }

            if (!nested)
            {
                return(VariableHelper.MakeList(iL, curItemDefMeta.TypeName));
            }
            return(iL);
        }