Vision ToolKit Class: Schema

The Vision Schema ToolKit has been created to provide a set of classes and messages that aid in tracking information about your Vision database itself. The Schema ToolKit enables you to:

  • Store documentation and descriptive information for each class and message in your database.
  • Cross reference all messages in your Vision database by message name, class, type, and function.
  • Track method changes over time.
  • Track superclass and subclass hierarchies for a class.

Because the Schema information is maintained as part of your database using standard classes and messages, all Vision protocol is available for managing and using the information.

This ToolKit has been a standard component of all databases bootstrapped since March 1994.

Schema Overview

The Schema class is used to support the protocol for managing information about your Vision database. As with all ToolKits, subclasses of the Schema ToolKit are named relative to the Schema class. The subclass hierarchy is shown below: 

    Object
       |
    ToolKit
       |
       Schema
          Schema Descriptor
          Schema ClassDescriptor
             Schema MessageDescriptor
             Schema MessageImplementationDescriptor

The Schema class organizes protocol used to process and manage schema information. It is not instantiated directly.

The class Schema ClassDescriptor (Schema CD) is used to manage information about each class in your database. There will be one instance in this class for every subclass created.

The class Schema MessageImplementationDescriptor (Schema MID) is used to manage information about each message in your database. There will be one instance in this class for every message defined for any class in your database. A separate instance is created for each definition of the message, even if the same message name is used with multiple classes.

The class Schema MessageDescriptor (Schema MD) is used to manage information about each unique message name in your database. There will be one instance in this class for every unique message name created. This class is not referenced directly by the user. Its instances are maintained and accessed via messages defined for the ClassDescriptor and MessageImplementationDescriptor classes.

Most of your interactions will be directly with the Schema class and with the ClassDescriptor and MessageImplementationDescriptor subclasses.

Basic Review

The basic rules for class and instance creation are presented in the documents Vision Fundamentals and Vision Classes. The basic rules for message creation and management are presented in the documents Vision Fundamentals and Vision Messages. This section reviews the relationship between Vision classes and messages and the Schema classes.

The class Schema ClassDescriptor is used to maintain information about the classes in your Vision database. Each instance of this class corresponds to a specific class in your database. Messages defined for this class record information pertaining to class hierarchy, naming dictionaries, and descriptions. The classDescriptor message is defined for each class to return the instance of the Schema ClassDescriptor class used to store descriptive information about the class.

You can create a new class from an existing class using the expression: 

    !NewClass <- Object createSubclass ;
In this case, the variable NewClass is defined to be a subclass of the class Object. The expression: 
    NewClass classDescriptor
returns the Schema ClassDescriptor instance associated with this class. The variations of the createSubclass message (i.e., createSubclass: and createSubclass:at:) also create a new Schema ClassDescriptor instance that can be accessed via the classDescriptor message at the new class.

The class Schema MessageImplementationDescriptor is used to maintain information about the messages in your Vision database. Each instance of Schema MessageImplementationDescriptor corresponds to a specific message in the Vision database. These instances track information about the message itself including its type, function, and description, as well as tracking changes to methods over time.

New instances of the Schema MessageImplementationDescriptor class are NOT created automatically. Each time you use one of the define messages, the class is flagged to indicate that new messages are pending. To process and refresh all pending messages, you execute the expression: 

    Schema processAllMessages
This process creates and refreshes information as needed.

The expression: 

    object getMessage: "message"
is used to access the descriptor associated with a specific implementation of a message. This message returns an instance of the class Schema MessageImplementationDescriptor. The messages displayInfo and describe display useful information about this message in a short and long format.

The Schema ClassDescriptor Class

This class is used to maintain information about the classes in your Vision database. Each instance of Schema ClassDescriptor corresponds to a specific class. Messages defined for this class enable you to record information pertaining to class hierarchy, naming conventions, and descriptions. The expression: 

    object classDescriptor
returns an instance of this class.

Descriptive Information

A number of messages defined for the Schema ClassDescriptor class are used to store and access descriptive information about the class:

Message Definition Update Using
class Default instance of class associated with descriptor. should not be modified
name Name of the class. This is normally the class' 'whatAmI'. should not be modified
parent Class descriptor associated with the super class of the recipient's underlying class. should not be modified
type Returns an instance of the class ClassType. setClassTypeTo:string
description Description of the class. setDescriptionTo:string
sampleUsage Describes sample syntax for accessing instances of the recipient's underlying class. setSampleUsageTo:string
_htmlDocName Name of the HTML document that describes this class in detail on insyte's www.insytenet.com web site. setHtmlDocNameTo: string
htmlDocName Name of the HTML document that describes this class in detail on insyte's www.insytenet.com web site; if no document is defined, the document name associated with the first super class in the recipient's hierarchy that has a document is returned. Cover Method for _htmlDocName
_imageName Name of the image file associated with this class. :_imageName <- "imageFile.gif" ;
imageName Name of the image file associated with this class formatted as an image tag if defined. The class name is returned otherwise. Cover Method for _imageName

New ClassDescriptor Instances

A new Schema ClassDescriptor instance is automatically created whenever a new subclass is created using a variation of the createSubclass: messages. When this new instance is created, the following operations are performed on it:

  1. The property class is set to the default instance of the new class.
  2. The property code is set to the name of the underlying class. This is the value of the parameter in the createSubclass: message. The property name is set to the value of whatAmI for the class.
  3. The property defaultAccessPath is set to the object at which the underlying class is defined. This is the class ^global by default and corresponds to the value of the at: parameter when the subclass is created using the form createSubclass:at:.
  4. The property parent is set to the class descriptor of the direct superclass of this class.
  5. The class constant classDescriptor is defined at the new class to return this new class descriptor instance.
  6. The property type is set to a default ClassType.
  7. A number of additional properties associated with class inheritance, and instantiations for the underlying class are initialized.

For example, the expression: 

    Entity createSubclass: "Company"
creates a new subclass of Entity named Company and a new instance of the Schema ClassDescriptor class initialized as follows:

  1. The property class is set to the default Company.
  2. The properties code and name are set to the string "Company".
  3. The property defaultAccessPath is set to ^global.
  4. The property parent is set to the class descriptor of the class Entity (i.e., Entity classDescriptor).
  5. The class constant classDescriptor is defined at the Company class to return this new class descriptor instance (i.e., Company classDescriptor returns the new instance).
  6. The property type is set to Named ClassType Application.
  7. A number of additional properties associated with class inheritance, and instantiations for the underlying class are initialized.

Assigning the ClassType

A Vision database contains a large number of classes organized into a hierarchy that all eventually inherit from the class Object. The property type has been defined for the Schema ClassDescriptor class to provide a mechanism for grouping subsets of classes into logical categories. The value of type is defined to be an instance of the ClassType class. The following ClassType instances have been defined:

ClassType Definition
BuiltIn all bootstrap classes such as List, Number, and Block ; these classes are part of all Vision databases.
Application user defined classes that are used to model the entities, data, and navigations that define a specific Vision system; all Entity, DataRecord, LinkRecord, and DataBridge subclasses are part of this category. This category also includes DataSet classes that manage external data that is accessed directly via other classes.
DataFeed user defined classes that model and store data loaded from external sources; instances of these classes are used to create and refresh Application instances and are not normally referenced by user applications.
ToolKit used to organize packages of classes and messages offered as a unit to perform a set of related functions.
Dictionary used to manage a set of names that return related objects.
ObjectSpace used to define separate work areas that inherit from the shared CoreWorkspace.
Other other classes used to support the development process.
Unused classes that are still part of the database but are not currently documented or used anywhere.

The underlying class is used to assign an initial ClassType to the type property for a Schema ClassDescriptor instance. The property value can be reassigned using the setClassTypeTo: message. To look at the current assignments use: 

    Schema CD instanceList
        groupedBy: [ type ] .
    do: [ "===> " print ; code printNL ;
          groupList sortUp: [ name ] .
          do: [ name printNL ] ;
          newLine print ;
        ] ;

Tracking Inheritance

The property inheritancePath is defined at Schema ClassDescriptor and contains an indexed list of the class descriptors in the recipient's super class hierarchy including the recipient. The property childList is defined at Schema ClassDescriptor and contains an indexed list of the class descriptors that are direct subclasses of the instance's underlying class. Both of these properties are maintained by the initialization methods defined for Schema ClassDescriptor and should not be changed manually.

Several messages have been defined at Schema ClassDescriptor to use these properties. Note that many of these messages are called by equivalent methods defined at Object.

Message Definition
inheritsFrom: cd Returns TRUE if the class associated with the recipient object inherits from the class associated with the class descriptor provided, FALSE otherwise. This is similar to the version at Object except the parameter must be a class descriptor.
isSubClassOf: cd Returns TRUE if the recipient is a sub class of the parameter.
isSuperClassOf: cd Returns TRUE if the recipient is a super class of the parameter.
isInInheritancePathOf: cd Returns TRUE if the recipient inherits from the supplied parameter or the supplied parameter inherits from the recipient.
getInheritancePath Returns a list of class descriptors representing the super class hierarchy of the recipient. The list is sorted with the class descriptor for Object first and the class descriptor for the recipient class last.
getAllChildren Returns a list of all the class descriptors that refer to subclasses of the recipient.
showChildren Recursively displays each subclass of the recipient.
showParents Displays the super class hierarchy for the recipient.
showInheritance Displays the inheritance hierarchy for the recipient. This method is called directory by the version at Object.

Naming Dictionaries

Naming Dictionaries are subclasses of Dictionary that are used to organize instance names for a class. To avoid conflicting names across classes, a separate naming dictionary is defined for any class that wants to be able to refer to individual instances using one or more aliases. Each Entity subclass has its own naming dictionary that is created when the class is created. You can define a naming dictionary for any class that needs it.

The property namingDictionary can be used to store a reference to the underlying class' naming dictionary, if it exists. By default this value will be NA. You can also flag a class to indicate that subclasses should automatically have a naming dictionary created for it.

When a new Schema ClassDescriptor instance is created, the naming dictionary for the class is set to the value of its parent's naming dictionary. If you've explicitly created your own naming dictionary and wish to record its value in the class descriptor, you can use the setNamingDictionaryTo: dictionary message. For example, the naming dictionary associated with application workspaces for the Interface class was defined as follows: 

    Dictionary createSubclass: "Named" at: Interface ;
    Interface Named createInstance: "ApplicationWS" ;
    Interface ApplicationWS classDescriptor
       setNamingDictionaryTo: Interface Named ApplicationWS ;

The message setAutoCreateNamingDictionaryOn can be sent to a class descriptor to indicate that a new naming dictionary should automatically be created when new subclasses of the instance's underlying class are created. For example, this flag has been set for the Entity class so that each subclass gets its own naming dictionary. When a new Schema ClassDescriptor instance is created, this flag is set to the value of its parent's flag. You can turn this flag off using the message setAutoCreateNamingDictionaryOff .

New Instances of the Underlying Class

Information recorded in a class' class descriptor is used to create new instances of the class. The createInstance: method at Object runs two methods that use information stored in the class descriptor: initializeDefaults and initializeNames.

The initializeDefaults message uses the class descriptor property defaultPropertyList to assign initial values to the new instance. The defaultPropertyList contains a list of Schema MessageImplementationDescriptor objects which contain default values for any properties that require them. The techniques for setting default values for properties are described below..

The initializeNames message updates the naming dictionary associated with the class descriptor with the code and any aliases defined for the new instance.

Additional Information

The Schema ClassDescriptor messages are described further in the document Schema Message Dictionary.

The Schema MessageImplementationDescriptor Class

This class is used to maintain information about each message implementation. Each message defined for a class in the Schema database has a corresponding instance in this class. The expression: 

    object getMessage: "string"
returns a message implementation descriptor if the string is defined as a message to which the object responds. You can send the displayInfo or describe message to the result to display a short or long description of the message.

Descriptive Information

A number of messages defined for the Schema MessageImplementationDescriptor class are used to store and access descriptive information about the class:

Message Definition Update Using
code Name of the message. should not be modified
messageClassDescriptor ClassDescriptor of the class defining this version of the message. should not be modified
class Class defining this version of the message. Cover method
messageDescriptor MessageDescriptor for this message name. should not be modified
message Same as code. Cover method
type MessageType of this message. Automatically updated based on the implementation, this value should only be manually reset to indicate that a method is time-varying using setTypeTo: Named MessageType MethodTV
isTimeVarying TRUE if the type is TimeSeriesProperty or MethodTV. Cover method
functionType FunctionType of this message. setFunctionTypeTo: string
parameterList ClassDescriptor indicating the class of each parameter to this message if it is a binary or keyword message. setParameter: n typeTo: cd
returnObjectType ClassDescriptor indicating the type of object returned by this message. setReturnObjectTypeTo: cd
returnObjectContainer ClassDescriptor indicating if the returned object is a scalar object or a collection. setReturnObjectContainerTo: cd
keyType KeyType of this message. flagAsKeyField ; flagAsPartialKeyField
usageLevel UsageLevel of this message. setUsageLevelTo: string
fullSelector Name of the message with appropriate parameters names filled in for binary and keyword messages. setSelectorTo: string

MessageType, FunctionType, UsageLevel, and KeyType

The class MessageType defines instances that correspond to the different types of message that can be defined in Vision. The possible instance values are: Constant, FixedProperty TimeSeriesProperty, Method, MethodTV, and Primitive. These instances are accessible via the naming dictionary Named MessageType. Messages of type Constant were created with the define:toBe: message. Messages of type FixedProperty were created with the defineFixedProperty: message. Messages of type TimeSeriesProperty were created with the define: message. Messages of type Method and MethodTV were created with the defineMethod: message. The latter type can be explicitly assigned to indicate that a method could return different values as of different points in time. Messages of type Primitive are defined as part of the process of bootstrapping a Vision database.

The class FunctionType defines instances used to classify messages by function such as Access, Update, and Inquiry. The value of the functionType property is set to an instance of FunctionType. You can create and set function types with the setFunctionTypeTo: message. If the supplied string does not define a current function, a new instance is created.

The class UsageLevel defines instances used to classify messages by usage level. Current levels are: Basic, Advanced, Internal, and DBA. The value of the usageLevel property is set to an instance of UsageLevel. The default value is Basic. You can reset the level using setUsageLevelTo:.

The class KeyType defines two instances: Full and Partial. The property keyType can be set to one of these instances using the flagAsKeyField or the flagAsPartialKeyField message. By default, this property is NA. This flag can be used to indicate that the message could serve as a "key" for the class. Although, Vision does not require or use keys directly, this is sometimes useful for classes that are presented as part of a data model.

Default Values

The property defaultValue is used to store a default value for a MessageImplementationDescriptor. It is only meaningful to store default values for messages that are properties. You can set this value using the setDefaultValueTo: message. You can clear this value using the clearDefaultValue message.

When a property is defined for a class using the defineFixedProperty: or define: message, the initial value of the property is NA for all instances of the class and for any new instance when it is created. The expression: 

    class defineFixedProperty: 'name' withDefault: object
or
    class define: 'name' withDefault: object
runs the defineFixedProperty: or define: message and sets the default value in the associated message implementation descriptor to the supplied object. All existing instances are initialized to have this value. In addition, this property will be set to this default value as part of the execution of the createInstance method.

Method History

The time series property implementationSource provides a history of method changes. To display the implementation history for a particular method use: 

    Number getMessage: "absoluteValue" .
    :implementationSource     #- returns time series of strings
    do: [ "Implementation As Of: " print; ^date printNL ;
          printNL ;           #- displays implementation
          "-" fill: 50 . printNL ;
        ] ;

New Instances

New instances of the Schema MessageImplementationDescriptor class are NOT created automatically. Each time you use one of the define messages, the class is flagged to indicate that new messages are pending. To process and refresh all pending messages, execute the expression: 

    Schema processAllMessages
This process creates new MessageImplementationDescriptor instances and refreshes information as needed. Four properties supply update information for an instance. The creationDate property contains the date that the instance was first created. The updateDate property contains the date the message implementation last changed (i.e., message type and method implementation changes). The createdInLastPosting property is set to TRUE if the instance was created during the last execution of the processAllMessages message. The refreshedInLastPosting property is set to TRUE if the instance implementation or type changed during the last update.

Additional Information

The Schema MessageImplementationDescriptor messages are described further in the document Schema Message Dictionary.

The Schema MessageDescriptor Class

This class is used to maintain information about the message names used in the database. It is primarily used for internal cross- referencing purposes and you should rarely need to access these values directly.

The Schema MessageDescriptor messages are described further in the document Schema Message Dictionary.

Maintaining Schema Information

Message implementation descriptors are not automatically generated for new messages. As a result, the Schema MID class will not contain up-to-date entries for messages defined or modified recently. To process and refresh all pending messages, execute the expression: 

    Schema processAllMessages
This process creates and refreshes message information as needed. Messages are normally updated as part of a a standard nightly production process.

Several messages are available for updating descriptive information about a class including:

  • setDescriptionTo: string
  • setSampleUsageTo: string
  • setHtmlDocNameTo: string
  • setClassTypeTo: string
  • setNamingDictionaryTo: dictionary

All of these messages return the current class descriptor and can therefore be streamed together. For example: 

    Currency classDescriptor
       setDescriptionTo:
       "Instances of the Class Currency represents different monetary units." .
       setSampleUsageTo: "Named Currency USD ;  "USD" asCurrency ; " .
       setHtmlDocNameTo: "clCurrency.htm" .
       ;

Several messages are available for updating descriptive information about a message including:

  • setDescriptionTo: string
  • setReturnObjectTypeTo: class
  • setReturnObjectContainerTo: class
  • setFunctionTypeTo: string
  • setLevelTo: string
  • setParameter: n typeTo: cd
  • setSelectorTo: string
  • setTypeTo: ClassType
  • flagAsKeyField
  • flagAsPartialKeyField
  • setDefaultValueTo: object
  • clearDefaultValue

All of these messages return the current message implementation descriptor and can therefore be streamed together. For example, to add descriptive information to the absoluteValue message defined at Number: 

    Number getMessage: "absoluteValue" .
       setDescriptionTo: "Returns the absolute value of the recipient" .
       setReturnObjectTypeTo: Number .
       setFunctionTypeTo: "Calc" .
       describe ;
producing: 
    Message:                 absoluteValue
    Class:                   Number
    Created:                 10/30/1992
    Updated:                 10/30/1992
    Function Type:           Calc
    Returns the absolute value of the recipient
    Returns:                 Number
    Implementation Type:     Method
    {|absoluteValue|
    ^self < 0 ifTrue: [^self negated]
    ifFalse: [^self]}

Using Schema Information

A number of messages have been defined at the class Object that interface with the Schema classes including:

Message Definition
getMessage: string Returns a Schema MID instance if string is defined as a message for recipient, NA otherwise.
deleteMessage: string Deletes the message if string is defined for the recipient class.
showInheritance Displays the inheritance hierarchy (parents and children) for the recipient.
inheritsFrom: class Returns TRUE if the recipient class inherits from the parameter class.
isSuperClassOf: class Returns TRUE if the recipient class is a super class of the parameter class.
subclassList Returns the list of classes that are subclasses of the recipient. The default instances of the actual classes are returned.
getMessages Returns a list of Schema MID instances that are the messages defined explicitly for the recipient class.
getMessagesX Returns a list of Schema MID instances that are the messages defined explicitly for the recipient class or any of its super classes.
getMessagesInInheritancePath Returns a list of Schema MID instances that are the messages defined explicitly for the recipient class or any of its super or sub classes.
getMessagesDefining: string Returns a list of Schema MID instances that explicitly define the message named by string for the recipient class or any of its super or sub classes.
getMessageNamesContaining: string Returns a list of Schema MID instances that define message names that contain string for the recipient class or any of its super or sub classes.
getMessagesUsing: string Returns a list of Schema MID instances that correspond to methods that contain string for the recipient class or any of its super or sub classes.
showMessages Displays the messages that are defined explicitly for the recipient class or any of its super classes.
showMessagesX Displays the messages defined explicitly for the recipient class or any of its super classes excluding messages at Object.
showProperties Displays the messages that are properties defined explicitly for the recipient class or any of its super classes.
showMessagesDefining: string Displays the messages that explicitly define the message named by string for the recipient class or any of its super or sub classes.
showMessageNamesContaining: string Displays the messages that define message names that contain string for the recipient class or any of its super or sub classes.
showMessagesUsing: string Displays the messages that correspond to methods that contain string for the recipient class or any of its super or sub classes.
showMethodsUsing: string Displays the method implementationis that contain string for the recipient class or any of its super or sub classes.

See Vision Messages: Access Techniques for samples that use these messages.

Two additional messages are defined at the Schema ClassDescriptor class which are useful for cross referencing the messages in your database. The message getMessagesReturningClass returns a list of Schema MID instances that return the recipient's class or a sub class of it. The message getMessagesReturningSuperClass returns a list of Schema MID instances that return a super class of the recipient's class.

The schema information can be used to answer a number of different questions. For example:

  1. Find all Constants and display message, class, and value: 
    Schema MessageImplementationDescriptor activeList
    select: [ type isConstant ] .
do: [ message print: 30 ;
      messageClassDescriptor print: 30 ;
      implementationSource printNL ;
] ;
  2. Get all messages defined for Integer and group by function: 
    Integer getMessagesX
    groupedBy: [ functionType ] .
    do: [ printNL ;
          groupList do: [ displayInfo ] ;
          newLine print ;
        ] ;
  3. Display all Entity messages that do not have a description: 
    Entity getMessages
   select: [ description isNA ] .
       do: [ displayInfo ] ;
  4. Display all methods that use the asDate message: 
    Object showMethodsUsing: "asDate" ;
  5. Display old versions of the 'absoluteValue' message: 
    Number getMessage: "absoluteValue" .
:implementationSource
do: [ "Implementation As Of: " print; ^date printNL ;
      printNL ;    # displays implementation
      "-" fill: 50 . printNL ;
    ] ;
  6. Show Messages by name, sorted by Message, then by Class within message: 
    "Message" print: 20 ;
"Class" print: 30 ;
"Type" print: 13 ;
"Function" printNL ;
Schema MessageImplementationDescriptor activeList
   sortUpBy: [ messageDescriptor message ]
       then: [ messageClassDescriptor ] .
   do: [ message print: 19 ; " " print ;
         messageClassDescriptor code print: 29 ; " " print ;
         type shortName print: 12 ; " " print ;
         functionType printNL ;
       ] ;
  7. Show Messages grouped by Function, sorted by Message and then by Class within Message: 
    "Message" print: 30 ;
"Class" print: 40 ;
"Type" printNL ;
Schema MessageImplementationDescriptor activeList
    groupedBy: [ functionType ] .
do: [ "===> Function Type: " print ; code printNL ;
      groupList
        sortUpBy: [ messageDescriptor message ]
            then: [ messageClassDescriptor ] .
        do: [ message print: 29 ; " " print ;
              messageClassDescriptor code print: 39 ; " " print ;
              type shortName printNL ;
            ] ;
      newLine print ;
    ] ;
  8. Show Messages by Class, excluding those at Object: 
    "Message" print: 50 ;
"Type" print: 13 ;
"Implemented At Class: " printNL ;
Schema ClassDescriptor activeList
do: [ "Extended Message Dictionary For Class: " print ;
      code printNL ;
      class getMessagesX
         select: [ messageClassDescriptor isObjectDescriptor not ] .
         do: [ message print: 49 ; " " print ;
               type shortName print: 12 ; " " print ;
               messageClassDescriptor name printNL ;
             ] ;
      newPage print ;
    ] ;

These examples can easily be modified to restrict the display to messages that have been updated since a known date using: 

Schema MessageImplementationDescriptor activeList
     select: [ updateDate >= ^today - 3 monthEnds ] .
        . . .

Database Navigation Tools

A sample kit of reports designed to work with HTML browsers, has been defined to display class and message information. These reports can be executed as part of a "live" Vision enviornment or can be pre-generated and stored on a server for static access.

For information describing the functionality and installation of this kit, see the document, The Vision Database Navigator Kit.

Installation

The Schema ToolKit has been a standard component of all databases bootstrapped since March 1994.

Adding Classes Created With specialized

Variations of the specialized message create subclasses without generating a corresponding ClassDescriptor instance. The message hasSchema can be sent to any object to determine if its class has a corresponding instance in the Schema ClassDescriptor class. Several messages have been provided with this tool kit that enable you to create a class descriptor for an existing class. To add a class, the following conditions must be true:

  • The class does not currently have a class descriptor.
  • The class' direct super class does have a class descriptor.

The expressions: 

    Schema addClass: class
and
    Schema addClass: class at: object
and
    Schema addClass: class as: id at: object
can be used to add a class descriptor for a class the does not have one. The parameter class refers to the class that needs a class descriptor. The id parameter is a string used to fill in the code property for the class descriptor. The 'whatAmI' of the class is used if the parameter is not supplied. The object parameter is used to fill in the defaultAccessPath property for the class descriptor. The path is defined relative to '^global' if this parameter is not supplied.

Related Topics