--- /dev/null
+package org.opendaylight.yangtools.concepts;
+
+import java.util.EventListener;
+
+public abstract class AbstractListenerRegistration<T extends EventListener> extends AbstractObjectRegistration<T>
+ implements ListenerRegistration<T> {
+
+ public AbstractListenerRegistration(T listener) {
+ super(listener);
+ }
+
+}
--- /dev/null
+package org.opendaylight.yangtools.concepts;\r
+\r
+/**\r
+ * Utility registration handle. It is a convenience for register-style method\r
+ * which can return an AutoCloseable realized by a subclass of this class.\r
+ * Invoking the close() method triggers unregistration of the state the method\r
+ * installed.\r
+ */\r
+public abstract class AbstractObjectRegistration<T> extends AbstractRegistration implements Registration<T> {\r
+\r
+ \r
+ private final T instance;\r
+\r
+ public AbstractObjectRegistration(T instance) {\r
+ this.instance = instance;\r
+ }\r
+\r
+ @Override\r
+ public final T getInstance() {\r
+ return instance;\r
+ }\r
+\r
+}\r
-package org.opendaylight.yangtools.concepts;\r
-\r
-/**\r
- * Utility registration handle. It is a convenience for register-style method\r
- * which can return an AutoCloseable realized by a subclass of this class.\r
- * Invoking the close() method triggers unregistration of the state the method\r
- * installed.\r
- */\r
-public abstract class AbstractRegistration<T> implements Registration<T> {\r
-\r
- private boolean closed = false;\r
- private final T instance;\r
-\r
- public AbstractRegistration(T instance) {\r
- this.instance = instance;\r
- }\r
-\r
- @Override\r
- public T getInstance() {\r
- return instance;\r
- }\r
-\r
- /**\r
- * Remove the state referenced by this registration. This method is\r
- * guaranteed to be called at most once. The referenced state must be\r
- * retained until this method is invoked.\r
- */\r
- protected abstract void removeRegistration();\r
-\r
- @Override\r
- public void close() throws Exception {\r
- if (!closed) {\r
- closed = true;\r
- removeRegistration();\r
- }\r
- }\r
-\r
-}\r
+package org.opendaylight.yangtools.concepts;
+
+/**
+ * Utility registration handle. It is a convenience for register-style method
+ * which can return an AutoCloseable realized by a subclass of this class.
+ * Invoking the close() method triggers unregistration of the state the method
+ * installed.
+ */
+public abstract class AbstractRegistration implements AutoCloseable {
+
+ private boolean closed = false;
+
+ /**
+ * Remove the state referenced by this registration. This method is
+ * guaranteed to be called at most once. The referenced state must be
+ * retained until this method is invoked.
+ */
+ protected abstract void removeRegistration();
+
+ @Override
+ public synchronized void close() throws Exception {
+ if (!closed) {
+ closed = true;
+ removeRegistration();
+ }
+ }
+}
* @author Tony Tkacik <ttkacik@cisco.com>\r
*/\r
public interface Builder<P> extends Mutable {\r
+ \r
+ /**\r
+ * Returns instance of the product.\r
+ * \r
+ * Multiple calls to this method are not required to return\r
+ * same instance if the state of the builder was changed.\r
+ * \r
+ * @return\r
+ */\r
P toInstance();\r
}\r
--- /dev/null
+package org.opendaylight.yangtools.concepts;
+
+public interface ClassBasedPropertyBuilder<P,T extends ClassBasedPropertyBuilder<P,T>> extends Builder<P> {
+
+ /**
+ * Sets a value of property uniquely identified by it's
+ * class.
+ *
+ * @param type Type of property to set
+ * @param value Value of property
+ * @return
+ */
+ <V> T set(Class<V> type,V value);
+
+ /**
+ * Gets a value of property based on it's type.
+ *
+ * @param type
+ * @return
+ */
+ <V> V get(Class<V> type);
+
+}
package org.opendaylight.yangtools.concepts;\r
\r
public interface Identifiable<T> {\r
+ \r
T getIdentifier();\r
}\r
--- /dev/null
+package org.opendaylight.yangtools.concepts.util;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.concepts.Mutable;
+
+public class Immutables {
+
+ private Immutables() {
+ throw new UnsupportedOperationException("Helper class");
+ }
+
+ public static final Set<Class<?>> KNOWN_IMMUTABLES = Immutables.<Class<?>> asHashSet(
+ //
+ Integer.class, Short.class, BigDecimal.class, BigInteger.class, Byte.class, Character.class, Double.class,
+ Float.class);
+
+ /**
+ * Determines if object is known to be immutable
+ *
+ * Note: This method may return false to immutable objects which
+ * immutability is not known, was defined not using concepts term.
+ *
+ * @param o
+ * Reference to check
+ * @return true if object is known to be immutable false otherwise.
+ */
+ public static boolean isImmutable(Object o) {
+ if (o == null) {
+ throw new IllegalArgumentException("Object should not be null");
+ }
+ if (o instanceof Mutable) {
+ return false;
+ } else if (o instanceof Immutable) {
+ return true;
+ } else if (o instanceof String) {
+ return true;
+ } else if (KNOWN_IMMUTABLES.contains(o.getClass())) {
+ return true;
+ }
+ return false;
+ }
+
+ private static boolean isNumberImmutable(Number o) {
+ if(o instanceof AtomicInteger) {
+ return false;
+ } else if(o instanceof AtomicLong) {
+ return false;
+ } else if(o instanceof Short) {
+ return true;
+ }
+ return false;
+ }
+
+ @SafeVarargs
+ private static <E> Set<E> asHashSet(E... list) {
+ HashSet<E> ret = new HashSet<>();
+ for (E e : list) {
+ ret.add(e);
+ }
+ return Collections.unmodifiableSet(ret);
+ }
+}
import java.util.List;\r
import java.util.Map;\r
\r
+import org.opendaylight.yangtools.concepts.Builder;\r
import org.opendaylight.yangtools.concepts.Immutable;\r
import org.opendaylight.yangtools.concepts.Path;\r
import org.opendaylight.yangtools.yang.common.QName;\r
\r
// Static factories & helpers\r
\r
- public InstanceIdentifier of(QName name) {\r
+ public static InstanceIdentifier of(QName name) {\r
return new InstanceIdentifier(new NodeIdentifier(name));\r
}\r
\r
- public InstanceIdentifierBuilder builder() {\r
+ static public InstanceIdentifierBuilder builder() {\r
return new BuilderImpl();\r
}\r
\r
\r
}\r
\r
- public interface InstanceIdentifierBuilder {\r
+ public interface InstanceIdentifierBuilder extends Builder<InstanceIdentifier>{\r
InstanceIdentifierBuilder node(QName nodeType);\r
\r
InstanceIdentifierBuilder nodeWithKey(QName nodeType, Map<QName, Object> keyValues);\r
\r
InstanceIdentifierBuilder nodeWithKey(QName nodeType, QName key, Object value);\r
\r
+ @Deprecated\r
InstanceIdentifier getIdentifier();\r
}\r
\r
}\r
\r
@Override\r
- public InstanceIdentifier getIdentifier() {\r
+ public InstanceIdentifier toInstance() {\r
return new InstanceIdentifier(path);\r
}\r
+ \r
+ @Override\r
+ public InstanceIdentifier getIdentifier() {\r
+ return toInstance();\r
+ }\r
}\r
\r
@Override\r
Code Review / yangtools.git / commitdiff