Checks if the <CODE>Cell</CODE> is empty.

@return	<CODE>false</CODE> if there are non-empty <CODE>Element</CODE>s in the <CODE>Cell</CODE>.
422500
public boolean isEmpty() {
		switch(size()) {
			case 0:
				return true;
			case 1:
				Element element = (Element) arrayList.get(0);
				switch (element.type()) {
					case Element.CHUNK:
						return ((Chunk) element).isEmpty();
					case Element.ANCHOR:
					case Element.PHRASE:
					case Element.PARAGRAPH:
						return ((Phrase) element).isEmpty();
					case Element.LIST:
						return ((List) element).isEmpty();
				}
			return false;
			default:
				return false;
		}
	}
904585
public static boolean isEmpty(Object bean) {
		if (null != bean) {
			for (Field field : ReflectUtil.getFields(bean.getClass())) {
				if (null != ReflectUtil.getFieldValue(bean, field)) {
					return false;
				}
			}
		}
		return true;
	}
1332727
@Override
    public boolean isEmpty() {
	final Segment<K, V>[] segments = this.segments;
	/*
	 * We keep track of per-segment modCounts to avoid ABA problems in which an element in one segment
	 * was added and in another removed during traversal, in which case the table was never actually
	 * empty at any point. Note the similar use of modCounts in the size() and containsValue() methods,
	 * which are the only other methods also susceptible to ABA problems.
	 */
	int[] mc = new int[segments.length];
	int mcsum = 0;
	for (int i = 0; i < segments.length; ++i) {
	    if (segments[i].count != 0) return false;
	    mcsum += mc[i] = segments[i].modCount;
	}
	// If mcsum happens to be zero, then we know we got a snapshot
	// before any modifications at all were made. This is
	// probably common enough to bother tracking.
	if (mcsum != 0) {
	    for (int i = 0; i < segments.length; ++i) {
		if (segments[i].count != 0 || mc[i] != segments[i].modCount) return false;
	    }
	}
	return true;
    }
191929
public boolean isEmpty(F element){
        if (isEmpty())
            return true;

        Counter<S> m = maps.get(element);
        if (m == null)
            return true;
        else
            return m.isEmpty();
    }
1337804
def is_empty(self):
        """"""
        if len(self.columns) == 0:
            return True

        if len(self.columns) == 1 and self.columns[0].name == 'id':
            return True

        return False
591364
public boolean inSameCell(int elementI, int elementJ) {
        for (int cellIndex = 0; cellIndex < size(); cellIndex++) {
            SortedSet<Integer> cell = getCell(cellIndex);
            if (cell.contains(elementI) && cell.contains(elementJ)) {
                return true;
            }
        }
        return false;
    }
11084
protected boolean isEmpty(Object o) {
		if (o == null) {
			return true;
		} else if (o instanceof String) {
			return !StringUtils.hasText((String) o);
		} else {
			return false;
		}
	}
285328
@Override
    public boolean hasNext() {
        if (throwable != null)
            throw throwable;

        try {
            if (hasDepleted.get())
                return false;

            if (nextElement != null && nextElement != terminator) {
                return true;
            } else if (nextElement == terminator)
                return false;


            nextElement = buffer.take();

            if (nextElement == terminator) {
                hasDepleted.set(true);
                return false;
            }

            return true;
        } catch (Exception e) {
            log.error("Premature end of loop!");
            throw new RuntimeException(e);
        }
    }
841089
public boolean mapsCell(String cell) {
        return mappers.values().stream().anyMatch(mapper -> mapper.mapsCell(cell));
    }
413990
public boolean isEmpty() {
		return (content.toString().trim().length() == 0)
				&& (content.toString().indexOf("\n") == -1)
				&& (attributes == null);
	}
1027826
public int numberOfElements() {
        int n = 0;
        for (SortedSet<Integer> cell : cells) {
            n += cell.size();
        }
        return n;
    }
527874
public boolean addCellLink(GridCell<P> cell) {
		if (this.cells.add(cell)) {
			return isReferenceCell(cell);
		}
		return false;
	}
335906
public boolean matches(Example cells)
    {
        for (int i = 0; i < cells.remainings(); ++i)
        {
            Example cell = cells.at( i );

            if (i < headers.length)
            {
                ExpectedColumn column = (ExpectedColumn) headers[i];
                String message = column.header();

                if (HeaderForm.parse(message).isExpected()) continue;
                if (StringUtil.isBlank( contentOf( cell ) )) {
                    if (column.getClass() == ExpectedColumn.class) continue;

                    try
                    {
                        column.setCheck(fixture.check(column.header()));
                        final Statistics statistics = column.doCell(cell, false);

                        if (statistics.indicatesFailure())
                        {
                            return false;
                        }
                    }
                    catch (Exception e)
                    {
                        return false;
                    }
                } else { // Check for equality
                    try
                    {
                        Call call = new Call( fixture.check( column.header() ) );
                        Expectation expectation = ShouldBe.literal( contentOf( cell ) );

                        Object result = call.execute();
                        if (!expectation.meets( result ))
                        {
                            return false;
                        }
                    }
                    catch (Exception e)
                    {
                        return false;
                    }
                }


            }
        }

        return true;
    }
1067598
public static boolean isElement(Node node) {
		return (null == node) ? false : Node.ELEMENT_NODE == node.getNodeType();
	}
199619
def _check_cell_validity(self, i, j):
        
        if i >= len(self._output):
            return True
        if j >= len(self._output[i]):
            return True
        if self._output[i][j] is None:
            return True
        return False
322255
def element_is_empty(elem_to_parse, element_path=None):
    

    element = get_element(elem_to_parse, element_path)

    if element is None:
        return True

    is_empty = (
        (element.text is None or not element.text.strip()) and
        (element.tail is None or not element.tail.strip()) and
        (element.attrib is None or not len(element.attrib)) and
        (not len(element.getchildren()))
    )

    return is_empty
813532
public boolean isEmpty() {
        return ((files == null) || files.isEmpty())
                && ((fileObjects == null) || fileObjects.isEmpty())
                && (classNames == null || classNames.isEmpty());
    }