public virtual IConstraint And(IConstraint andWith)
 {
     lock (StreamLock())
     {
         return Join(andWith, true);
     }
 }

        protected override object GetRandomValueCore(Type type, IConstraint[] constraints)
        {
            var valueScaled = _random.NextDouble();

            if (type == typeof(float))
                return this.ApplyConstraints(
                    constraints, 0.0f, 1.0f,
                    (minValue, maxValue) => minValue + valueScaled * (maxValue - minValue)
                );

            if (type == typeof(double))
                return this.ApplyConstraints(
                    constraints, 0.0d, 1.0d,
                    (minValue, maxValue) => minValue + valueScaled * (maxValue - minValue)
                );

            if (type == typeof(decimal))
                return this.ApplyConstraints(
                    constraints, 0.0m, 1.0m,
                    (minValue, maxValue) => minValue + (decimal)valueScaled * (maxValue - minValue)
                );

            throw new InvalidOperationException(
                string.Format("{0} does not support generation of {1}", this.GetType(), type
            ));
        }

        protected override void VisitGroup(ConstraintGroup node)
        {
            IConstraint where = null;

            for (int i = 0, c = node.Items.Count; i < c; i++)
            {
                this.Visit(node.Items[i]);

                if (i == 0)
                {
                    where = _whereResult;
                }
                else
                {
                    string op = node.Operators[i - 1];
                    if (op == Constraint.AndOperator)
                    {
                        where = f.And(where, _whereResult);
                    }
                    else if (op == Constraint.OrOperator)
                    {
                        where = f.Or(where, _whereResult);
                    }
                }
            }

            _whereResult = where;
        }

 /// <summary>
 /// Formats a prefix constraint's description.
 /// </summary>
 internal static string FormatDescription(string descriptionPrefix, IConstraint baseConstraint)
 {
     return string.Format(
         baseConstraint is EqualConstraint ? "{0} equal to {1}" : "{0} {1}",
         descriptionPrefix,
         baseConstraint.Description);
 }

			public virtual void Visit(OrExpression expression)
			{
				expression.Left().Accept(this);
				IConstraint left = _constraint;
				expression.Right().Accept(this);
				left.Or(_constraint);
				_constraint = left;
			}

        /// <summary>
        /// Construct a BinaryConstraint from two other constraints
        /// </summary>
        /// <param name="left">The first constraint</param>
        /// <param name="right">The second constraint</param>
        protected BinaryConstraint(IConstraint left, IConstraint right)
            : base(left, right)
        {
            Guard.ArgumentNotNull(left, "left");
            this.Left = left;

            Guard.ArgumentNotNull(right, "right");
            this.Right = right;
        }

        /// <summary>
        /// Writes the difference between the constraint and the actual value into a message.
        /// </summary>
        /// <param name="constraint">The constraint.</param>
        public string BuildMessage(IConstraint constraint)
        {
            this.Message = string.Format("Expected: '{0}' But was : '{1}'"
                , constraint.Description
                , this.GetString(constraint.Actual));

            this.BuildHeader(this.Message, constraint);
            return this.Message;
        }

        protected override object GetRandomValueCore(Type type, IConstraint[] constraints)
        {
            var randomNumber = _random.Next(Int32.MinValue, Int32.MaxValue);
            var valueScaled = (decimal)((long)randomNumber - Int32.MinValue) / ((long)Int32.MaxValue - Int32.MinValue);

            if (type == typeof(sbyte))
                return this.ApplyConstraints(
                    constraints, sbyte.MinValue, sbyte.MaxValue,
                    (minValue, maxValue) => minValue + valueScaled * (maxValue - minValue)
                );

            if (type == typeof(short))
                return this.ApplyConstraints(
                    constraints, short.MinValue, short.MaxValue,
                    (minValue, maxValue) => minValue + valueScaled * (maxValue - minValue)
                );

            if (type == typeof(int))
                return this.ApplyConstraints(
                    constraints, int.MinValue, int.MaxValue,
                    (minValue, maxValue) => minValue + valueScaled * ((long)maxValue - minValue)
                );

            if (type == typeof(long))
                return this.ApplyConstraints(
                    constraints, long.MinValue, long.MaxValue,
                    (minValue, maxValue) => this.ConstrictToRange(valueScaled, minValue, maxValue)
                );

            if (type == typeof(byte))
                return this.ApplyConstraints(
                    constraints, byte.MinValue, byte.MaxValue,
                    (minValue, maxValue) => minValue + valueScaled * (maxValue - minValue)
                );

            if (type == typeof(ushort))
                return this.ApplyConstraints(
                    constraints, ushort.MinValue, ushort.MaxValue,
                    (minValue, maxValue) => minValue + valueScaled * (maxValue - minValue)
                );

            if (type == typeof(uint))
                return this.ApplyConstraints(
                    constraints, uint.MinValue, uint.MaxValue,
                    (minValue, maxValue) => minValue + valueScaled * (maxValue - minValue)
                );

            if (type == typeof(ulong))
                return this.ApplyConstraints(
                    constraints, ulong.MinValue, ulong.MaxValue,
                    (minValue, maxValue) => minValue + valueScaled * (maxValue - minValue)
                );

            throw new InvalidOperationException(
                string.Format("{0} does not support generation of {1}", this.GetType(), type
            ));
        }

        public InstanceRegistration(IConstraint constraint, ActionDescriptor actionDescriptor, ControllerDescriptor controllerDescriptor, FilterScope scope1)
            : base(actionDescriptor, controllerDescriptor, scope1)
        {
            if (constraint == null)
            {
                throw new ArgumentNullException("constraint", "Constraint instance can not be null.");
            }

            Constraint = constraint;
            ConstraintType = Constraint.GetType();
        }

        public object GetRandomValue(Type type, IConstraint[] constraints)
        {
            Require.NotNull(type, "type");
            Require.That<InvalidOperationException>(
                this.IsTypeSupported(type),
                "{0} does not support generation of {1}.",
                this.GetType(), type
            );

            return this.GetRandomValueCore(type, constraints);
        }

		public virtual IConstraints Constraints()
		{
			lock (_cluster)
			{
				IConstraint[] constraints = new IConstraint[_queries.Length];
				for (int i = 0; i < constraints.Length; i++)
				{
					constraints[i] = _queries[i].Constraints();
				}
				return new ClusterConstraints(_cluster, constraints);
			}
		}

 public virtual IConstraint Constrain(object constraint)
 {
     lock (_cluster)
     {
         var constraints = new IConstraint[_queries.Length];
         for (var i = 0; i < constraints.Length; i++)
         {
             constraints[i] = _queries[i].Constrain(constraint);
         }
         return new ClusterConstraint(_cluster, constraints);
     }
 }

        private Pendulum(Particle point_a_, Particle point_b_, Vector3f equilibrium_position_, Render callback_, params IConstraint[] constraints_)
        {
            point_a = point_a_;
            point_b = point_b_;
            callback = callback_;
            equilibrium_position = equilibrium_position_;

            constraints = new IConstraint[constraints_.Length];
            for(int i = 0; i < constraints_.Length; ++i)
            {
                constraints[i] = constraints_[i];
            }
        }

		internal override IConstraint Join(IConstraint a_with, bool a_and)
		{
			lock (StreamLock())
			{
				if (!(a_with is QCon))
				{
					return null;
				}
				// resolving multiple constraints happens in QCon for
				// a_with, so we simply turn things around
				return ((QCon)a_with).Join1(this, a_and);
			}
		}

		private IConstraint[] argsAsConstraints(object[] args)
		{
			if (null == args)
			{
				return new IConstraint[0];
			}

			IConstraint[] result = new IConstraint[args.Length];
			for (int i = 0; i < result.Length; ++i)
			{
				result[i] = argAsConstraint(args[i]);
			}
			return result;
		}

		private IConstraint Join(IConstraint with, bool isAnd)
		{
			lock (_cluster)
			{
				Db4objects.Db4o.Internal.Cluster.ClusterConstraint other = Compatible(with);
				IConstraint[] newConstraints = new IConstraint[_constraints.Length];
				for (int i = 0; i < _constraints.Length; i++)
				{
					newConstraints[i] = isAnd ? _constraints[i].And(other._constraints[i]) : _constraints
						[i].Or(other._constraints[i]);
				}
				return new Db4objects.Db4o.Internal.Cluster.ClusterConstraint(_cluster, newConstraints
					);
			}
		}

		private Db4objects.Db4o.Internal.Cluster.ClusterConstraint Compatible(IConstraint
			 with)
		{
			if (!(with is Db4objects.Db4o.Internal.Cluster.ClusterConstraint))
			{
				throw new ArgumentException();
			}
			Db4objects.Db4o.Internal.Cluster.ClusterConstraint other = (Db4objects.Db4o.Internal.Cluster.ClusterConstraint
				)with;
			if (other._constraints.Length != _constraints.Length)
			{
				throw new ArgumentException();
			}
			return other;
		}

		private static int GetIndexOfConstraintDimension(IConstraint constraint, ReadOnlyCollection<DimensionWithValues> dimensionValues,
			QualifiedDimension dimension)
		{
			int ret = 0;
			foreach (DimensionWithValues dv in dimensionValues)
			{
				if (IsSubset(dimension, dv.Dimension))
				{
					return ret;
				}
				ret++;
			}
			throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
				"Dimension {0} from constraint {1} was not found in the matrix (all dimensions: {2}).",
				dimension.FullyQualifiedName, constraint.GetType().Name, string.Join(",", dimensionValues.Select(dv => dv.Dimension.FullyQualifiedName))));
		}

		public virtual IConstraint[] ToArray()
		{
			lock (_cluster)
			{
				Collection4 all = new Collection4();
				for (int i = 0; i < _constraints.Length; i++)
				{
					ClusterConstraint c = (ClusterConstraint)_constraints[i];
					for (int j = 0; j < c._constraints.Length; j++)
					{
						all.Add(c._constraints[j]);
					}
				}
				IConstraint[] res = new IConstraint[all.Size()];
				all.ToArray(res);
				return res;
			}
		}

        protected override object GetRandomValueCore(Type type, IConstraint[] constraints)
        {
            if (type == typeof(char))
                return (char)_random.Next(Char.MinValue, Char.MaxValue);

            if (type == typeof(bool))
                return _random.NextDouble() > 0.5;

            if (type == typeof(string))
            #if !SILVERLIGHT
                return Path.GetRandomFileName();
            #else
                return Guid.NewGuid().ToString();
            #endif

            if (type == typeof(Guid))
                return Guid.NewGuid();

            throw new InvalidOperationException(
                string.Format("{0} does not support generation of {1}", this.GetType(), type
            ));
        }