Component Model

Introduction

Built upon Niagara's object model is the component model. Components are a special class of BObjects used to assemble applications using graphical programming tools.

Slots

Niagara components are defined as a collection of Slots. There are three types of slots:

The Java interfaces used to model slots in the Niagara framework are:

javax.baja.sys.Slot
   |
   +- javax.baja.sys.Property
   |
   +- javax.baja.sys.Action
   |
   +- javax.baja.sys.Topic

Every slot is identified by a String name which is unique within its Type. Slot names must contain ASCII letters or numbers. Other characters may be escaped using "$xx" or "$uxxxx". Refer to SlotPath for the formal grammar of slot names and utilities for escaping and unescaping.

Slots also contain a 32-bit mask of flags which provide additional meta-data about the slot. These flag constants are defined in the javax.baja.sys.Flags class. Additional meta-data which is not predefined by a flag constant may be specified using BFacets which support arbitrary name/value pairs

Slots are either frozen or dynamic. A frozen slot is defined at compile time within a Type's Java class. Frozen slots are consistent across all instances of a specified Type. Dynamic slots may be added, removed, renamed, and reordered during runtime. The power of the Niagara Framework is in providing a consistent model for both compile time slots and runtime slots. Frozen and dynamic slots are discussed in detail in Building Complexes.

BValue

All values of Property slots are instances of javax.baja.sys.BValue. The BValue class hierarchy is:

javax.baja.sys.BObject
   |
   +- javax.baja.sys.BValue
      |
      +- javax.baja.sys.BSimple
      |
      +- javax.baja.sys.BComplex
        |
        +- javax.baja.sys.BStruct
        |
        +- javax.baja.sys.BComponent

BSimples are atomic Types in the Niagara Framework, they never contain any slots themselves. The BComplex class is used to built Types which are composed of slots. Every BComplex can be recursively broken down into its primitive BSimples.

Building BValues

To define new BValues types refer to the following for rules and design patterns: