b6a7b4b260e4bb5ce1cb94c0302e25c6df53dc3a
[controller.git] / opendaylight / md-sal / cds-access-api / src / main / java / org / opendaylight / controller / cluster / access / concepts / FrontendType.java
1 /*
2  * Copyright (c) 2016 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.access.concepts;
9
10 import static com.google.common.base.Preconditions.checkArgument;
11 import static com.google.common.base.Verify.verifyNotNull;
12 import static java.util.Objects.requireNonNull;
13
14 import com.google.common.annotations.Beta;
15 import com.google.common.base.MoreObjects;
16 import com.google.common.base.Strings;
17 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
18 import java.io.DataInput;
19 import java.io.DataOutput;
20 import java.io.Externalizable;
21 import java.io.IOException;
22 import java.io.ObjectInput;
23 import java.io.ObjectOutput;
24 import java.nio.charset.StandardCharsets;
25 import java.util.regex.Pattern;
26 import org.opendaylight.yangtools.concepts.Identifier;
27 import org.opendaylight.yangtools.concepts.WritableIdentifier;
28
29 /**
30  * An {@link Identifier} identifying a data store frontend type, which is able to access the data store backend.
31  * Frontend implementations need to define this identifier so that multiple clients existing on a member node can be
32  * discerned.
33  *
34  * @author Robert Varga
35  */
36 @Beta
37 public final class FrontendType implements Comparable<FrontendType>, WritableIdentifier {
38     private static final class Proxy implements Externalizable {
39         private static final long serialVersionUID = 1L;
40         private byte[] serialized;
41
42         // checkstyle flags the public modifier as redundant however it is explicitly needed for Java serialization to
43         // be able to create instances via reflection.
44         @SuppressWarnings("checkstyle:RedundantModifier")
45         public Proxy() {
46             // For Externalizable
47         }
48
49         Proxy(final byte[] serialized) {
50             this.serialized = requireNonNull(serialized);
51         }
52
53         @Override
54         public void writeExternal(final ObjectOutput out) throws IOException {
55             out.writeInt(serialized.length);
56             out.write(serialized);
57         }
58
59         @Override
60         public void readExternal(final ObjectInput in) throws IOException {
61             serialized = new byte[in.readInt()];
62             in.readFully(serialized);
63         }
64
65         private Object readResolve() {
66             // TODO: consider caching instances here
67             return new FrontendType(new String(serialized, StandardCharsets.UTF_8), serialized);
68         }
69     }
70
71     private static final String SIMPLE_STRING_REGEX = "^[a-zA-Z0-9-_.*+:=,!~';]+$";
72     private static final Pattern SIMPLE_STRING_PATTERN = Pattern.compile(SIMPLE_STRING_REGEX);
73     private static final long serialVersionUID = 1L;
74     private final String name;
75
76     @SuppressFBWarnings(value = "VO_VOLATILE_REFERENCE_TO_ARRAY",
77             justification = "The array elements are non-volatile but we don't access them.")
78     private volatile byte[] serialized;
79
80     private FrontendType(final String name) {
81         this.name = requireNonNull(name);
82     }
83
84     FrontendType(final String name, final byte[] serialized) {
85         this(name);
86         this.serialized = verifyNotNull(serialized);
87     }
88
89     /**
90      * Return a {@link FrontendType} corresponding to a string representation. Input string has constraints
91      * on what characters it can contain. It may contain the following:
92      * - US-ASCII letters and numbers
93      * - special characters: -_.*+:=,!~';
94      *
95      * @param name the input name
96      * @return A {@link FrontendType} instance
97      * @throws IllegalArgumentException if the string is null, empty or contains invalid characters
98      */
99     public static FrontendType forName(final String name) {
100         checkArgument(!Strings.isNullOrEmpty(name));
101         checkArgument(SIMPLE_STRING_PATTERN.matcher(name).matches(),
102             "Supplied name %s does not patch pattern %s", name, SIMPLE_STRING_REGEX);
103         return new FrontendType(name);
104     }
105
106     public static FrontendType readFrom(final DataInput in) throws IOException {
107         final byte[] serialized = new byte[in.readInt()];
108         in.readFully(serialized);
109         return new FrontendType(new String(serialized, StandardCharsets.UTF_8));
110     }
111
112     @Override
113     public void writeTo(final DataOutput out) throws IOException {
114         final byte[] local = getSerialized();
115         out.writeInt(local.length);
116         out.write(local);
117     }
118
119     public String getName() {
120         return name;
121     }
122
123     @Override
124     public int hashCode() {
125         return name.hashCode();
126     }
127
128     @Override
129     public boolean equals(final Object obj) {
130         return this == obj || obj instanceof FrontendType && name.equals(((FrontendType)obj).name);
131     }
132
133     @Override
134     public int compareTo(final FrontendType obj) {
135         return this == obj ? 0 : name.compareTo(obj.name);
136     }
137
138     @Override
139     public String toString() {
140         return MoreObjects.toStringHelper(FrontendType.class).add("name", name).toString();
141     }
142
143     private byte[] getSerialized() {
144         byte[] local = serialized;
145         if (local == null) {
146             local = name.getBytes(StandardCharsets.UTF_8);
147             serialized = local;
148         }
149         return local;
150     }
151
152     Object writeReplace() {
153         return new Proxy(getSerialized());
154     }
155 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.