Set the recursive value of this atom expression.

@param type the type of expression
@param mol  the recursive pattern
765063
private void setRecursive(Type type, IAtomContainer mol) {
        switch (type) {
            case RECURSIVE:
                this.type = type;
                this.value = 0;
                this.left = null;
                this.right = null;
                this.query = mol;
                this.ptrn  = null;
                break;
            default:
                throw new IllegalArgumentException();
        }
    }
798735
public void setType(TYPE type) {
    if(type == null) {
      type = TYPE.UNSET;
    }
    this.type = type;
  }
920473
private void setSecStrucType(int pos, SecStrucType type){
		SecStrucState ss = getSecStrucState(pos);
		if (type.compareTo(ss.getType()) < 0) ss.setType(type);
	}
624745
public static <E, Q extends SimpleExpression<? super E>> SetPath<E, Q> setPath(Class<E> type, Class<Q> queryType, PathMetadata metadata) {
        return new SetPath<E, Q>(type, queryType, metadata);
    }
1197298
private void setInstanceLevel_FG(int[] enabled, int[] enabledSync, boolean recursive) {
        if (instance != null) {
            // Fine grained instrumentation overrides the old level
            // First call setFineGrainedInstrumentation.
            // If fine grained level is undefined called old setInstrumentationLevel
            boolean action = instance.setFineGrainedInstrumentation(enabled, enabledSync);

            /*
             * not need since PmiConfigManager.updateWithRuntimeSpec is always called before persisting
             * // Update in-memory EMF object (PMIModule)
             * // call instance.getEnabled() to save the filtered set (filtering done by setFineGrainedInstrumentation, specifically bean module methods)
             * if (PmiConfigManager.isInitialized())
             * PmiConfigManager.updateSpec(instance.getPath(), instance.getWCCMStatsType(), instance.getEnabled(), instance.getEnabledSync(), false, false);
             */

            // FIXME: updating parent. may need to call this conditionally - when there is a change in fg spec        
            updateParent();
        }

        if (recursive) {
            ModuleItem[] items = children();
            if (items == null)
                return;
            for (int i = 0; i < items.length; i++) {
                items[i].setInstanceLevel_FG(enabled, enabledSync, recursive);
            }
        }
    }
117186
public void setDeclType(int declType) {
        if (!(declType == Token.FUNCTION
              || declType == Token.LP
              || declType == Token.VAR
              || declType == Token.LET
              || declType == Token.CONST))
            throw new IllegalArgumentException("Invalid declType: " + declType);
        this.declType = declType;
    }
1252602
public void setTypes(List<String> types) {

        if (types == null) {
            m_types = new ArrayList<String>();
        } else {
            m_types = types;
        }
    }
855768
public void setPrimitive(Type type, int val) {
        if (type.hasValue()) {
            this.type = type;
            this.value = val;
            this.left = null;
            this.right = null;
            this.query = null;
        } else {
            throw new IllegalArgumentException("Value provided for non-value "
                                               + "expression type!");
        }
    }
437117
@SuppressWarnings("unchecked")
	public <T> DatagraphEnvironment setInstance(Class<T> type, T value) {
		((Map<Class<T>, T>) instances).put(type, value);
		return this;
	}
109316
@NonNull
    public SourceParams setType(@Source.SourceType String type) {
        mType = type;
        mTypeRaw = type;
        return this;
    }
1292549
public function setType( $type )
	{
		if ( $type == $this->getType() ) { return; }

		$this->_checkType( $type );

		$this->_values['type'] = (string) $type;
		$this->setModified();
	}
124549
public void setType (int index, String type)
    {
    if (index >= 0 && index < length) {
        data[index*5+3] = type;
    } else {
        badIndex(index);
    }
    }
1215840
public static void setRenderer(int type) {
		switch (type) {
			case IMMEDIATE_RENDERER:
				setRenderer(new ImmediateModeOGLRenderer());
				return;
			case VERTEX_ARRAY_RENDERER:
				setRenderer(new VAOGLRenderer());
				return;
		}
		
		throw new RuntimeException("Unknown renderer type: "+type);
	}
983888
public void setType(String type) throws PageException {
	if (type == null) return;
	try {
	    this.type = toType(type);
	}
	catch (SearchException e) {
	    throw Caster.toPageException(e);
	}
    }
939941
@Override
  public void set(Object data, Class<?>... typeSpecs) {
    this.reset();
    this.mDefaultTypeSpecs = typeSpecs;
    this.add(data, typeSpecs);
  }
846715
@Api
	public void setMapType(MapType type) {
		this.type = type;
		if (googleMap != null) {
			setMapType(googleMap, type.toString());
		}
	}
315518
public Atom rewriteWithTypeVariable(Atom parentAtom) {
        if (parentAtom.getPredicateVariable().isReturned()
                && !this.getPredicateVariable().isReturned()
                && this.getClass() == parentAtom.getClass()) {
            return rewriteWithTypeVariable();
        }
        return this;
    }