Uses of Interface
proper.core.ProperInterface

Packages that use ProperInterface

proper.app	Contains command line classes, which can all be called with the option "-help" to get further information about the available parameters.
proper.core	The core package includes classes and interfaces most classes in Proper extend or implement.
proper.database	All classes concerning Database access and traversal or related structures can be found here.
proper.engine	The engine classes (all derived from Engine ) perform the actions defined by the parameters they get from the Application-classes.
proper.gui	Contains all classes concerning the GUI frontend of Proper.
proper.gui.core.frame	Frames that are used in Proper are located here.
proper.gui.experiment	This package serves as a frontend to the command line based Application classes.
proper.gui.help	Contains the Help for Proper and also the famous "About-Box".
proper.gui.milk	Contains some MILK GUI tools.
proper.gui.remote	Contains classes for administrating the JobServer, e.g.
proper.gui.util	Contains some utils, like XML/XSL-Transformer ( XSLer ) or a Logfile-Viewer ( Logger ).
proper.gui.weka	Contains some WEKA GUI tools.
proper.imp	Contains all the classes concerning the import of data, i.e.
proper.net	Network specific classes are located here.
proper.relaggs	contains the core classes of RELAGGS, without the GUI components
proper.remote	Classes for the distributed computing part of Proper can be found here, i.e.
proper.remote.messages	Contains the XML-messages used for the distributed computing.

Uses of ProperInterface in proper.app

Classes in proper.app that implement ProperInterface

class	Application This class functions as a Ancestor for all classes that are called from commandline with parameters.
class	ArffComparer A simple comparer of ARFF files created by different tools.
class	ArffFilter This class filters an ARFF filter: it can delete attributes by names, but also run WEKA filters.
class	Bagger This class Exports a table to an ARFF-file that can be used in MILK (the multi instance learning kit, based on Weka). For a complete list of commandline parameters just run it with the option "-help".
class	Classifier This class trains a classifier and classifies given instances. One can specify WEKA or MILK classifiers. For a complete list of commandline parameters just run it with the option "-help".
class	DatabaseApplication This class functions as a Ancestor for all classes that are called from commandline with parameters and that handle databases For a complete list of commandline parameters just run it with the option "-help".
class	Databases This class creates the necessary databases for the experiments.
class	Experimenter This class runs experiments with a given ARFF-file. For a complete list of commandline parameters just run it with the option "-help".
class	Export This class Exports a table to an ARFF-file that is used in WEKA.
class	ForeignKeys This class shows foreign keys of a given table.
class	Import This class imports Prolog programs or CSV files and creates a database from it with tables according to the predicates (Prolog) or filenames (CSV).
class	Jobs This class extracts the java calls (i.e.
class	MILK This class performs a flattening of a database into a single table.
class	Propagation This class performs the propagation of keys to outlying tables.
class	Reducer This class is used for reducing (= deleting) the amount of rows of tables in a database given a certain column.
class	RELAGGS This class runs Relaggs over an SQL-database. Relaggs: Mark-A.
class	Relations This class discovers the relations for a given table in a database based on the names of the columns.
class	REMILK This class combines RELAGGS and MILK. For a complete list of commandline parameters just run it with the option "-help".
class	Standalone This class creates a standalone version of a provided class.
class	Tester This class runs testing of a generated classifier, therefore learning and testing ARFF-files have to be provided (besides the classifier). One can specify WEKA or MILK classifiers. For a complete list of commandline parameters just run it with the option "-help".

Uses of ProperInterface in proper.core

Classes in proper.core that implement ProperInterface

class	ArgumentObject This abstract class adds some functionality for classes that handle arguments.
class	ProperObject This abstract class serves only for some common functionality of most classes.

Methods in proper.core with parameters of type ProperInterface

void	ProperObject.addListener(ProperInterface o) adds the object to the listener list
void	ProperInterface.addListener(ProperInterface o) adds the object to the listener list
void	ProperObject.notifyListener(ProperInterface o) notifies the specified listener of changes
void	ProperInterface.notifyListener(ProperInterface o) notifies the specified listener of changes
void	ProperObject.removeListener(ProperInterface o) removes the object from the listeners
void	ProperInterface.removeListener(ProperInterface o) removes the object from the listeners

Uses of ProperInterface in proper.database

Classes in proper.database that implement ProperInterface

class	ColumnLister This class retrieves a list of column names for a given table.
class	Connector This class connects to a given SQL database (standard is MySQL).
class	ConnectorObject This abstract class is an ancestor to all Connector-dependent classes.
class	Creator This class creates databases on a given host.
class	DatabaseLister Lists all available Databases on the given host
class	Dropper This class is just a convenient way for dropping tables.
class	Executor This class executes SQL-Statements (try-catch-wrapper to avoid long code).
class	ExecutorObject This abstract class is an ancestor to all classes that want to use an Executor instance.
class	Joiner This class can perform different kinds of joins: NATURAL, LEFT OUTER and RIGHT OUTER the two tables are joined via some keys like in SQL BEST before the join is performed the class checks whether a LEFT OUTER or a RIGHT OUTER join is better
class	Modifier A small helper class e.g.
class	Reader This class reads all the data from a given SQL table and creates WEKA instances from that. A verbose level of 2 prints also the SQL statements for retrieving the instances.
class	RelationDiscoverer This class discovers from a table all the tables that are dependent on it, i.e.
class	Sparser This class retrieves a certain percentage of data from a table.
class	TableLister This class retrieves a list of table names for the current database.
class	Writer This class is used for writing a table to an ARFF-file.

Uses of ProperInterface in proper.engine

Classes in proper.engine that implement ProperInterface

class	Arffer This class exports the data from a table to an ARFF-file.
class	BagArffer This class exports the data from a table to an ARFF-file that can be used for MILK (multi instance learning kit, based on Weka). If the bag is not provided the first index is taken in the target table.
class	DatabaseEngine This class encapsulates some common code for Engines that access DBs.
class	Engine This class provides a simple wrapper for code that needs several arguments.
class	Flattener This class flattens a given relational database into one table.
class	Importer This class imports the specified datafiles (Prolog or CSV) into a database. If verbose level is >=1 the parser's verbose is set to TRUE, if it is >=2 then also the inserts are printed to stdout (can be pretty much!).
class	Instancer This class creates Instances directly from the previously propositionalized database and stores them under the parameter "instances".
class	Milk This class starts an MILK classifier with either an ARFF-file (Parameter "type" is then "output") or previously generated Instances (Paramter "type" is then "instances").
class	MilkClassifier This class trains a MILK classifier and classifies given instances.
class	MilkExperimenter This class runs experiments with a given ARFF-file. It is using MILK (the Multi Instance extension of WEKA).
class	Propagator Transforms a tree structure of relations between tables into a star structure with a depth of one, i.e.
class	Relaggs This class is a wrapper around RELAGGS (Propositionalization of a relational data model).
class	ReMilker This class combines the aggregation from MILK and RELAGGS.
class	Weka This class starts a WEKA classifier with either an ARFF-file (Parameter "type" is then "output") or previously generated Instances (Paramter "type" is then "instances").
class	WekaClassifier This class trains a WEKA classifier and classifies given instances.
class	WekaExperimenter This class runs experiments with a given ARFF-file. It uses the WEKA Experimenter for this.

Uses of ProperInterface in proper.gui

Classes in proper.gui that implement ProperInterface

class

Proper This is the main GUI class, which starts all other windows.

Uses of ProperInterface in proper.gui.core.frame

Classes in proper.gui.core.frame that implement ProperInterface

class	ApplicationFrame This class defines the application window that handles subordinated windows.
class	ChildFrame This class has always the ApplicationFrame as parent.
class	CommandLineFrame This class defines a frame that handles command line arguments. This class is started with the command line parameters like this:
class	DatabaseChildFrame This class has always the ApplicationFrame as parent.
class	DummyFrame This Frame is only used for Dialogs, since there exists the problem if a JDialog is instantiated without a parent (e.g.
class	ProperFrame This abstract Frame is parent to all frames used for Proper. It only implements the Listener Interfaces, but adds no functionality only empty methods. Besides that it handles stuff like interpreting the verbose string and propagating changes to its registered listeners.

Methods in proper.gui.core.frame with parameters of type ProperInterface

void	ProperFrame.addListener(ProperInterface o) adds the object to the listener list
void	ProperFrame.notifyListener(ProperInterface o) notifies the specified listener of changes
void	ProperFrame.removeListener(ProperInterface o) removes the object from the listeners

Uses of ProperInterface in proper.gui.experiment

Classes in proper.gui.experiment that implement ProperInterface

class	Builder The Builder is used for building custom experiments, i.e.
class	ExperimentFrame This frame is the ancestor for all Experiment-based frames.
class	ReMilk This frame is for Propositionalization with REMILK.
class	Run This frame is for executing ANT files: it loads an XML file and displays the targets.
class	Setup This frame is for setting up the environment for Propositionalization.

Uses of ProperInterface in proper.gui.help

Classes in proper.gui.help that implement ProperInterface

class	About Displays a simple About-Box that display some system-settings etc.
class	Help This class is used as a simple HTML-Browser for displaying the Documentation.

Uses of ProperInterface in proper.gui.milk

Classes in proper.gui.milk that implement ProperInterface

class

MIExperimenter The MILK Experimenter.

Uses of ProperInterface in proper.gui.remote

Classes in proper.gui.remote that implement ProperInterface

class	Jobber This class is a GUI frontend for creating Jobslists for the distributed computing.
class	JobMonitor This class monitors a JobServer, offering a GUI for the current status. The deletion of jobs may not work if a job became obsolete, i.e.

Uses of ProperInterface in proper.gui.util

Classes in proper.gui.util that implement ProperInterface

class	Editor A little tool for editing files.
class	Logger A little tool for handling logfiles, e.g.
class	XSLer This class can be used for testing XSL scripts.

Uses of ProperInterface in proper.gui.weka

Classes in proper.gui.weka that implement ProperInterface

class	ArffViewer A little tool for viewing ARFF files.
class	Explorer The WEKA Explorer.
class	SqlViewer A small viewer for doing SQL queries.

Uses of ProperInterface in proper.imp

Classes in proper.imp that implement ProperInterface

class	CSVParser This parser works on CSV files.
class	Fingerprint This class handles Fingerprints, i.e.
class	Indexer This class interpretes the "verbal" indexes for files, e.g.
class	Namer A class for creating table names, column names, etc.
class	Parser This abstract is the ancestor for several Parsers that use predicates.
class	PostProcessor This class performs post processing of the stored predicates, like finding inconsistent ones, trying to fix inconsistencies.
class	PrologParser This parser works on files that contain Prolog ground facts.
class	Traverser This class extracts useful information from a given structure.

Uses of ProperInterface in proper.net

Classes in proper.net that implement ProperInterface

class

Data This class can send data to a receiver and also receive it (it is waiting until it's getting something, i.e.

Uses of ProperInterface in proper.relaggs

Classes in proper.relaggs that implement ProperInterface

class

RelaggsStructure Title: RelaggsStructure Description: Stores the information about the attributes of an aggregated table. ChangeLog: FracPete (2004-05-28): changed data types in getAlterTableColumns to ANSI types INT and DOUBLE PRECISION

class

SqlEngine Title: SqlEngine Description: Connection to database system. Changelog: FracPete: LEFT OUTER JOIN introduced (optional) see setLeftOuterJoin FracPete: can use any index instead of primary key (optional) see setUseAnyIndex FracPete: can use specific index for aggregation (optional) see setUseIndex FracPete: list of tables to exclude from aggregation possible (optional) see setExcludedTables FracPete (2004-05-27): broke down STDDEV into aggregate functions, since implementations differ (MySQL: population, PostgreSQL: sample) see getStddev, USE_BUILTIN_STDDEV, USE_SAMPLE_STDDEV FracPete (2004-05-28): removed limitation for tables with no schema getTables returns only tables now (with PostgreSQL it also returned the Indices) uses DB-independent DATA_TYPE instead TYPE_NAME, see RelaggsAttribute LIMIT %ROWS% implemented, see getLimit implemented method that generates a CREATE TABLE statement from a SELECT, since "CREATE TABLE ...

Uses of ProperInterface in proper.remote

Classes in proper.remote that implement ProperInterface

class	JobAdder This class adds jobs to a specified JobServer.
class	JobClient This class acts as a client to a server distributing jobs to be carried out. Every request the client sends to the server has the type of request in the first line, the port it is listening to in the second line and any other data after that. For a complete list of commandline parameters just run it with the option "-help".
class	JobServer This class is a server for performing distributed computation. The clients register and unregister themselves with the server, which handles a queue of jobs. Every Request that is sent between Server and Client has the type of request in the first line. The job list that the server reads is a simple text file where each line is either a comment (line is starting with a "#") or a real job.
class	Server This abstract class contains some basic functionality for a server. For a complete list of commandline parameters just run it with the option "-help".

Uses of ProperInterface in proper.remote.messages

Classes in proper.remote.messages that implement ProperInterface

class	DataMessage This class encapsulates a DataMessage, where the data of the payload (file or something like this) is in the <body> tag of the Message. The actual data looks like this:
class	FileMessage This class encapsulates a FileMessage, where the data of the payload (file or something like this) is in the <body> tag of the Message, besides the the name of the file. The actual data looks like this:
class	JobMessage This class encapsulates a JobMessage, where the job is inside the <body> tag of the Message. The actual Job looks like this:
class	Message This class encapsulates the standard behaviour and methods for all messages.