Gets the constraintType value for this PolicyTopicConstraint.

@return constraintType
543989
public com.google.api.ads.adwords.axis.v201809.cm.PolicyTopicConstraintPolicyTopicConstraintType getConstraintType() {
        return constraintType;
    }
1360587
private function getLimitationTypes()
    {
        $limitationTypes = [];
        foreach ($this->policyMap as $module) {
            foreach ($module as $policy) {
                if (null === $policy) {
                    continue;
                }

                foreach (array_keys($policy) as $limitationType) {
                    if (!in_array($limitationType, $limitationTypes)) {
                        $limitationTypes[] = $limitationType;
                    }
                }
            }
        }

        return $limitationTypes;
    }
1011999
private Set<String> getConstraintNameList(){
		Set<String> result = new HashSet<>();
		String propertyValue = getProperty(ConstraintContextProperty.ALL_CONSTRAINTS);
		if(propertyValue == null)
			return result;
		StringTokenizer attributeTokens = StringUtils.splitArrayString(propertyValue, String.valueOf(ArrayUtils.VALUE_SEPARATION));
		while(attributeTokens.hasMoreTokens()){
			String nextToken = attributeTokens.nextToken();
			result.add(nextToken);
		}
		return result;
	}
995427
protected function _constraintsStatement()
    {
        $cons = $this->_sql->getConstraints();
        if (empty($cons)) {
            return null;
        }

        return $this->_parseConstraints();
    }
198568
public function getConstraintsForType($version, $type)
    {
        $cache = & $this->constraintsForTypeCache[$version.$type];

        if ($cache === null) {
            $cache = [];

            foreach ($this->getConstraints($version) as $constraint) {
                if ($constraint->supports($type)) {
                    $cache[] = $constraint;
                }
            }
        }

        return $cache;
    }
595540
protected function _getPrimaryConstraint(Constraint\Primary $constraint)
    {
        $columns = implode(', ', $constraint->getColumnNames());
        return sprintf(
            'CONSTRAINT %s PRIMARY KEY (%s)',
            $constraint->getName(),
            $columns
        );
    }
462710
public function policyConstraints(): Ext\PolicyConstraintsExtension
    {
        /** @var Extension\PolicyConstraintsExtension $policyConstraints */
        $policyConstraints = $this->get(Ext\Extension::OID_POLICY_CONSTRAINTS);
        return $policyConstraints;
    }
212413
public List<SecurityConstraintType<WebFragmentType<T>>> getAllSecurityConstraint()
   {
      List<SecurityConstraintType<WebFragmentType<T>>> list = new ArrayList<SecurityConstraintType<WebFragmentType<T>>>();
      List<Node> nodeList = childNode.get("security-constraint");
      for(Node node: nodeList)
      {
         SecurityConstraintType<WebFragmentType<T>>  type = new SecurityConstraintTypeImpl<WebFragmentType<T>>(this, "security-constraint", childNode, node);
         list.add(type);
      }
      return list;
   }
578332
private function getStringType(Constraint $constraint) : ?string
    {
        $stringType = null;
        if (null !== ($typeFromPayload = $this->constraintPayloadDocHelper->getTypeIfExist($constraint))) {
            $stringType = $typeFromPayload;
        } elseif ($constraint instanceof Assert\Type) {
            $stringType = strtolower($constraint->type);
        } elseif ($constraint instanceof Assert\IdenticalTo) {// Strict comparison so value define the type
            $stringType = gettype($constraint->value);
        }

        return $stringType;
    }
1193601
public function getTypeIfExist(Constraint $constraint)
    {
        return $this->hasPayloadDoc($constraint)
            ? $this->getPayloadDocValue($constraint, self::PAYLOAD_DOCUMENTATION_TYPE_KEY)
            : null
        ;
    }
925179
protected function enumConstraint()
    {
        if (empty($this->enumConstraint)) {
            $this->enumConstraint = $this->table . '_' . $this->getName() . '_enum_' . uniqid();
        }

        return $this->enumConstraint;
    }
470164
protected function getConstraint($foreign)
    {
        foreach ($this->getConstraints() as $constraint) {
            if ($constraint->foreign == $foreign) {
                return (object) $constraint;
            }
        }

        return null;
    }
927545
public function guessTypeForConstraint(Constraint $constraint)
    {
        $empty = null;

        switch (\get_class($constraint)) {
            case 'Symfony\Component\Validator\Constraints\Type':
                /* @var \Symfony\Component\Validator\Constraints\Type $constraint */
                switch ($constraint->type) {
                    case 'array':
                        return new TypeGuess(CollectionType::class, [], Guess::MEDIUM_CONFIDENCE);
                    case 'boolean':
                    case 'bool':
                        return new TypeGuess(CheckboxType::class, [], Guess::MEDIUM_CONFIDENCE);

                    case 'double':
                    case 'float':
                    case 'numeric':
                    case 'real':
                        return new TypeGuess(NumberType::class, [], Guess::MEDIUM_CONFIDENCE);

                    case 'integer':
                    case 'int':
                    case 'long':
                        return new TypeGuess(IntegerType::class, [], Guess::MEDIUM_CONFIDENCE);

                    case '\DateTime':
                        return new TypeGuess(DateType::class, [], Guess::MEDIUM_CONFIDENCE);

                    case 'string':
                        return new TypeGuess(TextType::class, [], Guess::LOW_CONFIDENCE);
                }
                break;

            case 'Symfony\Component\Validator\Constraints\Country':
                return new TypeGuess(CountryType::class, [], Guess::HIGH_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Date':
                return new TypeGuess(DateType::class, ['input' => 'string'], Guess::HIGH_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\DateTime':
                return new TypeGuess(DateTimeType::class, ['input' => 'string'], Guess::HIGH_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Email':
                return new TypeGuess(EmailType::class, [], Guess::HIGH_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\File':
            case 'Symfony\Component\Validator\Constraints\Image':
                return new TypeGuess(TextType::class, [], Guess::HIGH_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Language':
                return new TypeGuess(LanguageType::class, [], Guess::HIGH_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Locale':
                return new TypeGuess(LocaleType::class, [], Guess::HIGH_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Time':
                return new TypeGuess(TimeType::class, ['input' => 'string'], Guess::HIGH_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Url':
                return new TypeGuess(UrlType::class, [], Guess::HIGH_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Ip':
                return new TypeGuess(TextType::class, [], Guess::MEDIUM_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Length':
            case 'Symfony\Component\Validator\Constraints\Regex':
                return new TypeGuess(TextType::class, [], Guess::LOW_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Range':
                return new TypeGuess(NumberType::class, [], Guess::LOW_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\Count':
                return new TypeGuess(CollectionType::class, [], Guess::LOW_CONFIDENCE);

            case 'Symfony\Component\Validator\Constraints\IsTrue':
            case 'Symfony\Component\Validator\Constraints\IsFalse':
                return new TypeGuess(CheckboxType::class, [], Guess::MEDIUM_CONFIDENCE);
        }

        return $empty;
    }
916916
public static Constraint required() {
		return new Constraint("required", simplePayload("required")) {
			public boolean isValid(Object actualValue) {
				return !(actualValue == null || StringUtils.isBlank(actualValue.toString()));
			}
		};
	}
1300936
function() {
        var that = this,
            constraints_id = lang_util.isPlainObject(that.constraints) && Object.keys(that.constraints)[0];

        return constraints_id ? that.constraints[constraints_id].label : '';
    }
361808
public function basicConstraints(): Ext\BasicConstraintsExtension
    {
        /** @var Extension\BasicConstraintsExtension $basicConstraints */
        $basicConstraints = $this->get(Ext\Extension::OID_BASIC_CONSTRAINTS);
        return $basicConstraints;
    }
391624
private function getSymfonyValidatorConstraints()
    {

        $constraints = array();

        $this->loadUnsettableProperties();

        foreach ( $this->dataTypes as $column => $type ) {

            // skip inherited columns
            if( $type->isInherited() ) {
                continue;
            }

            // Skip Columns designated unsetable.
            if( in_array( $column, $this->unsetableProperties ) ) {
                continue;
            }

            // Check if column is nullable.
            if( !$type->isNullable() and !$type->hasDefault() ){
                $constraints[] = $this->getSymfonyConstraint( $column, 'NotNull');
            }

            // Normality entity type constraints.
            if( $type->getEntity() === 'normality' ) {

                $dataType = $this->options['entityPlaceholder']."\\{$type->getNormality()}";
                $constraints[] = $this->getSymfonyTypeConstraint( $column, $dataType );

            } elseif( $type->getEntity() ){

                $dataType = "Bond\\Entity\\Types\\{$type->getEntity()}";
                $constraints[] = $this->getSymfonyTypeConstraint( $column, $dataType );

            } elseif( $type->isEnum( $enumName ) ) {

                $constraints[] = $this->getSymfonyChoiceConstraint(
                    $column,
                    $this->pgClass->getCatalog()->enum->getValues($enumName)
                );

            } else {

                switch( $type->getType() ) {

                    case 'int':

                        $constraints[] = $this->getSymfonyConstraint( $column, 'RealInt', null, false );
                        $this->class->addUses( 'Bond\\Bridge\\Normality\\Constraint\\RealInt' );
                        break;

                    case 'citext':
                    case 'text':

                        $constraints[] = $this->getSymfonyTypeConstraint( $column, 'string' );
                        if( is_numeric( $type->getLength() ) ) {
                            $constraints[] = $this->getSymfonyConstraint( $column, 'MaxLength', $type->getLength() );
                        }
                        break;

                    case 'bool':

                        $constraints[] = $this->getSymfonyTypeConstraint( $column, 'bool' );
                        break;

                }

            }

            $constraints[] = '';

        }

        return implode( "\n", $constraints );

    }