### Work with Modules and Module Types (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

Provides examples of accessing and analyzing modules from metadata objects. It shows how to retrieve all modules, get their types and properties, find module types by URI, identify module owners, and locate common modules by name. Requires a loaded Configuration object.

```java
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import com.github._1c_syntax.bsl.mdo.Module;
import com.github._1c_syntax.bsl.types.ModuleType;
import java.net.URI;
import java.util.Map;

Configuration configuration = getConfiguration();

// Get all modules from configuration
configuration.getAllModules().forEach(module -> {
    System.out.println("Module URI: " + module.getUri());
    System.out.println("Module type: " + module.getModuleType());
    System.out.println("Is support module: " + module.isSupportVariant());
});

// Get module type by URI
Map<URI, ModuleType> modulesByType = configuration.getModulesByType();
URI moduleUri = URI.create("file:///src/CommonModules/Global/Module.bsl");
ModuleType type = modulesByType.get(moduleUri);
System.out.println("Module type: " + type);

// Get module owner by URI
configuration.findChild(moduleUri).ifPresent(owner -> {
    System.out.println("Module owner: " + owner.getName());
    System.out.println("Owner type: " + owner.getMdoType());
});

// Find common module by name
configuration.findCommonModule("Global").ifPresent(module -> {
    System.out.println("Found module: " + module.getName());
    System.out.println("Description: " + module.getDescription());
});
```

--------------------------------

### Creating an Empty Configuration Instance (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

This Java code snippet shows how to create an empty 1C:Enterprise configuration object using the MDClasses library. It demonstrates initializing an empty configuration and checking its properties, such as name, UUID, and the count of common modules. This is useful for testing or initial setup scenarios.

```java
import com.github._1c_syntax.bsl.mdclasses.MDClasses;
import com.github._1c_syntax.bsl.mdclasses.Configuration;

// Create empty configuration
Configuration emptyConfig = (Configuration) MDClasses.createConfiguration();

// Check if configuration is empty
if (emptyConfig.isEmpty()) {
    System.out.println("Configuration is empty");
}

System.out.println("Name: " + emptyConfig.getName()); // "empty"
System.out.println("UUID: " + emptyConfig.getUuid()); // "empty"
System.out.println("Common modules: " + emptyConfig.getCommonModules().size()); // 0

```

--------------------------------

### Navigate 1C Metadata Hierarchy and Children (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

This snippet demonstrates how to navigate the 1C metadata hierarchy using references and find child objects. It shows how to get all plain children, find a specific child by MDO reference, retrieve localized MDO references, and identify subsystems containing a given object. Dependencies include the com.github._1c_syntax library.

```java
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import com.github._1c_syntax.bsl.mdo.MD;
import com.github._1c_syntax.bsl.mdo.Catalog;
import com.github._1c_syntax.bsl.mdo.Document;
import com.github._1c_syntax.bsl.types.MdoReference;
import com.github._1c_syntax.bsl.types.ScriptVariant;

Configuration configuration = getConfiguration();

// Get plain list of all child metadata objects
List<MD> allChildren = configuration.getPlainChildren();
System.out.println("Total metadata objects: " + allChildren.size());

// Find child by MDO reference
MdoReference catalogRef = MdoReference.create("Catalog.Users");
configuration.findChild(catalogRef).ifPresent(md -> {
    System.out.println("Found: " + md.getName());
    System.out.println("Type: " + md.getMdoType());
    System.out.println("UUID: " + md.getUuid());
    System.out.println("Comment: " + md.getComment());
    System.out.println("Synonym: " + md.getSynonym().get("ru"));
});

// Get localized MDO reference
configuration.getDocuments().forEach(document -> {
    String refEn = document.getMdoRef(ScriptVariant.ENGLISH);
    String refRu = document.getMdoRef(ScriptVariant.RUSSIAN);
    System.out.println("EN: " + refEn + " | RU: " + refRu);
});

// Find subsystems containing specific object
Catalog catalog = configuration.getCatalogs().get(0);
configuration.includedSubsystems(catalog, true).forEach(subsystem ->
    System.out.println("Catalog included in: " + subsystem.getName())
);
```

--------------------------------

### Access Configuration Metadata Tree (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

Demonstrates how to navigate through configuration metadata objects using the ConfigurationTree interface. It covers accessing common modules, finding specific catalogs by name, and iterating through subsystems and their contents. Assumes a Configuration object is already loaded.

```java
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import com.github._1c_syntax.bsl.mdo.*;
import java.util.Optional;

Configuration configuration = getConfiguration(); // assume loaded

// Access common modules
configuration.getCommonModules().forEach(module -> {
    System.out.println("Module: " + module.getName());
    System.out.println("  Server: " + module.isServer());
    System.out.println("  Global: " + module.isGlobal());
    System.out.println("  Client managed: " + module.isClientManagedApplication());
});

// Find specific catalog
Optional<Catalog> usersCatalog = configuration.findCatalog(
    catalog -> "Users".equals(catalog.getName())
);

usersCatalog.ifPresent(catalog -> {
    System.out.println("Found catalog: " + catalog.getName());
    catalog.getAttributes().forEach(attr ->
        System.out.println("  Attribute: " + attr.getName())
    );
});

// Access subsystems
configuration.getSubsystems().forEach(subsystem -> {
    System.out.println("Subsystem: " + subsystem.getName());
    subsystem.getContent().forEach(mdoRef ->
        System.out.println("  Contains: " + mdoRef.getMdoRef())
    );
});
```

--------------------------------

### Create 1C Configuration with Custom Read Settings using MDClasses

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

This code demonstrates creating a 1C:Enterprise configuration with custom read settings to optimize performance by skipping specific metadata. It utilizes `MDCReadSettings.builder()` to configure what to skip during reading, such as support configurations, role data, and XDTO packages. The output shows the count of common modules and catalogs based on the applied settings.

```java
import com.github._1c_syntax.bsl.mdclasses.MDClasses;
import com.github._1c_syntax.bsl.mdclasses.MDCReadSettings;
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import java.nio.file.Path;

// Configure what to skip during reading
MDCReadSettings settings = MDCReadSettings.builder()
    .skipSupport(true)           // Skip reading support configuration
    .skipRoleData(true)          // Skip reading role contents
    .skipXdtoPackage(true)       // Skip reading XDTO packages
    .skipFormElementItems(true)  // Skip reading form element items
    .skipDataCompositionSchema(true) // Skip reading data composition schemas
    .build();

Path projectPath = Path.of("/path/to/1c/project");
Configuration configuration = (Configuration) MDClasses.createConfiguration(projectPath, settings);

// Work with optimized configuration
System.out.println("Common modules: " + configuration.getCommonModules().size());
System.out.println("Catalogs: " + configuration.getCatalogs().size());
```

--------------------------------

### Create Solution with Merged Configurations (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

Reads an entire solution directory containing multiple configurations and extensions, automatically merging them into a single Configuration object. This allows for unified access to all metadata. Dependencies include the MDClasses library.

```java
import com.github._1c_syntax.bsl.mdclasses.MDClasses;
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import com.github._1c_syntax.bsl.mdo.Catalog;
import java.nio.file.Path;

// Read and merge all configurations and extensions in directory
Path solutionPath = Path.of("/path/to/solution");
Configuration mergedConfiguration = (Configuration) MDClasses.createSolution(solutionPath);

// The result is a merged view of base configuration + all extensions
System.out.println("Total catalogs: " + mergedConfiguration.getCatalogs().size());
System.out.println("Total common modules: " + mergedConfiguration.getCommonModules().size());

// Access merged metadata
mergedConfiguration.getCatalogs().forEach(catalog -> {
    System.out.println("Catalog: " + catalog.getName());
    System.out.println("  Attributes: " + catalog.getAttributes().size());
    System.out.println("  Forms: " + catalog.getForms().size());
});
```

--------------------------------

### Read 1C Configuration from File System using MDClasses

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

This snippet demonstrates how to read a 1C:Enterprise configuration from a directory containing source files using the MDClasses library. It shows basic configuration reading and accessing metadata like name, version, and vendor. Dependencies include the MDClasses library.

```java
import com.github._1c_syntax.bsl.mdclasses.MDClasses;
import com.github._1c_syntax.bsl.mdclasses.MDClass;
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import java.nio.file.Path;

// Basic configuration reading
Path projectPath = Path.of("/path/to/1c/project");
MDClass configuration = MDClasses.createConfiguration(projectPath);

// Access configuration metadata
if (configuration instanceof Configuration cf) {
    String configName = cf.getName();
    String version = cf.getVersion();
    String vendor = cf.getVendor();

    System.out.println("Configuration: " + configName);
    System.out.println("Version: " + version);
    System.out.println("Vendor: " + vendor);
}
```

--------------------------------

### Read Configurations and External Sources (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

Demonstrates batch reading of configurations, extensions, and external sources (reports and processors) from a specified directory structure. It provides methods to read configurations and external sources separately, or to read all metadata containers in a single call. Uses the MDClasses utility.

```java
import com.github._1c_syntax.bsl.mdclasses.MDClasses;
import com.github._1c_syntax.bsl.mdclasses.MDClass;
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import com.github._1c_syntax.bsl.mdclasses.ExternalSource;
import java.nio.file.Path;
import java.util.List;

Path sourcePath = Path.of("/path/to/sources");

// Read all configurations and extensions
List<MDClass> configurations = MDClasses.createConfigurations(sourcePath);
configurations.forEach(mdc -> {
    if (mdc instanceof Configuration config) {
        System.out.println("Configuration: " + config.getName());
    } else {
        System.out.println("Extension: " + mdc.getName());
    }
});

// Read all external reports and processors
List<MDClass> externalSources = MDClasses.createExternalSources(sourcePath);
externalSources.forEach(ext -> {
    System.out.println("External source: " + ext.getName());
    System.out.println("  Type: " + ext.getMdoType());
});

// Read everything in one call
List<MDClass> allMetadata = MDClasses.create(sourcePath);
System.out.println("Total metadata containers: " + allMetadata.size());
```

--------------------------------

### Work with 1C Registers (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

This snippet demonstrates how to access and analyze various types of 1C registers, including information registers, accumulation registers, accounting registers, and calculation registers. It shows how to retrieve dimensions, resources, and attributes for different register types. Dependencies include the com.github._1c_syntax library.

```java
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import com.github._1c_syntax.bsl.mdo.*;

Configuration configuration = getConfiguration();

// Information registers
configuration.getInformationRegisters().forEach(register -> {
    System.out.println("Information Register: " + register.getName());

    register.getDimensions().forEach(dim ->
        System.out.println("  Dimension: " + dim.getName())
    );

    register.getResources().forEach(res ->
        System.out.println("  Resource: " + res.getName())
    );

    register.getAttributes().forEach(attr ->
        System.out.println("  Attribute: " + attr.getName())
    );
});

// Accumulation registers
configuration.getAccumulationRegisters().forEach(register -> {
    System.out.println("Accumulation Register: " + register.getName());
    System.out.println("  Register type: " + register.getRegisterType());
});

// Accounting registers
configuration.getAccountingRegisters().forEach(register -> {
    System.out.println("Accounting Register: " + register.getName());
    register.getDimensions().forEach(dim ->
        System.out.println("  Dimension: " + dim.getName())
    );
});

// Calculation registers
configuration.getCalculationRegisters().forEach(register -> {
    System.out.println("Calculation Register: " + register.getName());
});
```

--------------------------------

### Read External Report/Data Processor using MDClasses

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

This snippet shows how to read external reports and data processors from their MDO/XML files using the `MDClasses.createExternalSource()` method. It illustrates accessing metadata such as the source's name, attributes, forms, commands, and all its modules, including their URIs and types. Dependencies include the MDClasses library.

```java
import com.github._1c_syntax.bsl.mdclasses.MDClasses;
import com.github._1c_syntax.bsl.mdclasses.ExternalReport;
import com.github._1c_syntax.bsl.mdclasses.ExternalDataProcessor;
import java.nio.file.Path;

// Read external report
Path reportPath = Path.of("/path/to/ExternalReport.xml");
ExternalReport externalReport = (ExternalReport) MDClasses.createExternalSource(reportPath);

System.out.println("Report name: " + externalReport.getName());
System.out.println("Attributes: " + externalReport.getAttributes().size());
System.out.println("Forms: " + externalReport.getForms().size());
System.out.println("Commands: " + externalReport.getCommands().size());

// Access report modules
externalReport.getAllModules().forEach(module -> {
    System.out.println("Module URI: " + module.getUri());
    System.out.println("Module type: " + module.getModuleType());
});
```

--------------------------------

### Working with Reports and Data Processors in 1C Metadata (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

This Java code snippet illustrates how to access metadata for reports and data processors within a 1C:Enterprise configuration. It shows how to retrieve information about reports, including their attributes, tabular sections, forms, and templates, as well as details about data processors like attributes, forms, and commands. Requires MDClasses library.

```java
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import com.github._1c_syntax.bsl.mdo.Report;
import com.github._1c_syntax.bsl.mdo.DataProcessor;

Configuration configuration = getConfiguration();

// Access reports
configuration.getReports().forEach(report -> {
    System.out.println("Report: " + report.getName());

    report.getAttributes().forEach(attr ->
        System.out.println("  Attribute: " + attr.getName())
    );

    report.getTabularSections().forEach(ts ->
        System.out.println("  Tabular section: " + ts.getName())
    );

    report.getForms().forEach(form ->
        System.out.println("  Form: " + form.getName())
    );

    report.getTemplates().forEach(template ->
        System.out.println("  Template: " + template.getName())
    );
});

// Access data processors
configuration.getDataProcessors().forEach(processor -> {
    System.out.println("Data Processor: " + processor.getName());
    System.out.println("  Attributes: " + processor.getAttributes().size());
    System.out.println("  Forms: " + processor.getForms().size());
    System.out.println("  Commands: " + processor.getCommands().size());
});

```

--------------------------------

### Accessing Roles and Rights in 1C Metadata (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

This Java code snippet demonstrates how to access and analyze security roles and their associated access rights within a 1C:Enterprise configuration. It shows how to retrieve all possible rights, iterate through roles, and find specific roles by name. Dependencies include MDClasses core components.

```java
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import com.github._1c_syntax.bsl.mdo.Role;
import com.github._1c_syntax.bsl.mdo.support.RoleRight;
import java.util.List;

Configuration configuration = getConfiguration();

// Get all possible rights in configuration
List<RoleRight> possibleRights = Configuration.possibleRights();
System.out.println("Possible rights: " + possibleRights.size());
possibleRights.forEach(right ->
    System.out.println("  " + right)
);

// Access roles
configuration.getRoles().forEach(role -> {
    System.out.println("Role: " + role.getName());
    System.out.println("  Description: " + role.getDescription());
    System.out.println("  Comment: " + role.getComment());

    // Role rights would be available if not skipped in read settings
    System.out.println("  Rights loaded: " + !role.getRights().isEmpty());
});

// Find specific role
configuration.findRole(role -> "FullRights".equals(role.getName()))
    .ifPresent(role -> {
        System.out.println("Found role: " + role.getName());
        System.out.println("Synonym: " + role.getSynonym().get("en"));
    });

```

--------------------------------

### Access 1C Document and Catalog Attributes (Java)

Source: https://context7.com/1c-syntax/mdclasses/llms.txt

This snippet illustrates how to access attributes, tabular sections, and storage fields for 1C documents and catalogs. It shows how to iterate through catalog attributes and tabular section columns, and how to retrieve information about a specific document's structure. Dependencies include the com.github._1c_syntax library.

```java
import com.github._1c_syntax.bsl.mdclasses.Configuration;
import com.github._1c_syntax.bsl.mdo.Catalog;
import com.github._1c_syntax.bsl.mdo.Document;
import com.github._1c_syntax.bsl.mdo.Attribute;
import com.github._1c_syntax.bsl.mdo.TabularSection;

Configuration configuration = getConfiguration();

// Access catalog attributes
configuration.getCatalogs().forEach(catalog -> {
    System.out.println("Catalog: " + catalog.getName());

    catalog.getAttributes().forEach(attr -> {
        System.out.println("  Attribute: " + attr.getName());
        System.out.println("    Type: " + attr.getType());
        System.out.println("    Synonym: " + attr.getDescription());
    });

    catalog.getTabularSections().forEach(ts -> {
        System.out.println("  Tabular section: " + ts.getName());
        ts.getAttributes().forEach(attr ->
            System.out.println("    Column: " + attr.getName())
        );
    });
});

// Access document structure
Optional<Document> salesDoc = configuration.findDocument(
    doc -> "SalesOrder".equals(doc.getName())
);

salesDoc.ifPresent(document -> {
    System.out.println("Document: " + document.getName());
    System.out.println("Attributes: " + document.getAttributes().size());
    System.out.println("Tabular sections: " + document.getTabularSections().size());
    System.out.println("Forms: " + document.getForms().size());
    System.out.println("Commands: " + document.getCommands().size());
});
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.