RiverSoftAVG Products Help

ActivityNetwork

Defines classes needed for an activity network, which is a graph of events linked by tasks.

A typical graph ( GGraph.TGCustomGraph component) implements an Activity On Vertex (AOV) network where the vertices or nodes represent tasks and the edges represent precedence relations between the tasks. With these type of activity networks, you can generate topological ordering of tasks within the network. The ActivityNetwork unit provides classes that extend the GGraph.TGGraph component for a weighted, directed graph to implement Activity On Edge (AOE) networks ( ActivityNetwork.TActivityNetwork component). An AOE network is a activity network or graph where the tasks to be performed on a project are represented by directed edges and the vertices or nodes represent events (completion of some activity). Therefore, activities represented by edges cannot be started (leave the node) until the event at that node has completed. Activities that start from the same event can be executed in parallel. The Weight of an edge usually represents an estimate of how long that activity will take to complete.

Activity On Edge networks are a useful representation for a project because they allow performance evaluations for the project. With these networks, you can answer such questions as: What is the minimum amount of time the entire project could be completed in? Which activities need to be speeded up in order to reduce completion time? etc.

The TActivityNetwork component, along with its TAOETask edge and TAOEEvent node, allow the representation of activity on edge networks and provide powerful algorithms for processing these networks. With this component, you can determine the earliest possible start time for a task, the latest possible start time for a task that can occur without lengthening the total project time, earliest and latest possible event times, and critical paths. A critical path is the longest path through the network, i.e., the critical path represents the path that controls the minimum project completion time. Finally, the component can calculate the criticality of each task; every task whose earliest start time equals its latest start time are called critical activities. The criticality of a task is the difference between the latest and earliest start time and gives the time by which an activity may be delayed or slowed without increasing the total time to finish the project. All tasks on a critical path are critical and speeding up noncritical tasks will not reduce the project completion time.
 

CommonInterfaces

Contains interfaces for common types of objects used in programming. These are interfaces that many objects could implement and could be used in more than one situation.

DataStructures

Defines heap classes and efficient priority queues. There are also object stacks and queues.

A heap is a complete binary tree where every node's value is guaranteed to be greater than its children's values.

FilerHelper

Defines helper classes for streaming.

GGraph

The GGraph unit contains objects for encapsulating graphs or networks (not the TeeChart type of graphs).

Graphs are made up of nodes ( GGraph.TGGraphNode class) and edges ( GGraph.TGGraphEdge class) connecting the nodes. Graphs may be directed or undirected. The GGraph.TGCustomGraph class manages the edges and nodes and provides routines for determining topological ordering, critical paths, and other graph operations. The TGCustomGraph class is the base abstract class for graphs, the TGLabelGraph and TGGraph classes are descendants of this class and actually implement all the functionality. The GGraph.TGLabelGraph class manages the nodes as a hash table and allows quick access to nodes based on their unique name. The GGraph.TGGraph class manages the nodes as a list and allows duplicately named nodes.
 

GHashTable

Defines hash table, or dictionary, collections

GLists

Defines linked list classes including a priority list. Also defines some stacks and queues.

GParser

The Parser unit provides a simple parser class ( GParser.TGCustomParser and GParser.TGParser) for parsing (tokenizing) a string. The TGCustomParser class serves as a base class for tokenizing strings, other classes can descend from this class for their special parsing needs. The TGParser class just exposes some properties of the base TGCustomParser class.
 

GRegularExpression

Regular expression search engine for Windows.

Deprecated since it does not support Unicode characters.

GStreams

Defines classes for manipulating other streams. These classes are passed a TStream or descendant and provide methods to manipulate those streams. The TGBufferStream class provides buffering capabilities for another stream, this is especially useful in speeding up TFileStream objects. The TGTextStream class provides methods for reading and writing a stream as if it was a long string.

Both classes are based on objects from "Secrets of Delphi 2" by Ray Lischner. Modified and used here by his kind permission.
 
 

GTree

Defines non-visual tree and binary tree structures.

GValue

Defines a generic value class, similar to a variant.

For Windows platforms only.

HelperFunctions

Useful Helper Functions

InterfaceCollections

Defines collection-type objects (lists, hash tables) for managing interfaces.

ListColl

Defines a TListCollection, a TList with enhancements

RefCount

Defines the RefCount.TRefCount class that implements the IUnknown interface for its owner by delegation (using the implements keyword). The TRefCount class makes it easy to quickly make a class to implement the IUnknown interface without descending from TInterfacedObject, TComponent or similar class.
 

RSConstants

Defines constants for RiverSoftAVG products

RSEncodedBits

Defines the RSEncodedBits.TRSEncodedBits class, which provides the ability to pack integers, strings, reals, etc into the smallest number of bits possible. This class is used by the Genetic Algorithm library to pack the encoding for each generation's attributes.
 

RSGenerics.Collections

Defines collections based on generics

RSInterfaceCollections

Defines collection-type objects (lists, hash tables) for managing interfaces.

RSMessages

Defines windows message structures

RSUIConsts

Defines constants useful for graphical user interfaces, currently path shapes.

RSVector

Vector classes

Structures

The Structures unit contains string list objects (similar to TStringList).

The Structures.TSFCList, in fact, descends from TStringList and modifies it to make it more efficient. Also, it adds an owner which can be notified when the list changes. The TSFCFreeList object descends from TSFCList and adds the ability for the list to automatically free the objects when they are deleted from the list (this is similar to the TObjectList in later versions of Delphi).

The Structures.TGStringList is a complete reimplementation of the TStringList building in the efficiencies of TSFCList from the ground up. It adds the memory management of the TSFCFreeList. Finally, it also adds a private Data field so that you may leave the Objects field empty for use by the user. Of course, this list may also be set to manage the memory in the Data field as well.