opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/LegacyDataChangeEvent.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.md.sal.binding.impl;
   9
  10 import java.util.Collections;
  11 import java.util.HashMap;
  12 import java.util.Map;
  13 import java.util.Set;
  14
  15 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  16 import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
  17 import org.opendaylight.yangtools.yang.binding.DataObject;
  18 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  19
  20 public abstract class LegacyDataChangeEvent implements
  21         DataChangeEvent<InstanceIdentifier<? extends DataObject>, DataObject> {
  22
  23     private LegacyDataChangeEvent() {
  24     }
  25
  26     public static final DataChangeEvent<InstanceIdentifier<?>, DataObject> createOperational(
  27             final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
  28         return new OperationalChangeEvent(change);
  29     }
  30
  31     public static final DataChangeEvent<InstanceIdentifier<?>, DataObject> createConfiguration(
  32             final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
  33         return new ConfigurationChangeEvent(change);
  34     }
  35
  36     @Override
  37     public Map<InstanceIdentifier<?>, DataObject> getCreatedOperationalData() {
  38         return Collections.emptyMap();
  39     }
  40
  41     @Override
  42     public Map<InstanceIdentifier<?>, DataObject> getCreatedConfigurationData() {
  43         return Collections.emptyMap();
  44     }
  45
  46     @Override
  47     public Map<InstanceIdentifier<?>, DataObject> getUpdatedOperationalData() {
  48         return Collections.emptyMap();
  49     }
  50
  51     @Override
  52     public Map<InstanceIdentifier<?>, DataObject> getUpdatedConfigurationData() {
  53         return Collections.emptyMap();
  54     }
  55
  56     @Override
  57     public Set<InstanceIdentifier<?>> getRemovedConfigurationData() {
  58         return Collections.emptySet();
  59     }
  60
  61     @Override
  62     public Set<InstanceIdentifier<?>> getRemovedOperationalData() {
  63         return Collections.emptySet();
  64     }
  65
  66     @Override
  67     public Map<InstanceIdentifier<?>, DataObject> getOriginalConfigurationData() {
  68         return Collections.emptyMap();
  69     }
  70
  71     @Override
  72     public Map<InstanceIdentifier<?>, DataObject> getOriginalOperationalData() {
  73         return Collections.emptyMap();
  74     }
  75
  76     @Override
  77     public DataObject getOriginalConfigurationSubtree() {
  78         return null;
  79     }
  80
  81     @Override
  82     public DataObject getOriginalOperationalSubtree() {
  83         return null;
  84     }
  85
  86     @Override
  87     public DataObject getUpdatedConfigurationSubtree() {
  88         return null;
  89     }
  90
  91     @Override
  92     public DataObject getUpdatedOperationalSubtree() {
  93         return null;
  94     }
  95
  96     @SuppressWarnings({ "rawtypes", "unchecked" })
  97     private final static class OperationalChangeEvent extends LegacyDataChangeEvent {
  98
  99         private final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> delegate;
 100         private Map<InstanceIdentifier<?>, DataObject> updatedCache;
 101
 102         public OperationalChangeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 103             this.delegate = change;
 104         }
 105
 106         @Override
 107         public Map<InstanceIdentifier<?>, DataObject> getCreatedOperationalData() {
 108             return delegate.getCreatedData();
 109         }
 110
 111         @Override
 112         public Set<InstanceIdentifier<?>> getRemovedOperationalData() {
 113             return delegate.getRemovedPaths();
 114         }
 115
 116         @Override
 117         public DataObject getOriginalOperationalSubtree() {
 118             return delegate.getOriginalSubtree();
 119         }
 120
 121         @Override
 122         public DataObject getUpdatedOperationalSubtree() {
 123             return delegate.getUpdatedSubtree();
 124         }
 125
 126         @Override
 127         public Map<InstanceIdentifier<?>, DataObject> getOriginalOperationalData() {
 128             return (Map) delegate.getOriginalData();
 129         }
 130
 131         @Override
 132         public Map<InstanceIdentifier<?>, DataObject> getUpdatedOperationalData() {
 133             if(updatedCache == null) {
 134                 Map<InstanceIdentifier<?>, DataObject> created = delegate.getCreatedData();
 135                 Map<InstanceIdentifier<?>, DataObject> updated = delegate.getUpdatedData();
 136                 HashMap<InstanceIdentifier<?>, DataObject> updatedComposite = new HashMap<>(created.size() + updated.size());
 137                 updatedComposite.putAll(created);
 138                 updatedComposite.putAll(updated);
 139                 updatedCache = Collections.unmodifiableMap(updatedComposite);
 140             }
 141             return updatedCache;
 142         }
 143
 144         @Override
 145         public String toString() {
 146             return "OperationalChangeEvent [delegate=" + delegate + "]";
 147         }
 148
 149     }
 150
 151     @SuppressWarnings({ "rawtypes", "unchecked" })
 152     private final static class ConfigurationChangeEvent extends LegacyDataChangeEvent {
 153
 154         private final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> delegate;
 155         private Map<InstanceIdentifier<?>, DataObject> updatedCache;
 156
 157         public ConfigurationChangeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 158             this.delegate = change;
 159         }
 160
 161         @Override
 162         public Map<InstanceIdentifier<?>, DataObject> getCreatedConfigurationData() {
 163             return delegate.getCreatedData();
 164         }
 165
 166         @Override
 167         public Set<InstanceIdentifier<?>> getRemovedConfigurationData() {
 168             return delegate.getRemovedPaths();
 169         }
 170
 171         @Override
 172         public DataObject getOriginalConfigurationSubtree() {
 173             return delegate.getOriginalSubtree();
 174         }
 175
 176         @Override
 177         public DataObject getUpdatedConfigurationSubtree() {
 178             return delegate.getUpdatedSubtree();
 179         }
 180
 181         @Override
 182         public Map<InstanceIdentifier<?>, DataObject> getOriginalConfigurationData() {
 183             return (Map) delegate.getOriginalData();
 184         }
 185
 186         @Override
 187         public Map<InstanceIdentifier<?>, DataObject> getUpdatedConfigurationData() {
 188             if(updatedCache == null) {
 189                 Map<InstanceIdentifier<?>, DataObject> created = delegate.getCreatedData();
 190                 Map<InstanceIdentifier<?>, DataObject> updated = delegate.getUpdatedData();
 191                 HashMap<InstanceIdentifier<?>, DataObject> updatedComposite = new HashMap<>(created.size() + updated.size());
 192                 updatedComposite.putAll(created);
 193                 updatedComposite.putAll(updated);
 194                 updatedCache = Collections.unmodifiableMap(updatedComposite);
 195             }
 196             return updatedCache;
 197         }
 198
 199         @Override
 200         public String toString() {
 201             return "ConfigurationChangeEvent [delegate=" + delegate + "]";
 202         }
 203
 204     }
 205
 206 }