VMS Help  —  CDD_REPOSITORY
  Oracle CDD/Repository is an active, distributed repository system that
  allows users to organize, manage, control, and integrate tools and
  applications across an entire enterprise.

  A repository is a central location where elements can be defined,
  stored, and shared.  Elements correspond to various entities involved
  in a project.  These include data definitions, models, files, reports,
  databases, tools, and system configurations.  Oracle CDD/Repository
  allows you to manage these entities throughout the system life cycle
  and across multiple applications.

  Elements also correspond to structures that support an integrated
  computing environment.  These structures further configuration
  management, project management, system building, file management, and
  tool integrations.  Oracle CDD/Repository allows you to organize and
  manage the environment for maximum efficiency and reporting.

  Oracle CDD/Repository provides full access to the capabilities of
  previous versions of CDD/Plus and includes the following capabilities:

   o  Extensible object-oriented information model

      The information model is implemented as an element type hierarchy
      that specifies both the relationship of elements and their
      definitions.  You can extend the element type hierarchy to
      incorporate new schema information as needed.

   o  Project support

      Oracle CDD/Repository includes functionality that furthers
      configuration management, project management, system building, file
      management, and tool integration.

1  –  Compatibility with Previous Versions

  CDD/Repository supports information in two formats:

   o  Metadata manipulated with the Common Dictionary Operator (CDO)

      Oracle CDD/Repository continues to support dictionaries created by
      previous versions of CDD/Plus.  You can continue to work with these
      dictionaries without taking advantage of new features.  A CDO
      dictionary is created on your system when you install Oracle
      CDD/Repository.

   o  Metadata manipulated with the Dictionary Management Utility (DMU)

      CDD/Plus continues to support dictionaries created by older
      versions of the CDD and the utilities that manipulate those
      dictionary definitions---DMU, CDDL, and CDDV.

      If a DMU dictionary does not already exist on your system, Oracle
      CDD/Repository creates one during the installation procedure.  The
      installation also installs the compatibility repository, a special
      overlapping CDO dictionary that coordinates DMU format definitions
      and CDO format definitions.

      You manipulate DMU dictionary definitions through the DMU utility;
      however, you can also read DMU definitions through CDO.

  For the most part, the features of Oracle CDD/Repository do not affect
  dictionaries that were created by earlier versions of the CDD.  This
  means that you can continue to access established DMU dictionaries with
  products such as DATATRIEVE and ACMS.

  Oracle CDD/Repository provides the DMU, CDDL, and CDDV utilities in
  addition to the CDO utility so you can perform all your dictionary work
  as with previous releases of CDD.  In addition, Oracle CDD/Repository
  automatically translates definitions in existing dictionaries so that
  you can read them from the CDO interface.

  For more information on the features of DMU dictionaries, see the help
  topics "DMU", "CDDL", and "CDDV".

2  –  Environment Management Features

  Oracle CDD/Repository provides the following environment management
  capabilities:

   o  Configuration Management

      Configuration management is tailored to the needs of large groups
      working on complex development efforts.  It provides for multiple
      versions of system elements, multiple versions of system
      configurations, and variant lines of development.

   o  Project Management

      Project management allows you to switch between activities equated
      to project tasks, and to maintain the current state of each
      activity.

   o  User-Designed Approval Structures

      These structures allow you to promote system elements to higher
      levels (and wider visibility) as they become more stable or meet
      specified criteria.

   o  Automatic Minimal System Building

      The repository allows you to model system builds.  You can
      associate source and derived versions of files and represent
      process information.

   o  Built-in File Management

      Oracle CDD/Repository provides functions that you can use to
      automatically manage project files.

   o  Tool Integration

      Oracle CDD/Repository is designed to accommodate CASE
      (Computer-Aided Software Engineering) and other tools so they work
      together sharing information, activities, and procedures.

3  –  Information Management Features

  Oracle CDD/Repository provides the following information management
  capabilities:

   o  Common View of Information

      The repository provides a storage area for common elements and
      their behaviors (methods) that can be accessed and shared by
      multiple applications.  Use (and re-use) of common elements and
      methods saves development time.

   o  Consistency of Information

      When multiple applications use the same elements and methods,
      redundant information and conflicting definitions can be
      eliminated.  The repository includes a notification system that
      alerts you to changes made to related elements.  Pieces tracking
      capabilities allow you to locate all uses of a shared element.  You
      can also check the effects of a projected change before the change
      is made.

   o  Distribution of Information

      The repository provides one logical storage point for information
      which can be physically dispersed as appropriate to business needs
      or computing loads.

   o  Integrity and Security of Information

      The repository provides means by which you can grant or deny access
      to elements and to repositories.  It also provides journaling
      capabilities that automatically protect repository sessions from
      system failures.

   o  Comprehensive Information Model

      The Oracle CDD/Repository Information Model contains a base set of
      elements and methods that spans all phases of the software
      development process.  This allows you to model, manipulate, and
      control all aspects of product and process as development occurs.

   o  Structured Information Model

      The Information Model is implemented in the form of an
      object-oriented type hierarchy.  This form is designed to reduce
      the amount of information that must be explicitly stated in
      application code.

   o  Extensible Information Model

      Through the Oracle CDD/Repository Callable Interface, you can
      extend the information model to include additional elements and
      methods.  This functionality allows you to customize the
      information model to integrate new applications and tools or to
      address business-specific needs.

4  –  IVP

  The Oracle CDD/Repository Installation Verification Procedure (IVP)
  files are provided by the installation.  You can run the IVP after the
  installation is complete by entering the following command:

    $ @SYS$COMMON:[SYSTEST]CDD$IVP

5  –  Release Notes

  Release notes for Oracle CDD/Repository are contained in the files:

      SYS$HELP:CDDnnn.RELEASE_NOTES
      SYS$HELP:CDDnnn_RELEASE_NOTES.PS

  Where nnn represents the Oracle CDD/Repository version number.  For
  example, to see the Version 7.2 release notes, type or print the
  CDD072.RELEASE_NOTES file to read the release note information.

  To find what release note files are available, use the following DCL
  command:

       $ DIRECTORY SYS$HELP:*.RELEASE_NOTES

6  –  Upgrade Procedure

  The recommended method of upgrading existing dictionaries or
  repositories is to use the CDD$UPGRADE.COM command procedure.  The
  CDD$UPGRADE.COM command procedure automatically invokes the appropriate
  upgrade utility based on the version number you specify.  The procedure
  is provided with the Oracle CDD/Repository installation.

  If you are performing an upgrade from a Version 5.n repository to a
  later Version 5.n or higher repository, CDD$UPGRADE.COM runs the CDO
  CONVERT utility using the CDO CONVERT/REPOSITORY command.  This is
  referred to as a minor upgrade.

  In Version 5.0, the upgrade portion of the CONVERT command was
  disabled.  However, in Version 5.1 and later, CDO CONVERT/REPOSITORY
  can be used to perform a minor upgrade.

  If you are performing an upgrade from a Version 4.n dictionary, the
  CDD$UPGRADE.COM procedure runs CDDX, the repository translation
  utility, using the REPOSITORY EXPORT and REPOSITORY IMPORT commands.
  This type of upgrade is referred to as a major upgrade.

  Note:  DMU dictionaries do not require an upgrade.

  The CDD$UPGRADE.COM procedure and the REPOSITORY IMPORT and REPOSITORY
  EXPORT commands must be invoked from the DCL level.  See the CDDX help
  topic for information on the REPOSITORY IMPORT and REPOSITORY EXPORT
  commands.

  You invoke the CONVERT/REPOSITORY command from CDO.  See the
  description of the CDO CONVERT command in the CDO utility online help.

6.1  –  Preparing for Upgrade

  Before you upgrade a repository or use the REPOSITORY EXPORT command,
  check the following:

   o  Ensure that you have SYSPRV or BYPASS privilege

   o  Check the paging file quota (PGFLQUOTA)

      The .CDDX export file requires approximately one half the number of
      blocks used by the CDD$DATABASE.RDB file.

      The following table lists the PGFLQUOTA values required for the
      upgrade:

       CDD$DATABASE.RDB Size        Required PGFLQUOTA
      ---------------------------------------------------
            0-20,000 blocks        50,000-200,000 pages
       20,000-35,000 blocks        70,000-200,000 pages
       35,000-55,000 blocks       100,000-200,000 pages
       55,000 + blocks                    200,000 pages
      ---------------------------------------------------

   o  Verify the repository

   o  If you do not have an adequate backup of your repository, perform a
      backup operation.

      See the instructions in the Oracle CDD/Repository User's Guide for
      verifying and backing up a repository.

   o  If you issue the REPOSITORY EXPORT command directly from the DCL
      level, redefine the CDD$SEPARATOR as a slash character (/) if any
      repository elements contain a period (.) in the name.

   o  If you are installing Oracle CDD/Repository, check for the
      SYS$SHARE:CDA$ACCESS.EXE image, which is required by the upgrade
      images.

      Also, if you installing Oracle CDD/Repository and the process you
      are in was created before the installation, log out and log back in
      again before executing the CDD$UPGRADE.COM procedure (or run
      CDD$UPGRADE.COM from the installing account) to update DCL
      commands.

7  –  User Account Quotas

  To work with Oracle CDD/Repository, user accounts must have certain
  quotas.  The following are the minimum settings specific to the use of
  Oracle CDD/Repository:

    Account Quota                Value
  ---------------------------------------
     ASTLM                         24
     BIOLM                         80
     BYTLM                     25,000
     DIOLM                         40
     ENQLM                      2,000
     FILLM                        100
     PGFLQUO                   50,000
  ---------------------------------------

  Settings required by users on your system might differ substantially.
  If you plan to use other layered products, the quotas required for
  these products must be added to the value you choose for Oracle
  CDD/Repository.

  For information on adjusting user account quotas, see the Oracle
  CDD/Repository installation guide.

8  –  Glossary

  This glossary defines Oracle CDD/Repository terms.

8.1  –  1-to-1_relation

  One object relates to no more than one other object, which is not
  allowed to relate to other objects using that type of relation.

8.2  –  1-to-n_relation

  An organization of relationships in which one element is related to
  multiple elements, with each element pair connected through a single
  relationship.

  Same as 1-to-many relation.

8.3  –  Application Control Architecture (ACA) Services

  A set of software services that allows a developer to integrate
  software applications in a distributed heterogeneous computing
  environment.

8.4  –  approval_level

  The position in a partition hierarchy that a system object attains
  after an approval process.  At higher approval levels, the requirements
  are more stringent and the objects that reside there are more stable.

8.5  –  argument_list

  A list used to pass arguments to the Oracle CDD/Repository callable
  interface routines.

8.6  –  argument_specifier

  An entry in an argument list.  An argument specifier consists of an
  argument name, argument value structure, and status field.

  See also argument list, value structure.

8.7  –  ATIS

  A Tools Integration Standard; a proposed common interface for tool
  integration.

8.8  –  attachment_type

  A characteristic of an element that describes how a version of the
  element is attached to a collection.  An attachment type determines
  whether an element is updated from the latest replaced version in a
  partition or from the latest version in either your context or
  partition.  An attachment type of Current indicates that the current
  element should be used in the updated collection---not the latest
  version from either the context or partition.

8.9  –  attribute

  See property.

8.10  –  base_partition

  A partition to which your context is attached.  From the base
  partition, you can view all the elements in the partition, all the
  elements in its successive parent partitions, and all the elements in
  its related partitions.

  See also partition.

8.11  –  binary_relationship

  An organization of relationships in which one element is related to
  other elements.  The element cannot be part of other relationships of
  the same type, as in a 1-to-n relationship.

8.12  –  branch

  A sequence of versions forming a line of development distinct from
  other sequences of versions of the same component.  Each branch
  represents a parallel thread of development.  Branches can be merged
  back into the main development path.

  Same as branch line of descent.

8.13  –  branching

  The act of creating a branch.  Branching allows more than one
  programmer to work on a component at one time.

8.14  –  branch_merge

  A merge back into the line of descent from which the branch came and
  that does not require a content merge.  Also called a genealogy merge.

  See also content merge.

8.15  –  browser

  A utility that presents repository information graphically and lets you
  "move through the repository" by traversing links between elements.

8.16  –  check_in

  See replace.

8.17  –  check_out

  See reserve.

8.18  –  child_partition

  A partition from which a version of a component may be promoted.  There
  can be multiple child partitions to any partition.

  See also partition.

8.19  –  class

  In conventional object-oriented terminology, a template for objects.  A
  class is comparable to an Oracle CDD/Repository element type.

8.20  –  clone

  When an object is included in a remote repository, through having a
  directory name entered for it in another repository or through being a
  member of a grouping relationship in another repository, a copy of that
  object resides in the remote repository.  This copy is called a clone.

8.21  –  closure_property

  A property whose value is formed by traversing a relation recursively.

  See also relation property.

8.22  –  collection

  A set of versions taken from different components that implements a
  configuration.

8.23  –  collection_hierarchy

  A tree of collections that represents a system, subsystem,
  sub-subsystem, and so on.

8.24  –  component

  A set of branches.  Broadly, the main line of descent and any branches.
  Similar to a VAX DEC/Code Management System (CMS) element.

8.25  –  composite

  A set of versions taken from different components.  A composite is
  similar to, but more general than, a collection.

8.26  –  computed_property

  A property whose value is found or modified by invoking a method.

  See also normal property, relation property .

8.27  –  configuration

  Identifies the parts that make up a particular version of a system.
  For example, when a system passes a baselevel review, that version of
  the system is identified by a baseline.

8.28  –  configuration_control

  The mechanism by which a software component is promoted within a
  partition hierarchy based on its level of stability.

8.29  –  configuration_hierarchy

  A tree of configurations that represents a system, subsystems,
  sub-subsystems, and so on.

8.30  –  configuration_management

  Oracle CDD/Repository facilities for storing and manipulating
  information about configurations.

8.31  –  content_merge

  A merge in which the content of two versions has diverged and must be
  reconciled.

  See also branch merge.

8.32  –  context

  The work space in which you can modify elements.  A context is attached
  to the base partition you specify, so you can reserve elements from the
  base partition and its successive parent partitions.  A context
  provides a view into a project as represented by a repository.

  An element that represents views of the repository.  It identifies a
  collection that represents a configuration, the base partition, and the
  configuration subdirectory.

8.33  –  context_management

  Oracle CDD/Repository facilities for storing, manipulating, and using
  context information.

8.34  –  context_merge

  The act of merging two contexts to form a single context.

8.35  –  data_aggregate

  A collection of data elements describing a record, an Oracle Rdb
  relation, or structure field.

8.36  –  data_element

  A field in Oracle CDD/Repository.

8.37  –  dependency_graph_navigator

  A network navigator that starts with a given element and follows the
  dependents and dependencies properties in both directions.  The
  dependency graph navigator displays the complete dependency network for
  a system.  This is the default navigator when you specify the /GRAPH
  qualifier.

8.38  –  dependency_relationship

  A relationship in which the modification of a member results in the
  automatic notification of the owner(s).  You use dependency
  relationships when a change to the member means that the owner must
  also change.

8.39  –  derived_object

  A system object (typically an object file or an executable file) that
  is the result of applying a translation process to one or more source
  objects.  Given the same source objects and translation processor, you
  can reproduce derived objects as needed.

8.40  –  distribution

  The ability to distribute information among several physical
  repositories.

8.41  –  element

  An object in conventional object-oriented terminology.

  An entity in the repository that generally represents a system object
  (such as a source file), a tool (such as a compiler), or a data
  definition.

8.42  –  element_access_right

  A right to a particular type of access to a specific element.

8.43  –  element_editor

  A facility that lets you create an element or lets you show or modify
  the information about an element.

8.44  –  element ID

  See element identifier.

8.45  –  element_identifier

  A unique value assigned by the system so that your program can work
  with an instance of an element type.  Also called a handle.

8.46  –  element_instantiation_hierarchy

  The hierarchy formed by elements that are instances of their parents.

8.47  –  element_type

  A class in conventional object-oriented terminology.  The type of an
  element is defined by its properties and methods.

  An element that represents a group of objects that have common
  characteristics.

8.48  –  element_type_hierarchy

  The hierarchy formed by the ELEMENT element type and its subtypes.

8.49  –  entity-relationship_diagram

  A diagram that illustrates how specific relations relate elements of
  one type to elements of another (or the same) type.

8.50  –  error_stack

  A stack upon which Oracle CDD/Repository places detailed information
  about errors as they occur.

8.51  –  external_code_method

  A method that is implemented outside of Oracle CDD/Repository by
  loading it at run time.

8.52  –  external_program_method

  A method that is implemented in a program invoked in a separate
  process.

8.53  –  external_storage_file

  A file that is represented in the repository but that Oracle
  CDD/Repository does not manage.

8.54  –  freeze

  An operation that prevents reserving the last version on the line of
  descent.

8.55  –  genealogy_merge

  See branch merge.

8.56  –  ghost

  A reserved, modifiable version of a component.  The ghost version is
  visible only to the person who reserved it.

8.57  –  handle

  See element identifier.

8.58  –  hierarchy_navigator

  A tree-structured outline view of repository directories that lets you
  expand your view down to named repository elements.  You can expand
  named elements to show what they contain and the elements on which they
  depend.

8.59  –  illegal_function

  A method function that results in an error indicating that no method
  was specified.  An illegal function disallows a message on an element
  type.

8.60  –  immutable

  A versioned element that cannot be changed.

8.61  –  inherit

  To take on the attributes of a parent.  An element type inherits the
  properties and methods of its supertypes.

8.62  –  instance

  A specific object that implements the element type.

8.63  –  instance_hierarchy

  A hierarchy in which sublevels are instances of higher levels.

8.64  –  instance_list

  A list of instances of a specific element type.

8.65  –  instantiable

  A type for which you can create an instance.

8.66  –  integrated_tool

  A tool that communicates and cooperates with other tools.

8.67  –  internal_code_method

  Methods linked into the Oracle CDD/Repository image and invoked by a
  subroutine call.

8.68  –  internal_storage_file

  A file represented in a repository and actively managed by Oracle
  CDD/Repository.  For internal storage files, storage location is
  transparent to the user.

8.69  –  leaf_partition

  A partition that has no child partitions.

  See also partition .

8.70  –  line_of_descent

  A succession of versions in which each version results from modifying
  its predecessor in the line of descent.

  A single thread of development.

  See also main line of descent.

8.71  –  list

  An ordered sequence of value structures.

8.72  –  logical_object

  An object in the sense of a "part of the system" that may be a
  subdivision of an object represented by an element.

8.73  –  main_line_of_descent

  The line of descent made up of the versions that implement the root
  branch.

  The main thread of development.

  See also line of descent.

8.74  –  member

  A participant in a relationship.  A member of a relationship cannot be
  deleted unless the relationship is deleted first.

8.75  –  merge

  To reconcile the differences between versions in separate branches of a
  component.

8.76  –  message

  The means by which tools manipulate objects.  A message requests that
  an element perform some action, but it does not specify how to perform
  that action.  The element responds by invoking the appropriate method
  to carry out the request.

8.77  –  metadata_elements

  Elements that define the repository schema.

8.78  –  method

  The specific response of an element to a message.  Methods provide a
  customized response to messages in the sense that the method is
  specific to the element type that defines it.

8.79  –  method_function

  The function that implements a method, as opposed to the METHOD element
  that represents that behavior.

8.80  –  method_refinement

  The modification by an element type of its inherited methods to make
  them more specific to the needs of the objects represented by the type.

8.81  –  multiple-inheritance_system

  An object-oriented programming system in which each element type may
  inherit its characteristics from more than one supertype.

  See also single-inheritance system.

8.82  –  mutable

  The ability of a property to be changed even though the version it
  belongs to is replaced.

8.83  –  naming_model

  The Oracle CDD/Repository model that shows how element names are
  constructed and how they are resolved.

8.84  –  navigator

  A facility that lets you display hierarchies and graphs of elements and
  the relationships between them.

8.85  –  network_navigator

  A navigator that displays objects in graphical form.

8.86  –  normal_property

  A property for which values are stored directly in the repository.

  See also computed property, relation property.

8.87  –  notice

  An encoded report of the status of an element of Oracle CDD/Repository.
  When an element in the repository changes, Oracle CDD/Repository sends
  a message to related elements.  The message contains a warning
  indicating that a portion of the repository has recently changed and
  that the change may affect the element receiving the message.

8.88  –  n-to-m_relation

  An organization of relationships in which multiple elements are related
  to multiple elements, with each element pair connected through a single
  relationship.

8.89  –  null_function

  A method function that does nothing.  A null function serves as a
  placeholder for a preamble or postamble.

8.90  –  object

  See element.

8.91  –  object_model

  A way of representing elements in a repository.  An object model
  includes the concept of objects, methods, and properties.  It provides
  the base type hierarchy and methods necessary to define and manipulate
  objects.

  Any of the parts that make up a software system or participate in the
  process of developing software.  Examples are source files, data
  definitions, documents, people, software tools, and so on.

8.92  –  object-oriented_programming

  A programming discipline in which operations are carried out by sending
  general requests (called messages) to objects, which are responsible
  for executing the appropriate detailed procedures (called methods) to
  implement the messages.

8.93  –  owner

  A participant in a relationship.  When an owner is deleted, all the
  relationships that it owns also are deleted.

  The person who creates an element.

8.94  –  parent_partition

  A partition into which a version of a component in a child partition
  may be promoted.

  See also partition.

8.95  –  partition

  An element that groups version elements at a specified level of
  configuration control.

  A named division of the repository corresponding to an approval level.

  See also base partition, child partition, leaf partition, parent
  partition, partition, root partition.

8.96  –  partition_control

  A system by which components are made visible to a wider group of
  users.

8.97  –  partition_hierarchy_navigator

  A hierarchy navigator that starts with the currently selected element
  type and graphs elements that satisfy the forward property
  childPartition and backward properties parentPartition and
  basePartition.

8.98  –  partition_list

  An ordered list of partitions.  You can see a version contained in a
  partition only if the partition is part of your partition list.

8.99  –  persistent_process

  An element that records the state of your work on a task by identifying
  a configuration as well as preserving current operating system
  information.

8.100  –  postamble

  Code that is executed after a method has been completed but before the
  method returns control to the client.  Postamble is one way to
  customize a method.  See also preamble.

8.101  –  preamble

  Code that is executed before a method is invoked.  Preamble is one way
  to customize a method.  See also postamble.

8.102  –  processing_name

  The name of an object in the Oracle CDD/Repository system.  In most
  cases, the processing name is the same as the given name of the object.

8.103  –  promote

  To move an object to the next-higher partition.

8.104  –  property

  A named value associated with an element.  A property provides
  information about the element or relates the element to one or more
  other elements.  It also differentiates an element from other elements
  of the same type.  An example of a property is the name of an element.

  In object-oriented terminology, property is the same as attribute.

8.105  –  register

  To make a tool known to the repository.

8.106  –  related_partition

  A partition that is linked to a partition in another partition
  hierarchy without being its parent, thus making the components in the
  related partition visible in the partition to which it is linked.

  See also partition.

8.107  –  relation

  Defines characteristics of a particular type of relationship between
  elements, such as the types of elements that can be owners and members
  of the relationship.

8.108  –  relation_property

  A property that is implemented by relationships.  The value of the
  property is the result of traversing the relationship in a specified
  fashion.

  See also closure property, computed property, normal property .

8.109  –  relationship

  A specific relation that links two elements together in such a way that
  if you know one, you can find the other.

8.110  –  relationship ID

  The element identifier of a relationship.

8.111  –  replace

  To place a reserved version of a component back into the partition
  hierarchy.  This causes the version to be read-only and visible in the
  current context's base partition.

  To make a previously reserved version public and immutable.  Also known
  as checking in.

  See also reserve.

8.112  –  repository

  An expanded dictionary model that contains data as well as metadata.
  The repository contains configuration information and lets you create
  and delete files.

8.113  –  repository_contents_navigator

  A hierarchy navigator that starts with a given element (or CDD$DEFAULT)
  and follows the hasChildren property of elements.  The repository
  contents navigator displays the contents of composite objects.  It is
  the default navigator.

8.114  –  reserve

  To create a new, private, writable version of a component by copying an
  existing public, immutable version of a component into your context.
  Also known as checking out.

  See also replace.

8.115  –  root_partition

  A partition that has no parent partition.  The root partition
  represents the highest level of configuration control in a partition
  hierarchy.

  See also partition.

8.116  –  scan

  An unordered list of element identifiers.

8.117  –  scope

  User access to specific elements in a repository.

8.118  –  single-inheritance_system

  An object-oriented programming system in which each element type
  inherits its characteristics from only one supertype.

  See also multiple-inheritance system.

8.119  –  source_object

  A system object you can create and from which you can make derived
  objects.

8.120  –  subtype

  An element type that inherits properties and methods from another
  element type a parent type or supertype.

8.121  –  superop

  The method that implements a given message for an element type's
  supertype.

8.122  –  superop_function

  A method function that invokes the method defined for an element type's
  supertype.

8.123  –  supertype

  The element type from which another element type inherits properties,
  methods, and messages.

8.124  –  surrogate

  An element that represents a system object without containing any of
  that object's data.

8.125  –  tool

  An application that performs or helps perform a software development
  task.

8.126  –  traverse

  To access a specified part of a relationship and gather information
  about the relationship.

8.127  –  type_hierarchy

  The definition of the element types, their properties, the messages
  that can be sent to them, and the methods that respond to those
  messages.

8.128  –  type_hierarchy_navigator

  A hierarchy navigator that starts with the ELEMENT element type and
  follows the subTypes property.  The type hierarchy navigator displays
  the type hierarchy as implemented in Oracle CDD/Repository.

8.129  –  type_list_navigator

  A hierarchy navigator that starts with the ELEMENT_TYPE element type
  and follows the instances property.  The type list navigator displays
  instances of types.

8.130  –  type_refinement

  The process by which a subtype is made more specialized than its
  supertype.

8.131  –  type_registration

  The process of defining new element types.

8.132  –  uninstantiable

  An element for which you cannot create instances.

8.133  –  unreserve

  To cancel a previous reserve operation on a version, discarding any
  changes that might have been made on the reserved version.

8.134  –  value_structure

  A data structure that identifies a data item's type and value or
  pointer to its value.

8.135  –  variant

  Alternate development occurring concurrently with main-line
  development.

8.136  –  variant_branch

  A branch consisting of elements that implement an alternate to the main
  line of descent.

8.137  –  version

  An element that records the state of a component at a specific time.
  Each version reflects the changes that were made at that particular
  point in development.

8.138  –  version_graph_navigator

  A network navigator that starts with the given element and follows the
  nextVersion and prevVersion properties in both directions.  The version
  graph navigator displays all versions of the given element and their
  interconnections.

8.139  –  version_management

  Controls how versions are manipulated in the repository.
Close Help