Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
sps(3)				 AFNIX Module				sps(3)

NAME
       sps - standard spreadsheet module

STANDARD SPREADSHEET MODULE
       The  Standard Spreadsheetmodule is an original implementation that pro-
       vides the necessary objects for designing a spreadsheet.	 A  spreasheet
       acts  a	great interface	which structure	data in	the form of record and
       sheets. Once structured,	these data can be indexed, manipulated and ex-
       ported into various formats.

       Spreadsheet concepts
       The  sole purpose of using a spreadsheet	is to collect various data and
       store them in such a way	that they can be accessed later. Unlike	 stan-
       dard spreadsheet	system,	the standard spreadsheet module	does not place
       restrictions on the data	organization. The  spreadsheet	module	stores
       data  in	 a  hierarchical  fashion.  The	basic data element is called a
       cell. A set of cells is a record. A set of records is a sheet. A	set of
       sheets and records is a folio.

       Cell and	data
       A  cellis  a  data  container. There is only one	data element per cell.
       Eventually a name can be	associated with	a cell.	The cell data  can  be
       any kind	of literals. Such literals are integer,	real, boolean, charac-
       ter or strings.

       Record
       A recordis a vector of cells. A record can be created by	adding cell or
       simply by adding	data. If the record has	a predefined size, the cell or
       data can	be set by indexing.

       Sheet
       A sheetis a vector of records. A	sheet can be created by	adding record.
       Similarly,  if the sheet	has a predefined size, record cell or data can
       be added	by indexing. A sheet can also be seen as a 2 dimensional array
       of  cells.  For	the  purpose  of managing extra	information, the sheet
       carry also several extra	records, namely, the marker record, the	header
       recordand footer	recordas well as the tag vectorand the signature.

       Folio
       A  foliois a set	of sheets and/or records. A folio of sheets permits to
       structure data in the form of tables. Since cell, record	and table  can
       have  a	name,  it is possible to create	link between various elements,
       thus creating a collection of structured	data.

       Storage model
       There are several ways to integrate data. In the	 simplest  form,  data
       are  integrated	in  a record list. A complex model can be built	with a
       sheet. More complex models can also be designed by using	a folio.

       Single record model
       With a single record model, the data are	accumulated in a single	array.
       This  kind  of  data  storing  is  particularly adapted for single list
       recording. As a single record, the basic	search and  sorting  algorithm
       can  be	applied.  For  instance, a list	name can be stored as a	single
       record. With this view, there is	no difference between a	list, a	vector
       and a record. The record	can also be named.

       Record importation
       Data  are  imported  into  the  record, either by construction, list or
       stream. Since the record	object is a serializeable object, the importa-
       tion  process  is  also	performed automatically	in the collection. The
       base record importation class implements	 a  simple  importation	 model
       based  on  blank	 separated literals. Complex importation models	can be
       devised by derivation. A	special	case with a cons  cell	is  also  sup-
       ported where the	caris the cell name and	the cadris the cell object.

       # an example of file importation
       1   "a string" 'a'

       The  previous  example shows the	file structure that can	be used	to im-
       port cell data. The fist	line defines a record with 3 cells. The	second
       line  defines  also  a  record with 3 cells. The	second cell is a named
       cell.

       Record exportation
       A record	is an object that can be serialized. It	can therefore  be  ex-
       ported  easily. However,	in the serialized form,	the record is in a bi-
       nary form. It is	also possible to walk through the record and  exports,
       for each	cell its literal form.

       Folio indexation
       There  are  various  ways to access a folio by reference. Since a folio
       can contain several sheets, it seems natural to access them by tag. The
       other  method is	to index the cells in a	cross-reference	album in order
       to access rapidly.

       Sheet access model
       The sheet access	model uses a tag to access one or several sheets in  a
       folio. A	tag is a string	attached to a sheet. It	is possible in a folio
       to have several sheet with the same tag.	It is also possible to	attach
       several	tags  to  a  sheet. When a folio is searched by	tag, the first
       sheet that matches the tag is said to be	the valid one. If  all	sheets
       that match the requested	tag are	needed,	it is possible to create a de-
       rived folio with	all sheets that	match the requested tag.

       Cell access model
       The cell	access model operates with a cross-reference table built  with
       an  index. An index is a	multiple entry record that stores the cell lo-
       cation. A cell coordinate comprises the cell index in the  record,  the
       record index in the sheet and the sheet index in	the folio. If an index
       contains	multiple entries, this indicates that several  cells  are  in-
       dexed. A	cell cross-reference table is a	collection of index. Generally
       the index name is the cell name.	 When  the  cross-reference  table  is
       built, all cell of interests are	scanned	and if a cell name exists, the
       cell is indexed in the cross-reference  table.  If  there  are  several
       cells  with the same name, the index length associated with the name is
       the number of cells with	that name.

       Search and access
       The methodology for searching is	to decide whether a sheet  or  a  cell
       should  be  accessible. If a sheet access is desired, the search	by tag
       method is the preferred way. This method	 assumes  that	the  requested
       sheet  is  structured in	a particular way, known	to the user. If	a cell
       access seems more appropriate, a	cross-reference	table should be	 built
       first,  and  the	search done from it. In	the case of search by tag, the
       method is dynamic and operates well when	sheets are added in  a	folio.
       When  a	cross-reference	 table is used,	proper care should be taken to
       rebuild the cross-reference table when some sheets are added unless the
       user knows that there is	no need	for it.

       Folio object
       The  Folioobject	is the primary object used for storing data. Although,
       a folio is a collection of sheets, it the primary object	that should be
       created when manipulating such collection.

       Creating	a folio
       The  Folioobject	 is built without argument. In this case, the folio is
       empty. A	predicate is available for testing the Folioobject.

       const sps (afnix:sps:Folio)
       afnix:sps:folio-p sps # true

       The constructor can operate also	by name	or by  input  stream.  With  a
       string, a new folio those name is the argument is created. By stream, a
       new folio is created and	loaded with the	input stream data. Eventually,
       the  folio  name	can be set with	the set-namecommand and	retrieved with
       the get-namecommand.

       const sps (afnix:sps:Folio)
       sps:set-name "planets"

       Sheet object
       The Sheetobject is the primary object used to store data	 in  a	folio.
       Since  a	 Folioobject is	a collection of	sheets,	a sheet	can be manipu-
       lated either by getting getting it from the folio or by creating	it in-
       dependently and adding it into the folio.

       Creating	a sheet
       An  empty sheet can be created simply with or without name. Without ar-
       gument, an unnamed sheet	is created. Similar  to	 the  Folioclass,  the
       sheet  name  can	 be  passed  at	 construction  or  set	with  the set-
       namemethod. As usual a predicate	is provided.

       const sht (afnix:sps:Sheet)
       afnix:sps:sheet-p sht # true

       When the	sheet is created, it can be added  to  the  folio  spreadsheet
       with the	addmethod.

       const sht (afnix:sps:Sheet "data")
       sps:add sht

       Adding data to the sheet
       The  process  of	 adding	data to	a sheet	is a straightforward operation
       with the	add-datamethod or the addmethod. With the add-datamethod, data
       are added as literals. With the addmethod, data are added with the help
       of a record object.

       sht:add-data "Mercury"	4840 "1407:36"
       sht:add-data "Venus"    12400 "5819:51"
       sht:add-data "Earth"    12756 "23:56"
       sht:add-data "Mars"	6800 "24:37"
       sht:add-data "Jupiter" 142800 "9:50"
       sht:add-data "Saturn"  120800 "10:14"
       sht:add-data "Uranus"   47600 "10:49"
       sht:add-data "Neptune"  44600 "15:40"
       sht:add-data "Pluto"	5850 "153:17"
       sht:add-data "Sedna"	1800 "960:00"

       Data can	be imported in a sheet by importation with  an	input  stream.
       During  the importation,	the serialized data are	decoded	and placed se-
       quentially in the stream.

       Sheet sorting
       A sheet can be sorted with the  sortmethod.  The	 sortmethod  uses  the
       first  integer argument as the column number. The second	optional argu-
       ment is a boolean argument that selects the sorting method which	can be
       ascending (by default) or descending if the flag	is false.

       sht:sort	0
       sht:sort	1 false

       Record object
       The  Recordobject is an alternative to the sheet	data filling. With the
       help of the addmethod, a	record can be added to a sheet.

       Creating	a record
       A record	is a named object that acts as a vector	of cells.  The	record
       name  can  be set either	by construction	or with	the set-namemethod. As
       usual a predicate is provided.

       const rcd (afnix:sps:Record)
       afnix:sps:record-p # true

       Filling a record
       A record	can be filled either with literal data or Cellobjects. In  the
       first case, the cell is automatically created for each literal added to
       the record. The addmethod add a cell or literal to the record.

       const rcd (Record)
       rcd:add "Mercury" 4840 "1407:36"

       For data	extraction, the	lengthmethod returns the record	 length.  Data
       can  be	extracted  by  index with either the getor mapmethod. The get-
       method returns the record cell while the	 mapmethod  returns  the  cell
       literal.

       Object search
       The search methodology is divided either	by sheet or cells. In a	folio,
       the search is done in terms of  sheets  while  the  construction	 of  a
       cross-reference table is	required for searching cells.

       Searching in a folio
       The Folioobject provides	the primary mean to search for sheet. The fin-
       dand lookupmethods return a sheet by tag. The first sheet that  matches
       the tag is returned by these methods. The findmethod returns nil	if the
       sheet cannot be found while the lookupmethod throws an exception.

       # get a sheet by	tag
       const sheet (folio:lookup "the tag")

       If there	are several sheets that	matched	the tag, the  filtermethod  is
       more  appropriate.  The	filtermethod returns a new folio that contains
       the sheet that matches the requested tag.

       # get a sub-folio by tag
       const sf	(folio:filter "the tag")

       Searching for a cell
       The Folioobject also provides the method	for building a cross-reference
       table.  The  cross-reference table is represented by the	Xrefobject. By
       default,	a complete Xrefobject table is	built  with  the  getxreffolio
       method.	Such  method,  scan all	cells in the folio and add them	in the
       cross-reference table if	the cell has a name.

       # get a default xref table
       const xref (folio:getxref)

       The cross-reference table can also be  built  by	 searching  for	 sheet
       tags.  With  a  string  argument, the getxrefsearch for all sheets that
       matches the tag and then	build a	cross-reference	table. This method  is
       equivalent  to  the  operation  of building a new folio by tag with the
       filtermethod and	then building the cross-reference table.

       # get a xref table by tag
       const xref (folio:getxref "the tag")
       # another method
       const sf	  (folio:filter	"the tag")
       const xref (sf:getxref)

       A cross-reference table can also	be built by cell index	and/or	record
       index.  With a cell index, the cross-reference table is built by	index-
       ing the sheet column. With both the cell	and record indexes, the	cross-
       reference  table	 is  built by indexing all cells at the	coordinate for
       all sheets.

       # get a xref table by cell index
       const xref (folio:getxref 0)
       # get a xref table by cell and record index
       const xref (folio:getxref 0 1)

STANDARD SPREADSHEET REFERENCE
       Cell
       The Cellclass is	a data container. There	is only	one data  element  per
       cell.  Eventually  a  name can be associated with a cell. The cell data
       can be any kind of literals. Such literals are integer, real,  boolean,
       character or strings. A cell is the basic block used to build a spread-
       sheet.

       Predicate

	      cell-p

       Inheritance

	      Nameable

       Constructors

	      Cell (none)
	      The Cellconstructor create a default cell	with no	 name  and  no
	      value. When evaluated, the cell returns nil.

	      Cell (Literal)
	      The Cellconstructor create a default cell	by value. The argument
	      is a literal object which	can be viewed with its	string	repre-
	      sentation.

	      Cell (String Literal)
	      The Cellconstructor create a default cell	by name	and value. The
	      first argument is	the cell name. The second argument is  a  lit-
	      eral object which	can be viewed with its string representation.

       Methods

	      get -> Literal (none)
	      The getmethod returns the	cell literal value.

	      set -> none (Literal)
	      The setmethod sets the cell literal value.

	      get-name -> String (none)
	      The get-namemethod returns the cell name.

	      set-name -> none (String)
	      The set-namemethod sets the cell name.

       Persist
       The Persistclass	is a base class	for the	 AFNIX spreadsheet module. The
       class defines the methods that are used to read of write	 a  particular
       persistent  object.  When saving, the object name is retreived with the
       get name	method.	The saveas method does the same	as save	 but  takes  a
       file name argument.

       Predicate

	      persist-p

       Inheritance

	      Nameable

       Methods

	      save -> none (none)
	      The savemethod saves the current object.

	      saveas ->	none (String)
	      The  saveasmethod	 saves	the current object into	the file those
	      name is the string argument.

       Record
       The Recordclass is a cell container. A record can be created by	adding
       cell or simply by adding	data. If the record has	a predefined size, the
       cell or data can	be set by indexing. A name  can	 be  attached  to  the
       record.	Facilities are provided	to access directly the cell associated
       with the	record.	A record can also be created by	name.

       Predicate

	      record-p

       Inheritance

	      Persist

       Constructors

	      Record (none)
	      The Recordconstructor create an empty record with	no name	and no
	      cell.

	      Record (String)
	      The  Recordconstructor  create an	empty record by	name name. The
	      argument is the record name to use.

       Methods

	      add -> none (Cell|Literal...)
	      The addmethod adds one or	several	cell objects to	the record. In
	      the  first  form,	 the  argument	is a cell that is added	in the
	      record. In the second form, the argument is a  literal  that  is
	      used to create a cell by value.

	      get -> Cell (Integer)
	      The  getmethod returns a record cell by index. The index must be
	      within the record	range or an exception is raised.

	      map -> Literal (Integer)
	      The mapmethod map	a record cell by  index.  The  index  must  be
	      within  the  record range	or an exception	is raised. The cell is
	      mapped to	a literal object.

	      set -> none (Integer Cell|Literal)
	      The setmethod sets the record cell by index.  The	 record	 index
	      must  be	valid in order to succeed. A new cell is created prior
	      the record update. The previous cell data	is lost	including  its
	      name.

	      sort -> none (none|Boolean)
	      The  sortmethod  sorts  a	record in place. Without argument, the
	      record is	sorted in ascending order. The optional	boolean	 argu-
	      ment  specifies the sorting mode.	If true, the record is sorting
	      in ascending order and in	descending order if false.

	      find -> Cell (String)
	      The findmethod finds a cell by name. If the cell is  not	found,
	      the  nil	object	is  returned.  This  method  is	similar	to the
	      lookupmethod.

	      get-index	-> Integer (String)
	      The get-indexmethod finds	a cell index by	name. If the  cell  is
	      not  found,  an exception	is raised. The index is	the cell posi-
	      tion in the record.

	      lookup ->	Cell (String)
	      The lookupmethod finds a cell by name. If	the cell is not	found,
	      an  exception  is	 raised.  This	method is similar to the find-
	      method.

	      length ->	Integer	(none)
	      The lengthmethod returns the record length.

	      get-name -> String (none)
	      The get-namemethod returns the record name.

	      reset -> none (none)
	      The resetmethod rest the record. The record name is not  changed
	      but all record cells are removed.

	      set-name -> none (String)
	      The set-namemethod sets the record name.

       Sheet
       The  Sheetclass is a record container. A	sheet can be created by	adding
       records.	Similarly, if the sheet	has a predefined size, record cell  or
       data  can  be added by indexing.	A sheet	can be also seen as a 2	dimen-
       sional array of cells. Like a record, a sheet can be named. Without ar-
       gument,	a  default sheet is created. With a string argument, the sheet
       is created with an initial name.

       Predicate

	      sheet-p

       Inheritance

	      Persist

       Constructors

	      Sheet (none)
	      The Sheetconstructor create an empty sheet with no name  and  no
	      cell.

	      Sheet (String)
	      The Sheetconstructor create an empty sheet by name. The argument
	      is the sheet name	to use.

	      Sheet (String String)
	      The Sheetconstructor create an empty sheet by name and info. The
	      first  argument is the sheet name	to use.	The second argument is
	      the sheet	information string.

       Methods

	      add -> none (Record)
	      The addmethod adds a record to the sheet.

	      get -> Record (Integer)
	      The getmethod returns a sheet record by index. The index must be
	      within the sheet range or	an exception is	raised.

	      set -> none (Integer Record)
	      The  setmethod  sets  the	sheet record by	index. The sheet index
	      must be valid in order to	succeed.

	      sort -> none (none|Integer|Boolean|Integer Boolean)
	      The sortmethod sorts the sheet in	place. By default,  the	 sheet
	      is  sorted  in ascending order with column 0. With one argument,
	      the argument can be either the sorting mode or the  column  num-
	      ber. If the mode is true,	the sheet is sorted in ascending mode.
	      If the mode is false, the	sheet is sorted	 in  descending	 mode.
	      With  two	arguments, the first argument is the column number and
	      the second is the	sorting	mode.

	      length ->	Integer	(none)
	      The lengthmethod returns the sheet length.

	      convert -> PrintTable ([Integer [Integer [Boolean]]])
	      The convertmethod	converts the sheet into	a  print-table	repre-
	      sentation.  Without argument, the	whole sheet is converted. With
	      one argument, the	sheet is converted unto	a maximum of rows. The
	      second  optional	argument is the	start index that default to 0.
	      The third	optional argument is the literal format.  By  default,
	      the  literal  is formatted as a string. If the flag is true, the
	      literal is formatted as a	literal	string representation.

	      add-data -> none ([Cell|Literal]+)
	      The add-datamethod adds one or several cell object  to  a	 sheet
	      record. The sheet	record is initially created and	the object el-
	      ements are added sequentially to the record. In the first	 form,
	      the  argument is a cell that is added in the record. In the sec-
	      ond form,	the argument is	a literal that is  used	 to  create  a
	      cell by value.

	      add-marker -> none ([Literal]+)
	      The  add-markermethod  adds  one or several literal objects to a
	      sheet marker record.

	      marker-length -> Integer (none)
	      The marker-lengthmethod returns the number  of  markers  defined
	      for this sheet.

	      get-marker -> Cell (Integer)
	      The  get-markermethod  returns  a	 marker	cell by	index from the
	      sheet marker record.

	      set-marker -> none (Integer Literal)
	      The set-markermethod set the sheet marker	record	by  index  and
	      literal.

	      find-marker -> Integer (String)
	      The find-markermethod find the marker index. The argument	is the
	      marker string value.

	      add-sign -> none ([Literal]+)
	      The add-signmethod adds one or  several  literal	objects	 to  a
	      sheet sign record.

	      signature-length -> Integer (none)
	      The  signature-lengthmethod  returns the number of signs defined
	      for this sheet.

	      get-sign -> Cell (Integer)
	      The get-signmethod returns a sign	cell by	index from  the	 sheet
	      sign record.

	      set-sign -> none (Integer	Literal)
	      The  set-signmethod  set the sheet sign record by	index and lit-
	      eral.

	      find-sign	-> Integer (String)
	      The find-signmethod find the sign	index.	The  argument  is  the
	      sign string value.

	      add-header -> none (Cell|Literal...)
	      The  add-headermethod adds one or	several	cell object to a sheet
	      header record. In	the first form,	the argument is	a cell that is
	      added  in	the record. In the second form,	the argument is	a lit-
	      eral that	is used	to create a cell by value.

	      get-header -> Cell (Integer)
	      The get-headermethod returns a header cell  by  index  from  the
	      sheet header record.

	      map-header -> Literal (Integer)
	      The  map-headermethod  maps to a literal object a	header cell by
	      index from the sheet header record.

	      set-header -> none (Integer Literal)
	      The set-headermethod set the header record by index and literal.
	      The  cell	 associated with the header record is updated with the
	      literal value.

	      add-footer -> none ([Cell|Literal]+)
	      The add-footermethod adds	one or several cell object to a	 sheet
	      footer record. In	the first form,	the argument is	a cell that is
	      added in the record. In the second form, the argument is a  lit-
	      eral that	is used	to create a cell by value.

	      get-footer -> Cell (Integer)
	      The  get-footermethod  returns  a	 footer	cell by	index from the
	      sheet footer record.

	      map-footer -> Literal (Integer)
	      The map-footermethod maps	to a literal object an footer cell  by
	      index from the sheet footer record.

	      set-footer -> none (Integer Literal)
	      The set-footermethod set the footer record by index and literal.
	      The cell associated with the footer record is updated  with  the
	      literal value.

	      get-name -> String (none)
	      The get-namemethod returns the sheet name.

	      set-name -> none (String)
	      The set-namemethod sets the sheet	name.

	      get-info -> String (none)
	      The get-infomethod returns the sheet info.

	      set-info -> none (String)
	      The set-infomethod sets the sheet	info.

	      add-tag -> none ([String]+)
	      The  add-tagmethod  adds a tag into the tags vector. The tag can
	      be used to mark a	sheet in a folio.

	      tag-p -> Boolean (string)
	      The tag-pmethod returns true if the given	 tag  is  defined  for
	      this sheet.

	      tag-length -> Integer (none)
	      The tag-lengthmethod returns the number of tags defined for this
	      sheet.

	      get-tag -> String	(Integer)
	      The get-tagmethod	returns	a tag by index.

	      set-tag -> none (Integer Literal)
	      The set-tagmethod	set the	sheet tag record by index and literal.

	      find-tag -> Integer (String)
	      The find-tagmethod find the tag index. The argument is  the  tag
	      string value.

	      reset -> none (none)
	      The  resetmethod	resets	the sheet. The name and	information is
	      unchanged	during this operation.

       Folio
       The Folioclass is a sheet container. A folio of sheets  can  be	struc-
       tured to	handle various data organization. Since	all objects are	named,
       it is possible to index them for	fast data search. An empty  folio  can
       be created by name or filled with an input stream.

       Predicate

	      folio-p

       Inheritance

	      Persist

       Constructors

	      Folio (none)
	      The  Folioconstructor  create an empty folio with	no name	and no
	      cell.

	      Folio (String)
	      The Folioconstructor create an empty folio by name. The argument
	      is the folio name	to use.

	      Folio (String String)
	      The Folioconstructor create an empty folio by name and info. The
	      first argument is	the folio name to use. The second argument  is
	      the folio	information string.

	      Folio (InputStream)
	      The  Folioconstructor create an empty folio and fill it by read-
	      ing the data from	the input stream. The input stream  must  have
	      the data in a serialized form.

       Methods

	      write -> none (OutputStream)
	      The  writemethod	write  the folio contents to an	output stream.
	      The written form is a serialized form.

	      add -> none (Sheet)
	      The addmethod adds a sheet to the	folio.

	      get -> Sheet (Integer)
	      The getmethod returns a sheet by index. The index	must be	within
	      the folio	range or an exception is raised.

	      set -> none (Integer Sheet)
	      The  setmethod sets the folio by index and sheet.	The index must
	      be within	the folio range	or an exception	is raised.

	      tag-p -> Boolean (String)
	      The tag-pmethod returns true if a	sheet with  the	 tag  argument
	      exists in	the folio.

	      find -> Sheet (String)
	      The findmethod finds a sheet by tag. The first found sheet those
	      tag is matched is	returned. In  the  case	 that  multiple	 sheet
	      share  the  same	tag,  the filtershould be used.	If no sheet is
	      found the	method return the nil object.

	      lookup ->	Sheet (String)
	      The lookupmethod finds a sheet by	tag.  The  first  found	 sheet
	      those  tag  is  matched  is  returned. In	the case that multiple
	      sheet share the same tag,	the filtershould be used. If no	 sheet
	      is  found	the method throws an exception.	This method is similar
	      to the findmethod.

	      filter ->	Folio (String)
	      The filtermethod return a	new folio with sheets that  match  the
	      argument tag. If no sheet	is found, the folio is empty.

	      reset -> none (none)
	      The  resetmethod	resets	the folio. The name and	information is
	      unchanged	during this operation.

	      length ->	Integer	(none)
	      The lengthmethod returns the folio length.

	      get-name -> String (none)
	      The get-namemethod returns the folio name.

	      set-name -> none (String)
	      The set-namemethod sets the folio	name.

	      get-info -> String (none)
	      The get-infomethod returns the folio info.

	      set-info -> none (String)
	      The set-infomethod sets the folio	info.

	      get-xref -> Xref (none|Integer|String|Integer Integer)
	      The get-xrefmethod returns a cross-reference table from the  fo-
	      lio.  Without argument, the whole	folio is scanned and all named
	      cells are	added in the cross-reference table.  With  an  integer
	      argument,	 all  cells  that  matches the cell index argument are
	      added in the cross-reference table. With a string	argument,  all
	      cells  that  have	the same name are added	in the table. Finally,
	      with two arguments that represents the cell index	and the	record
	      index  are used, all cells are added in the table	with these two
	      coordinates.

       Index
       The Indexclass is a class that maintain	a  cell	 index	at  the	 folio
       level.  A  cell	index is composed of the sheet index, the record index
       and the cell index. The index object can	be used	to access in a generic
       way  a particular cell. Additionally, the folio name can	also be	stored
       in the index. It	is possible to have multiple records  that  represents
       the same	cell.

       Predicate

	      index-p

       Inheritance

	      Object

       Constructors

	      Index (none)
	      The Indexconstructor creates an empty index.

	      Index (Integer)
	      The  Indexconstructor  creates an	index with a cell index	as its
	      coordinate.

	      Index (Integer Integer)
	      The Integerconstructor creates an	index with a cell  and	record
	      indexes as its coordinate. The first argument is the cell	index.
	      The second argument is the record	index.

	      Index (Integer Integer Integer)
	      The Indexconstructor creates an index with a  cell,  record  and
	      sheet  indexes as	its coordinate.	The first argument is the cell
	      index. The second	argument is the	record index. The third	 argu-
	      ment is the sheet	index.

       Methods

	      add -> none (Integer|Integer Integer|Integer Integer Integer)
	      The  addmethod  adds a new index coordinate in the index object.
	      In the first form, the cell index	is used	as the coordinate.  In
	      the second form, the cell	and record indexes are used as the co-
	      ordinate.	In the third form, the cell, record and	sheet  indexes
	      are used as the coordinate.

	      reset -> none (none)
	      The resetmethod reset the	index by removing all attached coordi-
	      nates.

	      length ->	Integer	(none)
	      The lengthmethod returns the index length. The index  length  is
	      the number of coordinate entries in the index.

	      exists-p -> Boolean (Integer|Integer Integer|Integer Integer In-
	      teger)
	      The exists-ppredicate returns true if a coordinate entry	exists
	      in  the  index. In the first form, the cell index	is used	as the
	      coordinate. In the second	form, the cell and record indexes  are
	      used  as the coordinate. In the third form, the cell, record and
	      sheet indexes are	used as	the coordinate.

	      set-index-cell ->	none (Integer Integer)
	      The set-index-cellmethod sets the	cell index  by	position.  The
	      first  argument  is the coordinate position. The second argument
	      is the cell index	to use.

	      update-index-cell	-> none	(Integer)
	      The update-index-cellmethod updates the cell index for  all  en-
	      tries  in	 the  index. The argument is the new cell index	to use
	      for the update process.

	      get-index-cell ->	Integer	(Integer)
	      The get-index-cellmethod returns the cell	index for a particular
	      entry. The argument is the entry position.

	      set-index-record -> none (Integer	Integer)
	      The  set-index-recordmethod  sets	 the record index by position.
	      The first	argument is the	coordinate position. The second	 argu-
	      ment is the record index to use.

	      update-index-record -> none (Integer)
	      The  update-index-recordmethod  updates the record index for all
	      entries in the index. The	argument is the	new  record  index  to
	      use for the update process.

	      get-index-record -> Integer (Integer)
	      The  get-index-recordmethod  returns the record index for	a par-
	      ticular entry. The argument is the entry position.

	      set-index-sheet -> none (Integer Integer)
	      The set-index-sheetmethod	sets the sheet index by	position.  The
	      first  argument  is the coordinate position. The second argument
	      is the cell sheet	to use.

	      update-index-sheet -> none (Integer)
	      The update-index-sheetmethod updates the sheet index for all en-
	      tries  in	 the index. The	argument is the	new sheet index	to use
	      for the update process.

	      get-index-sheet -> Integer (Integer)
	      The get-index-sheetmethod	returns	the sheet index	for a particu-
	      lar entry. The argument is the entry position.

       Xref
       The Xrefclass is	a cross-reference class. The class maintains the asso-
       ciation between a name and an index. with a particular name,  an	 index
       entry is	created	if it does not exists. Such entry can be later used to
       access the cell content by index.

       Predicate

	      xref-p

       Inheritance

	      Object

       Constructors

	      Xref (none)
	      The Xrefconstructor creates an empty cross-reference object.

       Methods

	      add -> none (String [Integer|Integer Integer|Integer Integer In-
	      teger])
	      The addmethod adds a new reference in the	table. The first argu-
	      ment is always the index name. In	the first form,	the cell index
	      is  used	as  the	 coordinate.  In the second form, the cell and
	      record indexes are used as the coordinate. In  the  third	 form,
	      the cell,	record and sheet indexes are used as the coordinate.

	      get -> Index (Integer|String)
	      The getmethod returns an Indexobject either by name or position.
	      With an integer argument,	the index  is  obtained	 by  position.
	      With  a string argument, the index with the matching name	is re-
	      turned.

	      reset -> none (none)
	      The resetmethod resets the cross-reference table.

	      length ->	Integer	(none)
	      The lengthmethod returns the length of the  cross-reference  ta-
	      ble.

	      lookup ->	Index (String)
	      The lookupmethod returns an index	those name is the matching ar-
	      gument. If the index cannot be found, an exception is raised.

	      exists-p -> Boolean (String)
	      The exists-ppredicate returns true if an index those name	is the
	      matching argument	exists in the cross-reference table.

	      get-name -> String (Integer)
	      The get-namemethod returns the index name	by position.

AFNIX				  2017-04-29				sps(3)

NAME | STANDARD SPREADSHEET MODULE | STANDARD SPREADSHEET REFERENCE

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=afnix::sps&sektion=3&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help