/// <summary>
        /// Booleans the compute.
        /// </summary>
        /// <param name="criteriaOperatorComputable">The criteria operator computable.</param>
        /// <param name="json">The json.</param>
        /// <returns><c>true</c> if compute as true, <c>false</c> otherwise.</returns>
        public static bool BooleanCompute(ICriteriaOperatorComputable criteriaOperatorComputable, JObject json)
        {
            bool result = false;

            if (criteriaOperatorComputable != null && criteriaOperatorComputable.IsKeyValid() && json != null)
            {
                var jToken = json.XPath(criteriaOperatorComputable.ItemLeft);
                if (jToken != null)
                {
                    switch (jToken.Type)
                    {
                    case JTokenType.Array:
                        result = ComputeAsArray((JArray)jToken, criteriaOperatorComputable.ItemRight, criteriaOperatorComputable.Operator);
                        break;

                    case JTokenType.Date:
                        result = Compute(jToken.ToObject <DateTime>(), Convert.ToDateTime(criteriaOperatorComputable.ItemRight), criteriaOperatorComputable.Operator);
                        break;

                    case JTokenType.Uri:
                    case JTokenType.String:
                        result = ComputeAsString(jToken.ToObject <string>(), criteriaOperatorComputable.ItemRight, criteriaOperatorComputable.Operator);
                        break;

                    case JTokenType.Integer:
                        result = Compute(jToken.ToObject <long>(), criteriaOperatorComputable.ItemRight.ToInt64(), criteriaOperatorComputable.Operator);
                        break;

                    case JTokenType.Guid:
                        result = Compute(jToken.ToObject <Guid>(), criteriaOperatorComputable.ItemRight.ToGuid().Value, criteriaOperatorComputable.Operator);
                        break;

                    case JTokenType.Float:
                        result = Compute(jToken.ToObject <double>(), criteriaOperatorComputable.ItemRight.ToDouble(), criteriaOperatorComputable.Operator);
                        break;

                    case JTokenType.Boolean:
                        result = ComputeAsBoolean(jToken.ToObject <bool>(), criteriaOperatorComputable.ItemRight.ToBoolean(), criteriaOperatorComputable.Operator);
                        break;

                    case JTokenType.Object:
                        result = ComputeAsObject((JObject)jToken, criteriaOperatorComputable.ItemRight, criteriaOperatorComputable.Operator);
                        break;

                    default:
                        break;
                    }
                }
            }

            return(result);
        }
        /// <summary>
        /// Computes the specified computable object.
        /// </summary>
        /// <param name="computableObject">The computable object.</param>
        /// <param name="json">The json.</param>
        /// <returns></returns>
        public static bool Compute(IBooleanComputable computableObject, JObject json)
        {
            if (json != null)
            {
                ICriteriaOperatorComputable operatorComputable = computableObject as ICriteriaOperatorComputable;

                if (operatorComputable != null)
                {
                    return(BooleanCompute(operatorComputable, json));
                }

                IRelationshipOperatorComputable relationshipComputable = computableObject as IRelationshipOperatorComputable;

                if (relationshipComputable != null)
                {
                    return(BooleanCompute(relationshipComputable, json));
                }
            }

            return(false);
        }
 /// <summary>
 /// Determines whether [is key valid].
 /// </summary>
 /// <param name="operatorComputable">The operator computable.</param>
 /// <returns>
 ///   <c>true</c> if [is key valid] [the specified operator computable]; otherwise, <c>false</c>.
 /// </returns>
 public static bool IsKeyValid(this ICriteriaOperatorComputable operatorComputable)
 {
     return(operatorComputable != null && criteriaKeyRegex.IsMatch(operatorComputable.ItemLeft));
 }