If not already created, a new <code>split</code> element will be created and returned.
Otherwise, the first existing <code>split</code> element will be returned.
@return the instance defined for the element <code>split</code>
762371
public Split<Flow<T>> getOrCreateSplit()
   {
      List<Node> nodeList = childNode.get("split");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new SplitImpl<Flow<T>>(this, "split", childNode, nodeList.get(0));
      }
      return createSplit();
   }
487371
public final Tuple2<Tuple6<T1, T2, T3, T4, T5, T6>, Tuple6<T7, T8, T9, T10, T11, T12>> split6() {
        return new Tuple2<>(limit6(), skip6());
    }
396608
static String[] splitName(String name) {
        logger.trace("splitting name for {}", name);

        Matcher m = ARR_ELEMENT_NAME.matcher(name);
        if (m.matches()) {
            return new String[]{ m.group(1), m.group(2), Boolean.TRUE.toString() };
        } else if ((m = OBJ_ELEMENT_NAME.matcher(name)).matches()) {
            return new String[]{ m.group(1), m.group(2), Boolean.FALSE.toString() };
        } else {
            return new String[]{ "", name, Boolean.FALSE.toString() };
        }
    }
1318061
public FacesConfigFlowDefinitionSwitchType<FacesConfigFlowDefinitionType<T>> getOrCreateSwitch()
   {
      List<Node> nodeList = childNode.get("switch");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigFlowDefinitionSwitchTypeImpl<FacesConfigFlowDefinitionType<T>>(this, "switch", childNode, nodeList.get(0));
      }
      return createSwitch();
   }
555511
@Override
  public NumberedSplit<InputSplit> getInputSplit(final NodeDescriptor nodeDescriptor, final String evaluatorId) {
    synchronized (evaluatorToSplits) {
      if (evaluatorToSplits.containsKey(evaluatorId)) {
        LOG.log(Level.FINE, "Found an already allocated split, {0}", evaluatorToSplits.toString());
        return evaluatorToSplits.get(evaluatorId);
      }
    }
    // always first try to allocate based on the hostName
    final String hostName = nodeDescriptor.getName();
    LOG.log(Level.FINE, "Allocated split not found, trying on {0}", hostName);
    if (locationToSplits.containsKey(hostName)) {
      LOG.log(Level.FINE, "Found splits possibly hosted for {0} at {1}", new Object[] {evaluatorId, hostName});
      final NumberedSplit<InputSplit> split = allocateSplit(evaluatorId, locationToSplits.get(hostName));
      if (split != null) {
        return split;
      }
    }
    LOG.log(Level.FINE, "{0} does not host any splits or someone else took splits hosted here. Picking other ones",
        hostName);
    final NumberedSplit<InputSplit> split = tryAllocate(nodeDescriptor, evaluatorId);
    if (split == null) {
      throw new RuntimeException("Unable to find an input split to evaluator " + evaluatorId);
    } else {
      LOG.log(Level.FINE, evaluatorToSplits.toString());
    }
    return split;
  }
1284014
public final Tuple2<Tuple5<T1, T2, T3, T4, T5>, Tuple7<T6, T7, T8, T9, T10, T11, T12>> split5() {
        return new Tuple2<>(limit5(), skip5());
    }
1174107
public final Tuple2<Tuple2<T1, T2>, Tuple10<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> split2() {
        return new Tuple2<>(limit2(), skip2());
    }
512343
private void split() throws IOException {
        hasSplit = true;
        IntegerBuffer before = new IntegerBuffer();
        IntegerBuffer after = new IntegerBuffer();

        int current;
        boolean ready = false;
        boolean stillNeedToSeeDoctype = true;
        while (!ready && (current = original.read()) != -1) {
            if (Character.isWhitespace((char) current)) {
                before.append(current);
            } else if (current == '<') {
                // could be XML declaration, comment, PI, DOCTYPE
                // or the first element
                int[] elementOrDeclOr = readUntilCloseCharIsReached();
                if (elementOrDeclOr.length > 0) {
                    if (elementOrDeclOr[0] == '?') {
                        // XML declaration or PI
                        before.append('<');
                        before.append(elementOrDeclOr);
                    } else if (elementOrDeclOr[0] != '!') {
                        // first element
                        after.append('<');
                        after.append(elementOrDeclOr);
                        stillNeedToSeeDoctype = false;
                        ready = true;
                    } else {
                        // comment or doctype
                        IntegerBuffer b =
                            new IntegerBuffer(elementOrDeclOr.length);
                        b.append(elementOrDeclOr);
                        if (b.indexOf(DOCTYPE_INTS) == -1) {
                            after.append('<');
                            after.append(elementOrDeclOr);
                        } else {
                            // swallow old declaration
                            stillNeedToSeeDoctype = false;
                        }
                        ready = true;
                    }
                } else {
                    after.append('<');
                    stillNeedToSeeDoctype = false;
                    ready = true;
                }
            } else {
                after.append(current);
                stillNeedToSeeDoctype = false;
                ready = true;
            }
        }

        // need to eliminate original DOCTYPE if it exists
        while (stillNeedToSeeDoctype && (current = original.read()) != -1) {
            if (Character.isWhitespace((char) current)) {
                after.append(current);
            } else if (current == '<') {
                int[] elementOrDeclOr = readUntilCloseCharIsReached();
                if (elementOrDeclOr.length > 0) {
                    if (elementOrDeclOr[0] == '?') {
                        // PI
                        after.append('<');
                        after.append(elementOrDeclOr);
                    } else if (elementOrDeclOr[0] != '!') {
                        // first element
                        after.append('<');
                        after.append(elementOrDeclOr);
                        stillNeedToSeeDoctype = false;
                    } else {
                        // comment or doctype
                        IntegerBuffer b =
                            new IntegerBuffer(elementOrDeclOr.length);
                        b.append(elementOrDeclOr);
                        if (b.indexOf(DOCTYPE_INTS) == -1) {
                            after.append('<');
                            after.append(elementOrDeclOr);
                        } else {
                            // swallow old declaration
                            stillNeedToSeeDoctype = false;
                        }
                    }
                } else {
                    after.append('<');
                    stillNeedToSeeDoctype = false;
                }
            } else {
                after.append(current);
                stillNeedToSeeDoctype = false;
            }
        }

        beforeDoctype = before.size() > 0
            ? new IntBufferReadable(before) : null;
        afterDoctype = after.size() > 0
            ? new IntBufferReadable(after) : null;
    }
1052039
public static VolleyFragment newInstance() {
		VolleyFragment fragment = new VolleyFragment();
		Bundle args = new Bundle();

		fragment.setArguments(args);
		return fragment;
	}
851584
@Override
    public RecordReader createReader(InputSplit split) throws IOException, InterruptedException {
        RecordReader reader = new ListStringRecordReader();
        reader.initialize(split);
        return reader;
    }
612477
Element<Corner> selectCornerToSplit( boolean loops ) {
		Element<Corner> selected = null;
		double bestChange = convex ? 0 : -Double.MAX_VALUE;

		// Pick the side that if split would improve the overall score the most
		Element<Corner> e=list.getHead();
		Element<Corner> end = loops ? null : list.getTail();

		while( e != end ) {
			Corner c = e.object;
			if( !c.splitable) {
				e = e.next;
				continue;
			}

			// compute how much better the score will improve because of the split
			double change = c.sideError*2 - c.splitError0 - c.splitError1;
			// it was found that selecting for the biggest change tends to produce better results
			if( change < 0 ) {
				change = -change;
			}
			if( change > bestChange ) {
				bestChange = change;
				selected = e;
			}
			e = e.next;
		}

		return selected;
	}
547719
public static BlankFragment newInstance() {
        BlankFragment fragment = new BlankFragment();
        Bundle args = new Bundle();

        fragment.setArguments(args);
        return fragment;
    }
1279107
public Collection<String> split() {
        String s = ident;
        Set<String> result = new HashSet<>();

        while (s.length() > 0) {
            StringBuilder buf = new StringBuilder();

            char first = s.charAt(0);
            buf.append(first);
            int i = 1;

            if (s.length() > 1) {
                boolean camelWord;
                if (Character.isLowerCase(first)) {
                    camelWord = true;
                } else {
                    char next = s.charAt(i++);
                    buf.append(next);
                    camelWord = Character.isLowerCase(next);
                }

                while (i < s.length()) {
                    char c = s.charAt(i);
                    if (Character.isUpperCase(c)) {
                        if (camelWord) {
                            break;
                        }
                    } else if (!camelWord) {
                        break;
                    }
                    buf.append(c);
                    ++i;
                }

                if (!camelWord && i < s.length()) {
                    buf.deleteCharAt(buf.length() - 1);
                    --i;
                }
            }

            result.add(buf.toString().toLowerCase(Locale.US));
            s = s.substring(i);
        }

        return result;
    }
1019262
public function splitSource()
	{
		$splitterRegexp = '@(\{/?(?:' . $this->getSignaturesRegexp() . ').*?/?\})@ims';

		$elementsRaw = preg_split($splitterRegexp, $this->source, -1, 
				PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_OFFSET_CAPTURE | PREG_SPLIT_NO_EMPTY);

		/* @var $element Abstraction\ElementAbstraction */
		$this->elements = array();

		foreach ($elementsRaw as $rawElement) {
			
			$elementSource = $rawElement[0];
			
			$firstCharOfElementSource = $elementSource{0};
			$secondCharOfElementSource = strlen($elementSource) > 1 ? $elementSource{1} : null;
			$preLastCharOfElementSource = strlen($elementSource) > 2 ? $elementSource{strlen($elementSource) - 2} : null;
			
			$element = true;
			$signature = null;

			// If this is SupraMarkup element, try to extract signature from raw element, ...
			if ($firstCharOfElementSource == '{') {
				$signature = $this->extractSignature($elementSource);
			}

			if ( ! empty($signature)) {

				// create element from signature, ...
				$elementClassName = $this->markupElements[$signature];

				$element = new $elementClassName();

				if (! $element instanceof Abstraction\SupraMarkupElement) {
					throw new Exception\RuntimeException(sprintf(
							'Expecting element to be instance of SupraMarkupElement, [%s] received.',
							get_class($element)
					));
				}

				/* @var $element Abstraction\ElementAbstraction */

				if ($preLastCharOfElementSource == '/') {
					// ... and if this is a standalone markup element - like {trololo.trololo /}, 
					// create and initialize it.

					$element->setSource($elementSource);
					$element->parseSource();
				}
				else if ($secondCharOfElementSource == '/') {
					// ... or if this this element is a closing part of a block, 
					// i.e. - begins with a slash, check if class of instace we 
					// created earlier actually is block constructor. If it is so,
					// treat created element as block constructor and get block 
					// end element from it. Otherwise do nothing, skip this element.

					if($element instanceof Abstraction\SupraMarkupBlockConstructor) {
						/* @var $element Abstraction\SupraMarkupBlockConstructor */
						$element = $element->makeEnd();
						$this->elements[] = $element;
					}
				}
				else {
					// ... otherwise this looks like an opening part of a block. We check if 
					// instace of this element is subclass of SupraMarkupBlockConstructor, then proceed to 
					// fetch coresponding block start element. Otherwise use element already created. This is because 
					// there might be some errornous SupraMarkup cases when, for exampl {supra.image ...} does not 
					// have a slash in the end.

					if($element instanceof Abstraction\SupraMarkupBlockConstructor) {
						/* @var $element Abstraction\SupraMarkupBlockConstructor */
						$element = $element->makeStart();
					}

					$element->setSource($elementSource);
					$element->parseSource();
					
					$this->elements[] = $element;
				}
			}
			else {
				// If is just a piece of content (HTML), just create element and set it's content.

				$element = new HtmlElement();
				$element->setContent($elementSource);
				
				$this->elements[] = $element;
			}
		}
	}
816787
public CodeBlock getInstance() {
        return CodeBlock.builder()
                .add( "new $T() {\n", ClassName.get( getMainClass() ) )
                .indent()
                .add( buildCreateMethod( getKeyClass(), key.getInstance() ) )
                .add( "\n" )
                .add( buildCreateMethod( getJsonClass(), json.getInstance() ) )
                .unindent()
                .add( "}" )
                .build();

    }
1124859
public void split() {
        if (!needsSplitting()) {
            return;
        }

        Node parent = getParentNode();
        String[] parts = getData().split("\\]\\]>");
        parent.insertBefore(new CDATASectionImpl(document, parts[0] + "]]"), this);
        for (int p = 1; p < parts.length - 1; p++) {
            parent.insertBefore(new CDATASectionImpl(document, ">" + parts[p] + "]]"), this);
        }
        setData(">" + parts[parts.length - 1]);
    }
902117
public List<Double> getSplits() {
        List<Double> splits = new ArrayList<Double>();
        for (Node curNode : getVisibleChildren()) {
            splits.add(nodeSplits.get(curNode));
        }
        return splits;
    }