champ-lib/champ-core/src/main/java/org/onap/aai/champcore/model/fluent/schema/impl/RelationshipConstraintSubStepImpl.java

   1 /**
   2  * ============LICENSE_START==========================================
   3  * org.onap.aai
   4  * ===================================================================
   5  * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * Copyright © 2017-2018 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  */
  21 package org.onap.aai.champcore.model.fluent.schema.impl;
  22
  23 import org.onap.aai.champcore.model.ChampConnectionConstraint;
  24 import org.onap.aai.champcore.model.ChampField;
  25 import org.onap.aai.champcore.model.ChampObject;
  26 import org.onap.aai.champcore.model.ChampRelationshipConstraint;
  27 import org.onap.aai.champcore.model.ChampConnectionMultiplicity;
  28 import org.onap.aai.champcore.model.ChampSchema;
  29 import org.onap.aai.champcore.model.fluent.BuildStep;
  30 import org.onap.aai.champcore.model.fluent.schema.CreateChampSchemable;
  31 import org.onap.aai.champcore.model.fluent.schema.RelationshipConstraintFieldStep;
  32 import org.onap.aai.champcore.model.fluent.schema.RelationshipConstraintMultiplicityStep;
  33 import org.onap.aai.champcore.model.fluent.schema.RelationshipConstraintPropertyOptionalsStep;
  34 import org.onap.aai.champcore.model.fluent.schema.RelationshipConstraintSourceStep;
  35 import org.onap.aai.champcore.model.fluent.schema.RelationshipConstraintSubStep;
  36 import org.onap.aai.champcore.model.fluent.schema.RelationshipConstraintTargetStep;
  37
  38 public class RelationshipConstraintSubStepImpl implements RelationshipConstraintSubStep {
  39
  40         private final ChampSchema.Builder schemaBuilder;
  41         private final ChampRelationshipConstraint.Builder relConstraintBuilder;
  42
  43         public RelationshipConstraintSubStepImpl(ChampSchema.Builder schemaBuilder,
  44                                 ChampRelationshipConstraint.Builder relConstraintBuilder) {
  45                 this.schemaBuilder = schemaBuilder;
  46                 this.relConstraintBuilder = relConstraintBuilder;
  47         }
  48
  49         @Override
  50         public CreateChampSchemable build() {
  51                 return new CreateChampSchemableImpl(schemaBuilder.constraint(relConstraintBuilder.build()));
  52         }
  53
  54         @Override
  55         public RelationshipConstraintFieldStep withPropertyConstraint() {
  56                 return new RelationshipConstraintFieldStep() {
  57
  58                         @Override
  59                         public RelationshipConstraintPropertyOptionalsStep onField(String name) {
  60                                 return new RelationshipConstraintPropertyOptionalsStepImpl(schemaBuilder, relConstraintBuilder, new ChampField.Builder(name));
  61                         }
  62                 };
  63         }
  64
  65         @Override
  66         public RelationshipConstraintSourceStep withConnectionConstraint() {
  67                 return new RelationshipConstraintSourceStep() {
  68
  69                         @Override
  70                         public RelationshipConstraintTargetStep sourcedFrom(String sourceType) {
  71
  72                                 return new RelationshipConstraintTargetStep() {
  73
  74                                         @Override
  75                                         public RelationshipConstraintMultiplicityStep targetedTo(String targetType) {
  76                                                 final ChampConnectionConstraint.Builder connectionConstraint = new ChampConnectionConstraint.Builder(sourceType, targetType);
  77
  78                                                 return new RelationshipConstraintMultiplicityStep() {
  79
  80                                                         @Override
  81                                                         public RelationshipConstraintSubStep build() {
  82                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
  83
  84                                                                 return RelationshipConstraintSubStepImpl.this;
  85                                                         }
  86
  87                                                         @Override
  88                                                         public BuildStep<RelationshipConstraintSubStep> withMultiplicity(
  89                                                                         ChampConnectionMultiplicity multiplicity) {
  90                                                                 connectionConstraint.multiplicity(multiplicity);
  91                                                                 return new BuildStep<RelationshipConstraintSubStep> () {
  92
  93                                                                         @Override
  94                                                                         public RelationshipConstraintSubStep build() {
  95                                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
  96
  97                                                                                 return RelationshipConstraintSubStepImpl.this;
  98                                                                         }
  99                                                                 };
 100                                                         }
 101                                                 };
 102                                         }
 103
 104                                         @Override
 105                                         public RelationshipConstraintMultiplicityStep targetedToAny() {
 106                                                 final ChampConnectionConstraint.Builder connectionConstraint = new ChampConnectionConstraint.Builder(sourceType, ChampObject.ReservedTypes.ANY.toString());
 107
 108                                                 return new RelationshipConstraintMultiplicityStep() {
 109
 110                                                         @Override
 111                                                         public RelationshipConstraintSubStep build() {
 112                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 113
 114                                                                 return RelationshipConstraintSubStepImpl.this;
 115                                                         }
 116
 117                                                         @Override
 118                                                         public BuildStep<RelationshipConstraintSubStep> withMultiplicity(
 119                                                                         ChampConnectionMultiplicity multiplicity) {
 120                                                                 connectionConstraint.multiplicity(multiplicity);
 121                                                                 return new BuildStep<RelationshipConstraintSubStep> () {
 122
 123                                                                         @Override
 124                                                                         public RelationshipConstraintSubStep build() {
 125                                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 126
 127                                                                                 return RelationshipConstraintSubStepImpl.this;
 128                                                                         }
 129                                                                 };
 130                                                         }
 131                                                 };
 132                                         }
 133                                 };
 134                         }
 135
 136                         @Override
 137                         public RelationshipConstraintTargetStep sourcedFromAny() {
 138                                 return new RelationshipConstraintTargetStep() {
 139
 140                                         @Override
 141                                         public RelationshipConstraintMultiplicityStep targetedTo(String targetType) {
 142                                                 final ChampConnectionConstraint.Builder connectionConstraint = new ChampConnectionConstraint.Builder(ChampObject.ReservedTypes.ANY.toString(), targetType);
 143
 144                                                 return new RelationshipConstraintMultiplicityStep() {
 145
 146                                                         @Override
 147                                                         public RelationshipConstraintSubStep build() {
 148                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 149
 150                                                                 return RelationshipConstraintSubStepImpl.this;
 151                                                         }
 152
 153                                                         @Override
 154                                                         public BuildStep<RelationshipConstraintSubStep> withMultiplicity(
 155                                                                         ChampConnectionMultiplicity multiplicity) {
 156                                                                 connectionConstraint.multiplicity(multiplicity);
 157                                                                 return new BuildStep<RelationshipConstraintSubStep> () {
 158
 159                                                                         @Override
 160                                                                         public RelationshipConstraintSubStep build() {
 161                                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 162
 163                                                                                 return RelationshipConstraintSubStepImpl.this;
 164                                                                         }
 165                                                                 };
 166                                                         }
 167                                                 };
 168                                         }
 169
 170                                         @Override
 171                                         public RelationshipConstraintMultiplicityStep targetedToAny() {
 172                                                 final ChampConnectionConstraint.Builder connectionConstraint = new ChampConnectionConstraint.Builder(ChampObject.ReservedTypes.ANY.toString(), ChampObject.ReservedTypes.ANY.toString());
 173
 174                                                 return new RelationshipConstraintMultiplicityStep() {
 175
 176                                                         @Override
 177                                                         public RelationshipConstraintSubStep build() {
 178                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 179
 180                                                                 return RelationshipConstraintSubStepImpl.this;
 181                                                         }
 182
 183                                                         @Override
 184                                                         public BuildStep<RelationshipConstraintSubStep> withMultiplicity(
 185                                                                         ChampConnectionMultiplicity multiplicity) {
 186                                                                 connectionConstraint.multiplicity(multiplicity);
 187                                                                 return new BuildStep<RelationshipConstraintSubStep> () {
 188
 189                                                                         @Override
 190                                                                         public RelationshipConstraintSubStep build() {
 191                                                                                 relConstraintBuilder.constraint(connectionConstraint.build());
 192
 193                                                                                 return RelationshipConstraintSubStepImpl.this;
 194                                                                         }
 195                                                                 };
 196                                                         }
 197                                                 };
 198                                         }
 199                                 };
 200                         }
 201                 };
 202         }
 203
 204 }