private void AddNode(IFsFeatureSpecification spec, FeatureTreeNode parentNode)
        {
            IFsFeatDefn        defn = spec.FeatureRA;
            TreeNodeCollection col;

            if (parentNode == null)
            {
                col = Nodes;
            }
            else
            {
                col = parentNode.Nodes;
            }
            IFsClosedValue closed = spec as IFsClosedValue;

            if (closed != null)
            {
                foreach (FeatureTreeNode node in col)
                {
                    if (defn.Hvo == node.Hvo)
                    {                     // already there (which is to be expected); see if its value is, too
                        AddNodeFromFS(closed.ValueRA, node);
                        return;
                    }
                }
                // did not find the node, so add it and its value (not to be expected, but we'd better deal with it)
                FeatureTreeNode newNode = new FeatureTreeNode(defn.Name.AnalysisDefaultWritingSystem,
                                                              (int)ImageKind.feature, (int)ImageKind.feature, defn.Hvo, FeatureTreeNodeInfo.NodeKind.Closed);
                InsertNode(newNode, parentNode);
                IFsSymFeatVal val = closed.ValueRA;
                if (val != null)
                {
                    FeatureTreeNode newValueNode = new FeatureTreeNode(val.Name.AnalysisDefaultWritingSystem,
                                                                       (int)ImageKind.radioSelected, (int)ImageKind.radioSelected, val.Hvo, FeatureTreeNodeInfo.NodeKind.SymFeatValue);
                    newValueNode.Chosen = true;
                    InsertNode(newValueNode, newNode);
                }
            }
            IFsComplexValue complex = spec as IFsComplexValue;

            if (complex != null)
            {
                foreach (FeatureTreeNode node in col)
                {
                    if (defn.Hvo == node.Hvo)
                    {                     // already there (which is to be expected); see if its value is, too
                        AddNode((IFsFeatStruc)complex.ValueOA, node);
                        return;
                    }
                }
                // did not find the node, so add it and its value (not to be expected, but we'd better deal with it)
                FeatureTreeNode newNode = new FeatureTreeNode(defn.Name.AnalysisDefaultWritingSystem,
                                                              (int)ImageKind.complex, (int)ImageKind.complex, defn.Hvo, FeatureTreeNodeInfo.NodeKind.Complex);
                InsertNode(newNode, parentNode);
                AddNode((IFsFeatStruc)complex.ValueOA, newNode);
            }
        }
Beispiel #2
0
        /// <summary>
        /// Builds the feature structure based on the items chosen
        /// </summary>
        /// <returns></returns>
        private void BuildFeatureStructure(int hvoClosedFeature, int hvoValue, ref IFsFeatureSpecification val)
        {
            val = (IFsClosedValue)m_fs.FindOrCreateClosedValue(hvoClosedFeature);
            val.FeatureRAHvo = hvoClosedFeature;
            IFsClosedValue closed = val as IFsClosedValue;

            if (closed != null)
            {
                closed.ValueRAHvo = hvoValue;
            }
        }
Beispiel #3
0
        /// <summary>
        /// Makes the feature structure reflect the values chosen
        /// </summary>
        /// <remarks>Is public for Unit Testing</remarks>
        public void UpdateFeatureStructure()
        {
            CheckDisposed();

            List <int> featureHvos = m_bvList.AllItems;

            foreach (int hvoClosedFeature in featureHvos)
            {
                int hvoDummy = m_cache.GetObjProperty(hvoClosedFeature, m_flidDummyValue);
                if (hvoDummy > 0)
                {
                    IFsFeatureSpecification val = null;
                    BuildFeatureStructure(hvoClosedFeature, hvoDummy, ref val);
                }
            }
        }
Beispiel #4
0
        /// <summary>
        /// Makes the feature structure reflect the values chosen in the treeview
        /// </summary>
        /// <remarks>Is public for Unit Testing</remarks>
        /// <param name="col">collection of nodes at this level</param>
        public void UpdateFeatureStructure(TreeNodeCollection col)
        {
            CheckDisposed();

            foreach (FeatureTreeNode tn in col)
            {
                if (tn.Nodes.Count > 0)
                {
                    UpdateFeatureStructure(tn.Nodes);
                }
                else if (tn.Chosen && (0 != tn.Hvo))
                {
                    var fs = m_fs;
                    IFsFeatureSpecification val = null;
                    // add any terminal nodes to db
                    BuildFeatureStructure(tn, ref fs, ref val);
                }
            }
        }
		private static XElement ExportFeatureSpecification(IFsFeatureSpecification featureSpec)
		{
			switch (featureSpec.ClassName)
			{
				default:
					// These are not supported as of 14 November 2009.
					// FsOpenValue
					// FsDisjunctiveValue
					// FsSharedValue
					throw new ArgumentException("Unrecognized feature specification");
				case "FsClosedValue":
					var closedValue = (IFsClosedValue) featureSpec;
					return new XElement("FsClosedValue",
						new XAttribute("Id", closedValue.Hvo),
						CreateAttribute("Value", closedValue.ValueRA),
						CreateAttribute("Feature", closedValue.FeatureRA));
				case "FsComplexValue":
					var complexValue = (IFsComplexValue)featureSpec;
					return new XElement("FsComplexValue",
						new XAttribute("Id", complexValue.Hvo),
						CreateAttribute("Feature", complexValue.FeatureRA),
						ExportFeatureStructure(complexValue.ValueOA));
				case "FsNegatedValue":
					var negatedValue = (IFsNegatedValue)featureSpec;
					return new XElement("FsNegatedValue",
						new XAttribute("Id", negatedValue.Hvo),
						CreateAttribute("Value", negatedValue.ValueRA),
						CreateAttribute("Feature", negatedValue.FeatureRA));
			}
		}
		private void AddNode(IFsFeatureSpecification spec, FeatureTreeNode parentNode)
		{
			var defn = spec.FeatureRA;
			TreeNodeCollection col;
			if (parentNode == null)
				col = Nodes;
			else
				col = parentNode.Nodes;
			var closed = spec as IFsClosedValue;
			if (closed != null)
			{
				foreach (FeatureTreeNode node in col)
				{
					if (defn.Hvo == node.Hvo)
					{ // already there (which is to be expected); see if its value is, too
						AddNodeFromFS(closed.ValueRA, node);
						return;
					}
				}
				// did not find the node, so add it and its value (not to be expected, but we'd better deal with it)
				FeatureTreeNode newNode = new FeatureTreeNode(defn.Name.AnalysisDefaultWritingSystem.Text,
					(int)ImageKind.feature, (int)ImageKind.feature, defn.Hvo, FeatureTreeNodeInfo.NodeKind.Closed);
				InsertNode(newNode, parentNode);
				var val = closed.ValueRA;
				if (val != null)
				{
					FeatureTreeNode newValueNode = new FeatureTreeNode(val.Name.AnalysisDefaultWritingSystem.Text,
						(int)ImageKind.radioSelected, (int)ImageKind.radioSelected, val.Hvo, FeatureTreeNodeInfo.NodeKind.SymFeatValue);
					newValueNode.Chosen = true;
					InsertNode(newValueNode, newNode);
				}
			}
			var complex = spec as IFsComplexValue;
			if (complex != null)
			{
				foreach (FeatureTreeNode node in col)
				{
					if (defn.Hvo == node.Hvo)
					{ // already there (which is to be expected); see if its value is, too
						AddNode((IFsFeatStruc)complex.ValueOA, node);
						return;
					}
				}
				// did not find the node, so add it and its value (not to be expected, but we'd better deal with it)
				FeatureTreeNode newNode = new FeatureTreeNode(defn.Name.AnalysisDefaultWritingSystem.Text,
					(int)ImageKind.complex, (int)ImageKind.complex, defn.Hvo, FeatureTreeNodeInfo.NodeKind.Complex);
				InsertNode(newNode, parentNode);
				AddNode((IFsFeatStruc)complex.ValueOA, newNode);
			}
		}
		/// <summary>
		/// Recursively builds the feature structure based on contents of treeview node path.
		/// It recurses back up the treeview node path to the top and then builds the feature structure
		/// as it goes back down.
		/// </summary>
		/// <param name="node"></param>
		/// <param name="fs"></param>
		/// <param name="val"></param>
		/// <returns></returns>
		private void BuildFeatureStructure(FeatureTreeNode node, ref IFsFeatStruc fs, ref IFsFeatureSpecification val)
		{
			if (node.Parent != null)
				BuildFeatureStructure((FeatureTreeNode)node.Parent, ref fs, ref val);
			switch (node.Kind)
			{
				case FeatureTreeNodeInfo.NodeKind.Complex:
					var complexFeat = m_cache.ServiceLocator.GetInstance<IFsComplexFeatureRepository>().GetObject(node.Hvo);
					var complex = fs.GetOrCreateValue(complexFeat);
					val = complex;
					val.FeatureRA = complexFeat;
					if (fs.TypeRA == null)
						fs.TypeRA = m_cache.LanguageProject.MsFeatureSystemOA.TypesOC.SingleOrDefault(type => type.FeaturesRS.Contains(complexFeat));
					fs = (IFsFeatStruc)complex.ValueOA;
					if (fs.TypeRA == null)
					{
						// this is the type of what's being embedded in the fs
						var cf = val.FeatureRA as IFsComplexFeature;
						if (cf != null)
						{
							fs.TypeRA = cf.TypeRA;
						}
					}
					break;
				case FeatureTreeNodeInfo.NodeKind.Closed:
					var closedFeat = m_cache.ServiceLocator.GetInstance<IFsClosedFeatureRepository>().GetObject(node.Hvo);
					val = fs.GetOrCreateValue(closedFeat);
					val.FeatureRA = closedFeat;
					if (fs.TypeRA == null)
					{
						// SingleOrDefault() gave an exception if 2 complex features used the same feature (LT-12780)
						fs.TypeRA = m_cache.LanguageProject.MsFeatureSystemOA.TypesOC.FirstOrDefault(type => type.FeaturesRS.Contains(closedFeat));
					}
					break;
				case FeatureTreeNodeInfo.NodeKind.SymFeatValue:
					var closed = val as IFsClosedValue;
					if (closed != null)
						closed.ValueRA = m_cache.ServiceLocator.GetInstance<IFsSymFeatValRepository>().GetObject(node.Hvo);
					break;
			}
		}
Beispiel #8
0
        /// <summary>
        /// Recursively builds the feature structure based on contents of treeview node path.
        /// It recurses back up the treeview node path to the top and then builds the feature structure
        /// as it goes back down.
        /// </summary>
        /// <param name="node"></param>
        /// <param name="fs"></param>
        /// <param name="val"></param>
        /// <returns></returns>
        private void BuildFeatureStructure(FeatureTreeNode node, ref IFsFeatStruc fs, ref IFsFeatureSpecification val)
        {
            if (node.Parent != null)
            {
                BuildFeatureStructure((FeatureTreeNode)node.Parent, ref fs, ref val);
            }
            switch (node.Kind)
            {
            case FeatureTreeNodeInfo.NodeKind.Complex:
                var complexFeat = m_cache.ServiceLocator.GetInstance <IFsComplexFeatureRepository>().GetObject(node.Hvo);
                var complex     = fs.GetOrCreateValue(complexFeat);
                val           = complex;
                val.FeatureRA = complexFeat;
                if (fs.TypeRA == null)
                {
                    fs.TypeRA = m_cache.LanguageProject.MsFeatureSystemOA.TypesOC.SingleOrDefault(type => type.FeaturesRS.Contains(complexFeat));
                }
                fs = (IFsFeatStruc)complex.ValueOA;
                if (fs.TypeRA == null)
                {
                    // this is the type of what's being embedded in the fs
                    var cf = val.FeatureRA as IFsComplexFeature;
                    if (cf != null)
                    {
                        fs.TypeRA = cf.TypeRA;
                    }
                }
                break;

            case FeatureTreeNodeInfo.NodeKind.Closed:
                var closedFeat = m_cache.ServiceLocator.GetInstance <IFsClosedFeatureRepository>().GetObject(node.Hvo);
                val           = fs.GetOrCreateValue(closedFeat);
                val.FeatureRA = closedFeat;
                if (fs.TypeRA == null)
                {
                    // SingleOrDefault() gave an exception if 2 complex features used the same feature (LT-12780)
                    fs.TypeRA = m_cache.LanguageProject.MsFeatureSystemOA.TypesOC.FirstOrDefault(type => type.FeaturesRS.Contains(closedFeat));
                }
                break;

            case FeatureTreeNodeInfo.NodeKind.SymFeatValue:
                var closed = val as IFsClosedValue;
                if (closed != null)
                {
                    closed.ValueRA = m_cache.ServiceLocator.GetInstance <IFsSymFeatValRepository>().GetObject(node.Hvo);
                }
                break;
            }
        }
Beispiel #9
0
		/// <summary>
		/// True if the two are 'equivalent'.
		/// </summary>
		/// <param name="other"></param>
		/// <returns></returns>
		public override bool IsEquivalent(IFsFeatureSpecification other)
		{
			if (!base.IsEquivalent(other))
				return false;

			return (other as IFsSharedValue).ValueRAHvo == this.ValueRAHvo;
		}
Beispiel #10
0
		/// <summary>
		/// True if the two are 'equivalent'.
		/// </summary>
		/// <param name="other"></param>
		/// <returns></returns>
		public override bool IsEquivalent(IFsFeatureSpecification other)
		{
			if (!base.IsEquivalent(other))
				return false;

			return (other as IFsDisjunctiveValue).ValueRC.IsEquivalent(ValueRC);
		}
Beispiel #11
0
		/// <summary>
		/// True if the two are 'equivalent'.
		/// Since FdoOpenValue isn't used yet, this is something of a skeleton. We just check
		/// the analysis writing systems.
		/// </summary>
		/// <param name="other"></param>
		/// <returns></returns>
		public override bool IsEquivalent(IFsFeatureSpecification other)
		{
			if (!base.IsEquivalent(other))
				return false;

			return this.Value.AnalysisDefaultWritingSystem == (other as IFsOpenValue).Value.AnalysisDefaultWritingSystem;
		}
Beispiel #12
0
		/// <summary>
		/// True if the objects are considered equivalent.
		/// </summary>
		/// <param name="other"></param>
		/// <returns></returns>
		public override bool IsEquivalent(IFsFeatureSpecification other)
		{
			if (!base.IsEquivalent(other))
				return false;

			IFsAbstractStructure otherValue = (other as IFsComplexValue).ValueOA;
			IFsAbstractStructure thisValue = ValueOA;
			if (otherValue == null && thisValue == null)
				return true;
			return otherValue.IsEquivalent(thisValue);
		}
Beispiel #13
0
		/// <summary>
		/// True if the objects are considered equivalent.
		/// </summary>
		/// <param name="other"></param>
		/// <returns></returns>
		public virtual bool IsEquivalent(IFsFeatureSpecification other)
		{
			if (other == null)
				return false;

			if (other.GetType() != this.GetType())
				return false;

			IFsFeatureSpecification fs = other as IFsFeatureSpecification;
			if (fs.RefNumber != this.RefNumber)
				return false;
			if (fs.ValueState != this.ValueState)
				return false;
			if (fs.FeatureRAHvo != this.FeatureRAHvo)
				return false;
			return true;
		}
		/// <summary>
		/// Builds the feature structure based on the items chosen
		/// </summary>
		/// <returns></returns>
		private void BuildFeatureStructure(int hvoClosedFeature, int hvoValue, ref IFsFeatureSpecification val)
		{
			val = (IFsClosedValue)m_fs.FindOrCreateClosedValue(hvoClosedFeature);
			val.FeatureRAHvo = hvoClosedFeature;
			IFsClosedValue closed = val as IFsClosedValue;
			if (closed != null)
			{
				closed.ValueRAHvo = hvoValue;
			}
		}
        /// <summary>
        /// Recursively builds the feature structure based on contents of treeview node path.
        /// It recurses back up the treeview node path to the top and then builds the feature structure
        /// as it goes back down.
        /// </summary>
        /// <param name="node"></param>
        /// <param name="fs"></param>
        /// <returns></returns>
        private void BuildFeatureStructure(FeatureTreeNode node, ref IFsFeatStruc fs, ref IFsFeatureSpecification val)
        {
            if (node.Parent != null)
            {
                BuildFeatureStructure((FeatureTreeNode)node.Parent, ref fs, ref val);
            }
            switch (node.Kind)
            {
            case FeatureTreeNodeInfo.NodeKind.Complex:
                IFsComplexValue complex = fs.FindOrCreateComplexValue(node.Hvo);
                val = complex as FsComplexValue;
                val.FeatureRAHvo = node.Hvo;
                if (fs.TypeRA == null)
                {
                    // this is the type which contains the complex feature
                    fs.TypeRAHvo = FsFeatureSystem.GetTypeFromFsComplexFeature(m_cache, node.Hvo);
                }
                fs = (IFsFeatStruc)complex.ValueOA;
                if (fs.TypeRA == null)
                {
                    // this is the type of what's being embedded in the fs
                    IFsComplexFeature cf = val.FeatureRA as IFsComplexFeature;
                    if (cf != null)
                    {
                        fs.TypeRA = cf.TypeRA;
                    }
                }
                break;

            case FeatureTreeNodeInfo.NodeKind.Closed:
                val = (IFsClosedValue)fs.FindOrCreateClosedValue(node.Hvo);
                val.FeatureRAHvo = node.Hvo;
                break;

            case FeatureTreeNodeInfo.NodeKind.SymFeatValue:
                IFsClosedValue closed = val as IFsClosedValue;
                if (closed != null)
                {
                    closed.ValueRAHvo = node.Hvo;
                }
                break;

            default:
                break;                         // do nothing
            }
        }
		/// <summary>
		/// Recursively builds the feature structure based on contents of treeview node path.
		/// It recurses back up the treeview node path to the top and then builds the feature structure
		/// as it goes back down.
		/// </summary>
		/// <param name="node"></param>
		/// <param name="fs"></param>
		/// <returns></returns>
		private void BuildFeatureStructure(FeatureTreeNode node, ref IFsFeatStruc fs, ref IFsFeatureSpecification val)
		{
			if (node.Parent != null)
				BuildFeatureStructure((FeatureTreeNode)node.Parent, ref fs, ref val);
			switch (node.Kind)
			{
				case FeatureTreeNodeInfo.NodeKind.Complex:
					IFsComplexValue complex = fs.FindOrCreateComplexValue(node.Hvo);
					val = complex as FsComplexValue;
					val.FeatureRAHvo = node.Hvo;
					if (fs.TypeRA == null)
					{
						// this is the type which contains the complex feature
						fs.TypeRAHvo = FsFeatureSystem.GetTypeFromFsComplexFeature(m_cache, node.Hvo);
					}
					fs = (IFsFeatStruc)complex.ValueOA;
					if (fs.TypeRA == null)
					{
						// this is the type of what's being embedded in the fs
						IFsComplexFeature cf = val.FeatureRA as IFsComplexFeature;
						if (cf != null)
						{
							fs.TypeRA = cf.TypeRA;
						}
					}
					break;
				case FeatureTreeNodeInfo.NodeKind.Closed:
					val = (IFsClosedValue)fs.FindOrCreateClosedValue(node.Hvo);
					val.FeatureRAHvo = node.Hvo;
					break;
				case FeatureTreeNodeInfo.NodeKind.SymFeatValue:
					IFsClosedValue closed = val as IFsClosedValue;
					if (closed != null)
						closed.ValueRAHvo = node.Hvo;
					break;
				default:
					break; // do nothing
			}
		}