public PendingBinaryStateOutputActuatorState WithParameter(IParameter parameter)
        {
            if (parameter == null) throw new ArgumentNullException(nameof(parameter));

            Parameters.Add(parameter);
            return this;
        }

        internal static CodeTypeReference GetParameterTypeReference(CodeTypeDeclaration classDeclaration,
            IParameter param)
        {
            Type underlyingType = GetParameterType(param);
            CodeTypeReference paramTypeRef = new CodeTypeReference(underlyingType);
            bool isValueType = underlyingType.IsValueType;

            // Check if we need to declare a custom type for this parameter.
            // If the parameter is an enum, try finding the matching enumeration in the current class
            if (!param.EnumValues.IsNullOrEmpty())
            {
                // Naming scheme: MethodnameParametername
                CodeTypeReference enumReference = DecoratorUtil.FindFittingEnumeration(
                    classDeclaration, param.EnumValues, param.EnumValueDescriptions);

                if (enumReference != null)
                {
                    paramTypeRef = enumReference;
                    isValueType = true;
                }
            }

            // Check if this is an optional value parameter.
            if (isValueType && !param.IsRequired)
            {
                paramTypeRef = new CodeTypeReference(typeof(Nullable<>))
                {
                    TypeArguments = { paramTypeRef.BaseType }
                };
                // An optional value parameter has to be nullable.
            }

            return paramTypeRef;
        }

 private void ProcessParameter(IParameter parameter, int index, StringBuilder preMemberCodeBulider)
 {
     // Dispatch to the typed parameter handler method.
     Type key = parameter.GetType().GetInterfaces().First(t => t.Namespace == typeof(IParameter).Namespace && t.Name.StartsWith("I") && t.Name.EndsWith("Parameter"));
     Action<IParameter, int, StringBuilder> method = _parameterCodeGeneratorMethodMap[key];
     method(parameter, index, preMemberCodeBulider);
 }

 public ConstructorInjectionComponentAdapter(object componentKey, Type componentImplementation,
                                             IParameter[] parameters, bool allowNonPublicClasses,
                                             IComponentMonitor componentMonitor)
     : base(componentKey, componentImplementation, parameters, allowNonPublicClasses)
 {
     this.componentMonitor = componentMonitor;
 }

 public ParameterCollection(IParameter[] parameters)
 {
     foreach (IParameter parameter in parameters)
     {
         AddParameter(parameter);
     }
 }

 public IComponentAdapter CreateComponentAdapter(object componentKey, Type componentImplementation,
                                                 IParameter[] parameters)
 {
     return
         new CachingComponentAdapter(
             new ConstructorInjectionComponentAdapter(componentKey, componentImplementation, parameters));
 }

        protected override IPresenter CreatePresenterInstance(Type presenterType, TypedPageData pageData, Type viewType, IEPiView view)
        {
            // Unfortunately, Ninject needs the bloody names of the parameters,
            // so we need to figure them out by reflecting.
            string pageDataParameterName = null;
            string viewParameterName = null;
            foreach (var constructor in presenterType.GetConstructors())
            {
                var constructorParameters = constructor.GetParameters();
                foreach (var parameter in constructorParameters)
                {
                    if (parameter.ParameterType.IsAssignableFrom(pageData.GetType()))
                        pageDataParameterName = parameter.Name;

                    if (parameter.ParameterType.IsAssignableFrom(view.GetType()))
                        viewParameterName = parameter.Name;
                }
            }
            var parameters = new IParameter[]
                                 {
                                     new ConstructorArgument(viewParameterName, view),
                                     new ConstructorArgument(pageDataParameterName, pageData)
                                 };
            return (IPresenter)Kernel.Get(presenterType, parameters);
        }

        public object[] Resolve(object requestParameters, IParameter[] targetParameters)
        {
            // Convert to array
            var parameters = ((IEnumerable) requestParameters).Cast<object>().ToArray();

            // If length does not match, throw.
            if (parameters.Length != targetParameters.Length)
            {
                throw new ParameterLengthMismatchException();
            }

            var result = new List<object>();

            // Loop through and parse parameters
            for (var i = 0; i < parameters.Length; i++)
            {
                var request = parameters[i];
                var target = targetParameters[i];

                // If the target parameter is `object`, do not try to convert it.
                if (target.ParameterType == typeof (object))
                {
                    result.Add(request);
                }
                else
                {
                    var serialized = _serializer.SerializeObject(request);
                    var converted = _serializer.DeserializeObject(serialized, target.ParameterType);

                    result.Add(converted);
                }
            }

            return result.ToArray();
        }

 private void btnOK_Click(object sender, EventArgs e)
 {
     this.NewParameter = this.cboxNewName.SelectedItem as IParameter;
     this.OldParameter = this.cboxOldName.SelectedItem as IParameter;
     this.DialogResult = DialogResult.OK;
     this.Close();
 }

        protected virtual IPicoContainer WrapComponentInstances(Type decoratingComponentAdapterClass,
                                                                IPicoContainer picoContainer,
                                                                object[] wrapperDependencies)
        {
            Assert.IsTrue(typeof (DecoratingComponentAdapter).IsAssignableFrom(decoratingComponentAdapterClass));
            IMutablePicoContainer mutablePicoContainer = new DefaultPicoContainer();
            int size = (wrapperDependencies != null ? wrapperDependencies.Length : 0) + 1;
            ICollection allComponentAdapters = picoContainer.ComponentAdapters;

            foreach (object adapter in allComponentAdapters)
            {
                IParameter[] parameters = new IParameter[size];
                parameters[0] = new ConstantParameter(adapter);
                for (int i = 1; i < parameters.Length; i++)
                {
                    parameters[i] = new ConstantParameter(wrapperDependencies[i - 1]);
                }
                IMutablePicoContainer instantiatingPicoContainer =
                    new DefaultPicoContainer(new ConstructorInjectionComponentAdapterFactory());
                instantiatingPicoContainer.RegisterComponentImplementation("decorator", decoratingComponentAdapterClass,
                                                                           parameters);
                mutablePicoContainer.RegisterComponent(
                    (IComponentAdapter) instantiatingPicoContainer.GetComponentInstance("decorator"));
            }
            return mutablePicoContainer;
        }

		public DefaultParameter(IParameter p)
		{
			this.name = p.Name;
			this.region = p.Region;
			this.modifier = p.Modifiers;
			this.returnType = p.ReturnType;
		}

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="componentKey">The component's key</param>
 /// <param name="componentImplementation">The component implementing type</param>
 /// <param name="parameters">Parameters used to initialize the component</param>
 /// <param name="allowNonPublicClasses">flag to allow instantiation of non-public classes.</param>
 public InstantiatingComponentAdapter(object componentKey, Type componentImplementation, IParameter[] parameters,
                                      bool allowNonPublicClasses)
     : base(componentKey, componentImplementation)
 {
     this.parameters = parameters;
     this.allowNonPublicClasses = allowNonPublicClasses;
 }

        public override bool ParseParameterValue(IParameter parameter, string parameterValue)
        {
            bool returnValue = base.ParseParameterValue(parameter, parameterValue);

            if (returnValue)
            {
                switch (parameter.Name)
                {
                    case _ParameterAlternateNameSource:
                    case _ParameterNameSource:
                        parameterValue = parameterValue.Trim();
                        if (Directory.Exists(parameterValue))
                        {
                            ((Parameter<string>)parameter).Value = parameterValue;
                        }
                        else
                        {
                            returnValue = false;
                        }
                        break;
                }
            }

            return returnValue;
        }

        /// <summary>
        /// Validates a parameter.
        /// 
        /// Checks to see if it is required, or if it needs regex validation.
        /// </summary>
        /// <param name="param">
        /// A <see cref="IParameter"/>
        /// </param>
        /// <returns>
        /// A <see cref="System.Boolean"/>
        /// </returns>
        public bool ValidateParameter(IParameter param)
        {
            if (Parameters == null)
            {
                return false;
            }

            string currentParam;
            bool parameterPresent = Parameters.TryGetValue(param.Name, out currentParam);

            // If a required parameter is not present, fail.
            if (String.IsNullOrEmpty(currentParam) || !parameterPresent)
            {
                return !param.IsRequired;
            }
        
            // The parameter is present, validate the regex.
            bool isValidData = ValidateRegex(param, currentParam) && ValidateEnum(param, currentParam);
            if (isValidData == false)
            {
                return false;
            }

            return true;
        }

        public void AddParameter(IParameter parameter)
        {
            if (parameter == null)
                throw new ArgumentNullException("parameter");

            parameters.Add(parameter.Name, parameter.Value);
        }

        public int CreateSubmission(Dictionary<string, string> dataDictionary)
        {
            IParameter[] parameters = new IParameter[2];
            parameters[0] = FormStorageCore.SqlHelper.CreateParameter("@DBformID", DBformID);
            parameters[1] = FormStorageCore.SqlHelper.CreateParameter("@ipAddress", FormStorageCore.GetUserIP());

            //create submission
            int submissionID = FormStorageCore.SqlHelper.ExecuteScalar<int>("INSERT INTO FormStorageSubmissions (formID, IP, datetime) VALUES (@DBformID, @ipAddress, GETDATE());SELECT SCOPE_IDENTITY() AS submissionID;", parameters);
            //HttpContext.Current.Response.Write("Submission ID=>" + submissionID + "<br/>");

            if (submissionID == 0)
            {
                throw new Exception("Could not create a record in table FormStorageSubmissions.");
            }

            parameters = new IParameter[3];
            parameters[0] = FormStorageCore.SqlHelper.CreateParameter("@submissionID", submissionID);

            foreach (string formField in formFields)
            {
                try
                {
                    parameters[1] = FormStorageCore.SqlHelper.CreateParameter("@fieldAlias", formField);
                    parameters[2] = FormStorageCore.SqlHelper.CreateParameter("@value", HttpUtility.HtmlEncode(dataDictionary[formField]));
                    int entryID = FormStorageCore.SqlHelper.ExecuteScalar<int>("INSERT INTO FormStorageEntries (submissionID, fieldAlias, value) VALUES (@submissionID, @fieldAlias, @value);SELECT SCOPE_IDENTITY() AS entryID;", parameters);
                }
                catch (Exception e2)
                {
                    //HttpContext.Current.Response.Write(e2.Message);
                }
            }

            return submissionID;
        }

        internal CodeTypeMemberCollection GenerateParameterProperty(IParameter parameter,
            IMethod method,
            CodeTypeDeclaration resourceClass,
            IEnumerable<string> usedNames)
        {
            // Get the name and return type of this parameter.
            string name = parameter.Name;
            CodeTypeReference returnType = ResourceBaseGenerator.GetParameterTypeReference(
                resourceClass, parameter);

            // Generate the property and field.
            CodeTypeMemberCollection newMembers = DecoratorUtil.CreateAutoProperty(
                name, parameter.Description, returnType, usedNames, parameter.IsRequired);

            // Add the KeyAttribute to the property.
            foreach (CodeTypeMember member in newMembers)
            {
                CodeMemberProperty property = member as CodeMemberProperty;
                if (property == null)
                {
                    continue;
                }

                // Declare the RequestParameter attribute.
                CodeTypeReference attributeType = new CodeTypeReference(typeof(RequestParameterAttribute));
                CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(attributeType);
                attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(parameter.Name)));
                property.CustomAttributes.Add(attribute);
            }

            return newMembers;
        }

 public override IComponentAdapter CreateComponentAdapter(object componentKey, Type componentImplementation,
                                                          IParameter[] parameters)
 {
     return
         new CachingComponentAdapter(
             base.CreateComponentAdapter(componentKey, componentImplementation, parameters));
 }

        public ValueOrderSignature(
            string syntax,
            string description,
            ITrackingSpan trackingSpan,
            ISignatureHelpSession session)
        {

            _propertyName = "Syntax";
            _syntax = syntax ?? string.Empty;
            _description = description;
            _trackingSpan = trackingSpan;

            _content = string.Format(CultureInfo.InvariantCulture, "{0}: {1}", _propertyName, _syntax);
            _nameParam = new CssPropertyNameParameter(this);
            _currentParam = _nameParam;

            _session = session;

            // In order to dismiss this tip at the appropriate time, I need to listen
            // to changes in the text buffer
            if (_trackingSpan != null && _session != null)
            {
                _session.Dismissed += OnSessionDismissed;
                _trackingSpan.TextBuffer.Changed += OnTextBufferChanged;
            }
        }

        public AddToDate(IElementCreationContext context) 
            : base(context, context.Owner.GetVplTypeOrThrow(VplTypeId.DateTime))
        {
            DateParameter = context.Owner.CreateParameter("date", context.Owner.GetVplTypeOrThrow(VplTypeId.DateTime),
                "Date");

            DateParameter.Postfix = " + ";

            AmountParameter = context.Owner.CreateParameter("amount", context.Owner.GetFloatType());

            Parameters.Add(DateParameter);
            Parameters.Add(AmountParameter);

            _services = new OperationService[]
            {
                new OperationService(OperationType.Seconds, "Seconds", TimeSpan.FromSeconds),
                new OperationService(OperationType.Minutes, "Minutes", TimeSpan.FromMinutes),
                new OperationService(OperationType.Hours, "Hours", TimeSpan.FromHours),
                new OperationService(OperationType.Days, "Days", TimeSpan.FromDays),
            };

            Operation = OperationType.Seconds;

            if (!string.IsNullOrWhiteSpace(context.Data))
            {
                var data = JsonConvert.DeserializeObject<OperatorData>(context.Data);

                Operation = data.Operation;
            }

            foreach (var service in _services)
            {
                AddAction(new ElementAction(service.Text, () => Operation = service.Operation, () => Operation != service.Operation));
            }
        }