Пример #1
0
        /// <summary>
        /// Updates the internal state when the declaration string changes
        /// </summary>
        internal void ParseDeclaration()
        {
            if (!this.parsedDeclaration)
            {
                ValueDeclarationParser p = new ValueDeclarationParser(this.Declaration);

                if (p.HasErrors)
                {
                    throw new InvalidDeclarationStringException(
                              string.Format(
                                  "The declaration contained one or more errors: {0}\n{1}",
                                  this.Declaration,
                                  p.Errors.Select(u => u.ToString()).ToNewLineSeparatedString()));
                }

                this.AttributeDeclarations = p.AttributeDeclarations.ToList();

                if (this.AttributeDeclarations.Any(t => t.HasReferenceAttribute))
                {
                    throw new InvalidDeclarationStringException("A complex declaration cannot contain reference attributes");
                }

                this.VariableDeclarations = p.VariableDeclarations.ToList();

                if (this.VariableDeclarations.Any(t => t.IsUniqueAllocationVariable))
                {
                    throw new InvalidDeclarationStringException("The declaration string contains a unique allocation variable");
                }

                this.parsedDeclaration = true;
            }
        }
Пример #2
0
        /// <summary>
        /// Occurs when the declaration string is updated
        /// </summary>
        private void ParseDeclaration()
        {
            if (!this.parsedDeclaration)
            {
                ValueDeclarationParser p = new ValueDeclarationParser(this.Declaration);

                if (p.HasErrors)
                {
                    throw new InvalidDeclarationStringException(
                              string.Format(
                                  "The declaration contained one or more errors: {0}\n{1}",
                                  this.Declaration,
                                  p.Errors.Select(u => u.ToString()).ToNewLineSeparatedString()));
                }

                IList <AttributeDeclaration> attributeDeclarations = p.AttributeDeclarations.ToList();

                IList <VariableDeclaration> variableDeclarations = p.VariableDeclarations.ToList();

                int totalDeclarations = attributeDeclarations.Count + variableDeclarations.Count;

                if (totalDeclarations > 1)
                {
                    throw new InvalidDeclarationStringException("The declaration string contained too many values for simple declaration");
                }
                else if (totalDeclarations == 0)
                {
                    throw new InvalidDeclarationStringException("The declaration string did not contain any attribute or variable declarations");
                }

                if (attributeDeclarations.Count == 1)
                {
                    this.DeclarationComponent = attributeDeclarations.First();
                }
                else if (variableDeclarations.Count == 1)
                {
                    VariableDeclaration variableDeclaration = variableDeclarations.First();

                    if (variableDeclaration.IsUniqueAllocationVariable)
                    {
                        throw new InvalidDeclarationStringException("A declaration containing only a unique allocator is not supported");
                    }

                    this.DeclarationComponent = variableDeclaration;
                }
                else
                {
                    throw new InvalidOperationException();
                }

                this.parsedDeclaration = true;
            }
        }