com.hazelcast.org.apache.calcite.util.Glossary Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to you under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hazelcast.org.apache.calcite.util;
import com.hazelcast.org.checkerframework.checker.nullness.qual.Nullable;
/**
* A collection of terms.
*
* (This is not a real class. It is here so that terms which do not map to
* classes can be referenced in Javadoc.)
*/
public interface Glossary {
//~ Static fields/initializers ---------------------------------------------
// CHECKSTYLE: OFF
/**
* This table shows how and where the Gang of Four patterns are applied.
* The table uses information from the GoF book and from a course on
* advanced object design taught by Craig Larman.
*
* The patterns are in three groups depicting frequency of use. The
* patterns in light green are used
* frequently. Those in yellow have
* moderate use. Patterns in red are
* infrequently used. The GoF column gives the original Gang Of Four
* category for the pattern. The Problem and Pattern columns are from
* Craig's refinement of the type of problems they apply to and a refinement
* of the original three pattern categories.
*
*
*
*
* Gang of Four Patterns
*
*
*
*
* Pattern Name
* GOF Category
* Problem
* Pattern
* Often Uses
* Related To
*
*
*
*
* Abstract Factory
*
* Creational
* Creating Instances
* Class/Interface Definition plus Inheritance
* Factory Method
* Prototype
* Singleton with
* Facade
* Factory Method
* Prototype
* Singleton
*
*
*
* Object Adapter
*
* Structural
* Interface
* Wrap One
* -
* Bridge
* Decorator
* Proxy
*
*
* Command
* Behavioral
* Organization or Communication of Work
* Action/Response
* Behavior Objects
* Composite
* Composite
* Memento
* Prototype
*
*
* Composite
* Structural
* Structural Decomposition of Objects or Subsystems
* Wrap Many
* -
* Decorator
* Iterator
* Visitor
*
*
* Decorator
* Structural
* Instance Behavior
* Wrap One
* -
* Object Adapter
* Composite
* Strategy
*
*
* Facade
* Structural
* Access Control
*
*
* Structural Decomposition of Objects or Subsystems
* Wrap Many
* Singleton with Abstract Factory
* Abstract Factory
* Mediator
*
*
* Flyweight
* Structural
* Shared Resource Handling
* Object State or Values
* -
* Singleton
* State
* Strategy
* Shareable
*
*
* Iterator
* Behavioral
* Traversal Algorithm
*
*
* Access Control
* Low Coupling
* -
* Composite
* Factory Method
* Memento
*
*
* Observer
* Behavioral
* Event Response
*
*
* Organization or Communication of Work
* Low Coupling
* -
* Mediator
* Singleton
*
*
* Proxy
* Structural
* Access Control
* Wrap One
* -
* Adapter
* Decorator
*
*
* Singleton
* Creational
* Access Control
* Other
* -
* Abstract Factory
* Builder
* Prototype
*
*
* State
* Behavioral
* Instance Behavior
* Object State or Values
* Flyweight
* Flyweight
* Singleton
*
*
* Strategy
* Behavioral
* Single Algorithm
* Behavior Objects
* -
* Flyweight
* State
* Template Method
*
*
* Template Method
*
* Behavioral
* Single Algorithm
* Class or Interface Definition plus Inheritance
* -
* Strategy
*
*
*
* Class Adapter
*
* Structural
* Interface
* Class or Interface Definition plus Inheritance
* -
* Bridge
* Decorator
* Proxy
*
*
* Bridge
* Structural
* Implementation
* Wrap One
* -
* Abstract Factory
* Class Adaptor
*
*
* Builder
* Creational
* Creating Structures
* Class or Interface Definition plus Inheritance
* -
* Abstract Factory
* Composite
*
*
* Chain of
* Responsibility
* Behavioral
* Single Algorithm
*
*
* Organization or Communication of Work
* Low Coupling
* -
* Composite
*
*
* Factory Method
*
* Creational
* Creating Instances
* Class or Interface Definition plus Inheritance
* Template Method
* Abstract Factory
* Template Method
* Prototype
*
*
* Mediator
* Behavioral
* Interaction between Objects
*
*
* Organization or Communication of Work
* Low Coupling
* -
* Facade
* Observer
*
*
* Prototype
* Creational
* Creating Instances
* Other
* -
* Prototype
* Composite
* Decorator
*
*
* Visitor
* Behavioral
* Single Algorithm
* Behavior Objects
* -
* Composite
* Visitor
*
*
*
*
* Interpreter
* Behavioral
* Organization or Communication of Work
* Other
* -
* Composite
* Flyweight
* Iterator
* Visitor
*
*
*
* Memento
* Behavioral
* Instance Management
* Object State or Values
* -
* Command
* Iterator
*
*
*/
// CHECKSTYLE: ON
@Nullable Glossary PATTERN = null;
/**
* Provide an interface for creating families of related or dependent
* objects without specifying their concrete classes. (See GoF.)
*/
@Nullable Glossary ABSTRACT_FACTORY_PATTERN = null;
/**
* Separate the construction of a complex object from its representation so
* that the same construction process can create different representations.
* (See GoF.)
*/
@Nullable Glossary BUILDER_PATTERN = null;
/**
* Define an interface for creating an object, but let subclasses decide
* which class to instantiate. Lets a class defer instantiation to
* subclasses. (See
* GoF.)
*/
@Nullable Glossary FACTORY_METHOD_PATTERN = null;
/**
* Specify the kinds of objects to create using a prototypical instance, and
* create new objects by copying this prototype. (See GoF.)
*/
@Nullable Glossary PROTOTYPE_PATTERN = null;
/**
* Ensure a class only has one instance, and provide a global point of
* access to it. (See
* GoF.)
*
* Note that a common way of implementing a singleton, the so-called
* double-checked locking pattern, is fatally flawed in Java. Don't use
* it!
*/
@Nullable Glossary SINGLETON_PATTERN = null;
/**
* Convert the interface of a class into another interface clients expect.
* Lets classes work together that couldn't otherwise because of
* incompatible interfaces. (See GoF.)
*/
@Nullable Glossary ADAPTER_PATTERN = null;
/**
* Decouple an abstraction from its implementation so that the two can very
* independently. (See
* GoF.)
*/
@Nullable Glossary BRIDGE_PATTERN = null;
/**
* Compose objects into tree structures to represent part-whole hierarchies.
* Lets clients treat individual objects and compositions of objects
* uniformly. (See
* GoF.)
*/
@Nullable Glossary COMPOSITE_PATTERN = null;
/**
* Attach additional responsibilities to an object dynamically. Provides a
* flexible alternative to subclassing for extending functionality. (See GoF.)
*/
@Nullable Glossary DECORATOR_PATTERN = null;
/**
* Provide a unified interface to a set of interfaces in a subsystem.
* Defines a higher-level interface that makes the subsystem easier to use.
* (See GoF.)
*/
@Nullable Glossary FACADE_PATTERN = null;
/**
* Use sharing to support large numbers of fine-grained objects efficiently.
* (See GoF.)
*/
@Nullable Glossary FLYWEIGHT_PATTERN = null;
/**
* Provide a surrogate or placeholder for another object to control access
* to it. (See GoF.)
*/
@Nullable Glossary PROXY_PATTERN = null;
/**
* Avoid coupling the sender of a request to its receiver by giving more
* than one object a chance to handle the request. Chain the receiving
* objects and pass the request along the chain until an object handles it.
* (See
* GoF.)
*/
@Nullable Glossary CHAIN_OF_RESPONSIBILITY_PATTERN = null;
/**
* Encapsulate a request as an object, thereby letting you parameterize
* clients with different requests, queue or log requests, and support
* undoable operations. (See GoF.)
*/
@Nullable Glossary COMMAND_PATTERN = null;
/**
* Given a language, define a representation for its grammar along with an
* interpreter that uses the representation to interpret sentences in the
* language. (See
* GoF.)
*/
@Nullable Glossary INTERPRETER_PATTERN = null;
/**
* Provide a way to access the elements of an aggregate object sequentially
* without exposing its underlying representation. (See GoF.)
*/
@Nullable Glossary ITERATOR_PATTERN = null;
/**
* Define an object that encapsulates how a set of objects interact.
* Promotes loose coupling by keeping objects from referring to each other
* explicitly, and it lets you vary their interaction independently. (See GoF.)
*/
@Nullable Glossary MEDIATOR_PATTERN = null;
/**
* Without violating encapsulation, capture and externalize an objects's
* internal state so that the object can be restored to this state later.
* (See GoF.)
*/
@Nullable Glossary MEMENTO_PATTERN = null;
/**
* Define a one-to-many dependency between objects so that when one object
* changes state, all its dependents are notified and updated automatically.
* (See GoF.)
*/
@Nullable Glossary OBSERVER_PATTERN = null;
/**
* Allow an object to alter its behavior when its internal state changes.
* The object will appear to change its class. (See GoF.)
*/
@Nullable Glossary STATE_PATTERN = null;
/**
* Define a family of algorithms, encapsulate each one, and make them
* interchangeable. Lets the algorithm vary independently from clients that
* use it. (See GoF.)
*/
@Nullable Glossary STRATEGY_PATTERN = null;
/**
* Define the skeleton of an algorithm in an operation, deferring some steps
* to subclasses. Lets subclasses redefine certain steps of an algorithm
* without changing the algorithm's structure. (See GoF.)
*/
@Nullable Glossary TEMPLATE_METHOD_PATTERN = null;
/**
* Represent an operation to be performed on the elements of an object
* structure. Lets you define a new operation without changing the classes
* of the elements on which it operates. (See GoF.)
*/
@Nullable Glossary VISITOR_PATTERN = null;
/**
* The official SQL-92 standard (ISO/IEC 9075:1992). To reference this
* standard from methods that implement its rules, use the @sql.92
* custom block tag in Javadoc comments; for the tag body, use the format
* <SectionId> [ ItemType <ItemId> ], where
*
*
* SectionId is the numbered or named section in the table
* of contents, e.g. "Section 4.18.9" or "Annex A"
* ItemType is one of { Table, Syntax Rule, Access Rule,
* General Rule, or Leveling Rule }
* ItemId is a dotted path expression to the specific item
*
*
* For example,
*
*
@sql.92 Section 11.4 Syntax Rule 7.c
*
*
* is a well-formed reference to the rule for the default character set to
* use for column definitions of character type.
*
*
Note that this tag is a block tag (like @see) and cannot be used
* inline.
*/
@Nullable Glossary SQL92 = null;
/**
* The official SQL:1999 standard (ISO/IEC 9075:1999), which is broken up
* into five parts. To reference this standard from methods that implement
* its rules, use the @sql.99 custom block tag in Javadoc comments; for
* the tag body, use the format <PartId> <SectionId> [
* ItemType <ItemId> ], where
*
*
* PartId is the numbered part (up to Part 5)
* SectionId is the numbered or named section in the part's
* table of contents, e.g. "Section 4.18.9" or "Annex A"
* ItemType is one of { Table, Syntax Rule, Access Rule,
* General Rule, or Conformance Rule }
* ItemId is a dotted path expression to the specific item
*
*
* For example,
*
*
@sql.99 Part 2 Section 11.4 Syntax Rule 7.b
*
*
* is a well-formed reference to the rule for the default character set to
* use for column definitions of character type.
*
*
Note that this tag is a block tag (like @see) and cannot be used
* inline.
*/
@Nullable Glossary SQL99 = null;
/**
* The official SQL:2003 standard (ISO/IEC 9075:2003), which is broken up
* into numerous parts. To reference this standard from methods that
* implement its rules, use the @sql.2003 custom block tag in Javadoc
* comments; for the tag body, use the format <PartId>
* <SectionId> [ ItemType <ItemId> ], where
*
*
* PartId is the numbered part
* SectionId is the numbered or named section in the part's
* table of contents, e.g. "Section 4.11.2" or "Annex A"
* ItemType is one of { Table, Syntax Rule, Access Rule,
* General Rule, or Conformance Rule }
* ItemId is a dotted path expression to the specific item
*
*
* For example,
*
*
@sql.2003 Part 2 Section 11.4 Syntax Rule 10.b
*
*
* is a well-formed reference to the rule for the default character set to
* use for column definitions of character type.
*
*
Note that this tag is a block tag (like @see) and cannot be used
* inline.
*/
@Nullable Glossary SQL2003 = null;
}