/// <summary>
 /// Create a new query plan property
 /// </summary>
 /// <param name="myVertexType">The interesting vertex type</param>
 /// <param name="myProperty">The interesting property</param>
 public QueryPlanProperty(IVertexType myVertexType, IPropertyDefinition myProperty, String myInterestingEdition, TimeSpanDefinition myInterestingTimeSpan)
 {
     VertexType = myVertexType;
     Property = myProperty;
     Edition = myInterestingEdition;
     Timespan = myInterestingTimeSpan;
 }

        /// <summary>
        /// Calculates the sum
        /// </summary>
        public FuncParameter Aggregate(IEnumerable<IComparable> myValues, IPropertyDefinition myPropertyDefinition)
        {
            var sumType = myPropertyDefinition.BaseType;
            IComparable sum = null;

            try
            {
                foreach (var value in myValues)
                {
                    if (sum == null)
                    {
                        sum = ArithmeticOperations.Add(sumType, 0, value);
                    }
                    else
                    {
                        sum = ArithmeticOperations.Add(sumType, sum, value);
                    }
                }
            }
            catch (ArithmeticException)
            {
                throw new InvalidArithmeticAggregationException(sumType, this.AggregateName);
            }

            return new FuncParameter(sum, myPropertyDefinition);
        }

		/// <summary>
		/// Creates the a <see cref="Column"/>.
		/// </summary>
		/// <param name="context">The <see cref="IMansionContext"/>.</param>
		/// <param name="table">The <see cref="Table"/> to which the column will be added.</param>
		/// <param name="property">The <see cref="IPropertyDefinition"/>.</param>
		/// <returns>Returns the created <see cref="Column"/>.</returns>
		protected virtual Column DoCreate(IMansionContext context, Table table, IPropertyDefinition property)
		{
			// get the column name
			var columnName = Properties.Get<string>(context, "columnName", null) ?? property.Name;

			// create the column
			return PropertyColumn.CreatePropertyColumn(context, property.Name, columnName, Properties);
		}

			/// <summary>
			/// Creates a <see cref="PropertyMapping"/> from this descriptor.
			/// </summary>
			/// <param name="context">The <see cref="IMansionContext"/>.</param>
			/// <param name="property">The <see cref="IPropertyDefinition"/>.</param>
			/// <returns>The created <see cref="PropertyMapping"/>.</returns>
			protected override SinglePropertyMapping DoCreateSingleMapping(IMansionContext context, IPropertyDefinition property)
			{
				// create the mapping
				return new SingleValuedPropertyMapping(property.Name) {
					// map the type
					Type = Properties.Get<string>(context, "type")
				};
			}

 public ServicePropertyDefinition(IPropertyDefinition myPropertyDefinition)
     : base(myPropertyDefinition)
 {
     this.IsMandatory = myPropertyDefinition.IsMandatory;
     this.InIndices = myPropertyDefinition.InIndices.Select(x => x.Name).ToList();
     this.Multiplicity = ConvertHelper.ToServicePropertyMultiplicity(myPropertyDefinition.Multiplicity);
     this.IsUserDefinedType = myPropertyDefinition.IsUserDefinedType;
     this.BaseType = myPropertyDefinition.BaseType.AssemblyQualifiedName;
     this.DefaultValue = myPropertyDefinition.DefaultValue;
 }

        public CciPropertyDetails(IPropertyDefinition property)
            : base(property)
        {
            if (property == null)
            {
                throw new ArgumentNullException("property");
            }

            _property = property;
        }

        public override void Visit(IPropertyDefinition property)
        {
            IMethodReference getter = property.Getter;
            IMethodReference setter = property.Setter;

            if (getter != null)
                AddMemberReference(getter.ResolvedMethod);
            if (setter != null)
                AddMemberReference(setter.ResolvedMethod);

            base.Visit(property);
        }

		/// <summary>
		/// Creates the a <see cref="Column"/>.
		/// </summary>
		/// <param name="context">The <see cref="IMansionContext"/>.</param>
		/// <param name="table">The <see cref="Table"/> to which the column will be added.</param>
		/// <param name="property">The <see cref="IPropertyDefinition"/>.</param>
		/// <returns>Returns the created <see cref="Column"/>.</returns>
		/// <exception cref="ArgumentNullException">Thrown if one of the parameters is null.</exception>
		public Column Create(IMansionContext context, Table table, IPropertyDefinition property)
		{
			// validate arguments
			if (context == null)
				throw new ArgumentNullException("context");
			if (property == null)
				throw new ArgumentNullException("property");
			if (table == null)
				throw new ArgumentNullException("table");

			// invoke template method
			return DoCreate(context, table, property);
		}

		/// <summary>
		/// Creates the <see cref="Table"/> from the descriptor.
		/// </summary>
		/// <param name="context">The <see cref="IMansionContext"/>.</param>
		/// <param name="schema">The <see cref="Schema"/>in which to create the table.</param>
		/// <param name="property">The <see cref="IPropertyDefinition"/>.</param>
		/// <exception cref="ArgumentNullException">Thrown if one of the parameters is null.</exception>
		public void Create(IMansionContext context, Schema schema, IPropertyDefinition property)
		{
			// validate arguments
			if (context == null)
				throw new ArgumentNullException("context");
			if (schema == null)
				throw new ArgumentNullException("schema");
			if (property == null)
				throw new ArgumentNullException("property");

			// invoke template method
			DoCreate(context, schema, property);
		}

        private void WriteAccessorDefinition(IPropertyDefinition property, IMethodDefinition accessor, string accessorType)
        {
            WriteSpace();
            WriteAttributes(accessor.Attributes, writeInline: true);
            // If the accessor is an internal call (or a PInvoke) we should put those attributes here as well

            WriteMethodPseudoCustomAttributes(accessor);

            if (accessor.Visibility != property.Visibility)
                WriteVisibility(accessor.Visibility);
            WriteKeyword(accessorType, noSpace: true);
            WriteMethodBody(accessor);
        }

        /// <summary>
        /// Calculates the maximum
        /// </summary>
        public FuncParameter Aggregate(IEnumerable<IComparable> myValues, IPropertyDefinition myPropertyDefinition)
        {
            IComparable max = null;

            foreach (var value in myValues)
            {
                if (max == null)
                {
                    max = value;
                }
                else if (max.CompareTo(value) < 0)
                {
                    max = value;
                }
            }

            return new FuncParameter(max, myPropertyDefinition);
        }

		/// <summary>
		/// Adds <see cref="PropertyMapping"/>s of <paramref name="property"/> to the given <paramref name="typeMapping"/>.
		/// </summary>
		/// <param name="context">The <see cref="IMansionContext"/>.</param>
		/// <param name="property">The <see cref="IPropertyDefinition"/> of the property for which to add the <see cref="PropertyMapping"/>s.</param>
		/// <param name="typeMapping">The <see cref="TypeMapping"/> to which to add the new <see cref="PropertyMapping"/>s.</param>
		protected override void DoAddMappingTo(IMansionContext context, IPropertyDefinition property, TypeMapping typeMapping)
		{
			typeMapping.Add(new SingleValuedPropertyMapping("approved")
			                {
			                	Type = "boolean"
			                });
			typeMapping.Add(new SingleValuedPropertyMapping("archived")
			                {
			                	Type = "boolean"
			                });
			typeMapping.Add(new SingleValuedPropertyMapping("publicationDate")
			                {
			                	Type = "date"
			                });
			typeMapping.Add(new SingleValuedPropertyMapping("expirationDate")
			                {
			                	Type = "date"
			                });
		}

        /// <summary>
        /// Calculates the average
        /// </summary>
        public FuncParameter Aggregate(IEnumerable<IComparable> myValues, IPropertyDefinition myPropertyDefinition)
        {
            var divType = myPropertyDefinition.BaseType;
            IComparable sum = null;
            uint total = 0;

            foreach (var value in myValues)
            {
                if (sum == null)
                {
                    sum = ArithmeticOperations.Add(divType, 0, value);
                }
                else
                {
                    sum = ArithmeticOperations.Add(divType, sum, value);
                }

                total++;
            }

            var aggregateResult = ArithmeticOperations.Div(typeof(Double), sum, total);

            return new FuncParameter(aggregateResult, myPropertyDefinition);
        }

 public virtual void onMetadataElement(IPropertyDefinition propertyDefinition) { }

 public override void Visit(IPropertyDefinition property)
 {
     if (IsMemberExternallyVisible2(property))
     {
         // Recursion
         Visit(property.Parameters);
         Visit(property.Type);
     }
 }

 public virtual void PrintPropertyDefinitionReturnType(IPropertyDefinition propertyDefinition) {
   PrintTypeReference(propertyDefinition.Type);
 }

 public virtual void PrintPropertyDefinitionVisibility(IPropertyDefinition propertyDefinition) {
   PrintTypeMemberVisibility(propertyDefinition.Visibility);
 }

 public virtual void PrintPropertyDefinitionModifiers(IPropertyDefinition propertyDefinition) {
   PrintMethodDefinitionModifiers(propertyDefinition.Getter == null ?
     propertyDefinition.Setter.ResolvedMethod :
     propertyDefinition.Getter.ResolvedMethod);
 }

 public virtual void PrintPropertyDefinitionName(IPropertyDefinition propertyDefinition) {
   PrintIdentifier(propertyDefinition.Name);
 }

    public override void TraverseChildren(IPropertyDefinition propertyDefinition) {

      PrintAttributes(propertyDefinition);

      bool isIndexer = false;
      if (IteratorHelper.EnumerableIsNotEmpty(propertyDefinition.Parameters)) {
        // We have an indexer.  Note that this could still be an explicit interface implementation.
        // If it's got a name other than 'Item', we need an attribute to rename it.
        // Note that there will usually be a DefaultMemberAttribute on the class with the name
        // but the attribute doesn't always exist (eg. if it's an explicit interaface impl)
        isIndexer = true;
        string id = propertyDefinition.Name.Value;
        string simpleId = id.Substring(id.LastIndexOf('.') + 1);  // excludes any interface type
        if (simpleId != "Item") {
          PrintPseudoCustomAttribute(propertyDefinition, "System.Runtime.CompilerServices.IndexerName", QuoteString(simpleId), true, null);
        }
      }

      PrintToken(VBToken.Indent);

      IMethodDefinition propMeth = propertyDefinition.Getter == null ?
        propertyDefinition.Setter.ResolvedMethod :
        propertyDefinition.Getter.ResolvedMethod;
      if (!propertyDefinition.ContainingTypeDefinition.IsInterface && 
        IteratorHelper.EnumerableIsEmpty(MemberHelper.GetExplicitlyOverriddenMethods(propMeth)))
          PrintPropertyDefinitionVisibility(propertyDefinition);
      PrintPropertyDefinitionModifiers(propertyDefinition);
      PrintPropertyDefinitionReturnType(propertyDefinition);
      PrintToken(VBToken.Space);

      if (isIndexer) {
        // Indexers are always identified with a 'this' keyword, but might have an interface prefix
        string id = propertyDefinition.Name.Value;
        int lastDot = id.LastIndexOf('.');
        if (lastDot != -1)
          sourceEmitterOutput.Write(id.Substring(0, lastDot +1));
        PrintToken(VBToken.This);
        PrintToken(VBToken.LeftSquareBracket);
        bool fFirstParameter = true;
        var parms = propertyDefinition.Parameters;
        if (propertyDefinition.Getter != null)
          parms = propertyDefinition.Getter.ResolvedMethod.Parameters;  // more likely to have names
        else if (propertyDefinition.Setter != null) {
          // Use the setter's names except for the final 'value' parameter
          var l = new List<IParameterDefinition>(propertyDefinition.Setter.ResolvedMethod.Parameters);
          l.RemoveAt(l.Count - 1);
          parms = l;
        }
        foreach (IParameterDefinition parameterDefinition in parms) {
          if (!fFirstParameter)
            PrintParameterListDelimiter();
          this.Traverse(parameterDefinition);
          fFirstParameter = false;
        }
        PrintToken(VBToken.RightSquareBracket);
      } else {
        PrintPropertyDefinitionName(propertyDefinition);
      }
      //PrintToken(CSharpToken.LeftCurly);
      if (propertyDefinition.Getter != null) {
        PrintToken(VBToken.Indent);
        var getMeth = propertyDefinition.Getter.ResolvedMethod;
        if (getMeth.Visibility != propertyDefinition.Visibility)
          PrintTypeMemberVisibility(getMeth.Visibility);
        PrintToken(VBToken.Get);
        if (getMeth.IsAbstract || getMeth.IsExternal)
          PrintToken(VBToken.Semicolon);
        else
          Traverse(getMeth.Body);
      }
      if (propertyDefinition.Setter != null) {
        PrintToken(VBToken.Indent);
        var setMeth = propertyDefinition.Setter.ResolvedMethod;
        if (setMeth.Visibility != propertyDefinition.Visibility)
          PrintTypeMemberVisibility(setMeth.Visibility);
        PrintToken(VBToken.Set);
        if (setMeth.IsAbstract || setMeth.IsExternal)
          PrintToken(VBToken.Semicolon);
        else
          Traverse(setMeth.Body);
      }
      //PrintToken(CSharpToken.RightCurly);
    }