private Predicate ReadPredicate(CompoundExpression exp, Domain d)
 {
     ParametrizedPredicate pp = new ParametrizedPredicate(exp.Type);
     int iExpression = 0;
     Parameter p = null;
     string sName = "";
     List<Parameter> lUntypedParameters = new List<Parameter>();
     for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
     {
         sName = exp.SubExpressions[iExpression].ToString();
         if (sName == "-")
         {
             string sType = exp.SubExpressions[iExpression + 1].ToString();
             foreach (Parameter pUntyped in lUntypedParameters)
                 pUntyped.Type = sType;
             lUntypedParameters.Clear();
             iExpression++;//skip the "-" and the type
         }
         else
         {
             p = new Parameter("", sName);
             lUntypedParameters.Add(p);
             pp.AddParameter(p);
         }
     }
     if (d.Types.Count == 1)
     {
         foreach (Parameter pUntyped in lUntypedParameters)
             pUntyped.Type = d.Types[0];
     }
     return pp;
 }
        private Formula ReadPredicate(CompoundExpression exp, Dictionary<string, string> dParameterNameToType, bool bParametrized, Domain d)
        {
            Predicate p = null;
            int iExpression = 0;
            string sName = "";

            if (bParametrized)
                p = new ParametrizedPredicate(exp.Type);
            else
                p = new GroundedPredicate(exp.Type);
            bool bAllConstants = true;
            for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
            {
                sName = exp.SubExpressions[iExpression].ToString();
                if (bParametrized)
                {
                    Argument a = null;
                    if (sName.StartsWith("?"))
                    {
                        a = new Parameter(dParameterNameToType[sName], sName);
                        bAllConstants = false;
                    }
                    else
                    {
                        a = new Constant(d.ConstantNameToType[sName], sName);
                    }
                    ((ParametrizedPredicate)p).AddParameter(a);
                }
                else
                {
                    try
                    {
                        Constant c = new Constant(d.ConstantNameToType[sName], sName);
                        ((GroundedPredicate)p).AddConstant(c);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine();
                    }
                }
            }
            if (bParametrized)
                if (!MatchParametersToPredicateDeclaration((ParametrizedPredicate)p, d))
                    throw new NotImplementedException();

            if (bParametrized && bAllConstants)
            {
                GroundedPredicate gp = new GroundedPredicate(p.Name);
                foreach (Constant c in ((ParametrizedPredicate)p).Parameters)
                    gp.AddConstant(c);
                p = gp;
            }

            PredicateFormula vf = new PredicateFormula(p);
            return vf;
        }
 public void AddParameter(Parameter parameter)
 {
     Parameters.Add(parameter);
     ParameterNameToType[parameter.Name] = parameter.Type;
 }