This script has been conceived as a php interface that would allow you to interact quickly between php grabbed SQL queries and your need to print the results.

The idea is that when you have questioned a SQL or mySQL database (for instance by a mySQL PHP Database Manager script) and you have fetched the returned query by a php method such as say mysql_fetch_array, you may want a set of php methods able to print out to the browsers those fields in a set of specified form tags, such as text fields, or textareas, or checkboxes or whatever other form tag.
In this fashion the fields would carry as their value the query value (though with this script you can also instruct to print as the form tag values the query fetched field name rather than the query fetched field value) and an optional label that describes the form field nature.

In this way you can rapidly show to the browser the fetched query in a suitable html format, or print fields quickly so that the user can, if he/she wants, update them. That is, you have an html output format immediately available both for reading purposes and for updating purposes namely also for submitting it again.

The class does not take care of producing the submit buttons or the form tags so by and large your php code might look like, say:
<form action="blah blah">
<?php
//php class manipulations go here
print("<input type='submit' etc...>");
?>
</form>

The name of this class is (of course case sensitive):
queryToForm

To initialize it, pick a variable name (our placeholder is foo) and do:
$foo=new queryToForm();

You can pass to that one argument, either zero or 1, which sets the value assigned to an internal variable named doPrint whose role will be discussed in the next section. First your codes.

Here is an overview of the main methods. In the following section after this one I will also discuss the few additional methods that perform less common tasks and that yet will help you to produce even more customized or sophisticated layout formats.

These methods all share the same characteristic, namely if the class property named doPrint is set to its default value of 1, they will directly print on the browser the fetched input array fields into specified html form input fields, otherwise if doPrint is set to zero the would just store (which they do also if doPrint is set to 1, actually) the produced html form input fields into a class variable array named lastOutput.

By the way, to change the value of the doPrint class variable you can use the method named setPrint and pass to it as its only argument either zero or 1, which gets then assigned to doPrint:
$foo->setPrint(0);/*inhibits immediate printing*/
$foo->setPrint(1);/*restores immediate printing*/

All the methods, each tailored to produce a specified type of form tag to host the input fetched array (textareas, text fields, checkboxes, radio buttons, drop down menus, hidden fields...), allow for a significant amount of arguments to be passed. Normally only the first one is mandatory (the input array).
For each method the arguments are documented below. Study the type of argument values combinations that may best suit your needs, and once devised the argument signatures for each method that best meets your requirement, you can just go on using it consistently throughout all your applications that take avail of this php class interface.

Another characteristic that all these methods share is that the default value of their second argument is set to 1.
This signifies that while scanning the input array, those entries which are indexed after a numerical index (key) will be skipped, thus grabbing only those key/value pairs of the input array where the key element is a string and not a number . This feature has been set in this way because the methods are ideally suited to work with php methods that pass to them as their input array a query fetched by its query table field names/values pairs, whereas the formers are typically strings.
Yet if you want to change this behaviour, set the second argument of these methods to zero, and the methods will honour it and print also numerically indexed entries. It is up to you to decide what behaviour best suits your needs. You rule, I provide the options you can pick from.

There are a few methods that you may want to use to get more customed types of printings. Here they are.


This methods actually allows you to remove specific field names from an incoming associative array. Yet the right way to exclude field names that you do not want to be printed down would be to make sure that your query already excludes them from the produced fetched array (that is, you do not include those fields names as wanted in the SQL query itself).
Yet I provide you with this additional method that can do that all the same onto an already produced and fetched array.

It takes these arguments

1. inputArray: the array you want to exclude a few field names from.
2. removeThese_array: an array whose each value is the string reproducing (case sensitive) the field name you want to delete from the input array.
   Example:
   $foofoo=array("username"=>"John Foo", "password"=>"A big secret", "email"=>"", "11"=>"key is numerical");
   
   $foo=new queryToForm();
   
   $cleaned=$foo->cleanKeys($foofoo, array("password"), 0, 0);
   $test=$foo->text($cleaned, 0);/*This now prints all except the password named field*/
   
   That would remove from the input array the field whose name is "password". You could add more field names to the remove these array, of course. This is just an example.
3. skipNumeric: if set to 1 it skips numerically indexed fields in the input array. If you pass as removeThese_array an empty array, and you set skipNumeric to 1, the returned output will just exclude the numerically indexed fields.
4. skipEmptyValues: if set to 1, it skips all the input array entries which return boolean false: that is, empty strings with not even one whitespace, null, false, zero, and in php the string "0" too.

The method returns a copy of the cleaned up array - does not affect the original.


This method is a conceptual integration to cleanKeys: you pass as first argument the usual associative array, arguably the query fetched row, and as a second argument an array whose each entry is the string name of a field you want to keep - whereas in the previous method (cleanKeys) this latter argument was meant to array the string names you wanted to exclude.
You can use then the method that best suits your needs.
Keep in mind that if cleanKeys2 would include a numerical index in the second argument array, if such number is present in the first passed array, such numerical field will be kept also if the argument skipNumeric is set to 1.
It takes these arguments :

1. inputArray: the array you want to exclude a few field names from.
2. keepThese_array: an array whose each value is the string reproducing (case sensitive) the field name you want to keep from the input array.
   Example:
   $foofoo=array("username"=>"John Foo", "password"=>"A big secret", "email"=>"", "11"=>"key is numerical");
   
   $foo=new queryToForm();
   
   $cleaned=$foo->cleanKeys2($foofoo, array("password","11"), 0, 0);
   $test=$foo->text($cleaned, 0);/*This now prints only the password and the 11 named fields*/
   
   That would remove from the input array the field whose name is not "password" or "11", namely would keep these latter. You could add more field names, of course. This is just an example.
3. skipNumeric: if set to 1 it skips numerically indexed fields in the input array, unless a specific number is mentioned in the second argument array.
   If you pass as keepThese_array an empty array, all fields would be erased from the returned output (that is, the function assumes then you wanted to keep none) and nothing gets printed!
4. skipEmptyValues: if set to 1, it skips all the input array entries which return boolean false: that is, empty strings with not even one whitespace, null, false, zero, and in php the string "0" too.

The method returns a copy of the cleaned up array - does not affect the original.


As you may remember all methods designed to print, also return an array of two entries, the first one an array with the form fields, the second entry an array carrying the corresponding label names you may want to use in order to describe onto a browser what the printed form fields are.

You can therefore imagine a situation as follows: you have initialized your class and you have set it not to print:
$foo=new queryToForm(0);
You may remember that your methods now, when called, just return the produced output - without printing if instructed not to print, but would return anyway:

---

$foofoo=array("username"=>"John Foo", "password"=>"A big secret", "email"=>"", "11"=>"key is numerical");

$foo=new queryToForm(0);

$test=$foo->text($foofoo, 0);/*This does NOT print now but just RETURNS an array, now STORED in $test
I used the method text, but other methods would have stored the same changing only the type of tags hosted in the first array entry*/

---

What is now stored in $test is an array of two entries: Entry zero is the set of the form html tags already populated, the second entry is the label names you may want to use: see it and analyze it to understand better what is going on:
Array ( [0] => Array ( [0] => <input type="text" name="username" value="John Foo" etc...> [1] => <input type="text" name="password" value="A big secret" etc...> [2] => <input type="text" name="email" value="" etc...> [3] => <input type="text" name="11" value="key is numerical" etc...> ) [1] => Array ( [0] => username [1] => password [2] => email [3] => 11 ) ) Now, it is possible you may want to produce out of them one single array that for each entry of the former array concatenates before it its corresponding label. To do that you use outputJoin.
It takes in the following arguments:

1. output: it is the output produced (returned that is) by one of the main printing class methods.
2. betweenRecords: when the records get rejoined, you may want to include some html between them: defaults to an empty space, inserted before each label; that is, the concatenated record would be like:
   betweenRecords + label + tag.
3. header: whatever html you want to put as header of each rejoined recordset of label + tag. Defaults to a <strong> tag:
   header + betweenRecords + label + tag
4. betweenNameAndValue: whatever html you may want to put between the label and the form tag. Defaults to ": ":
   header + betweenRecords + label + betweenNameAndValue + tag
5. footer: whatever html you want to put as ending footer of each rejoined recordset of label+form field. Defaults to a </strong> tag:
   header + betweenRecords + label + betweenNameAndValue + tag + footer

REJOINED RECORDSET APPEARANCE
header	between Records	label	between Name And Value	tag	footer
<strong>	" "	field name	": "	form tag	</strong>
<strong> password : <input type="text" name="password" value="A big secret" etc> </strong>

Thus:
$rejoined=$foo->outputJoin($test);
Produces and returns an array whose each entry concatenates the sets as follows: Array ( [0] => <strong>username: <input type="text" name="username" etc></strong> [1] => <strong> password: <input type="text" name="password" value="A big secret" etc></strong> [2] => <strong> email: <input type="text" name="email" value="" etc></strong> [3] => <strong> 11: <input type="text" name="11" value="key is numerical" etc></strong> )
Only if you have used outputJoin, you can take avail of this method upon the array outputJoin has returned, in order to format your form fields output and labels stored in that returned array in a way that you prefer, that is without the default table and determining, for instance, how many items you want in a line before breaking the line with a carriage return.

If the class variable doPrint is set to 1, the method prints, otherwise it just returns the, arguably long, generated formatted string.

Its argument are as follows:

1. output: the output of a rejoined array (see outputJoin)
2. itemsPerRow: a Number: how many items do you want per line? One form field, maybe 2 or 1 or 4... Possible exceeding or lacking fields are managed just fine.
3. header: whatever html you want before the whole thing (defaults to a starting <form> tag)
4. footer: whatever html you want after the whole thing (defaults to a closing </form> tag)
5. startRow: whatever html you want before each line.
6. endRow: whatever html you want after each line.

Example:
$foofoo=array("username"=>"John Foo", "password"=>"A big secret", "email"=>"", "11"=>"key is numerical");

$foo=new queryToForm(0);/*suspend printing*/

$test=$foo->text($foofoo, 0);

$rejoined=$foo->outputJoin($test);

$format=$foo->formatOutput($rejoined, 3, "HEADERS<br>", "FOOTERS", "Start Row: ", " End Row<br>");

---

If you now print $format, it would prints:

You may want to rewrite your labels so that rather than including the names of the SQL query fields, they carry more user friendly names.
Top achieve this you pass to this method two arguments. The first is the portion of the returned array by some of the print main methods which holds the labels, namely the returned entry that belongs to index [1].

The second argument can't be but an array you yourself wrote, and must be an associative one whose each index is the exact match of an old label, and whose pointed value is the new label, say for instance:
$newOnes=array("password"=>"Insert Your Password", "email"=>"Write Your Email", "username"=>"Choose A Username");/*new labels associative array*/

There is actually a third optional argument, must be either zero (its default) or 1. If zero, it means that the first argument array is a numerically indexed array and thus the search for the swaps is performed on its values. If set to 1 it flags the first array is an associative one (its keys are not numbers but strings, that is) and the search for the swaps would be performed on its keys. Just an additional power feature.

Follow these guidelines:

---

//Just initializations, relevant section is the next one
$foofoo=array("username"=>"John Foo", "password"=>"A big secret", "email"=>"", "11"=>"key is numerical");/*Just the usual fake fetched query row*/

$newOnes=array("password"=>"Insert Your Password", "email"=>"Write Your Email", "username"=>"Choose A Username");/*new labels associative array; by the way: in whatever order!*/

$foo=new queryToForm(0);/*initialized and suspend printing*/

---

$test=$foo->text($foofoo, 0);/*used method text, but could have been whichever else; this line has produced the returned output with form fields and labels, and stored it in $test without printing it for printing was inhibited upon initialization by passing zero as the constructor's argument*/

$foo->resetLabels($test[1], $newOnes);/*generated new lables. Now $test[1] holds REWRITTEN labels!*/

$rejoined=$foo->outputJoin($test);/*Rejoin to prepare the printing*/

$format=$foo->formatOutput($rejoined, 2, "HEADERS<br>", "FOOTERS", "Start Row: ", " End Row<br>");/*You can print now!*/

print $format;

---

The above requires a bit of work by you, but first consider that if you now print what was stored (returned) into $format that nicely prints:

---

---

---

In the apparently "convoluted" procedure above is implied a remarkable feature which I'd like you to posit and possibly appreciate before hastening to the conclusion that the procedure just appears (at least relatively) complex.
And this is that, having that procedure separated the two moments the one in which we assign to the form tags their relative name properties and the other in which we assign the descriptive textual labels, the former (the tag name properties) can still carry as values the very same names of the original SQL query key index fields, while at the same time allowing for their modification into a more user friendly format (the latter namely the labels) at a second time that does not interfere with the former assignments.
The importance of this being in place is this: if the form tags still carry the original SQL query key fields, they can still be submitted via http again to another php script keeping intact the consistency of the involved php applications and of the php interfaces which normally and traditionally want to handle the SQL table keys by the same names assigned to their HTML form tag embodiements.
This is why I have separated the two moments, the one that assigns names/values pairs to the form tags, the other that rewrites the copy of such names as stored in the second branch of the arrays returned by the printing methods in order to produce more user friendly textual labels.


resetLabels affects the original of the first passed argument.

You may want to consider writing a custom template of the 5 or 6 php "commands" above, to use such template including it in all your applications that resort to this class feature. It's server side stuff and therefore write once, print everywhere, and thenceforth worth a tidbit of your cooperation or efforts while you use the cooperation and efforts that I put at your disposal here quite gladly and quite for free.

And if eventually you do think you can do better, and that it is badly necessary, well I have at least provided you with a rather good draft, isn't it?
And now don't be mistaken: answer no.