Defines whether objects in other Modules can access the object.
This property is available at the Module and Object level. Setting a value at the Module level changes the default value for all objects in the Module.
| Public |
Any object in any module can access a public object. In addition, when packaging modules to be distributed, this value indicates that the object will be part of the interface and accessible in other KBs. |
| Knowledge Base |
Any object in any module inside the same Knowledge Base can access an object with this visibility. However, an object with this visibility cannot be packaged to be distributed. |
| Private |
Only objects in the same module (and its child modules) can access private objects. An object with this visibility cannot be packaged to be distributed. |
| Internal |
Only objects with a common root module (children of the 'Root Module') can access internal objects. An object with this visibility cannot be packaged to be distributed. |
When designing a Module object, one goal is to define how it is going to be used (that is, how other modules can interact with the one that is being defined). Some Module Objects may be accessed elsewhere in the Knowledge Base and some may not.
It is also important to define which modules and objects can be distributed or not when packaging modules (whether they will be part of the interface and accessible in other KBs).
By setting the appropriate value for the Object Visibility property you can define all these aspects.
- The Root module visibility property (available at Version level) initializes the Object Visibility property of every Module and every Object in the KB (unless they have a value explicitly set in advance).
- If you modify the value of the Object Visibility property of a Module, all the objects included in it will inherit the same value in their Object Visibility property. In any case, the child objects get the same value as the parent object.
Sample
Root Module
|-- ProcRoot
|-- ModuleA
|-- |-- ProcA
|-- |-- ModuleA1
|-- | |-- ProcA1 //Public
|-- | |-- ModuleA11
|-- | |-- ProcA11_Internal //Internal
|-- | |-- ProcA11_Private // Private
|-- |-- ModuleA2
|-- |-- ProcA2
In this example:
- ProcRoot can call ProcA1. It cannot call ProcA11_Internal and ProcA11_Private.
- ProcA, ProcA1 and ProcA2 can call ProcA11_Internal. They cannot call ProcA11_Private.
- ProcA11_Internal can call ProcA11_Private.
- When packaging ModuleA1, only ProcA1 is part of its interface.
When an object's visibility is changed, all the objects that have references to it are automatically specified by the next Build operation. They may not need to be generated.
Modules
Modules vs. Folders
Modules - Dynamic calls