示例#1
0
        /// <summary>
        ///     Provides the namespace of the element provided in this container
        /// </summary>
        /// <param name="source">The element from which the namespace should be found</param>
        /// <param name="container">The container which contains the namespace</param>
        /// <param name="allowOutsideContainer">Indicaes that namespace can be found outside of the container</param>
        /// <returns></returns>
        private static NameSpace getCorrespondingNameSpace(ModelElement source, IEnclosesNameSpaces container,
                                                           bool allowOutsideContainer)
        {
            NameSpace retVal = null;

            IEnclosed current = source;

            while (current != null && retVal == null)
            {
                NameSpace nameSpace = EnclosingNameSpaceFinder.find(current);
                if (container == null || container.NameSpaces.Contains(nameSpace))
                {
                    retVal = nameSpace;
                }

                current = nameSpace;
            }

            // If no name space has been found in the container, take the first one
            if (retVal == null && allowOutsideContainer)
            {
                retVal = EnclosingNameSpaceFinder.find(source);
            }

            return(retVal);
        }
示例#2
0
        public StandardValuesCollection GetValues(IModelElement element)
        {
            FinderRepository.INSTANCE.ClearCache();

            Dictionary dictionary = EnclosingFinder <Dictionary> .find(element);

            NameSpace nameSpace = EnclosingNameSpaceFinder.find(element);

            List <string> retVal = new List <string>();

            if (nameSpace != null)
            {
                OverallTypeFinder.INSTANCE.findAllValueNames("", nameSpace, true, retVal);
            }
            else
            {
                OverallTypeFinder.INSTANCE.findAllValueNames("", dictionary, false, retVal);
            }
            retVal.Sort();

            foreach (string name in dictionary.EFSSystem.PredefinedTypes.Keys)
            {
                retVal.Add(name);
            }

            return(new StandardValuesCollection(retVal));
        }
示例#3
0
        /// <summary>
        ///     Combines two types to create a new one
        /// </summary>
        /// <param name="right"></param>
        /// <returns></returns>
        public override Type CombineType(Type right, BinaryExpression.Operator Operator)
        {
            Type retVal = null;

            if (Operator == BinaryExpression.Operator.Mult)
            {
                if (FullName.CompareTo("Default.BaseTypes.Speed") == 0 &&
                    right.FullName.CompareTo("Default.BaseTypes.Time") == 0)
                {
                    NameSpace nameSpace = EnclosingNameSpaceFinder.find(this);
                    retVal = nameSpace.findTypeByName("Distance");
                }
            }
            else
            {
                if (IsDouble())
                {
                    if (right == EFSSystem.DoubleType)
                    {
                        retVal = this;
                    }
                }
                else
                {
                    if (right == EFSSystem.IntegerType)
                    {
                        retVal = this;
                    }
                }
            }

            return(retVal);
        }
        /// <summary>
        /// Provides the image associated to a model element
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public Image GetImage(IModelElement model)
        {
            Image retVal = null;

            NameSpace nameSpace = EnclosingNameSpaceFinder.find(model, true);

            while (retVal == null && nameSpace != null)
            {
                if (nameSpace.getImageIndex() != 0 && nameSpace.getImageIndex() <= Images.Images.Count)
                {
                    retVal = Images.Images[nameSpace.getImageIndex() - 1];
                }
                nameSpace = EnclosingNameSpaceFinder.find(nameSpace, false);
            }

            return(retVal);
        }