If not already created, a new <code>step</code> element will be created and returned.
Otherwise, the first existing <code>step</code> element will be returned.
@return the instance defined for the element <code>step</code>
167680
public Step<Flow<T>> getOrCreateStep()
   {
      List<Node> nodeList = childNode.get("step");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new StepImpl<Flow<T>>(this, "step", childNode, nodeList.get(0));
      }
      return createStep();
   }
868298
public Step pollLast() {
        Deque<Step> queue = get();
        Step last = queue.pollLast();
        if (queue.isEmpty()) {
            queue.add(createRootStep());
        }
        return last;
    }
657961
private function createStepsNodeDefinition()
    {
        $stepsNode = new ArrayNodeDefinition('steps');

        $stepsNode
            ->defaultValue(array())
            ->useAttributeAsKey('name')
            ->prototype('array')
                ->addDefaultsIfNotSet()
                ->children()
                    ->scalarNode('label')
                        ->defaultValue('')
                    ->end()

                    ->arrayNode('roles')
                        ->prototype('scalar')->end()
                    ->end()

                    ->arrayNode('model_status')
                        ->validate()
                            ->ifTrue(function ($value) {
                                return (is_array($value) && count($value) < 2);
                            })
                            ->thenInvalid('You must specify an array with [ method, constant ]')
                            ->ifTrue(function ($value) {
                                return ( ! defined($value[1]));
                            })
                            ->thenInvalid('You must specify a valid constant name as second parameter')
                        ->end()
                        ->prototype('scalar')->end()
                    ->end()

                    ->scalarNode('on_invalid')
                        ->defaultNull()
                    ->end()
                ->end()
                ->append($this->createNextStatesNodeDefinition())
            ->end()
        ;

        return $stepsNode;
    }
1252079
public FacesConfigComponentType<FacesConfigType<T>> getOrCreateComponent()
   {
      List<Node> nodeList = childNode.get("component");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigComponentTypeImpl<FacesConfigType<T>>(this, "component", childNode, nodeList.get(0));
      }
      return createComponent();
   }
367064
public OrderItem createOrderItem() {
        if (orderByItemSegment instanceof IndexOrderByItemSegment) {
            return createOrderItem((IndexOrderByItemSegment) orderByItemSegment);
        }
        if (orderByItemSegment instanceof ColumnOrderByItemSegment) {
            return createOrderItem(selectStatement, (ColumnOrderByItemSegment) orderByItemSegment);
        }
        if (orderByItemSegment instanceof ExpressionOrderByItemSegment) {
            return createOrderItem(selectStatement, (ExpressionOrderByItemSegment) orderByItemSegment);
        }
        throw new UnsupportedOperationException();
    }
474506
public Object next() {

        // for chained iterators
        if (chained) {
            if (it1 == null) {
                if (it2 == null) {
                    throw new NoSuchElementException();
                }

                if (it2.hasNext()) {
                    return it2.next();
                }

                it2 = null;

                next();
            } else {
                if (it1.hasNext()) {
                    return it1.next();
                }

                it1 = null;

                next();
            }
        }

        // for other itertors
        if (hasNext()) {
            return elements[i++];
        }

        throw new NoSuchElementException();
    }
208969
public List getSteps() {
	// simply merge our 'step' with our 'next'
	List l;
	if (next != null)
	    l = next.getSteps();
	else
	    l = new Vector();
	l.add(0, step);
	return l;
    }
984705
public PossibleStep findMatchedStep(Step step)
	{
		for (PossibleStep possibleStep : possibleSteps)
		{
			if (possibleStep.getStepType().equals(step.getStepType()))
			{
				if (possibleStep.getRegexStepMatcher().matches(step.getCombinedStepLines()))
				{
					return possibleStep;
				}
			}
		}
		return null;
	}
816380
public static Step step(String stepName)
  {
    Root root = PROFILER_STEPS.get();
    if (root != null)
    {
      Profile data = new Profile(root.nextId(), stepName);
      return new Step(root, data);
    } else
    {
      return new Step(null, null);
    }
  }
1046068
@Override
    protected Deque<Step> initialValue() {
        Deque<Step> queue = new LinkedList<>();
        queue.add(createRootStep());
        return queue;
    }
852631
public FacesConfigFlowDefinitionSwitchCaseType<FacesConfigFlowDefinitionSwitchType<T>> getOrCreateCase()
   {
      List<Node> nodeList = childNode.get("case");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigFlowDefinitionSwitchCaseTypeImpl<FacesConfigFlowDefinitionSwitchType<T>>(this, "case", childNode, nodeList.get(0));
      }
      return createCase();
   }
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();

    }
1184751
public OrderingOrderingType<OrderingType<T>> getOrCreateAfter()
   {
      Node node = childNode.getOrCreate("after");
      OrderingOrderingType<OrderingType<T>> after = new OrderingOrderingTypeImpl<OrderingType<T>>(this, "after", childNode, node);
      return after;
   }
422901
public FacesConfigLifecycleType<FacesConfigType<T>> getOrCreateLifecycle()
   {
      List<Node> nodeList = childNode.get("lifecycle");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigLifecycleTypeImpl<FacesConfigType<T>>(this, "lifecycle", childNode, nodeList.get(0));
      }
      return createLifecycle();
   }
7800
public <T extends BioPAXElement> T copy(T source, String newID) 
	{
		T copy = (T) level.getDefaultFactory().create(
				(Class<T>) source.getModelInterface(), newID);
		this.copy = copy;
		// to avoid unnecessary checks/warnings when existing valid element is being cloned  
		//(e.g., copying BPS.stepProcess values, if there is a Conversion, which was set via stepConversion).
		AbstractPropertyEditor.checkRestrictions.set(false);
		traverser.traverse(source, null);
		AbstractPropertyEditor.checkRestrictions.set(true);//back to default
		return copy;
	}
405627
public Selector createSelector()
    {
        selectorSync.lock();
        try {
            Selector selector = Selector.open();
            assert (selector != null);
            selectors.add(selector);
            return selector;
        }
        catch (IOException e) {
            throw new ZError.IOException(e);
        }
        finally {
            selectorSync.unlock();
        }
    }
1326090
public java.lang.Object getStep() {
		return (java.lang.Object) getStateHelper().eval(PropertyKeys.step, 1);
	}