public Question PopQuestion(IQuestionKey keyToUseForReference)
            {
                ResolveDeletionsAndAdditions();

                PhraseCustomization questionToInsert;

                try
                {
                    questionToInsert = AdditionsAndInsertions.First();
                }
                catch (Exception e)
                {
                    throw new InvalidOperationException("PopQuestion should only be called for a customization that is not tied to any other question and has " +
                                                        "at least one insertion or addition.", e);
                }
                AdditionsAndInsertions.RemoveAt(0);
                var newQ = new Question(keyToUseForReference.ScriptureReference, keyToUseForReference.StartRef, keyToUseForReference.EndRef,
                                        questionToInsert.ModifiedPhrase ?? questionToInsert.OriginalPhrase, questionToInsert.Answer);

                SetExcludedAndModified(newQ);
                if (AllAnswers != null && AllAnswers.Any())                 // Note: If there are any, there are at least 2
                {
                    newQ.Answers = AllAnswers.ToArray();
                }
                return(newQ);
            }
            public bool IsInsertionAtOrBeforeReference(IQuestionKey keyToUseForReference, IEnumerable <Question> existingQuestionsInCategory, bool inclusive)
            {
                var addition = AdditionsAndInsertions.FirstOrDefault();

                return(addition != null && addition.Key.IsAtOrBeforeReference(keyToUseForReference, inclusive) &&
                       !existingQuestionsInCategory.Any(q => q.Matches(addition.Key)));
            }
Exemple #3
0
 /// ------------------------------------------------------------------------------------
 /// <summary>
 /// Initializes a new instance of the <see cref="TranslatablePhrase"/> class.
 /// </summary>
 /// <param name="questionInfo">Information about the original question</param>
 /// <param name="category">The category (e.g. Overview vs. Detail question).</param>
 /// <param name="seqNumber">The sequence number (used to sort and/or uniquely identify
 /// a phrase within a particular category and reference).</param>
 /// ------------------------------------------------------------------------------------
 public TranslatablePhrase(IQuestionKey questionInfo, int category, int seqNumber)
     : this(questionInfo.Text, (questionInfo as Question)?.ModifiedPhrase)
 {
     m_questionInfo = questionInfo;
     Category       = category;
     SequenceNumber = seqNumber;
     // The following is normally done by the ModifiedPhrase setter, but there's a
     // chicken-and-egg problem when constructing this, so we need to do it here.
     if (IsUserAdded && m_sModifiedPhrase != null)
     {
         // This cast is entirely safe. Note above that for m_sModifiedPhrase to be non-null,
         // the questionInfo object
         ((Question)questionInfo).Text = m_sModifiedPhrase;
     }
 }
        public static int CompareTo(this IQuestionKey me, object obj)
        {
            var refsComparison = me.CompareRefs(obj);

            if (refsComparison != 0)
            {
                return(refsComparison);
            }

            // REVIEW: If both keys are for the same single verse or reference range, we can't say they are equal (because their text is different), but the comparison
            // is a little bit arbitrary. For built-in questions or insertions/additions hanging off them, this shouldn't be a problem, since they stay in their natural order.
            // Only questions added that do not correspond to any existing question could be compared. But generally, only one such "free" addition can happen for any given
            // reference (range). Any subsequent additions would be an insertion before that one or an addition after. Possible exception would be if two users independently
            // added questions.
            return(Compare(me.Text, ((IQuestionKey)obj).Text, StringComparison.Ordinal));
        }
        public static int CompareRefs(this IQuestionKey me, int startRef, int endRef)
        {
            var startRefComparison = me.StartRef.CompareTo(startRef);

            if (startRefComparison != 0)
            {
                return(startRefComparison);
            }
            if (me.EndRef == me.StartRef)
            {
                return(endRef == startRef ? 0 : 1);                // A key that represents a range always sorts before one that represents a single verse.
            }
            if (endRef == startRef)
            {
                return(-1);
            }
            return(me.EndRef.CompareTo(endRef));
        }
        public static int CompareRefs(this IQuestionKey me, object other)
        {
            if (other == null)
            {
                throw new ArgumentNullException(nameof(other));
            }
            if (me == other)
            {
                return(0);
            }
            var otherKey = other as IQuestionKey;

            if (otherKey == null)
            {
                throw new ArgumentException(nameof(other), $"Attempt to compare question key ({me}) to an unexpected object ({other}).");
            }

            return(me.CompareRefs(otherKey.StartRef, otherKey.EndRef));
        }
 public static bool Matches(this IQuestionKey me, IQuestionKey other)
 {
     return(me.CompareTo(other) == 0);
 }
 public UIQuestionDataString(IQuestionKey questionKey, bool original, bool useAnyAlternate)
 {
     m_questionKey    = questionKey;
     m_modifiedString = original || questionKey.PhraseInUse == questionKey.Text ? null : questionKey.PhraseInUse;
     UseAnyAlternate  = useAnyAlternate;
 }