Determines if required properties are populated or not.

@return boolean Whether required properties are populated or not.
343387
public function has_required_properties() {

        return (
            ! empty( $this->plural_name )
            && ! empty( $this->post_type )
            && ! empty( $this->singular_name )
            && ! empty( $this->slug )
        );

    }
863432
protected function checkRequirements()
    {
        $required_properties = array('_buildFile');
        foreach ($required_properties as $required_property) {
            if (empty($this->$required_property)) {
                throw new \BuildException(
                    "Missing required property '" . $required_property . "'."
                );
            }
        }
    }
1052330
public function isValueSet() {
		if ($this->propertyDescriptor->isPublicFieldProperty()) {
			return $this->moufManager->isParameterSet($this->instanceDescriptor->getIdentifierName(), $this->name);
		} elseif ($this->propertyDescriptor->isSetterProperty()) {
			return $this->moufManager->isParameterSetForSetter($this->instanceDescriptor->getIdentifierName(), $this->name);
		} elseif ($this->propertyDescriptor->isConstructor()) {
			return $this->moufManager->isParameterSetForConstructor($this->instanceDescriptor->getIdentifierName(), $this->propertyDescriptor->getParameterIndex());
		} else {
			throw new MoufException("Unsupported property type: it is not a public field nor a setter nor a constructor...");
		}
	}
195582
public static function are_requirements_met() {
        if (self::$requirementsmet === null) {
            $requirementsmet = self::test_unoconv_path()->status === self::UNOCONVPATH_OK;
            $requirementsmet = $requirementsmet && self::is_minimum_version_met();
            self::$requirementsmet = $requirementsmet;
        }

        return self::$requirementsmet;
    }
1276099
public function isSetter() {
    	$methodName = $this->getName();
    	
    	   
    	if (strpos($methodName, "set") === 0 && strlen($methodName)>3) {
    		// A setter must have exactly one compulsory parameter
    		$parameters = $this->getParameters();
    		if (count($parameters) == 0) {
    			return false;
    		}
    		if (count($parameters)>1) {
    			for ($i=1, $count=count($parameters); $i<$count; $i++) {
    				$param = $parameters[$i];
    				if (!$param->isDefaultValueAvailable()) {
    					return false;
    				}
    			}
    		}
    		
    		return true;
    	}
    	return false;
    }
93664
public function isAquired() {
        if (isset(self::$hSemaphores[$this->key]))
            return is_resource(self::$hSemaphores[$this->key]);
        return false;
    }
593387
private function hasPropertiesToCache() {
		if (!isset($this->{__METHOD__})) {
			$this->{__METHOD__} = !!$this->cachedAll();
		}
		return $this->{__METHOD__};
	}
892189
public function listInvalidProperties()
    {
        $invalid_properties = [];

        if ($this->container['name'] === null) {
            $invalid_properties[] = "'name' can't be null";
        }
        if ($this->container['document_type'] === null) {
            $invalid_properties[] = "'document_type' can't be null";
        }
        $allowed_values = $this->getDocumentTypeAllowableValues();
        if (!in_array($this->container['document_type'], $allowed_values)) {
            $invalid_properties[] = sprintf(
                "invalid value for 'document_type', must be one of '%s'",
                implode("', '", $allowed_values)
            );
        }

        if ($this->container['document_content'] === null) {
            $invalid_properties[] = "'document_content' can't be null";
        }
        $allowed_values = $this->getStrictAllowableValues();
        if (!in_array($this->container['strict'], $allowed_values)) {
            $invalid_properties[] = sprintf(
                "invalid value for 'strict', must be one of '%s'",
                implode("', '", $allowed_values)
            );
        }

        return $invalid_properties;
    }
1203061
public function valid()
    {
        if (!isset($this->resources[$this->position])) {
            $this->fetchBatch();
        }

        return isset($this->resources[$this->position]);
    }
178091
protected function checkRequired()
    {
        $errors = new Exceptions();
        foreach ($this->getRequiredKeys() as $required) {
            if (!isset($this->$required)) {
                $errors->add(new Exception('Required property "' . $required . '" is missing'));
            }
        }
        if (!$errors->empty()) {
            throw $errors;
        }
        return true;
    }
684055
public function isRequired()
    {
        if (!empty($this->validation)) {
            foreach ($this->validation as $validation) {
                if ($validation instanceof Validation\Required) {
                    return true;
                }
            }
        }

        return false;
    }
584496
public function isValid()
    {
        if (null === $this->_isValid) {
            $this->_isValid = false;

            if (null !== $data_object = $this->getDataObject()) {
                if (true === property_exists($data_object, 'templateLayouts')
                        && true === is_array($data_object->templateLayouts)
                        && 0 < count($data_object->templateLayouts)) {
                    $this->_isValid = true;

                    foreach ($data_object->templateLayouts as $zone) {
                        if (false === property_exists($zone, 'id')
                                || false === property_exists($zone, 'defaultContainer')
                                || false === property_exists($zone, 'target')
                                || false === property_exists($zone, 'gridClassPrefix')
                                || false === property_exists($zone, 'gridSize')) {
                            $this->_isValid = false;
                            break;
                        }
                    }
                }
            }
        }

        return $this->_isValid;
    }
582690
private boolean isPropertiesSet() {
        return !this.host.isEmpty() &&
                this.port > 0 &&
                !this.username.isEmpty() &&
                !this.password.isEmpty() &&
                !this.toAdd.isEmpty() &&
                !this.fromAdd.isEmpty() &&
                !this.subject.isEmpty() &&
                !this.msg.isEmpty() &&
                this.attachments != null && this.attachments.length > 0;
    }
942712
public function listInvalidProperties()
    {
        $invalidProperties = [];

        if ($this->container['typeId'] === null) {
            $invalidProperties[] = "'typeId' can't be null";
        }
        if ($this->container['quantity'] === null) {
            $invalidProperties[] = "'quantity' can't be null";
        }
        if ($this->container['locationId'] === null) {
            $invalidProperties[] = "'locationId' can't be null";
        }
        if ($this->container['locationType'] === null) {
            $invalidProperties[] = "'locationType' can't be null";
        }
        $allowedValues = $this->getLocationTypeAllowableValues();
        if (!in_array($this->container['locationType'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'locationType', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        if ($this->container['itemId'] === null) {
            $invalidProperties[] = "'itemId' can't be null";
        }
        if ($this->container['locationFlag'] === null) {
            $invalidProperties[] = "'locationFlag' can't be null";
        }
        $allowedValues = $this->getLocationFlagAllowableValues();
        if (!in_array($this->container['locationFlag'], $allowedValues)) {
            $invalidProperties[] = sprintf(
                "invalid value for 'locationFlag', must be one of '%s'",
                implode("', '", $allowedValues)
            );
        }

        if ($this->container['isSingleton'] === null) {
            $invalidProperties[] = "'isSingleton' can't be null";
        }
        return $invalidProperties;
    }
1261635
public function isValid() {
        if($this->isRequired()) {
            if($this->getValue() == null) return false;
            if($this->getValue() == "") return false;
        }
        return true;
    }
514708
public function valid()
    {
        $isValid = $this->isFlagSet(self::STATUS_VALID);
        $subscriptionFlags = self::STATUS_SUBSCRIBED | self::STATUS_PSUBSCRIBED;
        $hasSubscriptions = ($this->statusFlags & $subscriptionFlags) > 0;

        return $isValid && $hasSubscriptions;
    }
1247297
protected function validateRequiredAttributes()
    {
        if (!empty($this->requiredAttributes)) {
            $attributes = $this->fetchAttributes();
            foreach ($this->requiredAttributes as $openIdAttributeName) {
                if (!isset($attributes[$openIdAttributeName])) {
                    return false;
                }
            }
        }

        return true;
    }