TernaryConstraint.java

  1. /* Copyright 2015 Laurent COCAULT
  2.  * Licensed to Laurent COCAULT under one or more contributor license agreements.
  3.  * See the NOTICE file distributed with this work for additional information
  4.  * regarding copyright ownership. Laurent COCAULT licenses this file to You
  5.  * under the Apache License, Version 2.0 (the "License"); you may not use this
  6.  * file except in compliance with the License.  You may obtain a copy of the
  7.  * License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.csp.constraint.model;

  19. /**
  20.  * Represents a ternary constraint in a constraint solving problem To define a
  21.  * new ternary constraint, inherit this class and define the propagate method
  22.  * that must fill the list _recentChangedVariables.
  23.  */
  24. public abstract class TernaryConstraint<T> extends NAryConstraint<T> {

  26.     /**
  27.      * A ternary constraint is associated with three variables. This attribute
  28.      * is the first variable.
  29.      */
  30.     private Variable<T> firstVariable_;

  32.     /**
  33.      * A ternary constraint is associated with three variables. This attribute
  34.      * is the second variable.
  35.      */
  36.     private Variable<T> secondVariable_;

  38.     /**
  39.      * A ternary constraint is associated with three variables. This attribute
  40.      * is the third variable.
  41.      */
  42.     private Variable<T> thirdVariable_;

  44.     /**
  45.      * Constructor of a ternary constraint. It references three variables given
  46.      * as parameters.
  47.      * @param name
  48.      *            Name of the ternary constraint
  49.      * @param first
  50.      *            Reference of the first variable
  51.      * @param second
  52.      *            Reference of the second variable
  53.      * @param third
  54.      *            Reference of the third variable
  55.      */
  56.     public TernaryConstraint(final String name, final Variable<T> first,
  57.             final Variable<T> second, final Variable<T> third) {
  58.         super(name);
  59.         firstVariable_ = first;
  60.         secondVariable_ = second;
  61.         thirdVariable_ = third;
  62.         first.addNAryConstraint(this);
  63.         second.addNAryConstraint(this);
  64.         third.addNAryConstraint(this);
  65.     }

  67.     /**
  68.      * Get the first variable.
  69.      * @return First variable of the constraint
  70.      */
  71.     public Variable<T> getFirstVariable() {
  72.         return firstVariable_;
  73.     }

  75.     /**
  76.      * Get the second variable.
  77.      * @return Second variable of the constraint
  78.      */
  79.     public Variable<T> getSecondVariable() {
  80.         return secondVariable_;
  81.     }

  83.     /**
  84.      * Get the third variable.
  85.      * @return Third variable of the constraint
  86.      */
  87.     public Variable<T> getThirdVariable() {
  88.         return thirdVariable_;
  89.     }

  91.     /**
  92.      * {@inheritDoc}
  93.      */
  94.     @Override
  95.     public boolean isBinary() {
  96.         return false;
  97.     }

  99.     /**
  100.      * {@inheritDoc}
  101.      */
  102.     @Override
  103.     public boolean isTernary() {
  104.         return true;
  105.     }

  107.     /**
  108.      * {@inheritDoc}
  109.      */
  110.     @Override
  111.     public boolean isUnary() {
  112.         return false;
  113.     }

  115.     /**
  116.      * {@inheritDoc}
  117.      */
  118.     @Override
  119.     public boolean isUnsized() {
  120.         return false;
  121.     }

  123.     /**
  124.      * {@inheritDoc}
  125.      */
  126.     @Override
  127.     public boolean isVariableReferenced(final Variable<T> variable) {
  128.         return firstVariable_ == variable || secondVariable_ == variable ||
  129.                 thirdVariable_ == variable;
  130.     }

  132.     /**
  133.      * {@inheritDoc}
  134.      */
  135.     @Override
  136.     public boolean revise() {

  138.         try {
  139.             // Initialize the list of reduced variables
  140.             clearRecentChangedVariables();
  141.             if (isPropagationEnabled()) {
  142.                 // This list must be updated by the propagation method
  143.                 propagate();
  144.             }

  146.             return !firstVariable_.getDomain().isEmpty() &&
  147.                     !secondVariable_.getDomain().isEmpty() &&
  148.                     !thirdVariable_.getDomain().isEmpty();

  150.         } catch (EmptyDomainException e) {
  151.             // If the domain has been emptied, return false
  152.             return false;
  153.         }
  154.     }

  156. }
Created with JaCoCo 0.7.4.201502262128