opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/utils/QNameFactory.java

   1 /*
   2  * Copyright (c) 2014, 2015 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.cluster.datastore.node.utils;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.cache.CacheBuilder;
  13 import com.google.common.cache.CacheLoader;
  14 import com.google.common.cache.LoadingCache;
  15 import java.net.URI;
  16 import java.util.Objects;
  17 import java.util.concurrent.ExecutionException;
  18 import org.eclipse.jdt.annotation.NonNull;
  19 import org.eclipse.jdt.annotation.Nullable;
  20 import org.opendaylight.yangtools.concepts.Immutable;
  21 import org.opendaylight.yangtools.yang.common.QName;
  22 import org.opendaylight.yangtools.yang.common.QNameModule;
  23 import org.opendaylight.yangtools.yang.common.Revision;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  25
  26 public final class QNameFactory {
  27     private static final class StringQName implements Immutable {
  28         private final @NonNull String localName;
  29         private final @NonNull String namespace;
  30         private final @Nullable String revision;
  31
  32         StringQName(final String localName, final String namespace, final String revision) {
  33             this.localName = requireNonNull(localName);
  34             this.namespace = requireNonNull(namespace);
  35             this.revision = revision;
  36         }
  37
  38         @Override
  39         public int hashCode() {
  40             return Objects.hash(localName, namespace, revision);
  41         }
  42
  43         @Override
  44         public boolean equals(final Object obj) {
  45             if (this == obj) {
  46                 return true;
  47             }
  48             if (!(obj instanceof StringQName)) {
  49                 return false;
  50             }
  51             final StringQName other = (StringQName) obj;
  52             return localName.equals(other.localName) && namespace.equals(other.namespace)
  53                     && Objects.equals(revision, other.revision);
  54         }
  55
  56         QName toQName() {
  57             return revision != null ? QName.create(namespace, revision, localName) : QName.create(namespace, localName);
  58         }
  59     }
  60
  61     private static final class ModuleQName implements Immutable {
  62         private final @NonNull QNameModule module;
  63         private final @NonNull String localName;
  64
  65         ModuleQName(final QNameModule module, final String localName) {
  66             this.module = requireNonNull(module);
  67             this.localName = requireNonNull(localName);
  68         }
  69
  70         @Override
  71         public int hashCode() {
  72             return 31 * module.hashCode() + localName.hashCode();
  73         }
  74
  75         @Override
  76         public boolean equals(final Object obj) {
  77             if (this == obj) {
  78                 return true;
  79             }
  80             if (!(obj instanceof ModuleQName)) {
  81                 return false;
  82             }
  83             final ModuleQName other = (ModuleQName) obj;
  84             return localName.equals(other.localName) && module.equals(other.module);
  85         }
  86
  87         QName toQName() {
  88             return QName.create(module, localName);
  89         }
  90     }
  91
  92     private static final class StringModule implements Immutable {
  93         private final @NonNull String namespace;
  94         private final @Nullable String revision;
  95
  96         StringModule(final String namespace, final String revision) {
  97             this.namespace = requireNonNull(namespace);
  98             this.revision = revision;
  99         }
 100
 101         @Override
 102         public int hashCode() {
 103             return 31 * namespace.hashCode() + Objects.hashCode(revision);
 104         }
 105
 106         @Override
 107         public boolean equals(final Object obj) {
 108             if (this == obj) {
 109                 return true;
 110             }
 111             if (!(obj instanceof StringModule)) {
 112                 return false;
 113             }
 114             final StringModule other = (StringModule) obj;
 115             return namespace.equals(other.namespace) && Objects.equals(revision, other.revision);
 116         }
 117
 118         QNameModule toQNameModule() {
 119             return QNameModule.create(URI.create(namespace), Revision.ofNullable(revision));
 120         }
 121     }
 122
 123     private static final int MAX_QNAME_CACHE_SIZE = Integer.getInteger(
 124         "org.opendaylight.controller.cluster.datastore.node.utils.qname-cache.max-size", 10000);
 125     private static final int MAX_MODULE_CACHE_SIZE = Integer.getInteger(
 126         "org.opendaylight.controller.cluster.datastore.node.utils.module-cache.max-size", 2000);
 127
 128     private static final LoadingCache<String, QName> LEGACY_CACHE = CacheBuilder.newBuilder()
 129             .maximumSize(MAX_QNAME_CACHE_SIZE).weakValues().build(new CacheLoader<String, QName>() {
 130                 @Override
 131                 public QName load(final String key) {
 132                     return QName.create(key).intern();
 133                 }
 134             });
 135     private static final LoadingCache<StringQName, QName> STRING_CACHE = CacheBuilder.newBuilder()
 136             .maximumSize(MAX_QNAME_CACHE_SIZE).weakValues().build(new CacheLoader<StringQName, QName>() {
 137                 @Override
 138                 public QName load(final StringQName key) {
 139                     return key.toQName().intern();
 140                 }
 141             });
 142     private static final LoadingCache<ModuleQName, QName> QNAME_CACHE = CacheBuilder.newBuilder()
 143             .maximumSize(MAX_QNAME_CACHE_SIZE).weakValues().build(new CacheLoader<ModuleQName, QName>() {
 144                 @Override
 145                 public QName load(final ModuleQName key) {
 146                     return key.toQName().intern();
 147                 }
 148             });
 149     private static final LoadingCache<StringModule, QNameModule> MODULE_CACHE = CacheBuilder.newBuilder()
 150             .maximumSize(MAX_MODULE_CACHE_SIZE).weakValues().build(new CacheLoader<StringModule, QNameModule>() {
 151                 @Override
 152                 public QNameModule load(final StringModule key) {
 153                     return key.toQNameModule().intern();
 154                 }
 155             });
 156     private static final LoadingCache<ModuleQName, NodeIdentifier> NODEID_CACHE = CacheBuilder.newBuilder()
 157             .maximumSize(MAX_QNAME_CACHE_SIZE).weakValues().build(new CacheLoader<ModuleQName, NodeIdentifier>() {
 158                 @Override
 159                 public NodeIdentifier load(final ModuleQName key) throws ExecutionException {
 160                     return NodeIdentifier.create(QNAME_CACHE.get(key));
 161                 }
 162             });
 163
 164     private QNameFactory() {
 165
 166     }
 167
 168     @Deprecated
 169     public static QName create(final String name) {
 170         return LEGACY_CACHE.getUnchecked(name);
 171     }
 172
 173     public static QName create(final String localName, final String namespace, final @Nullable String revision) {
 174         return STRING_CACHE.getUnchecked(new StringQName(localName, namespace, revision));
 175     }
 176
 177     public static QName create(final QNameModule module, final String localName) {
 178         return QNAME_CACHE.getUnchecked(new ModuleQName(module, localName));
 179     }
 180
 181     public static QNameModule createModule(final String namespace, final @Nullable String revision) {
 182         return MODULE_CACHE.getUnchecked(new StringModule(namespace, revision));
 183     }
 184
 185     public static @NonNull NodeIdentifier getNodeIdentifier(final QNameModule module, final String localName)
 186             throws ExecutionException {
 187         return NODEID_CACHE.get(new ModuleQName(module, localName));
 188     }
 189 }