opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/DataBrokerImpl.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.sal.binding.impl;\r
   9 \r
  10 import java.util.Map;
  11 import java.util.Map.Entry;
  12 import java.util.concurrent.Future;
  13 import java.util.concurrent.atomic.AtomicLong;
  14
  15 import org.opendaylight.controller.md.sal.common.impl.service.AbstractDataBroker;
  16 import org.opendaylight.controller.sal.binding.api.data.DataChangeListener;
  17 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
  18 import org.opendaylight.controller.sal.binding.impl.util.BindingAwareDataReaderRouter;
  19 import org.opendaylight.controller.sal.common.DataStoreIdentifier;
  20 import org.opendaylight.yangtools.yang.binding.DataObject;
  21 import org.opendaylight.yangtools.yang.binding.DataRoot;
  22 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  23 import org.opendaylight.yangtools.yang.binding.util.DataObjectReadingUtil;
  24 import org.opendaylight.yangtools.yang.common.RpcResult;
  25
  26 import com.google.common.base.Predicate;
  27 import com.google.common.collect.ImmutableMap;
  28 import com.google.common.collect.ImmutableMap.Builder;
  29 import com.google.common.collect.Maps;
  30 \r
  31 \r
  32 public class DataBrokerImpl extends AbstractDataBroker<InstanceIdentifier<? extends DataObject>, DataObject, DataChangeListener> //\r
  33        implements DataProviderService, AutoCloseable {\r
  34 \r
  35     private final static class ContainsWildcarded implements Predicate<InstanceIdentifier<? extends DataObject>> {
  36
  37         private final  InstanceIdentifier<? extends DataObject> key;
  38
  39         public ContainsWildcarded(InstanceIdentifier<? extends DataObject> key) {
  40             this.key = key;
  41         }
  42
  43         @Override
  44         public boolean apply(InstanceIdentifier<? extends DataObject> input) {
  45             return key.containsWildcarded(input);
  46         }
  47     }
  48
  49     private final static class IsContainedWildcarded implements Predicate<InstanceIdentifier<? extends DataObject>> {
  50
  51         private final  InstanceIdentifier<? extends DataObject> key;
  52
  53         public IsContainedWildcarded(InstanceIdentifier<? extends DataObject> key) {
  54             this.key = key;
  55         }
  56
  57         @Override
  58         public boolean apply(InstanceIdentifier<? extends DataObject> input) {
  59             return input.containsWildcarded(key);
  60         }
  61     }
  62
  63     private final AtomicLong nextTransaction = new AtomicLong();\r
  64     private final AtomicLong createdTransactionsCount = new AtomicLong();\r
  65 \r
  66     public AtomicLong getCreatedTransactionsCount() {\r
  67         return createdTransactionsCount;\r
  68     }\r
  69 \r
  70     public DataBrokerImpl() {\r
  71         setDataReadRouter(new BindingAwareDataReaderRouter());\r
  72     }\r
  73 \r
  74     @Override\r
  75     public DataTransactionImpl beginTransaction() {\r
  76         String transactionId = "BA-" + nextTransaction.getAndIncrement();\r
  77         createdTransactionsCount.getAndIncrement();\r
  78         return new DataTransactionImpl(transactionId,this);\r
  79     }\r
  80 \r
  81     @Override\r
  82     @Deprecated\r
  83     public <T extends DataRoot> T getData(DataStoreIdentifier store, Class<T> rootType) {\r
  84         throw new UnsupportedOperationException("Deprecated");\r
  85     }\r
  86 \r
  87     @Override\r
  88     @Deprecated\r
  89     public <T extends DataRoot> T getData(DataStoreIdentifier store, T filter) {\r
  90         throw new UnsupportedOperationException("Deprecated");\r
  91     }\r
  92 \r
  93     @Override\r
  94     @Deprecated\r
  95     public <T extends DataRoot> T getCandidateData(DataStoreIdentifier store, Class<T> rootType) {\r
  96         throw new UnsupportedOperationException("Deprecated");\r
  97     }\r
  98 \r
  99     @Override\r
 100     @Deprecated\r
 101     public <T extends DataRoot> T getCandidateData(DataStoreIdentifier store, T filter) {\r
 102         throw new UnsupportedOperationException("Deprecated");\r
 103     }\r
 104 \r
 105     @Override\r
 106     @Deprecated\r
 107     public RpcResult<DataRoot> editCandidateData(DataStoreIdentifier store, DataRoot changeSet) {\r
 108         throw new UnsupportedOperationException("Deprecated");\r
 109     }\r
 110 \r
 111     @Override\r
 112     @Deprecated\r
 113     public Future<RpcResult<Void>> commit(DataStoreIdentifier store) {\r
 114         throw new UnsupportedOperationException("Deprecated");\r
 115     }\r
 116 \r
 117     @Override\r
 118     @Deprecated\r
 119     public DataObject getData(InstanceIdentifier<? extends DataObject> data) {\r
 120         throw new UnsupportedOperationException("Deprecated");\r
 121     }\r
 122 \r
 123     @Override\r
 124     @Deprecated\r
 125     public DataObject getConfigurationData(InstanceIdentifier<?> data) {\r
 126         throw new UnsupportedOperationException("Deprecated");\r
 127     }\r
 128 \r
 129     @Override\r
 130     @Deprecated\r
 131     public void registerChangeListener(InstanceIdentifier<? extends DataObject> path, DataChangeListener changeListener) {\r
 132         throw new UnsupportedOperationException("Deprecated");\r
 133     }\r
 134 \r
 135     @Override\r
 136     @Deprecated\r
 137     public void unregisterChangeListener(InstanceIdentifier<? extends DataObject> path,\r
 138             DataChangeListener changeListener) {\r
 139         throw new UnsupportedOperationException("Deprecated");\r
 140     }\r
 141 \r
 142     @Override\r
 143     public void close() throws Exception {\r
 144 \r
 145     }
 146
 147     @Override
 148     protected Predicate<InstanceIdentifier<? extends DataObject>> createContainsPredicate(final
 149             InstanceIdentifier<? extends DataObject> key) {
 150         return new ContainsWildcarded(key);
 151     }
 152
 153     @Override
 154     protected Predicate<InstanceIdentifier<? extends DataObject>> createIsContainedPredicate(final
 155             InstanceIdentifier<? extends DataObject> key) {
 156         return new IsContainedWildcarded(key);
 157     }
 158
 159     @SuppressWarnings({ "unchecked", "rawtypes" })
 160     @Override
 161     protected Map<InstanceIdentifier<? extends DataObject>, DataObject> deepGetBySubpath(
 162             Map<InstanceIdentifier<? extends DataObject>, DataObject> dataSet,
 163             InstanceIdentifier<? extends DataObject> path) {
 164         Builder<InstanceIdentifier<? extends DataObject>, DataObject> builder = ImmutableMap.builder();
 165         Map<InstanceIdentifier<? extends DataObject>, DataObject> potential = Maps.filterKeys(dataSet, createIsContainedPredicate(path));
 166         for(Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry : potential.entrySet()) {
 167             try {
 168                 builder.putAll(DataObjectReadingUtil.readData(entry.getValue(),(InstanceIdentifier)entry.getKey(),path));
 169             } catch (Exception e) {
 170                 // FIXME : Log exception;
 171             }
 172         }
 173         return builder.build();
 174
 175     }
 176 \r
 177 }