Assembler (Apache Jena)

All Known Implementing Classes:

AssemblerBase, AssemblerGroup, AssemblerGroup.ExpandingAssemblerGroup, ContentAssembler, DefaultModelAssembler, DocumentManagerAssembler, FileManagerAssembler, InfModelAssembler, LocationMapperAssembler, MemoryModelAssembler, ModelAssembler, ModelSourceAssembler, NamedModelAssembler, OntModelAssembler, OntModelSpecAssembler, PrefixMappingAssembler, ReasonerFactoryAssembler, RuleSetAssembler, UnionModelAssembler
```
public interface Assembler
```
An Assembler creates objects from their RDF descriptions. The root motivation is to create Models, but other objects are required as sub-components of those Models, so a general mechanism is available.

API Note:

Methods accepting Model as a parameter treat appropriate values of Model as passing down to sub-assemblers a requirement to share for certain setups that work as tightly coordinated groups. It's a hint, not an instruction.

Field Summary

Fields
Modifier and Type	Field	Description
`static Assembler`	`content`
`static Assembler`	`defaultModel`
`static Assembler`	`documentManager`
`static Assembler`	`fileManager`
`static AssemblerGroup`	`general`
`static Assembler`	`infModel`
`static Assembler`	`locationMapper`
`static Assembler`	`memoryModel`
`static Assembler`	`modelSource`
`static Assembler`	`ontModel`
`static Assembler`	`ontModelSpec`
`static Assembler`	`prefixMapping`
`static Assembler`	`reasonerFactory`
`static Assembler`	`ruleSet`
`static Assembler`	`unionModel`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`java.lang.Object`	`open(Assembler a, Resource root)`	Answer `open( a, root, Mode.DEFAULT )`.
`java.lang.Object`	`open(Assembler a, Resource root, Mode mode)`	The core operation: answer a new object constructed according to the object description hanging from `root`, using the assembler `a` for any sub-objects.
`java.lang.Object`	`open(Resource root)`	Answer `open( this, root, Mode.DEFAULT )`.
`Model`	`openModel(Resource root)`	Answer `(Model) open( this, root, Mode.DEFAULT )`, unless the result cannot be or is not a Model, in which case throw an exception.
`Model`	`openModel(Resource root, Mode mode)`	Answer `(Model) open( this, root, mode )`, unless the result cannot be or is not a Model, in which case throw an exception.

Field Detail

defaultModel
```
static final Assembler defaultModel
```

memoryModel
```
static final Assembler memoryModel
```

infModel
```
static final Assembler infModel
```

ontModel
```
static final Assembler ontModel
```

reasonerFactory
```
static final Assembler reasonerFactory
```

content
```
static final Assembler content
```

prefixMapping
```
static final Assembler prefixMapping
```

unionModel
```
static final Assembler unionModel
```

ontModelSpec
```
static final Assembler ontModelSpec
```

ruleSet
```
static final Assembler ruleSet
```

modelSource
```
static final Assembler modelSource
```

locationMapper
```
static final Assembler locationMapper
```

fileManager
```
static final Assembler fileManager
```

documentManager
```
static final Assembler documentManager
```

general
```
static final AssemblerGroup general
```

Method Detail
- open
```
java.lang.Object open(Assembler a,
                      Resource root,
                      Mode mode)
```
  The core operation: answer a new object constructed according to the object description hanging from root, using the assembler a for any sub-objects. Use mode to decide if persistent objects are to be re-used or created; this mode is passed down to all sub-object construction.
- open
```
java.lang.Object open(Assembler a,
                      Resource root)
```
  Answer open( a, root, Mode.DEFAULT ).
- open
```
java.lang.Object open(Resource root)
```
  Answer open( this, root, Mode.DEFAULT ).
- openModel
```
Model openModel(Resource root)
```
  Answer (Model) open( this, root, Mode.DEFAULT ), unless the result cannot be or is not a Model, in which case throw an exception.
- openModel
```
Model openModel(Resource root,
                Mode mode)
```
  Answer (Model) open( this, root, mode ), unless the result cannot be or is not a Model, in which case throw an exception.