src/main/java/org/openecomp/aai/champ/model/fluent/schema/impl/RelationshipConstraintSubStepImpl.java

   1 /**
   2  * ============LICENSE_START==========================================
   3  * org.onap.aai
   4  * ===================================================================
   5  * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * Copyright © 2017 Amdocs
   7  * ===================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *        http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END============================================
  20  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  21  */
  22 package org.openecomp.aai.champ.model.fluent.schema.impl;
  23
  24 import org.openecomp.aai.champ.model.ChampConnectionConstraint;
  25 import org.openecomp.aai.champ.model.ChampField;
  26 import org.openecomp.aai.champ.model.ChampObject;
  27 import org.openecomp.aai.champ.model.ChampRelationshipConstraint;
  28 import org.openecomp.aai.champ.model.ChampConnectionMultiplicity;
  29 import org.openecomp.aai.champ.model.ChampSchema;
  30 import org.openecomp.aai.champ.model.fluent.BuildStep;
  31 import org.openecomp.aai.champ.model.fluent.schema.CreateChampSchemable;
  32 import org.openecomp.aai.champ.model.fluent.schema.RelationshipConstraintFieldStep;
  33 import org.openecomp.aai.champ.model.fluent.schema.RelationshipConstraintMultiplicityStep;
  34 import org.openecomp.aai.champ.model.fluent.schema.RelationshipConstraintPropertyOptionalsStep;
  35 import org.openecomp.aai.champ.model.fluent.schema.RelationshipConstraintSourceStep;
  36 import org.openecomp.aai.champ.model.fluent.schema.RelationshipConstraintSubStep;
  37 import org.openecomp.aai.champ.model.fluent.schema.RelationshipConstraintTargetStep;
  38
  39 public class RelationshipConstraintSubStepImpl implements RelationshipConstraintSubStep {
  40
  41         private final ChampSchema.Builder schemaBuilder;
  42         private final ChampRelationshipConstraint.Builder relConstraintBuilder;
  43
  44         public RelationshipConstraintSubStepImpl(ChampSchema.Builder schemaBuilder,
  45                                 ChampRelationshipConstraint.Builder relConstraintBuilder) {
  46                 this.schemaBuilder = schemaBuilder;
  47                 this.relConstraintBuilder = relConstraintBuilder;
  48         }
  49
  50         @Override
  51         public CreateChampSchemable build() {
  52                 return new CreateChampSchemableImpl(schemaBuilder.constraint(relConstraintBuilder.build()));
  53         }
  54
  55         @Override
  56         public RelationshipConstraintFieldStep withPropertyConstraint() {
  57                 return new RelationshipConstraintFieldStep() {
  58
  59                         @Override
  60                         public RelationshipConstraintPropertyOptionalsStep onField(String name) {
  61                                 return new RelationshipConstraintPropertyOptionalsStepImpl(schemaBuilder, relConstraintBuilder, new ChampField.Builder(name));
  62                         }
  63                 };
  64         }
  65
  66         @Override
  67         public RelationshipConstraintSourceStep withConnectionConstraint() {
  68                 return new RelationshipConstraintSourceStep() {
  69
  70                         @Override
  71                         public RelationshipConstraintTargetStep sourcedFrom(String sourceType) {
  72
  73                                 return new RelationshipConstraintTargetStep() {
  74
  75                                         @Override
  76                                         public RelationshipConstraintMultiplicityStep targetedTo(String targetType) {
  77                                                 final ChampConnectionConstraint.Builder connectionConstraint = new ChampConnectionConstraint.Builder(sourceType, targetType);
  78
  79                                                 return new RelationshipConstraintMultiplicityStep() {
  80
  81                                                         @Override
  82                                                         public RelationshipConstraintSubStep build() {
  83                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
  84
  85                                                                 return RelationshipConstraintSubStepImpl.this;
  86                                                         }
  87
  88                                                         @Override
  89                                                         public BuildStep<RelationshipConstraintSubStep> withMultiplicity(
  90                                                                         ChampConnectionMultiplicity multiplicity) {
  91                                                                 connectionConstraint.multiplicity(multiplicity);
  92                                                                 return new BuildStep<RelationshipConstraintSubStep> () {
  93
  94                                                                         @Override
  95                                                                         public RelationshipConstraintSubStep build() {
  96                                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
  97
  98                                                                                 return RelationshipConstraintSubStepImpl.this;
  99                                                                         }
 100                                                                 };
 101                                                         }
 102                                                 };
 103                                         }
 104
 105                                         @Override
 106                                         public RelationshipConstraintMultiplicityStep targetedToAny() {
 107                                                 final ChampConnectionConstraint.Builder connectionConstraint = new ChampConnectionConstraint.Builder(sourceType, ChampObject.ReservedTypes.ANY.toString());
 108
 109                                                 return new RelationshipConstraintMultiplicityStep() {
 110
 111                                                         @Override
 112                                                         public RelationshipConstraintSubStep build() {
 113                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 114
 115                                                                 return RelationshipConstraintSubStepImpl.this;
 116                                                         }
 117
 118                                                         @Override
 119                                                         public BuildStep<RelationshipConstraintSubStep> withMultiplicity(
 120                                                                         ChampConnectionMultiplicity multiplicity) {
 121                                                                 connectionConstraint.multiplicity(multiplicity);
 122                                                                 return new BuildStep<RelationshipConstraintSubStep> () {
 123
 124                                                                         @Override
 125                                                                         public RelationshipConstraintSubStep build() {
 126                                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 127
 128                                                                                 return RelationshipConstraintSubStepImpl.this;
 129                                                                         }
 130                                                                 };
 131                                                         }
 132                                                 };
 133                                         }
 134                                 };
 135                         }
 136
 137                         @Override
 138                         public RelationshipConstraintTargetStep sourcedFromAny() {
 139                                 return new RelationshipConstraintTargetStep() {
 140
 141                                         @Override
 142                                         public RelationshipConstraintMultiplicityStep targetedTo(String targetType) {
 143                                                 final ChampConnectionConstraint.Builder connectionConstraint = new ChampConnectionConstraint.Builder(ChampObject.ReservedTypes.ANY.toString(), targetType);
 144
 145                                                 return new RelationshipConstraintMultiplicityStep() {
 146
 147                                                         @Override
 148                                                         public RelationshipConstraintSubStep build() {
 149                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 150
 151                                                                 return RelationshipConstraintSubStepImpl.this;
 152                                                         }
 153
 154                                                         @Override
 155                                                         public BuildStep<RelationshipConstraintSubStep> withMultiplicity(
 156                                                                         ChampConnectionMultiplicity multiplicity) {
 157                                                                 connectionConstraint.multiplicity(multiplicity);
 158                                                                 return new BuildStep<RelationshipConstraintSubStep> () {
 159
 160                                                                         @Override
 161                                                                         public RelationshipConstraintSubStep build() {
 162                                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 163
 164                                                                                 return RelationshipConstraintSubStepImpl.this;
 165                                                                         }
 166                                                                 };
 167                                                         }
 168                                                 };
 169                                         }
 170
 171                                         @Override
 172                                         public RelationshipConstraintMultiplicityStep targetedToAny() {
 173                                                 final ChampConnectionConstraint.Builder connectionConstraint = new ChampConnectionConstraint.Builder(ChampObject.ReservedTypes.ANY.toString(), ChampObject.ReservedTypes.ANY.toString());
 174
 175                                                 return new RelationshipConstraintMultiplicityStep() {
 176
 177                                                         @Override
 178                                                         public RelationshipConstraintSubStep build() {
 179                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 180
 181                                                                 return RelationshipConstraintSubStepImpl.this;
 182                                                         }
 183
 184                                                         @Override
 185                                                         public BuildStep<RelationshipConstraintSubStep> withMultiplicity(
 186                                                                         ChampConnectionMultiplicity multiplicity) {
 187                                                                 connectionConstraint.multiplicity(multiplicity);
 188                                                                 return new BuildStep<RelationshipConstraintSubStep> () {
 189
 190                                                                         @Override
 191                                                                         public RelationshipConstraintSubStep build() {
 192                                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 193
 194                                                                                 return RelationshipConstraintSubStepImpl.this;
 195                                                                         }
 196                                                                 };
 197                                                         }
 198                                                 };
 199                                         }
 200                                 };
 201                         }
 202                 };
 203         }
 204
 205 }