Checks if the given properties exists in the specified object

@param mixed $obj The object to check
@param string $prop1 to check for
@return boolean true if all properties are found, otherwise false
481874
public static function propertiesExist($obj /*, $prop1, $prop2, etc... */){
		
		for($i = 1, $l = \func_num_args() - 1; $i <= $l; ++$i){
			if(!\property_exists($obj, \func_get_arg($i))){
				return false;
			}
		}
		
		return true;
		
	}
164480
public function Equals( $obj )
	{
		/**
		 * @var SequenceType $dest
		 */
		$dest = $obj;
		if ( ! is_null( $obj ) )
		{
			return $this->TypeCode == $dest->TypeCode &&
				$this->SchemaElement == $dest->SchemaElement &&
				$this->SchemaAttribute == $dest->SchemaAttribute &&
				$this->SchemaType == $dest->SchemaType &&
				$this->Cardinality == $dest->Cardinality;
		}
		return false;
	}
366795
public function equals($obj)
    {
        // TODO: optimize me with early outs
        if ($this === $obj) {
            return true;
        }

        if ((null === $obj) || !($obj instanceof AbstractCriterion)) {
            return false;
        }

        /** @var AbstractCriterion $crit */
        $crit = $obj;

        $isEquiv = (((null === $this->table && null === $crit->getTable())
            || (null !== $this->table && $this->table === $crit->getTable()))
            && $this->column === $crit->getColumn()
            && $this->comparison === $crit->getComparison())
        ;

        // check chained criterion

        $clausesLength = count($this->clauses);
        $isEquiv &= (count($crit->getClauses()) == $clausesLength);
        $critConjunctions = $crit->getConjunctions();
        $critClauses = $crit->getClauses();
        for ($i = 0; $i < $clausesLength && $isEquiv; $i++) {
            $isEquiv &= ($this->conjunctions[$i] === $critConjunctions[$i]);
            $isEquiv &= ($this->clauses[$i] === $critClauses[$i]);
        }

        if ($isEquiv) {
            $isEquiv &= $this->value === $crit->getValue();
        }

        return $isEquiv;
    }
555058
public static function property_exists( $object, $property )
    {
        if ( !is_array( $property ) )
        {
            $property = array($property);
        }

        foreach ( $property as $_property )
        {
            if ( property_exists( $object, $_property ) )
            {
                return $_property;
            }
        }

        return false;
    }
180792
function checkProperties(obj) {
        for (var key in obj) {
                if (obj[key] !== null && obj[key] != "")
                        return false;
        }
        return true;
}
763991
public static boolean setProperty(Object obj, String propName, Object value) {
        try {
            setFieldValue(obj, propName, value);
            return true;
        } catch (Throwable e) {
            return false;
        }
    }
1344529
public function propertyExists($property, $item)
    {
        if (gettype($item) == 'array') {
            return array_key_exists($property, $item);
        } elseif (gettype($item) == 'object') {
            return property_exists($item , $property);
        }
        return false;
    }
430638
public function Equals( $obj )
	{
		if ( ! $obj instanceof HexBinaryValue )
		{
			return false;
		}

		return strcmp( $this->BinaryValue, $obj->BinaryValue ) == 0;
	}
809129
private function resolveProperty(Type $objType, $propName) {
        if ($objType->type === Type::TYPE_OBJECT) {
            $types = [];
            $ut = strtolower($objType->userType);
            if (!isset($this->state->classResolves[$ut])) {
                // unknown type
                return false;
            }
            foreach ($this->state->classResolves[$ut] as $class) {
                // Lookup property on class
                $property = $this->findProperty($class, $propName);
                if ($property) {
                    if ($property->type) {
                        $types[] = $property->type;
                    } else {
                        echo "Property found to be untyped: $propName\n";
                        // untyped property
                        return false;
                    }
                }
            }
            if ($types) {
                return $types;
            }
        }
        return false;
    }
343898
private function propertyExists($object, $fieldName)
    {
        if (property_exists($object, $fieldName)) {
            return true;
        }

        foreach (explode('.', $fieldName) as $field) {
            if (property_exists($object, $field)) {
                $object = $object->{$field};
                if (!is_object($object)) {
                    break;
                }
                continue;
            } else {
                return false;
            }
        }
        return true;
    }
1042373
public function Equals( $obj )
	{
		if ( ! $obj instanceof QNameValue )
		{
			return false;
		}

		/**
		 * @var QNameValue $other
		 */
		$other = $obj;
		// // BMS 2017-09-13 The xfi test fact-dimension-s-equal2 V18 requires this comparison
		// return (string)$this == (string)$other;
		return $this->LocalName == $other->LocalName && $this->NamespaceUri == $other->NamespaceUri;
	}
1273330
function isScalar ($propName)
  {
    $type = $this->getTypeOf ($propName);
    return $type == type::bool || $type == type::id || $type == type::number ||
           $type == type::string;
  }
941883
public function equals($obj) {
		return $obj instanceof EiProp && $this->getWrapper()->getEiPropPath()->equals(
				$obj->getWrapper()->getEiPropPath());
	}
882234
public function equals(Module $obj)
    {
        if (get_called_class() !== get_class($obj)) {
            return false;
        }

        /** @var Module $this */
        return $this->getValue() === $obj->getValue();
    }
780986
def has_prop_value(self, prop: typing.Union[str, EnvvarProfileProperty]) -> bool:
        
        return self._loader.has_prop_value(self, prop)
912965
public function Equals( $obj )
	{
		if ( is_string( $obj ) )
		{
	        return $this->Value == $obj;
		}
		else if ( $obj instanceof AnyUriValue )
		{
			/**
			 * @var AnyUriValue $other
			 */
			$other = $obj;
	        return $this->Value == $other->Value;
		}

	    return false;
	}
33805
public function Equals( $obj )
	{
		if ( ! $obj instanceof UntypedAtomic )
			return false;

		/**
		 * @var UntypedAtomic $other
		 */
		$other = $obj;
		return $this->Value === $other->Value;
	}