```
public interface ModelRoot
```
Represents a logically connected group of models that come from a related physical origin, such as a file or a directory. For implementation consider extending jetbrains.mps.extapi.persistence.ModelRootBase, jetbrains.mps.extapi.persistence.FolderModelRootBase or jetbrains.mps.extapi.persistence.FileBasedModelRoot. The model root MPS workflow is as follows: 1. ModelRoot is constructed; 2. The method load(Memento) is called to fill the ModelRoot with data. Note that any model root must be attached to a module during construction

See Also:

getModule()

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method	Description
`boolean`	`canCreateModel(String modelName)`	Deprecated. we have a `DataSourceFactory#create` + `ModelFactory.create(DataSource, SModelName, ModelLoadingOption...)` to create a new model (from a new data source) having just a model name and a model root.
`boolean`	`canCreateModels()`	Deprecated. use specific #canCreateModel(SModelName)
`SModel`	`createModel(String modelName)`	Creates a new model with the given name.
`SModel`	`getModel(SModelId id)`
`Iterable<SModel>`	`getModels()`
`SModule`	`getModule()`	The owning module which must be present as well.
`String`	`getPresentation()`	A textual representation of the model root TODO what is the difference with the `Object.toString()`?? TODO very ambiguous in API: is it to be used in UI? somewhere else? TODO one needs to clarify or replace it with a prosy #getName
`String`	`getType()`	A customizable categorization identifier, such as JavaStubs
`void`	`load(Memento memento)`	Allows the model root to read its previously saved configuration information
`void`	`save(Memento memento)`	Gives the model root the opportunity to persist into the supplied memento whatever configuration information may be needed to restore the models in the future.

- Method Detail
  - getType
```
String getType()
```
    A customizable categorization identifier, such as JavaStubs
  - getPresentation
```
String getPresentation()
```
    A textual representation of the model root TODO what is the difference with the Object.toString()?? TODO very ambiguous in API: is it to be used in UI? somewhere else? TODO one needs to clarify or replace it with a prosy #getName
  - getModule
```
SModule getModule()
```
    The owning module which must be present as well. The module must be fixed for a model root and passed via constructor (TODO) obviously the returned module is the one which has this model root among its SModule.getModelRoots()
  - getModel
```
@Nullable
SModel getModel(@NotNull
                SModelId id)
```
    Returns:
    
    the model with a given id one-to-one relation is assumed
  - getModels
```
@NotNull
Iterable<SModel> getModels()
```
    Returns:
    
    a sequence of the models under this model root. Implementors must impose some order on the returned result, such that two consequent invocations of this method return equal results. Note that owning module also returns all the models (module is believed to be a model container) SModule.getModels(), however it might contain the models which are not attached to the model roots as well (!)
  - canCreateModels
```
@Deprecated
boolean canCreateModels()
```
    Deprecated.
    use specific #canCreateModel(SModelName)
    
    There are model roots which are read-only and fix the result of getModels() right away from the construction FIXME it is strange to have two similar methods: we are better to merge this method into the method canCreateModel(java.lang.String).
    
    Returns:
    
    whether this model root is read-only in the way described above
  - canCreateModel
```
boolean canCreateModel(@NotNull
                       String modelName)
```
    Deprecated.
    we have a DataSourceFactory#create + ModelFactory.create(DataSource, SModelName, ModelLoadingOption...) to create a new model (from a new data source) having just a model name and a model root. this method gives out an insufficient API -- it kind of implies that a model root has the only way to create a model given a name, however obviously it is not true in a current MPS setup. Semantics of this method (as for 3.5) is to create a new model via default DataSourceFactory and default ModelFactory. Not sure if it makes sense at all shaped like this. The signature needs to be extended with a ModelFactory parameter. The same applies to the #createModel as well. [AP]
    
    Parameters:
    
    modelName - -- the same as in the createModel(String)
    
    Returns:
    
    whether a model with a name modelName can be created under this model root.
  - createModel
```
@Nullable
SModel createModel(@NotNull
                   String modelName)
```
    Creates a new model with the given name. The new model will be contained in this model root (methods #getModel, #getModels).
    
    Parameters:
    
    modelName - -- might fq name or just simple short model name. Up to implementor
    
    See Also:
    
    // * @deprecated // * @return null if failed, for instance returned false.
  - save
```
void save(@NotNull
          Memento memento)
```
    Gives the model root the opportunity to persist into the supplied memento whatever configuration information may be needed to restore the models in the future.
  - load
```
void load(@NotNull
          Memento memento)
```
    Allows the model root to read its previously saved configuration information

Interface ModelRoot

Method Summary

Method Detail

getType

getPresentation

getModule

getModel

getModels

canCreateModels

canCreateModel

createModel

save

load