Method getSolutionWithVarNames

src/main/java/org/jpl7/Query.java:543–598

Deprecated. Used to be used only in the context of Term.textToTerm() but a better solution has been implemented there and hence does not require this difficult method anymore. Left it for reference. This is called with query atom_to_term(Atom, Term, Bindings) https://www.swi-prolog.org/pldoc/doc_f

()

	 * @return a Term with the variables with names
	 */
	@Deprecated
	public final Map<String, Term> getSolutionWithVarNames() {
		if (!open) {
			throw new JPLException("Query is not open");
		} else {
			// We will operate on the solution of query of the form atom_to_term('hello(a, X, Y)', T, B)
			//	The query has been executed and a solution is there, B and T have bindings
			// 		T will be the atom converted into a term, in our case the term hello(a, _1, _2)
			//		B will map the name of the variables (as atoms) to the Prolog Vars _ thus providing access to
			//			the Prolog _ variables via the names in the query (X and Y here)
			//		In our example 	T = hello(1, _1, _2) and
			//						B = ['X' = _1, 'Y' = _2]
			//
			//

			// FIRST, retrieve the binding of B as a JPL Term (a Compound list) and name (a String)
			//		BindingVarTerm = the JPL Variable instance of the binding variable "B" in the atom_to_term/3 query
			//		BindingVarName = the name "B" as a String
			Term[] args = goal_.args(); // for slight convenience below
			Term BindingVarTerm = args[args.length - 1]; // the Query's last arg: a variable binding list; type Variable
			String BindingVarName = ((Variable) BindingVarTerm).name; // its textual name ("Bindings" in example)

//			Term TermVar = args[args.length - 2]; // the Query's last arg: a variable binding list; type Variable
//			String TermVarName = ((Variable) TermVar).name; // its textual name ("Bindings" in example)

			// SECOND, we store what B was bound to as JPL Compound list instance BindingVarValue
			//	If B was bound to ['X' = _1, 'Y' = _2] in the current solution
			// 		then BindingVarValue will be the JPL Compound instance storing that value of B
			//			BindingVarValue will be a LIST
			//			'X', 'Y' will be JPL Atoms
			//			_1, _2 will be JPL Variables
			//
			// 	(Note: the second argument vars_to_Vars1 will contain the map between the variables and Prolg term
			//		representation, but will NOT be used.)
			//
			//	Notation: 	vars = refers to the Prolog term for variables (term_t type)
			//				Vars = refers to JPL Variable type (a subclass of Term)
			//				varnames = refers to the textual name of the variable (e.g., "X")
			Map<String, Term> varNames_to_Terms1 = new HashMap<String, Term>();
			Map<term_t, Variable> aux_vars_to_Vars1 = new HashMap<term_t, Variable>();
			BindingVarTerm.getSubst(varNames_to_Terms1, aux_vars_to_Vars1);
			Term BindingVarValue = varNames_to_Terms1.get(BindingVarName); // The binding as a JPL Compound list


			// THIRD, build the mapping we will return
			// Associate the Prolog term for the _ vars to a new JPL Variable with the name as per B
			//		For example Prolog term_t@930 instance representing JPL Variable _1 will map to Variable@933 for "X"
			//		So here we do the link from _ vars to named Variables
			Map<String, Term> varnames_to_Terms2 = new HashMap<String, Term>();
			Map<term_t, Variable> vars_to_Vars2 = Util.namevarsToMap(BindingVarValue);
			for (int i = 0; i < args.length - 1; ++i) {
				args[i].getSubst(varnames_to_Terms2, vars_to_Vars2);
			}
			return varnames_to_Terms2;
		}
	}

	/**