Z DIRECTORY: REFERENCE MANUAL
Version ZP9, build 21
This section provides a reference manual for the individual components of
the Z Directory, and this web page is its entry point. The organization of
the 'man' pages starts with a category (sometimes called a group here).
Each category has its own web page. The categories page provides a description
of the components found in the category, across all layers. Categories can and
typically do span multiple layers. From there, you can access documentation
about the Z Directory components for that group. Components refer to functions
The on-line manual pages in this reference section are specific to the latest
build (listed above). If you need earlier versions, please
The second half of this page is organized by layers, starting with layer 0.
This is the only place in the reference manual where the sorting is layer
first, then category. This makes it hard if you want to see, say everything
related to file systems. Instead, you would have to dig through sections about
file systems at layer 0, file systems at layer 1, This page contains only brief
summary information. The current list of categories is this:
|| clases to manage [postal, e-mail, ..] addresses
|| an integral part of the Z Directory are basic, template-based
containers: linked lists, arrays, etc
|| data bags represent a simple, easy-to-read protocol for putting
text into containers. The container is inside a string. These
containers can be parsed to extract a giving datum. Similar to
|| some basic classes to manage a "document"
|| a cluster of classes exist for creating, sending, and processing
e-mail messages. There are also classes for managing e-mail
servers, and webmail - a [currently] experimental class for sending
e-mail via web sites
|| The domain of error processing which includes tracing source code
and logging. In layer 0, you can access and control flag that
manage how to process errors.
|| classes and subroutines are put here that are too small
to make a new group for, or defy categorization
|| a cluster of classes for exam questions and answers;
also with support (formatting) for web servers
|| everything to manage files and directories
("folders", in Microsoft-speak)
|| functions for looking up geographical information -
countries, cities, landmarks, postal (zip) codes, and more.
Requires installing the geo database (included).
|| 2 classes - "flag" and "property flag", for setting flags
|| components to manage console input-output, and some [old]
classes to manage terminal [CRT] I/O
|| strictly speaking, this is not a real category. The keyword
parser is part of the strings group, found in layer 4. But in this
reference manual, this pseudo-group is treated like a real one,
as it is significant enough to get its own special treatment.
|| a collection of functions that provide basic mathematical and
statistical operations exist.
|| classes for handling money and doing [simple] accounting
|| higher-level constructs specific to the area of networking
|| operating system- oriented classes and subroutines, dealing
with computer processes, semaphores, and threads. Also,
subroutines for accessing the [Microsoft-only] registry,
and an object for computers ("computer_o") as well
as some computer hardware components, such as a class for
CPUs and disk drives.
|| The "people" domain provides clases to help manage things such
as people, businesses, telephones, and workers
|| 'quick &: Dirty' classes and functions - mostly classes
to support the overall structure of console-based programs
and getting the user's input for interactive console-based
|| The most notable component is a cluster of objects for encrypting
and decrypting text (this group was formerly in its own group - "crypt").
Encryption algorithms are considered a component of security since it
relates to protecting information; it could fall under the "strings"
domain, as it operates on and modifies the contents of strings.
A variety of encryption algorithms are available.
There is also an object for user account access control, in layer 7.
|| classes and functions that allow you to easily create your own
|| classes and support to access relational databases (based on
SQL). Requires a third-party database (eg, Sybase, Oracle,
mySQL, Informix, etc.). It includes a complete system for
storing your own objects (based on the 'orthodox_o'
class), similar to an O-O database.
|| a large assortment of classes and subroutines for dealing with
strings and text, including classes for regular expression
processing, and components for calculating CRC checksums
and binry-to-text encode - decode (eg, uuencode and base 64).
|| a large assortment of classes and subroutines for setting and
measuring time. "time" in the Z Directory refers to dates, as well
as time of day. you can add time intervals (ie, 2 weeks) to a time,
or find the interval of time between to time [-date] objects
|| "message transport" allows you to move a string from one
address point to another (eg, a circuit). The interface
hides the transport mechanism, but sockets are the most
commonly used in the Z Directory
|| support for web servers and CGI programs. Currently, this
is mainly the CGIclient object, which interfaces between
a web page form and a Z Directory server program.
|| X Window support; mostly convenient aids to constructing
This page, the pages underneath it, contains documentation
for the latest version of the publicly released Z Directory. The documentation
may vary from the version you have, if your version is different. Usually
the variations - including class object member functions and global subroutine
signitures - are minor. However, sometimes objects are added or removed,
or even overall functionality and behavior may change. So make sure your
Z Directory version matches the reference pages you are looking at.
If this documentatation differs markedly, please check the version you have.
If you cannot reconcile the differences between what is here and the
signitures you have in your header files, please contact Vettrasoft.
The current version (as documented here): Version ZP9, build 22
Clicking on the links in this table will put you at the start page for
A synopsis of the contents, by layers, follows.
a few minimal functions for configuring a program how to react
when an error is encountered.
as the name implies, an assortment of things defying grouping into a
common purpose: functions compute sizes of built-in types (integer, long,
char, etc); bitwise operations on bytes (such as rotating bits); and a
simple state object that uses transition diagrams to maintain state.
simple functions to get and set the current working directory.
A set of subroutines to do basic disk file operations: create,
delete, test existence. These functions use char *
(simple, native language type) for file and directory names
in the function parameters.
contains the flag_o and propflag_o class objects. These
are hard-working objects designed to maintain state information. they
are also known as "bit vectors". The "property flag" class is similar
to the flag class, but you can assign behaviours to the flags such
as if a flag can be inherited from a 'mother' instance, read-only,
and several other characteristics.
The "io" group contains a group of functions to handle getting input from
a console, such as z_getline_stdin(); some "convenience functions"
related to getting input, such as simply_get_yes() and
simply_get_number(); functions that interface between iostreams
and string objects; and a "tty" (tty = TeleTYpe) class. The latter is for
unix environments only. It gets and sets terminal modes; and handles
terminal I/O functions. This class is rusting, being rarely used nowadays.
common mathematical (and related) functions, including statistics,
getting and setting digits in a number, etc. Functions here include the
sum of a set of numbers, least common denominator, factors, if a number
is prime or divisible by another number, modulus, LUB, GLB, and others.
functions relating to the operating system: getting an environment
variable, host name, process ID (the PID), and thread objects.
For Unix environments, a function to "daemonize" a process.
Some "Quick & Dirty" items. In this layer, the menu loop class,
which is a construct for console applications to print a menu of
choices, get the user's selection, and call the corresponding code.
A large group of functions (no classes here) that operate on or with the
"char *" data type, including: OS-wrappers such as z_stricmp(), z_strcpy(),
z_strcat(), z_strdup(), z_isdigit(), etc; stripping trailing whitespace
(like perl's chomp); copying binary strings, getting a line of input,
converting case, string - [type] conversion (such as int to long or
double, etc); number-to-string conversion functions, including special
ones for formatting as dollar amounts; much more
This contains only 'sleep()' routines, to put the program to sleep
contains a few simple support routines that web servers might use
This code is used only for interfacing with the [unix based] X Window
contains only the "list axiom" (list_axiom_o) class: a root-base
class for all container classes. It is an abstract class necessary
for containers found in subsequent layers, not intended for public
contains "e-mail header" (email_header_o) and "e-mail message"
contains classes for angles and [mathematical] hashes.
operations on angles, including degree-radian conversion
contains classes for semaphores and threads
contains the classes "run driver" (rundriver_o) and "test driver"
(testdriver_o), Vettrasoft's objects for a standard interface to
typical command-line based programs that interact with a user at a
console. this "convenience code" allows for automating command-line
processing and protocol for main driver logic flow-control
contains a class for strings ("string_o"). Similar to STL's
"string" class. this class is heavily used
contains the function z_IPaddress_to_hostname().
Since it uses string objects, it habitats in layer 2
At this layer comes a Simple, template-based list-of-objects interface,
and a linked list. This place is rather ethereal, as almost all the code
exists entirely in the header files.
encryption and decryption cluster of classes, including crypt_o,
the generic interface to a variety of implementations (ROT-13, RSA,
Blowfish, 'simple hash', and Vettrasoft-proprietary)
here lies parent classes that establish the foundation for classes
relating to e-mail, found in higher layers
Contains the "skeleton" class (z_Skeleton) - this special file
is a template file for creating other classes
contains the "money" class (money_o). Put your money into these
holds 2 functions: z_hostid() and z_run_command()
contains the "simply" functions, such as simply_get_yes(),
which prints a prompt message and gets input from the user, in the
form of a yes/no reply
Encryption algorithms for encoding and decoding blocks of text,
or binary data (good for encrypting files). Several algorithms
are available, such as DES, RSA, and Blowfish. There is a singular
common interface for all.
This layer marks the introduction of SQL support.
The "dbconnection_o" class is found here
Here habitat more elaborate subroutines for strings, such as
z_wrap_text_in_quotes(), and the text string object
(textstring_o), a subclass of the string object. it
provides more powerful text-oriented operations. this location
also contains the regular expression class regex_o,
with which you can do string pattern matching using regular
contains the time class object (time_o), which you can set to a
specific time + date, or the current time. many operations are provided,
including telling if it's a leap year; getting the number of days in a
month; ++ and -- operators. this class is required for other classes
based on time, found at higher layers
contains subroutines for X Windows Motif, such as creating various widgets,
such as labels, text fields, and push buttons
Data bags are introduced here: data bags for lists, arrays, matrices;
recursive data bags. These objects hold strings of meta-data. The data bag
concept is similar to XML
contains the classes mapi_store_o and email_store_axiom_o.
These are internal classes related to e-mail operations
contains "primitives" - fundamental operations for SQL-based RDBMS's.
3 access methods are currently available and implemented: ODBC, ADO,
and Informix's esql.
provides more specialized string operations - "keywords"; parameter string
), which defines a mechanism for passing
name-value pairs of strings amongst objects; and a set of subroutines
for more complex string-focused jobs:
z_extract_pattern() --- take out all matching regex patterns
z_find_anycase() --- find substring; upper- or lower- case
z_worded_number() --- given 25, this returns "twenty five"
z_num_to_ordstring() --- given 21, returns "21st", as a string
contains the "date format" class (datefmt_o), for printing out
time and date in a wide variety of formats. also contains the time span
class (timespan_o), which allows you to calculate the amount of
time between to time_o objects.
For time operations with string formatting skills, you may prefer the
"string-time" (stime_o) class - a child of the time object, found
at the next higher layer. The date-format class found here acts as a
support class for stime_o (however, its use is klunky)
The first occurance of message transport heralds the "packet" class
(packet_o), which puts a string into a message packet
This contains only the function load_dbag_from_cgi_query_string(),
which loads a data bag given an CGI query string
More X-Windows Motif support, including an X-window Motif list widget class
(xmlist_o). and an assortment of utility functions, usually with
very long names, such as z_xm_create_toggle_box()
contains classes for e-mail accounts (email_acct_o)
Contains Database - [data] Bag Interface, or DBBI (pronounced "Debbie").
This class provides a mechanism to save a data bag into a database table.
It was originally written to accommodate the Informix database.
In the summer of 2001, a Microsoft Win32 COM/ADO version was developed,
with features to support concurrent access to a table. This provides the
foundation for the orthodox_o class object, found in layer 6.
The "keyword parser" (
class is here. It uses several internal, supporting classes, such as:
keyword_o, line_item_parser_o, text_item_parser_o, mblock_item_parser_o,
kw_schema_o. The purpose of the keyword parser is to take a line like so:
who: Maxwell Smart
and parse it. Well, there is a lot more to it: a keyword can span multiple
lines, or each line can mark the start of a new entry. An entry can have
who: Maxwell Smart
phone: (212) 555-1212
loc: Control HQ
notes: this represents a TV series that terminated.
no further notes will be written about it here.
Please see the man page
for more details.
Contains the class "string-time" (stime_o), which is basically
the time class (time_o) with string formatting capability.
Here also habitats the class "time period (timeperiod_o),
a currently  experimental class for operations on time on a
The "packet buffer" (pktbuff_o) class resides here. This is used
in message transport - a Z Directory term referring to the act of moving
a block of bytes around, or what some may call networking.
contains classes designed to make HTML code management easier,
including "HTI_dbag_o", "HTI_text_o", "HTI_image_o", and "HTI_tabrow_o"
contains the class "xmlookup_o", for displaying a list of things
in x Windows / motif
Contains [only] the function "z_fetch_next_databag_fromfile()",
which returns successive data-bags stored in a file.
Layer 5 marks the beginning of classes that handle error processing, logging,
and tracing. These are tools a developer can use to embed messages in the
code, dynamically set a level to control emission of messages, useful for
debugging and logging. Major classes include trace_o, error_o,
Contains the class "database-table" (dbtable_o),
which manages database tables in an RDBMS. It uses data bags heavily,
as do many other classes at higher layers.
The "orthodox" object, orthodox_o, is here. This object is so important,
it had its own group earlier. However, all its operations relate to [SQL]
database access, so the orthodox group was merged into sql on
August 11, 2012.
The orthodox_o class is a 'structural' componenent in the sense that it
doesn't apply to any real-world domain, but serves as a base class to other
classes that do. It allows you to save and fetch a class object to/from a
database. The name derives from James Coplien's purple book, where he
describes standard behaviors of a class with extended properties.
contains some esoteric operations: the "bgi2x" class, which maps
Borland Graphics Interface to X Window graphics calls; and "xmfdisp_item_o",
for displaying a set of X Window - Motif text widgets
an abstract base class for addresses (address_o) is realized here.
subclasses of the address class, at higher layers, will provide useful
objects for manipulation of many sorts of addresses
The group of classses here (such as exam_question_text_o) may be a
little odd: they provide a mechanism for examinations. This was developed
in order to provide support for on-line, web-based testing systems.
Issues dealing with money focus on accounting here:
- account_o account object (as in Chart Of Accounts)
- vendor_o class object for vendor information
- bank_rec_o Bank reconciliation object
- check_entry_o Check-entry object
contains the "orthodox database set" (orthodb_set_o),
used to copy-export a set of tables in a database.
contains 'people-oriented' classes: "phone number" class
(phone_number_o); "person" class (person_o);
"extended data" (xdata_o), and events (event_o).
Events are in the people-historical context - not computer-related
events. Extended Data is a class that supports the "business" class.
a class to manage user accounts is here (uacct_o).
this area deals with access permissions for users, which can
be applied to class objects.
contains classes for manipulating various addresses: e-mail
(email_address_o); internet addresses (internet_address_o),
referring to the 4 sets of dotted numbers (IPv4); and postal addresses
(postal_address_o), which can parse most any [American]
postal addresses into the components - street number, city, state, zip,
Note that the alternative category "email" to the e-mail address class
is not used, as an e-mail address is a type of address.
contains several classes to handle all things e-mail: e-mail servers,
messages, accounts, etc. Classes here include mapi_store_o,
email_header_o, and email_store_axiom_o
classes for manipulating file and directory addresses
(file_address_o, directory_address_o) - eg, a file name,
or the path of a directory. Note: a "file address" exemplifies the problem
of multiple inheritance - does this object belong in "files" or "address"?
contains the class "message transport" (msgtrans_o). This is
the primary class used for moving a block of data across a circuit
contains a couple functions only: examq_to_html(),
exam_to_html(). These routines take an exam class instance and format
the text to HTML. The group was formerly called "www_exam", reflecting the
[MI] nature of belonging to the web group and belonging to the domain of exams.
contains the major classes file and directory (file_o, directory_o).
You can do all common operations with these classes - create, delete,
copy, add / write, read, etc
contains classes "proxy" (proxy_o) and "webpage spider"
(webpage_spider_o). These are highly experimental classes
subject to major changes in the future. We include but discourage
their use at present
contains server databag class objects (server_dbag_o). this class
is not for public consumption. it provides support for communication
contains a cluster of "message transport" classe using sockets for the
implementation. classes include:
msgtrans_socket_o ....: a top-level class for socket communication;
msgtrans_sockaddr_o ..: a class to hold the address of a socket;
msgtrans_inetsocket_o : class for inernet domain sockets;
msgtrans_unixsocket_o : class for unix domain sockets;
socket_channel_o .....: holds information about a circuit
(eg, if open; connected; if it's a server socket)
Layer 10 is a busy layer, covering many domains. a new category, "documents",
provides classes to manage a document. in the "people" domain, the "business"
class utilizes simpler people-domain objects (telphone number, postal address,
person) to manage information about a business.
contains class "filecrypt_header_o", used for encrypting files
contains the document class (document_o), which manages document
properties - category, title, subject matter, character encoding, notes,
location, etc.; and a class for HTML documents (htmldoc_o)
contains [only] the routine "z_get_next_input_line()". This subroutine
employs file_o and string_o classes to get sequential input lines from
a text file or standard input
a class for a random number generator (RNG_o). 2 types of random
numbers are supplied here: the first just returns whatever value the
OS gets. The second is a psuedo-random number generator that returns
random numbers uniformly distributed over the interval [0.0 .. 1.0]
contains the "business" class (nothing related to flying in an airplane).
A large part of this class focuses on reading and writing a textual
representation of the business, which can be put onto a web page, a file,
or into a database
contains subroutines related to a computer process (aka, "program"):
get the ID of a process; terminate a process; wait for a process
contains 2 classes: "gateway session" (gateway_session_o) class
provides support for web servers and user sessions with them;
"server-mover" (server_mover_o) is an 'internal' class for
support code for processing HTML in CGI programs
contains global-level functions for obtaining data relating to Earth
geography (from a human point of view). This includes functions such as
zgeo_country_info(), and zgeo_postal_info().
contains "business textstream" class (business_textstream_o),
for processing a list of businesses (eg, put into a file);
a "job" class (job_o), relating to the person-to-business link;
and the "worker" class (worker_o). This rather Marxian-sounding
name is used to describe a person's relationship to a business.
"employee" would be incorrect, as a person can be a contractor, partner,
owner, or otherwise not an employee and still work for the business.
Note that a person can have more than 1 job, and a business can have
more than 1 worker, so the business class does not "own" the worker class
all the support classes at lower layers finally culminate into the server
class (server_o). With this object, you have lots of plumbing to
create a server that will patiently wait for incoming messages and process
them according to your specifications
contains the "executive monitor server" class
(Executive_Monitor_Server_o), which is a special type of server.
it monitors, shuts down, and starts other servers
contains the class "CGI_webclient_server_o", which kicks off a CGI
program under a web server