Java TreeType类代码示例

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
public InMemoryDOMDataStore(final String name, final LogicalDatastoreType type,
        final ExecutorService dataChangeListenerExecutor,
        final int maxDataChangeListenerQueueSize, final boolean debugTransactions) {
    this.name = Preconditions.checkNotNull(name);
    this.dataChangeListenerExecutor = Preconditions.checkNotNull(dataChangeListenerExecutor);
    this.debugTransactions = debugTransactions;

    dataChangeListenerNotificationManager =
            new QueuedNotificationManager<>(this.dataChangeListenerExecutor,
                    DCL_NOTIFICATION_MGR_INVOKER, maxDataChangeListenerQueueSize,
                    "DataChangeListenerQueueMgr");
    changePublisher = new InMemoryDOMStoreTreeChangePublisher(this.dataChangeListenerExecutor, maxDataChangeListenerQueueSize);

    switch (type) {
        case CONFIGURATION:
            dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
            break;
        case OPERATIONAL:
            dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
            break;
        default:
            throw new IllegalArgumentException("Data store " + type + " not supported");
    }
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
public DistributedShardChangePublisher(final DataStoreClient client,
                                       final AbstractDataStore distributedDataStore,
                                       final DOMDataTreeIdentifier prefix,
                                       final Map<DOMDataTreeIdentifier, ChildShardContext> childShards) {
    this.distributedDataStore = distributedDataStore;
    // TODO keeping the whole dataTree thats contained in subshards doesn't seem like a good idea
    // maybe the whole listener logic would be better in the backend shards where we have direct access to the
    // dataTree and wont have to cache it redundantly.
    this.dataTree = InMemoryDataTreeFactory.getInstance().create(
            TreeType.valueOf(prefix.getDatastoreType().name()), prefix.getRootIdentifier());

    dataTree.setSchemaContext(distributedDataStore.getActorContext().getSchemaContext());

    this.shardPath = prefix.getRootIdentifier();
    this.childShards = childShards;
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
private static ShardSnapshotState createSnapshot() {
    final TipProducingDataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
    dataTree.setSchemaContext(SchemaContextHelper.select(SchemaContextHelper.CARS_YANG,
            SchemaContextHelper.PEOPLE_YANG));

    DataTreeSnapshot snapshot = dataTree.takeSnapshot();

    DataTreeModification modification = snapshot.newModification();

    modification.merge(CarsModel.BASE_PATH, CarsModel.create());
    modification.merge(PeopleModel.BASE_PATH, PeopleModel.create());
    modification.ready();
    dataTree.commit(dataTree.prepare(modification));

    return new ShardSnapshotState(new MetadataShardDataTreeSnapshot(dataTree.takeSnapshot().readNode(
            YangInstanceIdentifier.EMPTY).get()));
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
@Before
public void setUp() {
    MockitoAnnotations.initMocks(this);

    dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
    dataTree.setSchemaContext(SCHEMA_CONTEXT);

    realModification = dataTree.takeSnapshot().newModification();
    proxyModification = Reflection.newProxy(DataTreeModification.class, (proxy, method, args) -> {
        try {
            method.invoke(mockModification, args);
            return method.invoke(realModification, args);
        } catch (InvocationTargetException e) {
            throw e.getCause();
        }
    });

    pruningDataTreeModification = new PruningDataTreeModification(proxyModification, dataTree, SCHEMA_CONTEXT);
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
@Test
public void testWriteRootNode() throws Exception {
    final DataTree localDataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
    localDataTree.setSchemaContext(SCHEMA_CONTEXT);

    DataTreeModification mod = localDataTree.takeSnapshot().newModification();
    mod.write(CarsModel.BASE_PATH, CarsModel.create());
    mod.ready();
    localDataTree.validate(mod);
    localDataTree.commit(localDataTree.prepare(mod));

    NormalizedNode<?, ?> normalizedNode = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.EMPTY).get();
    pruningDataTreeModification.write(YangInstanceIdentifier.EMPTY, normalizedNode);
    dataTree.commit(getCandidate());

    Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.EMPTY);
    assertEquals("Root present", true, actual.isPresent());
    assertEquals("Root node", normalizedNode, actual.get());
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
@Test
public void testWriteRootNodeWithInvalidChild() throws Exception {
    final Shard mockShard = Mockito.mock(Shard.class);

    ShardDataTree shardDataTree = new ShardDataTree(mockShard, SCHEMA_CONTEXT, TreeType.CONFIGURATION);
    NormalizedNode<?, ?> root = shardDataTree.readNode(YangInstanceIdentifier.EMPTY).get();

    NormalizedNode<?, ?> normalizedNode = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
            new YangInstanceIdentifier.NodeIdentifier(root.getNodeType())).withChild(
                    ImmutableNodes.containerNode(AUG_CONTAINER)).build();
    pruningDataTreeModification.write(YangInstanceIdentifier.EMPTY, normalizedNode);
    dataTree.commit(getCandidate());

    Optional<NormalizedNode<?, ?>> actual = dataTree.takeSnapshot().readNode(YangInstanceIdentifier.EMPTY);
    assertEquals("Root present", true, actual.isPresent());
    assertEquals("Root node", root, actual.get());

}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
public static ModificationApplyOperation from(final DataSchemaNode schemaNode,
        final DataTreeConfiguration treeConfig) {
    if (treeConfig.getTreeType() == TreeType.CONFIGURATION) {
        Preconditions.checkArgument(schemaNode.isConfiguration(),
            "Supplied %s does not belongs to configuration tree.", schemaNode.getPath());
    }
    if (schemaNode instanceof ContainerSchemaNode) {
        final ContainerSchemaNode containerSchema = (ContainerSchemaNode) schemaNode;
        if (containerSchema.isPresenceContainer()) {
            return new PresenceContainerModificationStrategy(containerSchema, treeConfig);
        }

        return new StructuralContainerModificationStrategy(containerSchema, treeConfig);
    } else if (schemaNode instanceof ListSchemaNode) {
        return fromListSchemaNode((ListSchemaNode) schemaNode, treeConfig);
    } else if (schemaNode instanceof ChoiceSchemaNode) {
        return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode, treeConfig);
    } else if (schemaNode instanceof LeafListSchemaNode) {
        return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode, treeConfig);
    } else if (schemaNode instanceof LeafSchemaNode) {
        return new LeafModificationStrategy((LeafSchemaNode) schemaNode);
    }
    throw new IllegalArgumentException("Not supported schema node type for " + schemaNode.getClass());
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
static CaseEnforcer forTree(final CaseSchemaNode schema, final DataTreeConfiguration treeConfig) {
    final TreeType type = treeConfig.getTreeType();
    final Builder<NodeIdentifier, DataSchemaNode> childrenBuilder = ImmutableMap.builder();
    final Builder<AugmentationIdentifier, AugmentationSchemaNode> augmentationsBuilder = ImmutableMap.builder();
    if (SchemaAwareApplyOperation.belongsToTree(type, schema)) {
        for (final DataSchemaNode child : schema.getChildNodes()) {
            if (SchemaAwareApplyOperation.belongsToTree(type, child)) {
                childrenBuilder.put(NodeIdentifier.create(child.getQName()), child);
            }
        }
        for (final AugmentationSchemaNode augment : schema.getAvailableAugmentations()) {
            if (augment.getChildNodes().stream()
                    .anyMatch(child -> SchemaAwareApplyOperation.belongsToTree(type, child))) {
                augmentationsBuilder.put(SchemaUtils.getNodeIdentifierForAugmentation(augment), augment);
            }
        }
    }

    final Map<NodeIdentifier, DataSchemaNode> children = childrenBuilder.build();
    final Map<AugmentationIdentifier, AugmentationSchemaNode> augmentations = augmentationsBuilder.build();
    return children.isEmpty() ? null
            : new CaseEnforcer(children, augmentations, MandatoryLeafEnforcer.forContainer(schema, treeConfig));
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
public TreeType getTreeType() {
    switch (datastoreContext.getLogicalStoreType()) {
        case CONFIGURATION:
            return TreeType.CONFIGURATION;
        case OPERATIONAL:
            return TreeType.OPERATIONAL;
        default:
            throw new IllegalStateException("Unhandled logical store type "
                    + datastoreContext.getLogicalStoreType());
    }
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
private NormalizedNodeAggregator(final YangInstanceIdentifier rootIdentifier,
        final List<Optional<NormalizedNode<?, ?>>> nodes, final SchemaContext schemaContext,
        LogicalDatastoreType logicalDatastoreType) {
    this.rootIdentifier = rootIdentifier;
    this.nodes = nodes;
    this.dataTree = InMemoryDataTreeFactory.getInstance().create(
            logicalDatastoreType == LogicalDatastoreType.CONFIGURATION ? TreeType.CONFIGURATION :
                TreeType.OPERATIONAL);
    this.dataTree.setSchemaContext(schemaContext);
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
ShardDataTree(final Shard shard, final SchemaContext schemaContext, final TreeType treeType,
        final YangInstanceIdentifier root,
        final ShardDataTreeChangeListenerPublisher treeChangeListenerPublisher,
        final ShardDataChangeListenerPublisher dataChangeListenerPublisher, final String logContext,
        final ShardDataTreeMetadata<?>... metadata) {
    this(shard, schemaContext, InMemoryDataTreeFactory.getInstance().create(treeType, root),
            treeChangeListenerPublisher, dataChangeListenerPublisher, logContext, metadata);
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
@Before
public void setUp() {
    peopleSchemaContext = SchemaContextHelper.select(SchemaContextHelper.PEOPLE_YANG);
    carsSchemaContext = SchemaContextHelper.select(SchemaContextHelper.CARS_YANG);

    final Shard mockShard = Mockito.mock(Shard.class);

    peopleDataTree = new ShardDataTree(mockShard, peopleSchemaContext, TreeType.OPERATIONAL);
    coordinator = ShardRecoveryCoordinator.create(peopleDataTree, "foobar", FOO_LOGGER);
    coordinator.startLogRecoveryBatch(10);
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
private DataTreeCandidateTip createCar() {
    final TipProducingDataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
    dataTree.setSchemaContext(carsSchemaContext);

    final DataTreeSnapshot snapshot = dataTree.takeSnapshot();

    final DataTreeModification modification = snapshot.newModification();

    modification.merge(CarsModel.BASE_PATH, CarsModel.create());
    modification.ready();
    return dataTree.prepare(modification);
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
private static Snapshot newSnapshot(YangInstanceIdentifier path, NormalizedNode<?, ?> node)
        throws Exception {
    DataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.OPERATIONAL);
    dataTree.setSchemaContext(SchemaContextHelper.full());
    AbstractShardTest.writeToStore(dataTree, path, node);
    NormalizedNode<?, ?> root = AbstractShardTest.readStore(dataTree, YangInstanceIdentifier.EMPTY);

    return Snapshot.create(new ShardSnapshotState(new MetadataShardDataTreeSnapshot(root)),
            Collections.<ReplicatedLogEntry>emptyList(), 2, 1, 2, 1, 1, "member-1", null);
}
 

import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; //导入依赖的package包/类
@Test
public void testUnmodifiedRootCandidate() throws Exception {
    final TipProducingDataTree dataTree = InMemoryDataTreeFactory.getInstance().create(TreeType.CONFIGURATION);
    dataTree.setSchemaContext(SchemaContextHelper.select(SchemaContextHelper.CARS_YANG));

    DataTreeModification modification = dataTree.takeSnapshot().newModification();
    modification.ready();
    candidate = dataTree.prepare(modification);

    CommitTransactionPayload payload = CommitTransactionPayload.create(nextTransactionId(), candidate);
    assertCandidateEquals(candidate, payload.getCandidate().getValue());
}