io.sundr.codegen.model.ClassRefFluent Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sundr-codegen Show documentation
There is a newer version: 1.14.0
/*
 *      Copyright 2019 The original authors.
 *
 *      Licensed under the Apache License, Version 2.0 (the "License");
 *      you may not use this file except in compliance with the License.
 *      You may obtain a copy of the License at
 *
 *          http://www.apache.org/licenses/LICENSE-2.0
 *
 *      Unless required by applicable law or agreed to in writing, software
 *      distributed under the License is distributed on an "AS IS" BASIS,
 *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *      See the License for the specific language governing permissions and
 *      limitations under the License.
 */

package io.sundr.codegen.model;

import io.sundr.builder.Nested;
import io.sundr.builder.Predicate;
import io.sundr.builder.VisitableBuilder;

import java.util.Collection;
import java.util.List;

public interface ClassRefFluent> extends TypeRefFluent{


    
/**
 * This method has been deprecated, please use method buildDefinition instead.
 * @return The buildable object.
 */
@Deprecated public TypeDef getDefinition();
    public TypeDef buildDefinition();
    public A withDefinition(TypeDef definition);
    public Boolean hasDefinition();
    public ClassRefFluent.DefinitionNested withNewDefinition();
    public ClassRefFluent.DefinitionNested withNewDefinitionLike(TypeDef item);
    public ClassRefFluent.DefinitionNested editDefinition();
    public ClassRefFluent.DefinitionNested editOrNewDefinition();
    public ClassRefFluent.DefinitionNested editOrNewDefinitionLike(TypeDef item);
    public String getFullyQualifiedName();
    public A withFullyQualifiedName(String fullyQualifiedName);
    public Boolean hasFullyQualifiedName();
    public A withNewFullyQualifiedName(String arg1);
    public A withNewFullyQualifiedName(StringBuilder arg1);
    public A withNewFullyQualifiedName(StringBuffer arg1);
    public int getDimensions();
    public A withDimensions(int dimensions);
    public Boolean hasDimensions();
    public A addToArguments(VisitableBuilder builder);
    public A addToArguments(int index, VisitableBuilder builder);
    public A addToArguments(int index, TypeRef item);
    public A setToArguments(int index, TypeRef item);
    public A addToArguments(TypeRef... items);
    public A addAllToArguments(Collection items);
    public A removeFromArguments(VisitableBuilder builder);
    public A removeFromArguments(TypeRef... items);
    public A removeAllFromArguments(Collection items);

/**
 * This method has been deprecated, please use method buildArguments instead.
 * @return The buildable object.
 */
@Deprecated public List getArguments();
    public List buildArguments();
    public TypeRef buildArgument(int index);
    public TypeRef buildFirstArgument();
    public TypeRef buildLastArgument();
    public TypeRef buildMatchingArgument(Predicate> predicate);
    public Boolean hasMatchingArgument(Predicate> predicate);
    public A withArguments(List arguments);
    public A withArguments(TypeRef... arguments);
    public Boolean hasArguments();
    public A addToPrimitiveRefArguments(int index, PrimitiveRef item);
    public A setToPrimitiveRefArguments(int index, PrimitiveRef item);
    public A addToPrimitiveRefArguments(PrimitiveRef... items);
    public A addAllToPrimitiveRefArguments(Collection items);
    public A removeFromPrimitiveRefArguments(PrimitiveRef... items);
    public A removeAllFromPrimitiveRefArguments(Collection items);
    public ClassRefFluent.PrimitiveRefArgumentsNested setNewPrimitiveRefArgumentLike(int index, PrimitiveRef item);
    public ClassRefFluent.PrimitiveRefArgumentsNested addNewPrimitiveRefArgument();
    public ClassRefFluent.PrimitiveRefArgumentsNested addNewPrimitiveRefArgumentLike(PrimitiveRef item);
    public A addToVoidRefArguments(int index, VoidRef item);
    public A setToVoidRefArguments(int index, VoidRef item);
    public A addToVoidRefArguments(VoidRef... items);
    public A addAllToVoidRefArguments(Collection items);
    public A removeFromVoidRefArguments(VoidRef... items);
    public A removeAllFromVoidRefArguments(Collection items);
    public ClassRefFluent.VoidRefArgumentsNested setNewVoidRefArgumentLike(int index, VoidRef item);
    public ClassRefFluent.VoidRefArgumentsNested addNewVoidRefArgument();
    public ClassRefFluent.VoidRefArgumentsNested addNewVoidRefArgumentLike(VoidRef item);
    public A addToWildcardRefArguments(int index, WildcardRef item);
    public A setToWildcardRefArguments(int index, WildcardRef item);
    public A addToWildcardRefArguments(WildcardRef... items);
    public A addAllToWildcardRefArguments(Collection items);
    public A removeFromWildcardRefArguments(WildcardRef... items);
    public A removeAllFromWildcardRefArguments(Collection items);
    public ClassRefFluent.WildcardRefArgumentsNested setNewWildcardRefArgumentLike(int index, WildcardRef item);
    public ClassRefFluent.WildcardRefArgumentsNested addNewWildcardRefArgument();
    public ClassRefFluent.WildcardRefArgumentsNested addNewWildcardRefArgumentLike(WildcardRef item);
    public A addToClassRefArguments(int index, ClassRef item);
    public A setToClassRefArguments(int index, ClassRef item);
    public A addToClassRefArguments(ClassRef... items);
    public A addAllToClassRefArguments(Collection items);
    public A removeFromClassRefArguments(ClassRef... items);
    public A removeAllFromClassRefArguments(Collection items);
    public ClassRefFluent.ClassRefArgumentsNested setNewClassRefArgumentLike(int index, ClassRef item);
    public ClassRefFluent.ClassRefArgumentsNested addNewClassRefArgument();
    public ClassRefFluent.ClassRefArgumentsNested addNewClassRefArgumentLike(ClassRef item);
    public A addToTypeParamRefArguments(int index, TypeParamRef item);
    public A setToTypeParamRefArguments(int index, TypeParamRef item);
    public A addToTypeParamRefArguments(TypeParamRef... items);
    public A addAllToTypeParamRefArguments(Collection items);
    public A removeFromTypeParamRefArguments(TypeParamRef... items);
    public A removeAllFromTypeParamRefArguments(Collection items);
    public ClassRefFluent.TypeParamRefArgumentsNested setNewTypeParamRefArgumentLike(int index, TypeParamRef item);
    public ClassRefFluent.TypeParamRefArgumentsNested addNewTypeParamRefArgument();
    public ClassRefFluent.TypeParamRefArgumentsNested addNewTypeParamRefArgumentLike(TypeParamRef item);

    public interface DefinitionNested extends Nested,TypeDefFluent>{


    public N and();    public N endDefinition();
}
    public interface PrimitiveRefArgumentsNested extends Nested,PrimitiveRefFluent>{


    public N and();    public N endPrimitiveRefArgument();
}
    public interface VoidRefArgumentsNested extends Nested,VoidRefFluent>{


    public N and();    public N endVoidRefArgument();
}
    public interface WildcardRefArgumentsNested extends Nested,WildcardRefFluent>{


    public N and();    public N endWildcardRefArgument();
}
    public interface ClassRefArgumentsNested extends Nested,ClassRefFluent>{


    public N and();    public N endClassRefArgument();
}
    public interface TypeParamRefArgumentsNested extends Nested,TypeParamRefFluent>{

        
    public N and();    public N endTypeParamRefArgument();
}


}