Returns a boolean stating whether there are more properties

@return boolean <code>true</code> if there are more properties to read,
<code>false</code> otherwise
773947
public boolean hasMoreProperties() {
		if (buf.remaining() >= 3) {
			byte[] threeBytes = new byte[3];
			int pos = buf.position();
			buf.get(threeBytes);
			if (Arrays.equals(AMF.END_OF_OBJECT_SEQUENCE, threeBytes)) {
				log.trace("End of object");
				return false;
			}
			buf.position(pos);
			return true;
		}
		// an end-of-object marker can't occupy less than 3 bytes so return true
		return true;
	}
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...");
		}
	}
1319347
def has_more_pages(self):
        

        # if has_next property exists, it represents whether more pages exist
        if self.has_next is not None:
            return self.has_next

        # otherwise, try to compute whether or not more pages exist
        total_pages = self.get_total_pages()
        if self.page_number is None or total_pages is None:
            return None
        else:
            return self.page_number + 1 < total_pages
817953
public function hasIdentifierPropertiesOnly() {
		if ($this->attributes !== null && $this->attributes->isEmpty() === false) {
			return false;
		}
		if ($this->relationships !== null && $this->relationships->isEmpty() === false) {
			return false;
		}
		if ($this->links !== null && $this->links->isEmpty() === false) {
			return false;
		}
		
		return true;
	}
579420
public boolean hasProperties(Set<PropertyKey> keys) {
        for (PropertyKey key : keys) {
            if (null == getProperty(key.m_key)) {
                return false;
            }
        }
        
        return true;
    }
742982
public boolean hasSiblings() {

        try {
            return getCms().readResource(getParamResource(), CmsResourceFilter.ALL).getSiblingCount() > 1;
        } catch (CmsException e) {
            LOG.error(e.getLocalizedMessage(getLocale()), e);
            return false;
        }

    }
1067699
public Pair<Boolean, String> property() {
    String name = method.getName();
    if (Modifier.isStatic(method.getModifiers())) return null;
    if (0 == parameterTypes.length) {
      if (name.startsWith("get")) {
        if (name.length() > 3) return of(TRUE, uncapitalize(substringAfter(name, "get")));
      } else if (name.startsWith("is")) {
        if (name.length() > 2) return of(TRUE, uncapitalize(substringAfter(name, "is")));
      }
    } else if (1 == parameterTypes.length) {
      if (name.startsWith("set") && name.length() > 3) return of(FALSE,
          uncapitalize(substringAfter(name, "set")));
    }
    return null;
  }
371824
public boolean hasNext()
	{
		try {
			if (result != null && result.next()) {
				return true;
			}

			if (this.statement != null) {
				this.statement.close();
			}
			if (this.result != null) {
				this.result.close();
			}

			return query();

		}
		catch (SQLException e) {
			throw new RuntimeException(e);
		}
	}
794844
public boolean hasNext() {
		if(next != null) {
			return true;
		}
		// find lowest next:
		PeekableIterator<E> nextSource = null;
		for(int i = 0; i < components.size(); i++) {
			PeekableIterator<E> pi = components.get(i);
			if(pi.hasNext()) {
				E piNext = pi.peekNext();
				if((next == null) || (comparator.compare(next,piNext) > 0)) {
					nextSource = pi;
					next = piNext;
				}
			}
		}
		if(nextSource != null) {
			nextSource.next();
		}
		return next != null;
	}
1238993
private boolean hasSameStructure() {
        Object wrappedCollection = getWrappedValue();
        if (wrappedCollection == null) {
            return bufferedListModel.size() == 0;
        }
        else if (wrappedCollection instanceof Object[]) {
            Object[] wrappedArray = (Object[])wrappedCollection;
            if (wrappedArray.length != bufferedListModel.size()) {
                return false;
            }
            for (int i = 0; i < bufferedListModel.size(); i++) {
                if(super.hasValueChanged(wrappedArray[i], bufferedListModel.get(i))) {
                    return false;
                }
            }
        }
        else {
            if (((Collection)wrappedCollection).size() != bufferedListModel.size()) {
                return false;
            }
            for (Iterator i = ((Collection)wrappedCollection).iterator(), j = bufferedListModel.iterator(); i.hasNext();) {
                if (super.hasValueChanged(i.next(), j.next())) {
                    return false;
                }
            }
        }
        return true;
    }
1187296
public function showNotes()
    {
        if ($this->showNotes === null) {
            $prop = $this->property();
            $show = $prop['show_notes'];
            if ($show !== null) {
                $this->showNotes = $show;
            } else {
                $this->showNotes = true;
            }
        }

        if ($this->showNotes !== false) {
            return !!strval($this->property()->notes());
        } else {
            return false;
        }
    }
787540
private Properties getStatusProperties() {
		final File statusFile = getStatusFile();
		if (statusFile != null) {
			try {
				Properties statusFileProps = new Properties();
				final FileReader statusReader = new FileReader(statusFile);
				try {
					statusFileProps.load(statusReader);
					return statusFileProps;
				} finally {
					statusReader.close();
				}
			} catch (IOException e) {
				getLog().warn("Reading status file failed: " + e.getMessage());
			}
		}
		return null;
	}
956289
@Override
	public boolean isReadonly() {

		if (isIdProperty() || isVersionProperty()) {
			return false;
		}

		Indexed indexedAnnotation = getIndexAnnotation();
		if (indexedAnnotation != null && indexedAnnotation.readonly()) {
			return true;
		}
		if (indexedAnnotation == null && getFieldAnnotation() == null) {
			return true;
		}
		return false;
	}
912781
@Override
    public boolean hasNext() {
        boolean has = true;

        for (val i: iterators)
            if (!i.hasNext()) {
                has = false;
                break;
            }

        return has;
    }
61408
private Boolean getBooleanProperty(Properties prop, String name) {
        String propertyValue = prop.getProperty(name);
        return Boolean.parseBoolean(propertyValue);
    }
1114185
public boolean hasNext() {

        if (items != null) {
            if (items.hasNext()) {
                return (true);
            } else {
                items = null;
            }
        }
        Object next = findNextValidChild();
        while (next != null) {
            initializeItems(next);
            if (items != null) {
                return true;
            } else {
                next = findNextValidChild();
            }
        }
        return false;

    }
120395
@Override
	public boolean hasNext()
	{
		if (this.items != null)
			return i != this.itemsSize;
		else if (this.itemsIterator != null)
			return this.itemsIterator.hasNext();
		else
			return this.itemsEnumerator.hasMoreElements();
	}