X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fcds-access-api%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Faccess%2Fconcepts%2FFrontendType.java;h=471b489046fb20fab5b0789275dcb67391bcf7a2;hp=27db82068dc6b38e5974a185e8c32cd9ec3ee5a7;hb=93fd13870364f77c234d6bd981906d7ef3bd3b46;hpb=104ce145c9cd637c9b1caecfe0fe02c4ce4f343c

diff --git a/opendaylight/md-sal/cds-access-api/src/main/java/org/opendaylight/controller/cluster/access/concepts/FrontendType.java b/opendaylight/md-sal/cds-access-api/src/main/java/org/opendaylight/controller/cluster/access/concepts/FrontendType.java
index 27db82068d..471b489046 100644
--- a/opendaylight/md-sal/cds-access-api/src/main/java/org/opendaylight/controller/cluster/access/concepts/FrontendType.java
+++ b/opendaylight/md-sal/cds-access-api/src/main/java/org/opendaylight/controller/cluster/access/concepts/FrontendType.java
@@ -8,8 +8,19 @@
 package org.opendaylight.controller.cluster.access.concepts;
 
 import com.google.common.annotations.Beta;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.google.common.base.Verify;
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.nio.charset.StandardCharsets;
 import java.util.regex.Pattern;
-import javax.annotation.Nonnull;
+import javax.annotation.RegEx;
 import org.opendaylight.yangtools.concepts.Identifier;
 
 /**
@@ -20,16 +31,116 @@ import org.opendaylight.yangtools.concepts.Identifier;
  * @author Robert Varga
  */
 @Beta
-public interface FrontendType extends Identifier {
-    Pattern SIMPLE_STRING_PATTERN = Pattern.compile("[a-zA-Z-_.*+:=,!~';]+");
+public final class FrontendType implements Comparable<FrontendType>, Identifier, WritableObject {
+    private static final class Proxy implements Externalizable {
+        private static final long serialVersionUID = 1L;
+        private byte[] serialized;
+
+        public Proxy() {
+            // For Externalizable
+        }
+
+        Proxy(final byte[] serialized) {
+            this.serialized = Preconditions.checkNotNull(serialized);
+        }
+
+        @Override
+        public void writeExternal(final ObjectOutput out) throws IOException {
+            out.writeInt(serialized.length);
+            out.write(serialized);
+        }
+
+        @Override
+        public void readExternal(final ObjectInput in) throws IOException {
+            serialized = new byte[in.readInt()];
+            in.readFully(serialized);
+        }
+
+        private Object readResolve() {
+            // TODO: consider caching instances here
+            return new FrontendType(new String(serialized, StandardCharsets.UTF_8), serialized);
+        }
+    }
+
+    @RegEx
+    private static final String SIMPLE_STRING_REGEX = "^[a-zA-Z0-9-_.*+:=,!~';]+$";
+    private static final Pattern SIMPLE_STRING_PATTERN = Pattern.compile(SIMPLE_STRING_REGEX);
+    private static final long serialVersionUID = 1L;
+    private final String name;
+    private volatile byte[] serialized;
+
+    private FrontendType(final String name) {
+        this.name = Preconditions.checkNotNull(name);
+    }
+
+    FrontendType(final String name, final byte[] serialized) {
+        this(name);
+        this.serialized = Verify.verifyNotNull(serialized);
+    }
 
     /**
-     * Return a string representation of this frontend type. Unlike {@link #toString()}, returned string has
-     * restricted rules on what it can contain:
-     * - US-ASCII letters
+     * Return a {@link FrontendType} corresponding to a string representation. Input string has constraints
+     * on what characters it can contain. It may contain the following:
+     * - US-ASCII letters and numbers
      * - special characters: -_.*+:=,!~';
      *
-     * A validation pattern for this string is available as {@link #SIMPLE_STRING_PATTERN}.
+     * @return A {@link FrontendType} instance
+     * @throws IllegalArgumentException if the string is null, empty or contains invalid characters
      */
-    @Nonnull String toSimpleString();
+    public static FrontendType forName(final String name) {
+        Preconditions.checkArgument(!Strings.isNullOrEmpty(name));
+        Preconditions.checkArgument(SIMPLE_STRING_PATTERN.matcher(name).matches(),
+            "Supplied name %s does not patch pattern %s", name, SIMPLE_STRING_REGEX);
+        return new FrontendType(name);
+    }
+
+    public static FrontendType readFrom(final DataInput in) throws IOException {
+        final byte[] serialized = new byte[in.readInt()];
+        in.readFully(serialized);
+        return new FrontendType(new String(serialized, StandardCharsets.UTF_8));
+    }
+
+    @Override
+    public void writeTo(final DataOutput out) throws IOException {
+        final byte[] serialized = getSerialized();
+        out.writeInt(serialized.length);
+        out.write(serialized);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int hashCode() {
+        return name.hashCode();
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        return this == o || (o instanceof FrontendType && name.equals(((FrontendType)o).name));
+    }
+
+    @Override
+    public int compareTo(final FrontendType o) {
+        return this == o ? 0 : name.compareTo(o.name);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(FrontendType.class).add("name", name).toString();
+    }
+
+    private byte[] getSerialized() {
+        byte[] local = serialized;
+        if (local == null) {
+            local = name.getBytes(StandardCharsets.UTF_8);
+            serialized = local;
+        }
+        return local;
+    }
+
+    Object writeReplace() {
+        return new Proxy(getSerialized());
+    }
 }