FileIO Library - Revision history

Gordon.dye: /* File Layouts */

2024-09-19T03:22:29Z

File Layouts

← Older revision		Revision as of 03:22, 19 September 2024
Line 135:		Line 135:
	99060 fnend		99060 fnend

	== File Layouts ==		=== File Layouts ===
	Now lets inspect the anatomy of a properly formatted file layout. These should be placed in a subdirectory called filelay.		Now lets inspect the anatomy of a properly formatted file layout. These should be placed in a subdirectory called filelay.
	In this example, a farm management system uses a price file to manage seasonal prices:		In this example, a farm management system uses a price file to manage seasonal prices:

Gordon.dye: /* File Layouts */

2024-09-11T21:52:57Z

File Layouts

← Older revision		Revision as of 21:52, 11 September 2024
Line 137:		Line 137:
	== File Layouts ==		== File Layouts ==
	Now lets inspect the anatomy of a properly formatted file layout. These should be placed in a subdirectory called filelay.		Now lets inspect the anatomy of a properly formatted file layout. These should be placed in a subdirectory called filelay.
			In this example, a farm management system uses a price file to manage seasonal prices:

	price.dat, PR_, 1		price.dat, PR_, 1
Line 164:		Line 165:
	price.dat, PR_, 1		price.dat, PR_, 1

	The first line contains the name of the Farm ~~File~~, a unique string to prefix all of your subscript pointers, and the file version number. The subscript ~~value~~ is to ensure that the program knows the difference between the Farm File’s Farm Code, and the Route File’s Route Code. (One will be RT_CODE and the other is FM_CODE). These are separated by a comma. Spacing does not matter, so adjust your spacing so that it looks nice.		The first line contains the name of the Farm Record, a unique string to prefix all of your subscript pointers, and the file version number. The subscript prefix is to ensure that the program knows the difference between the Farm File’s Farm Code, and the Route File’s Route Code. (One will be RT_CODE and the other is FM_CODE). These are separated by a comma. Spacing does not matter, so adjust your spacing so that it looks nice.

	The Version number is used to determine when the data has changed, and an update needs to be made to your data file. Your file layouts should all start at version 0, and each time you want to make a change, you may increment this value by 1.		The Version number is used to determine when the data has changed, and an update needs to be made to your data file. Your file layouts should all start at version 0, and each time you want to make a change, you may increment this value by 1.

Gordon.dye: /* How it Works */

2024-09-11T15:49:43Z

How it Works

← Older revision		Revision as of 15:49, 11 September 2024
Line 78:		Line 78:
	The above statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and read it to find out what the Color File looks like. Then it OPENs the Color File, and sets MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers (subscripts) into these arrays to access the data read into the 2 arrays, and it will assign the file handle to a variable called "colorfile".		The above statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and read it to find out what the Color File looks like. Then it OPENs the Color File, and sets MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers (subscripts) into these arrays to access the data read into the 2 arrays, and it will assign the file handle to a variable called "colorfile".

	The second open above will do the same thing to the color category file, except the 1 parameter value tells the function to open readonly. The array subscripts ~~populate~~ procedure (passed back from Fileio) will be executed, thereby assigning values to the subscript names in the calling program. So, if I had a file layout such as the following:		The second open statement above will do the same thing to the color category file, except the parameter value "1" tells the function to open readonly. The array subscripts assignment procedure file (passed back from Fileio) will be executed, thereby assigning values to the subscript names in the calling program. So, if I had a file layout such as the following:

	color.dat, CO_, 1		color.dat, CO_, 1

Gordon.dye: /* fnOpen Function */

2024-09-11T15:34:46Z

fnOpen Function

← Older revision		Revision as of 15:34, 11 September 2024
Line 41:		Line 41:
	=== fnOpen Function ===		=== fnOpen Function ===

	Now, add a snippet of code to interface with the library.		Now, add the following snippet of code to interface with the library. Note that this snippet can be copied in exactly as provided and no customization of it is needed.

	Because BR libraries do not share global variables with the programs they are called from, we will need to execute a procedure file whenever we open a file - to set the names of all of our variables. Add the following snippet of code into your program. It will create an FnOpen function that calls the library and runs the proc file. The $$$ at the end of the procfile name tells the procfile to self-destruct after execution. Since this procfile is used simply to return variable information back from the library to the main program, we don’t need it sitting around collecting dust.		Because BR libraries do not share global variables with the programs they are called from, we will need to execute a procedure file whenever we open a file - to set the names of all of our variables. Add the following snippet of code into your program. It will create an FnOpen function that calls the library and runs the proc file. The $$$ at the end of the procfile name tells the procfile to self-destruct after execution. Since this procfile is used simply to return variable information back from the library to the main program, we don’t need it sitting around collecting dust.
Line 52:		Line 52:
	99060 fnend		99060 fnend

	Or, for those with [[Lexi]]:		Or, for those with [[Lexi]]: (same but without line numbers)
	OPEN: ! ***** Function To Call Library Openfile And Proc Subs		OPEN: ! ***** Function To Call Library Openfile And Proc Subs
	def Fnopen(Filename$255, Mat F$, Mat F, Mat Form$; Inputonly, Keynum, Dont_Sort_Subs, Path$255, Mat Descr$, Mat Field_Widths,Supress_Prompt,Ignore_Errors,Suppress_Log,___,Index)		def Fnopen(Filename$255, Mat F$, Mat F, Mat Form$; Inputonly, Keynum, Dont_Sort_Subs, Path$255, Mat Descr$, Mat Field_Widths,Supress_Prompt,Ignore_Errors,Suppress_Log,___,Index)

Gordon.dye at 14:36, 11 September 2024

2024-09-11T14:36:29Z

Gordon.dye at 13:35, 11 September 2024

2024-09-11T13:35:12Z

← Older revision		Revision as of 13:35, 11 September 2024
Line 1:		Line 1:
	The '''FileIO''' Library began as a project to find a way to reduce the ~~headache~~ associated with making changes to data ~~files~~. ~~In my experiences working for [[BRC]]~~, I ~~had~~ to make a change to ~~the commun file,~~ a data file ~~that stores information about communication with EDI VANs.~~ I ~~added some new fields~~, and ~~removed~~ a ~~couple of old fields, and then I began searching through the BRC~~ program ~~suite~~ to ~~find and modify each program that referenced this data file~~ in order to ~~update it~~ with the ~~proper~~ new ~~form statement~~. ~~This task quickly became daunting as~~ I ~~noticed that out of BRC’s program suite of over 600 programs, more than one third of them referenced the commun file. With 223 programs~~ to ~~modify~~, the ~~task was given up~~ as ~~hopeless and tabled indefinitely~~.		The '''FileIO''' Library began as a project to find a way to reduce the effort associated with making changes to data file layouts. Thanks to the Fileio library, when I have to make a change to a data file layout for my customers today, I can complete the task in under 1 minute, and not a single program needs to be changed in order to continue working with the new file layout. In fact, I don’t even have to update my customer’s data files, as the FileIO library takes care of this for me as well.

	I am happy to announce that we have solved this problem. When I have to make a change to a data file layout for my customers today, I can complete the task in under 1 minute, and not a single program needs to be changed in order to continue working with the new file layout. In fact, I don’t even have to update my customer’s data files, as the FileIO library takes care of this for me as well.		The trick is to define each of your file layouts in an ASCII text file layout file that is described below. The FileIO Library will parse through your file layouts, and it will instruct your programs how to access the file data after it has been read. It will also automatically detect when you make changes to the file layout, and it will update your customer’s data files on the fly to make sure they have the latest version. Finally, it contains a DataCrawler that you can use to examine the contents of any of your BR data files in a raw format.

	The trick is to define your file layouts in an ASCII text file layout file that ~~I will tell you about in a minute~~. The FileIO Library will ~~actually~~ parse through your file layouts, and it will instruct your programs how to ~~read~~ the data ~~file, so that you don’t have to~~. It will also automatically detect when you make changes to the file layout, and it will update your customer’s data files on the fly to make sure they have the latest version. Finally, it ~~even~~ contains a DataCrawler that you can use to examine the contents of any of your BR data files in a raw format.

	For more information about the FileIO Library visit the [http://www.sageax.com/products/fileio-library/ Sage AX Website]		For more information about the FileIO Library visit the [http://www.sageax.com/products/fileio-library/ Sage AX Website]

Gordon.dye: /* How it Works */

2024-09-11T13:26:07Z

How it Works

← Older revision		Revision as of 13:26, 11 September 2024
Line 78:		Line 78:

	=== How it Works ===		=== How it Works ===
	The above statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and ~~READ~~ it to find out what the Color File looks like. Then it OPENs the Color File, and sets MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers (subscripts) into these arrays to access the data read into the 2 arrays, and it will assign the file handle to a variable called "colorfile".		The above statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and read it to find out what the Color File looks like. Then it OPENs the Color File, and sets MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers (subscripts) into these arrays to access the data read into the 2 arrays, and it will assign the file handle to a variable called "colorfile".

	The second open above will do the same thing to the color category file, except the 1 parameter value tells the function to open readonly. The array subscripts populate procedure (passed back from Fileio) will be executed, thereby assigning values to the subscript names in the calling program. So, if I had a file layout such as the following:		The second open above will do the same thing to the color category file, except the 1 parameter value tells the function to open readonly. The array subscripts populate procedure (passed back from Fileio) will be executed, thereby assigning values to the subscript names in the calling program. So, if I had a file layout such as the following:

Gordon.dye: /* How it Works */

2024-09-11T13:24:42Z

How it Works

← Older revision		Revision as of 13:24, 11 September 2024
Line 78:		Line 78:

	=== How it Works ===		=== How it Works ===
	The above statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and ~~read~~ it to find out what the Color File looks like. Then ~~Open~~ the Color File, and ~~set~~ MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers (subscripts) into these arrays to access the data ~~we after reading it~~, and it will ~~place~~ the file handle ~~into~~ a variable called colorfile.		The above statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and READ it to find out what the Color File looks like. Then it OPENs the Color File, and sets MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers (subscripts) into these arrays to access the data read into the 2 arrays, and it will assign the file handle to a variable called "colorfile".

	The second open above will do the same thing to the color category file, except the 1 parameter value tells the function to open readonly. The array subscripts populate procedure (passed back from Fileio) will be executed, thereby assigning values to the subscript names in the calling program. So, if I had a file layout such as the following:		The second open above will do the same thing to the color category file, except the 1 parameter value tells the function to open readonly. The array subscripts populate procedure (passed back from Fileio) will be executed, thereby assigning values to the subscript names in the calling program. So, if I had a file layout such as the following:

Gordon.dye: /* How it Works */

2024-09-11T13:19:08Z

How it Works

← Older revision		Revision as of 13:19, 11 September 2024
Line 78:		Line 78:

	=== How it Works ===		=== How it Works ===
	~~These~~ statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and read it to find out what the Color File looks like. Then Open the Color File, and set MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers (subscripts) into these arrays to access the data we after reading it, and it will place the file handle into a variable called colorfile.		The above statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and read it to find out what the Color File looks like. Then Open the Color File, and set MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers (subscripts) into these arrays to access the data we after reading it, and it will place the file handle into a variable called colorfile.

	The second open above will do the same thing to the color category file, except the 1 parameter tells the function to open readonly. The subscripts ~~array~~ will be executed, ~~creating~~ the ~~subscripts in memory, and the pointers (subscripts) will be set~~ in the calling program. So, if I had a file layout such as the following:		The second open above will do the same thing to the color category file, except the 1 parameter value tells the function to open readonly. The array subscripts populate procedure (passed back from Fileio) will be executed, thereby assigning values to the subscript names in the calling program. So, if I had a file layout such as the following:

	color.dat, CO_, 1		color.dat, CO_, 1

Gordon.dye: /* Method of Operation */

2024-09-11T05:32:46Z

Method of Operation

← Older revision		Revision as of 05:32, 11 September 2024
Line 12:		Line 12:
	The file IO library parses a formatted text file layout and uses this information to structure the opening and initializing of the reading of a file “object”. The word object here is used to refer to all the data in a given record layout in one of your files. This library is easy to use, and provided you follow some simple standards, it will simplify your life immensely.		The file IO library parses a formatted text file layout and uses this information to structure the opening and initializing of the reading of a file “object”. The word object here is used to refer to all the data in a given record layout in one of your files. This library is easy to use, and provided you follow some simple standards, it will simplify your life immensely.

	~~You~~ will need to define one array for all ~~forms~~ and add a snippet of code (given below) to the program for interfacing with with the library. For each file you will need to define a couple of arrays and use the library to open them. From that point on access to data is simple and direct.		Your programs will need to define one array for all [[Form\|file layout form statements]] and add a snippet of code (given below) to the program for interfacing with with the library. For each file you will need to define a couple of arrays and use the library to open them. From that point on access to data is simple and direct.

	=== File Object Arrays ===		=== File Object Arrays ===
Line 29:		Line 29:
	=== Forms Array ===		=== Forms Array ===

	~~You~~ will ~~also~~ need a variable to store the form ~~statement~~ associated with reading ~~the~~ files. This form ~~statement~~ will be dynamically generated whenever a ~~new~~ file is opened. It will say:		Your programs will need a string variable array to store the form statements associated with reading files. This form statements array will be dynamically generated or expanded whenever the a file is opened. It will say:

	~~01020~~ DIM form$(1)*255		01234 DIM form$(1)*255

	This form statement will be compiled by the FileIO open statement ~~and~~ BR limits all form statements to 255 bytes ~~compiled anyway~~, so 255 is ~~enough for~~ the Forms$ ~~array~~.		This form statement will be compiled by the FileIO open statement. BR limits all form statements to 255 bytes, so 255 is sufficient to hold the compiled Forms$ statements.

	=== Library Linkage ===		=== Library Linkage ===
Line 45:		Line 45:
	Now, add a snippet of code to interface with the library.		Now, add a snippet of code to interface with the library.

	Because BR libraries do not share variables with the programs they are called from, we will need to execute a proc file whenever we open a file to set the names of all our variables after we return. Add the following snippet of code into your program. It will create an FnOpen function that calls the library ~~version~~ and runs the proc file. The $$$ at the end of the procfile name tells the procfile to self-destruct after execution. Since this procfile is used simply to return variable information back from the library to the main program, we don’t need it sitting around collecting dust.		Because BR libraries do not share global variables with the programs they are called from, we will need to execute a proc file whenever we open a file to set the names of all our variables after we return. Add the following snippet of code into your program. It will create an FnOpen function that calls the library and runs the proc file. The $$$ at the end of the procfile name tells the procfile to self-destruct after execution. Since this procfile is used simply to return variable information back from the library to the main program, we don’t need it sitting around collecting dust.

	99010 OPEN: ! ***** Function To Call Library Openfile And Proc Subs		99010 OPEN: ! ***** Function To Call Library Openfile And Proc Subs
Line 78:		Line 78:

	=== How it Works ===		=== How it Works ===
	These statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and read it to find out what the Color File looks like. Then Open the Color File, and set MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers ~~into~~ (subscripts) these arrays to access the data we after reading it, and it will place the file handle into a variable called colorfile.		These statements tell the File Library to look in the filelay folder to find the file layout for the Color File, and read it to find out what the Color File looks like. Then Open the Color File, and set MAT COLOR$ and MAT COLOR to the correct number of elements to hold an entire color record. Finally, it will define several variables that we can use as pointers (subscripts) into these arrays to access the data we after reading it, and it will place the file handle into a variable called colorfile.

	The second open above will do the same thing to the color category file, except the 1 parameter tells the function to open readonly. The subscripts array will be executed, creating the subscripts in memory, and the pointers (subscripts) will be set in the calling program. So, if I had a file layout such as the following:		The second open above will do the same thing to the color category file, except the 1 parameter tells the function to open readonly. The subscripts array will be executed, creating the subscripts in memory, and the pointers (subscripts) will be set in the calling program. So, if I had a file layout such as the following:

← Older revision		Revision as of 14:36, 11 September 2024
Line 8:		Line 8:

	== Method of Operation ==		== Method of Operation ==
	The file IO library parses a formatted text file layout and uses this information to structure the opening and ~~initializing of~~ the reading of a file “object”. The word object here is used to refer to all the data in a given record layout in one of your files. This library is easy to use, and provided you follow some simple standards, it will simplify your life immensely.		The file IO library parses a formatted text file layout and uses this information to structure the opening and the reading of a file “object”. The word object here is used to refer to all the data in a given record layout in one of your files. This library is easy to use, and provided you follow some simple standards, it will simplify your life immensely.

	Your programs will need to define one array for all [[Form\|file ~~layout~~ form statements]] and add a snippet of code (given below) to the program for interfacing with with the library. For each file you will need to define a couple of arrays and use the library to open them. From that point on access to data is simple and direct.		Your programs will need to define one array for all [[Form\|BR data file form statements]] and add a snippet of code (given below) to the program for interfacing with with the library. For each file you will need to define a couple of arrays and use the library to open them. From that point on access to data is simple and direct.

	=== File Object Arrays ===		=== File Object Arrays ===

	First, in your program you must create two arrays to store the file information. If we are dealing with the Color File these would be MAT COLOR$ and MAT COLOR. One will store all the string information about a color, and the other will store ~~all~~ the numeric data. Our working example will involve two files: a Color File and a Color Category File. You should dimension these to:		First, in your program you must create two arrays to store the file information. If we are dealing with the Color File these would be MAT COLOR$ and MAT COLOR. One will store all the string information about a color, and the other will store the related numeric data. Our working example will involve two files: a Color File and a Color Category File. You should dimension these as follows:

	01030 DIM color$(1)*1000,color(1)		01030 DIM color$(1)*1000,color(1)
	01040 DIM colorcat$(1)*1000,colorcat(1)		01040 DIM colorcat$(1)*1000,colorcat(1)

	We're dimensioning the string ~~arrays~~ to 1000. This is the length of one field in the color file. It needs to be at least as big as the largest string field in the data file.		We're dimensioning the string array elements to 1000 bytes each. This is the length of one field in the color file. The array element length needs to be at least as big as the largest string field in the data file.

	However, it is recommended to make sure the length is long enough to handle any field you might eventually add to the file at any point in the future. BR supports multi-line textboxes, so I sometimes add long memo fields to my data files that might be 400 or 800 or even 1000 characters long, therefore 1000 is the length I use now in all my new development.		However, it is recommended to make sure the length is long enough to handle any field you might eventually add to the file at any point in the future. BR supports multi-line textboxes, so I sometimes add long memo fields to my data files that might be 400 or 800 or even 1000 characters long, therefore 1000 is the length I use now in all my new development.
Line 29:		Line 29:
	Your programs will need a string variable array to store the form statements associated with reading files. This form statements array will be dynamically generated or expanded whenever the a file is opened. It will say:		Your programs will need a string variable array to store the form statements associated with reading files. This form statements array will be dynamically generated or expanded whenever the a file is opened. It will say:

	~~01234~~ DIM form$(1)*255		01020 DIM form$(1)*255

	This form statement will be compiled by the FileIO open statement. BR limits all form statements to 255 bytes, so 255 is sufficient to hold the compiled Forms$ statements.		This form statement will be compiled by the FileIO open statement. BR limits all compiloed form statements to 255 bytes, so 255 is sufficient to hold the compiled Forms$ statements.

	=== Library Linkage ===		=== Library Linkage ===
Line 43:		Line 43:
	Now, add a snippet of code to interface with the library.		Now, add a snippet of code to interface with the library.

	Because BR libraries do not share global variables with the programs they are called from, we will need to execute a ~~proc~~ file whenever we open a file to set the names of all our variables ~~after we return~~. Add the following snippet of code into your program. It will create an FnOpen function that calls the library and runs the proc file. The $$$ at the end of the procfile name tells the procfile to self-destruct after execution. Since this procfile is used simply to return variable information back from the library to the main program, we don’t need it sitting around collecting dust.		Because BR libraries do not share global variables with the programs they are called from, we will need to execute a procedure file whenever we open a file - to set the names of all of our variables. Add the following snippet of code into your program. It will create an FnOpen function that calls the library and runs the proc file. The $$$ at the end of the procfile name tells the procfile to self-destruct after execution. Since this procfile is used simply to return variable information back from the library to the main program, we don’t need it sitting around collecting dust.

	99010 OPEN: ! ***** Function To Call Library Openfile And Proc Subs		99010 OPEN: ! ***** Function To Call Library Openfile And Proc Subs