import java.util.Set;\r
import java.util.concurrent.Future;\r
\r
+import org.opendaylight.yangtools.binding.generator.util.BindingTypes;\r
import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl;\r
import org.opendaylight.yangtools.binding.generator.util.Types;\r
import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;\r
import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;\r
import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;\r
import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider;\r
+import org.opendaylight.yangtools.sal.binding.model.api.AccessModifier;\r
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;\r
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;\r
import org.opendaylight.yangtools.sal.binding.model.api.ParameterizedType;\r
throw new IllegalArgumentException("Reference to Set of Notification Definitions in module "\r
+ module.getName() + " cannot be NULL.");\r
}\r
-\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
- final List<Type> genNotifyTypes = new ArrayList<>();\r
final Set<NotificationDefinition> notifications = module.getNotifications();\r
-\r
+ if(notifications.isEmpty()) return Collections.emptyList();\r
+ \r
+ final GeneratedTypeBuilder listenerInterface = moduleTypeBuilder(module, "Listener");\r
+ listenerInterface.addImplementsType(BindingTypes.NOTIFICATION_LISTENER);\r
+ \r
+ \r
+ \r
+ final String basePackageName = moduleNamespaceToPackageName(module);\r
+ final List<Type> generatedTypes = new ArrayList<>();\r
+ \r
+ \r
for (final NotificationDefinition notification : notifications) {\r
if (notification != null) {\r
DataNodeIterator it = new DataNodeIterator(notification);\r
// Containers\r
for (ContainerSchemaNode node : it.allContainers()) {\r
if (!node.isAddedByUses()) {\r
- genNotifyTypes.add(containerToGenType(basePackageName, node));\r
+ generatedTypes.add(containerToGenType(basePackageName, node));\r
}\r
}\r
// Lists\r
for (ListSchemaNode node : it.allLists()) {\r
if (!node.isAddedByUses()) {\r
- genNotifyTypes.addAll(listToGenType(basePackageName, node));\r
+ generatedTypes.addAll(listToGenType(basePackageName, node));\r
}\r
}\r
- final GeneratedTypeBuilder notificationTypeBuilder = addDefaultInterfaceDefinition(basePackageName,\r
+ final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(basePackageName,\r
notification);\r
- notificationTypeBuilder.addImplementsType(Types\r
+ notificationInterface.addImplementsType(Types\r
.typeForClass(org.opendaylight.yangtools.yang.binding.Notification.class));\r
// Notification object\r
- resolveDataSchemaNodes(basePackageName, notificationTypeBuilder, notification.getChildNodes());\r
- genNotifyTypes.add(notificationTypeBuilder.toInstance());\r
+ resolveDataSchemaNodes(basePackageName, notificationInterface, notification.getChildNodes());\r
+ \r
+ listenerInterface.addMethod("on"+notificationInterface.getName()) //\r
+ .setAccessModifier(AccessModifier.PUBLIC)\r
+ .addParameter(notificationInterface, "notification")\r
+ .setReturnType(Types.VOID);\r
+ \r
+ generatedTypes.add(notificationInterface.toInstance());\r
}\r
}\r
- return genNotifyTypes;\r
+ generatedTypes.add(listenerInterface.toInstance());\r
+ return generatedTypes;\r
}\r
\r
/**\r
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
*
*/
private Enumeration addInnerEnumerationToTypeBuilder(final EnumTypeDefinition enumTypeDef, final String enumName,
- final GeneratedTypeBuilder typeBuilder) {
+ final GeneratedTypeBuilderBase<?> typeBuilder) {
Preconditions.checkArgument(enumTypeDef != null, "EnumTypeDefinition reference cannot be NULL!");
Preconditions.checkArgument(enumTypeDef.getValues() != null,
"EnumTypeDefinition MUST contain at least ONE value definition!");
private GeneratedTransferObject wrapJavaTypeIntoTO(final String basePackageName, final TypeDefinition<?> typedef,
final Type javaType) {
if (javaType != null) {
- final String typedefName = typedef.getQName().getLocalName();
final String propertyName = "value";
final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(basePackageName, typedef);
import java.util.ArrayList;\r
import java.util.List;\r
\r
-abstract class AbstractGeneratedTypeBuilder extends AbstractBaseType implements GeneratedTypeBuilder {\r
+abstract class AbstractGeneratedTypeBuilder<T extends GeneratedTypeBuilderBase<T>> extends AbstractBaseType implements GeneratedTypeBuilderBase<T> {\r
\r
private String comment = "";\r
\r
private final List<Constant> constants = new ArrayList<>();\r
private final List<MethodSignatureBuilder> methodDefinitions = new ArrayList<>();\r
private final List<GeneratedTypeBuilder> enclosedTypes = new ArrayList<>();\r
- private final List<GeneratedTOBuilder> enclosingTransferObjects = new ArrayList<>();\r
+ private final List<GeneratedTOBuilder> enclosedTransferObjects = new ArrayList<>();\r
private final List<GeneratedPropertyBuilder> properties = new ArrayList<>();\r
private boolean isAbstract;\r
\r
}\r
\r
protected List<GeneratedTOBuilder> getEnclosedTransferObjects() {\r
- return enclosingTransferObjects;\r
- }\r
-\r
- @Override\r
- public GeneratedTypeBuilder addEnclosingType(String name) {\r
- if (name == null) {\r
- throw new IllegalArgumentException("Name for Enclosing Generated Type cannot be null!");\r
- }\r
- GeneratedTypeBuilder builder = new GeneratedTOBuilderImpl(getFullyQualifiedName(), name);\r
- enclosedTypes.add(builder);\r
- return builder;\r
+ return enclosedTransferObjects;\r
}\r
\r
+ abstract protected T thisInstance();\r
+ \r
@Override\r
public GeneratedTOBuilder addEnclosingTransferObject(String name) {\r
if (name == null) {\r
throw new IllegalArgumentException("Name for Enclosing Generated Transfer Object cannot be null!");\r
}\r
GeneratedTOBuilder builder = new GeneratedTOBuilderImpl(getFullyQualifiedName(), name);\r
- enclosingTransferObjects.add(builder);\r
+ enclosedTransferObjects.add(builder);\r
return builder;\r
}\r
\r
@Override\r
- public void addEnclosingTransferObject(final GeneratedTOBuilder genTOBuilder) {\r
+ public T addEnclosingTransferObject(final GeneratedTOBuilder genTOBuilder) {\r
if (genTOBuilder == null) {\r
throw new IllegalArgumentException("Parameter genTOBuilder cannot be null!");\r
}\r
- enclosingTransferObjects.add(genTOBuilder);\r
+ enclosedTransferObjects.add(genTOBuilder);\r
+ return thisInstance();\r
}\r
\r
@Override\r
- public void addComment(String comment) {\r
+ public T addComment(String comment) {\r
this.comment = comment;\r
+ return thisInstance();\r
}\r
\r
@Override\r
}\r
\r
@Override\r
- public void setAbstract(boolean isAbstract) {\r
+ public T setAbstract(boolean isAbstract) {\r
this.isAbstract = isAbstract;\r
+ return thisInstance();\r
}\r
\r
@Override\r
- public boolean addImplementsType(Type genType) {\r
+ public T addImplementsType(Type genType) {\r
if (genType == null) {\r
throw new IllegalArgumentException("Type cannot be null");\r
}\r
- return implementsTypes.add(genType);\r
+ implementsTypes.add(genType);\r
+ return thisInstance();\r
}\r
\r
@Override\r
if (getClass() != obj.getClass()) {\r
return false;\r
}\r
- AbstractGeneratedTypeBuilder other = (AbstractGeneratedTypeBuilder) obj;\r
+ AbstractGeneratedTypeBuilder<T> other = (AbstractGeneratedTypeBuilder<T>) obj;\r
if (getName() == null) {\r
if (other.getName() != null) {\r
return false;\r
import java.util.ArrayList;
import java.util.List;
-abstract class AbstractTypeMemberBuilder implements TypeMemberBuilder {
+abstract class AbstractTypeMemberBuilder<T extends TypeMemberBuilder<T>> implements TypeMemberBuilder<T> {
private final String name;
private Type returnType;
private final List<AnnotationTypeBuilder> annotationBuilders;
return name;
}
+ protected abstract T thisInstance();
+
@Override
- public void setReturnType(Type returnType) {
+ public T setReturnType(Type returnType) {
if (returnType == null) {
throw new IllegalArgumentException("Return Type of member cannot be null!");
}
this.returnType = returnType;
+ return thisInstance();
}
@Override
- public void setAccessModifier(AccessModifier modifier) {
+ public T setAccessModifier(AccessModifier modifier) {
if (modifier == null) {
throw new IllegalArgumentException("Access Modifier for member type cannot be null!");
}
this.accessModifier = modifier;
+ return thisInstance();
}
@Override
- public void setComment(String comment) {
+ public T setComment(String comment) {
if (comment == null) {
this.comment = "";
}
this.comment = comment;
+ return thisInstance();
}
@Override
- public void setFinal(boolean isFinal) {
+ public T setFinal(boolean isFinal) {
this.isFinal = isFinal;
+ return thisInstance();
}
protected List<AnnotationType> toAnnotationTypes() {
import java.util.List;
-final class GeneratedPropertyBuilderImpl extends AbstractTypeMemberBuilder implements GeneratedPropertyBuilder {
+final class GeneratedPropertyBuilderImpl extends AbstractTypeMemberBuilder<GeneratedPropertyBuilder> implements GeneratedPropertyBuilder {
private boolean isReadOnly;
}
@Override
- public void setReadOnly(boolean isReadOnly) {
+ public GeneratedPropertyBuilderImpl setReadOnly(boolean isReadOnly) {
this.isReadOnly = isReadOnly;
+ return this;
}
+ @Override
+ protected GeneratedPropertyBuilderImpl thisInstance() {
+ return this;
+ }
+
@Override
public GeneratedProperty toInstance(Type definingType) {
final List<AnnotationType> annotations = toAnnotationTypes();
import java.util.ArrayList;\r
import java.util.List;\r
\r
-public final class GeneratedTOBuilderImpl extends AbstractGeneratedTypeBuilder implements GeneratedTOBuilder {\r
+public final class GeneratedTOBuilderImpl extends AbstractGeneratedTypeBuilder<GeneratedTOBuilder> implements GeneratedTOBuilder {\r
\r
private GeneratedTransferObject extendsType;\r
private final List<GeneratedPropertyBuilder> properties = new ArrayList<>();\r
}\r
\r
@Override\r
- public void setExtendsType(final GeneratedTransferObject genTransObj) {\r
+ public GeneratedTOBuilder setExtendsType(final GeneratedTransferObject genTransObj) {\r
if (genTransObj == null) {\r
throw new IllegalArgumentException("Generated Transfer Object cannot be null!");\r
}\r
extendsType = genTransObj;\r
+ return this;\r
}\r
\r
\r
}\r
\r
@Override\r
- public boolean addEqualsIdentity(GeneratedPropertyBuilder property) {\r
- return equalsProperties.add(property);\r
+ public GeneratedTOBuilder addEqualsIdentity(GeneratedPropertyBuilder property) {\r
+ equalsProperties.add(property);\r
+ return this;\r
}\r
\r
@Override\r
- public boolean addHashIdentity(GeneratedPropertyBuilder property) {\r
- return hashProperties.add(property);\r
+ public GeneratedTOBuilder addHashIdentity(GeneratedPropertyBuilder property) {\r
+ hashProperties.add(property);\r
+ return this;\r
}\r
\r
@Override\r
- public boolean addToStringProperty(GeneratedPropertyBuilder property) {\r
- return toStringProperties.add(property);\r
+ public GeneratedTOBuilder addToStringProperty(GeneratedPropertyBuilder property) {\r
+ toStringProperties.add(property);\r
+ return this;\r
}\r
\r
+ @Override\r
+ protected GeneratedTOBuilder thisInstance() {\r
+ return this;\r
+ }\r
+ \r
@Override\r
public GeneratedTransferObject toInstance() {\r
return new GeneratedTransferObjectImpl(this);\r
\r
\r
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;\r
+import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;\r
\r
-public final class GeneratedTypeBuilderImpl extends AbstractGeneratedTypeBuilder {\r
+public final class GeneratedTypeBuilderImpl extends AbstractGeneratedTypeBuilder<GeneratedTypeBuilder> implements GeneratedTypeBuilder {\r
\r
public GeneratedTypeBuilderImpl(String packageName, String name) {\r
super(packageName, name);\r
builder.append("]");\r
return builder.toString();\r
}\r
+ \r
+ @Override\r
+ protected GeneratedTypeBuilderImpl thisInstance() {\r
+ return this;\r
+ }\r
\r
private static final class GeneratedTypeImpl extends AbstractGeneratedType {\r
\r
import org.opendaylight.yangtools.sal.binding.model.api.Type;
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;
-final class MethodSignatureBuilderImpl extends AbstractTypeMemberBuilder implements MethodSignatureBuilder {
+final class MethodSignatureBuilderImpl extends AbstractTypeMemberBuilder<MethodSignatureBuilder> implements MethodSignatureBuilder {
private final List<MethodSignature.Parameter> parameters;
private boolean isAbstract;
}
@Override
- public void setAbstract(boolean isAbstract) {
+ public MethodSignatureBuilder setAbstract(boolean isAbstract) {
this.isAbstract = isAbstract;
+ return this;
}
@Override
- public void addParameter(Type type, String name) {
+ public MethodSignatureBuilder addParameter(Type type, String name) {
parameters.add(new MethodParameterImpl(name, type));
+ return this;
}
+@Override
+ protected MethodSignatureBuilder thisInstance() {
+ return this;
+ }
+
@Override
public MethodSignature toInstance(Type definingType) {
final List<AnnotationType> annotations = toAnnotationTypes();
*
* @see GeneratedProperty
*/
-public interface GeneratedPropertyBuilder extends TypeMemberBuilder {
+public interface GeneratedPropertyBuilder extends TypeMemberBuilder<GeneratedPropertyBuilder> {
/**
* Sets isReadOnly flag for property. If property is marked as read only
*
* @param isReadOnly Read Only property flag.
*/
- public void setReadOnly(final boolean isReadOnly);
+ public GeneratedPropertyBuilder setReadOnly(final boolean isReadOnly);
/**
* Returns <code>new</code> <i>immutable</i> instance of Generated
* \r
* @see GeneratedTransferObject\r
*/\r
-public interface GeneratedTOBuilder extends GeneratedTypeBuilder {\r
+public interface GeneratedTOBuilder extends GeneratedTypeBuilderBase<GeneratedTOBuilder> {\r
\r
/**\r
* Add Generated Transfer Object from which will be extended current\r
* \r
* @param genTransObj\r
* Generated Transfer Object\r
+ * @return This instance of builder\r
*/\r
- public void setExtendsType(final GeneratedTransferObject genTransObj);\r
+ public GeneratedTOBuilder setExtendsType(final GeneratedTransferObject genTransObj);\r
\r
/**\r
* Add Property that will be part of <code>equals</code> definition. <br>\r
* \r
* @param property\r
* Generated Property Builder\r
- * @return <code>true</code> if addition of Generated Property into list of\r
- * <code>equals</code> properties is successful.\r
+ * @return This instance of builder\r
*/\r
- public boolean addEqualsIdentity(final GeneratedPropertyBuilder property);\r
+ public GeneratedTOBuilder addEqualsIdentity(final GeneratedPropertyBuilder property);\r
\r
/**\r
* Add Property that will be part of <code>hashCode</code> definition. <br>\r
* \r
* @param property\r
* Generated Property Builder\r
- * @return <code>true</code> if addition of Generated Property into list of\r
- * <code>hashCode</code> properties is successful.\r
+ * @return This instance of builder\r
*/\r
- public boolean addHashIdentity(final GeneratedPropertyBuilder property);\r
+ public GeneratedTOBuilder addHashIdentity(final GeneratedPropertyBuilder property);\r
\r
/**\r
* Add Property that will be part of <code>toString</code> definition. <br>\r
* \r
* @param property\r
* Generated Property Builder\r
- * @return <code>true</code> if addition of Generated Property into list of\r
- * <code>toString</code> properties is successful.\r
+ * @return This instance of builder\r
*/\r
- public boolean addToStringProperty(final GeneratedPropertyBuilder property);\r
+ public GeneratedTOBuilder addToStringProperty(final GeneratedPropertyBuilder property);\r
\r
- @Override\r
public GeneratedTransferObject toInstance();\r
\r
/**\r
* \r
* @see GeneratedType\r
*/\r
-public interface GeneratedTypeBuilder extends Type {\r
-\r
- /**\r
- * Adds new Enclosing Type into definition of Generated Type and returns\r
- * <code>new</code> Instance of Generated Type Builder. <br>\r
- * There is no need of specifying of Package Name because enclosing Type is\r
- * already defined inside Generated Type with specific package name. <br>\r
- * The name of enclosing Type cannot be same as Name of parent type and if\r
- * there is already defined enclosing type with the same name, the new\r
- * enclosing type will simply overwrite the older definition. <br>\r
- * If the name of enclosing type is <code>null</code> the method SHOULD\r
- * throw {@link IllegalArgumentException}\r
- * \r
- * @param name\r
- * Name of Enclosing Type\r
- * @return <code>new</code> Instance of Generated Type Builder.\r
- */\r
- public GeneratedTypeBuilder addEnclosingType(final String name);\r
-\r
- /**\r
- * Adds new Enclosing Transfer Object into definition of Generated Type and\r
- * returns <code>new</code> Instance of Generated TO Builder. <br>\r
- * There is no need of specifying of Package Name because enclosing Type is\r
- * already defined inside Generated Type with specific package name. <br>\r
- * The name of enclosing Type cannot be same as Name of parent type and if\r
- * there is already defined enclosing type with the same name, the new\r
- * enclosing type will simply overwrite the older definition. <br>\r
- * If the name of enclosing type is <code>null</code> the method SHOULD\r
- * throw {@link IllegalArgumentException}\r
- * \r
- * @param name\r
- * Name of Enclosing Type\r
- * @return <code>new</code> Instance of Generated Type Builder.\r
- */\r
- public GeneratedTOBuilder addEnclosingTransferObject(final String name);\r
-\r
- /**\r
- * Adds new Enclosing Transfer Object <code>genTOBuilder</code> into\r
- * definition of Generated Type\r
- * \r
- * <br>\r
- * There is no need of specifying of Package Name because enclosing Type is\r
- * already defined inside Generated Type with specific package name. <br>\r
- * The name of enclosing Type cannot be same as Name of parent type and if\r
- * there is already defined enclosing type with the same name, the new\r
- * enclosing type will simply overwrite the older definition. <br>\r
- * If the parameter <code>genTOBuilder</code> of enclosing type is\r
- * <code>null</code> the method SHOULD throw\r
- * {@link IllegalArgumentException}\r
- * \r
- * @param <code>genTOBuilder</code> Name of Enclosing Type\r
- */\r
- public void addEnclosingTransferObject(final GeneratedTOBuilder genTOBuilder);\r
-\r
- /**\r
- * Adds String definition of comment into Method Signature definition. <br>\r
- * The comment String MUST NOT contain anny comment specific chars (i.e.\r
- * "/**" or "//") just plain String text description.\r
- * \r
- * @param comment\r
- * Comment String.\r
- */\r
- public void addComment(final String comment);\r
-\r
- /**\r
- * The method creates new AnnotationTypeBuilder containing specified package\r
- * name an annotation name. <br>\r
- * Neither the package name or annotation name can contain <code>null</code>\r
- * references. In case that any of parameters contains <code>null</code> the\r
- * method SHOULD thrown {@link IllegalArgumentException}\r
- * \r
- * @param packageName\r
- * Package Name of Annotation Type\r
- * @param name\r
- * Name of Annotation Type\r
- * @return <code>new</code> instance of Annotation Type Builder.\r
- */\r
- public AnnotationTypeBuilder addAnnotation(final String packageName, final String name);\r
-\r
- /**\r
- * Sets the <code>abstract</code> flag to define Generated Type as\r
- * <i>abstract</i> type.\r
- * \r
- * @param isAbstract\r
- * abstract flag\r
- */\r
- public void setAbstract(boolean isAbstract);\r
-\r
- /**\r
- * Add Type to implements.\r
- * \r
- * @param genType\r
- * Type to implement\r
- * @return <code>true</code> if the addition of type is successful.\r
- */\r
- public boolean addImplementsType(final Type genType);\r
-\r
- /**\r
- * Adds Constant definition and returns <code>new</code> Constant instance. <br>\r
- * By definition Constant MUST be defined by return Type, Name and assigned\r
- * value. The name SHOULD be defined with cpaital letters. Neither of method\r
- * parameters can be <code>null</code> and the method SHOULD throw\r
- * {@link IllegalArgumentException} if the contract is broken.\r
- * \r
- * @param type\r
- * Constant Type\r
- * @param name\r
- * Name of Constant\r
- * @param value\r
- * Assigned Value\r
- * @return <code>new</code> Constant instance.\r
- */\r
- public Constant addConstant(final Type type, final String name, final Object value);\r
-\r
- /**\r
- * Adds new Enumeration definition for Generated Type Builder and returns\r
- * Enum Builder for specifying all Enum parameters. <br>\r
- * If there is already Enumeration stored with the same name, the old enum\r
- * will be simply overwritten byt new enum definition. <br>\r
- * Name of Enumeration cannot be <code>null</code>, if it is\r
- * <code>null</code> the method SHOULD throw\r
- * {@link IllegalArgumentException}\r
- * \r
- * @param name\r
- * Enumeration Name\r
- * @return <code>new</code> instance of Enumeration Builder.\r
- */\r
- public EnumBuilder addEnumeration(final String name);\r
-\r
- /**\r
- * Add new Method Signature definition for Generated Type Builder and\r
- * returns Method Signature Builder for specifying all Method parameters. <br>\r
- * Name of Method cannot be <code>null</code>, if it is <code>null</code>\r
- * the method SHOULD throw {@link IllegalArgumentException} <br>\r
- * By <i>Default</i> the MethodSignatureBuilder SHOULD be pre-set as\r
- * {@link MethodSignatureBuilder#setAbstract(true)},\r
- * {@link MethodSignatureBuilder#setFinal(false)} and\r
- * {@link MethodSignatureBuilder#setAccessModifier(PUBLIC)}\r
- * \r
- * @param name\r
- * Name of Method\r
- * @return <code>new</code> instance of Method Signature Builder.\r
- */\r
- public MethodSignatureBuilder addMethod(final String name);\r
-\r
- /**\r
- * Checks if GeneratedTypeBuilder contains method with name\r
- * <code>methodName</code>\r
- * \r
- * @param methodName\r
- * is method name\r
- */\r
- public boolean containsMethod(final String methodName);\r
- \r
- /**\r
- * Add new Generated Property definition for Generated Transfer Object\r
- * Builder and returns Generated Property Builder for specifying Property. <br>\r
- * Name of Property cannot be <code>null</code>, if it is <code>null</code>\r
- * the method SHOULD throw {@link IllegalArgumentException}\r
- * \r
- * @param name\r
- * Name of Property\r
- * @return <code>new</code> instance of Generated Property Builder.\r
- */\r
- public GeneratedPropertyBuilder addProperty(final String name);\r
-\r
- /**\r
- * Check whether GeneratedTOBuilder contains property with name\r
- * <code>name</code>\r
- * \r
- * @param name\r
- * of property which existance is checked\r
- * @return true if property <code>name</code> exists in list of properties.\r
- */\r
- public boolean containsProperty(final String name);\r
-\r
+public interface GeneratedTypeBuilder extends GeneratedTypeBuilderBase<GeneratedTypeBuilder> {\r
+ \r
/**\r
* Returns the <code>new</code> <i>immutable</i> instance of Generated Type.\r
* \r
* @return the <code>new</code> <i>immutable</i> instance of Generated Type.\r
*/\r
public GeneratedType toInstance();\r
+\r
}\r
--- /dev/null
+package org.opendaylight.yangtools.sal.binding.model.api.type.builder;
+
+import org.opendaylight.yangtools.sal.binding.model.api.Constant;
+import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
+import org.opendaylight.yangtools.sal.binding.model.api.Type;
+
+public interface GeneratedTypeBuilderBase <T extends GeneratedTypeBuilderBase<T>> extends Type {
+
+ /**
+ * Adds new Enclosing Transfer Object into definition of Generated Type and
+ * returns <code>new</code> Instance of Generated TO Builder. <br>
+ * There is no need of specifying of Package Name because enclosing Type is
+ * already defined inside Generated Type with specific package name. <br>
+ * The name of enclosing Type cannot be same as Name of parent type and if
+ * there is already defined enclosing type with the same name, the new
+ * enclosing type will simply overwrite the older definition. <br>
+ * If the name of enclosing type is <code>null</code> the method SHOULD
+ * throw {@link IllegalArgumentException}
+ *
+ * @param name
+ * Name of Enclosing Type
+ * @return <code>new</code> Instance of Generated Type Builder.
+ */
+ public GeneratedTOBuilder addEnclosingTransferObject(final String name);
+
+ /**
+ * Adds new Enclosing Transfer Object <code>genTOBuilder</code> into
+ * definition of Generated Type
+ *
+ * <br>
+ * There is no need of specifying of Package Name because enclosing Type is
+ * already defined inside Generated Type with specific package name. <br>
+ * The name of enclosing Type cannot be same as Name of parent type and if
+ * there is already defined enclosing type with the same name, the new
+ * enclosing type will simply overwrite the older definition. <br>
+ * If the parameter <code>genTOBuilder</code> of enclosing type is
+ * <code>null</code> the method SHOULD throw
+ * {@link IllegalArgumentException}
+ *
+ * @param <code>genTOBuilder</code> Name of Enclosing Type
+ */
+ public T addEnclosingTransferObject(final GeneratedTOBuilder genTOBuilder);
+
+ /**
+ * Adds String definition of comment into Method Signature definition. <br>
+ * The comment String MUST NOT contain anny comment specific chars (i.e.
+ * "/**" or "//") just plain String text description.
+ *
+ * @param comment
+ * Comment String.
+ */
+ public T addComment(final String comment);
+
+ /**
+ * The method creates new AnnotationTypeBuilder containing specified package
+ * name an annotation name. <br>
+ * Neither the package name or annotation name can contain <code>null</code>
+ * references. In case that any of parameters contains <code>null</code> the
+ * method SHOULD thrown {@link IllegalArgumentException}
+ *
+ * @param packageName
+ * Package Name of Annotation Type
+ * @param name
+ * Name of Annotation Type
+ * @return <code>new</code> instance of Annotation Type Builder.
+ */
+ public AnnotationTypeBuilder addAnnotation(final String packageName, final String name);
+
+ /**
+ * Sets the <code>abstract</code> flag to define Generated Type as
+ * <i>abstract</i> type.
+ *
+ * @param isAbstract
+ * abstract flag
+ */
+ public T setAbstract(boolean isAbstract);
+
+ /**
+ * Add Type to implements.
+ *
+ * @param genType
+ * Type to implement
+ * @return <code>true</code> if the addition of type is successful.
+ */
+ public T addImplementsType(final Type genType);
+
+ /**
+ * Adds Constant definition and returns <code>new</code> Constant instance. <br>
+ * By definition Constant MUST be defined by return Type, Name and assigned
+ * value. The name SHOULD be defined with capital letters. Neither of method
+ * parameters can be <code>null</code> and the method SHOULD throw
+ * {@link IllegalArgumentException} if the contract is broken.
+ *
+ * @param type
+ * Constant Type
+ * @param name
+ * Name of Constant
+ * @param value
+ * Assigned Value
+ * @return <code>new</code> Constant instance.
+ */
+ public Constant addConstant(final Type type, final String name, final Object value);
+
+ /**
+ * Adds new Enumeration definition for Generated Type Builder and returns
+ * Enum Builder for specifying all Enum parameters. <br>
+ * If there is already Enumeration stored with the same name, the old enum
+ * will be simply overwritten byt new enum definition. <br>
+ * Name of Enumeration cannot be <code>null</code>, if it is
+ * <code>null</code> the method SHOULD throw
+ * {@link IllegalArgumentException}
+ *
+ * @param name
+ * Enumeration Name
+ * @return <code>new</code> instance of Enumeration Builder.
+ */
+ public EnumBuilder addEnumeration(final String name);
+
+ /**
+ * Add new Method Signature definition for Generated Type Builder and
+ * returns Method Signature Builder for specifying all Method parameters. <br>
+ * Name of Method cannot be <code>null</code>, if it is <code>null</code>
+ * the method SHOULD throw {@link IllegalArgumentException} <br>
+ * By <i>Default</i> the MethodSignatureBuilder SHOULD be pre-set as
+ * {@link MethodSignatureBuilder#setAbstract(true)},
+ * {@link MethodSignatureBuilder#setFinal(false)} and
+ * {@link MethodSignatureBuilder#setAccessModifier(PUBLIC)}
+ *
+ * @param name
+ * Name of Method
+ * @return <code>new</code> instance of Method Signature Builder.
+ */
+ public MethodSignatureBuilder addMethod(final String name);
+
+ /**
+ * Checks if GeneratedTypeBuilder contains method with name
+ * <code>methodName</code>
+ *
+ * @param methodName
+ * is method name
+ */
+ public boolean containsMethod(final String methodName);
+
+ /**
+ * Add new Generated Property definition for Generated Transfer Object
+ * Builder and returns Generated Property Builder for specifying Property. <br>
+ * Name of Property cannot be <code>null</code>, if it is <code>null</code>
+ * the method SHOULD throw {@link IllegalArgumentException}
+ *
+ * @param name
+ * Name of Property
+ * @return <code>new</code> instance of Generated Property Builder.
+ */
+ public GeneratedPropertyBuilder addProperty(final String name);
+
+ /**
+ * Check whether GeneratedTOBuilder contains property with name
+ * <code>name</code>
+ *
+ * @param name
+ * of property which existance is checked
+ * @return true if property <code>name</code> exists in list of properties.
+ */
+ public boolean containsProperty(final String name);
+
+
+
+}
*
* @see MethodSignature
*/
-public interface MethodSignatureBuilder extends TypeMemberBuilder {
+public interface MethodSignatureBuilder extends TypeMemberBuilder<MethodSignatureBuilder> {
/**
* Sets the flag for declaration of method as abstract or non abstract. If the flag <code>isAbstract == true</code>
*
* @param isAbstract is abstract flag
*/
- public void setAbstract(boolean isAbstract);
+ public MethodSignatureBuilder setAbstract(boolean isAbstract);
/**
* Adds Parameter into the List of method parameters. Neither the Name or
* @param type Parameter Type
* @param name Parameter Name
*/
- public void addParameter(final Type type, final String name);
+ public MethodSignatureBuilder addParameter(final Type type, final String name);
/**
* Returns <code>new</code> <i>immutable</i> instance of Method Signature.
/**
*
*/
-public interface TypeMemberBuilder {
+public interface TypeMemberBuilder<T extends TypeMemberBuilder<T>> {
/**
* The method creates new AnnotationTypeBuilder containing specified
*
* @param returnType Return Type of property.
*/
- public void setReturnType(final Type returnType);
+ public T setReturnType(final Type returnType);
/**
* Sets the access modifier of property.
*
* @param modifier Access Modifier value.
*/
- public void setAccessModifier(final AccessModifier modifier);
+ public T setAccessModifier(final AccessModifier modifier);
/**
* Adds String definition of comment into Method Signature definition.
*
* @param comment Comment String.
*/
- public void setComment(final String comment);
+ public T setComment(final String comment);
/**
* Sets the flag final for method signature. If this is set the method will be prohibited from overriding.
*
* @param isFinal Is Final
*/
- public void setFinal(final boolean isFinal);
+ public T setFinal(final boolean isFinal);
}
Code Review / yangtools.git / commitdiff