The input type we use.

@return type information
171642
private TypeInformation getInputTypeRestriction() {
    // Find maximum dimension requested
    int m = dims[0];
    for(int i = 1; i < dims.length; i++) {
      m = Math.max(dims[i], m);
    }
    return VectorFieldTypeInformation.typeRequest(NumberVector.class, m, Integer.MAX_VALUE);
  }
648370
public function getType() : ?int 
    {
        if ( ! $this->hasType()) {
            $this->setType($this->getDefaultType());
        }
        return $this->type;
    }
294198
public function getRespondType()
    {
        $_respondType = $this->_respondType;
        if($respondType = $this->getConfig('respondType')) {
            $_respondType  =  $respondType;
        }

        return $_respondType;
    }
1147430
public EventType getType() {
        String typeStr = getTypeString();
        EventType type = null;
        try {
            type = EventType.valueOf(typeStr);
        } catch (Exception ex) {
            logger.warn("Unexpected type: " + typeStr);
        }
        return type;
    }
690062
public String getType()
    {
        if ( _propDecl == null || _propDecl.getReturnType() == null )
            return "";
        
        return _propDecl.getReturnType().toString();
    }
1220327
public function type()
    {
        if ($this->type === null) {
            $this->type = self::DEFAULT_INPUT_TYPE;
        }

        return $this->type;
    }
12993
protected function initTypes()
    {
        foreach ($this->result->getFieldNames() as $index => $name) {
            $type = $this->result->getFieldType($name);

            if ($type === null) {
                $type = 'text';
            }

            $this->types[$name] = $type;
            $this->converters[$name] = $this
                ->session
                ->getClientUsingPooler('converter', $type)
            ;
        }

        return $this;
    }
664134
public function getType() {
	    if (!array_key_exists('type', $this->configs)
            || empty($this->configs['type'])) {
	        return self::MYSQL;
        }
        return strtolower($this->configs['type']);
    }
686812
public Class<?> getType()
    {
        if ( this == Primitive.VOID )
            return Void.TYPE;

        // NULL return null as type... we currently use null type to indicate
        // loose typing throughout bsh.
        if ( this == Primitive.NULL )
            return null;

        return unboxType( value.getClass() );
    }
1269571
private function input() {
		if ($this->input===null) {
			$this->input=new ValidationInputOne($this->prefix,$this->messageList); // we used the same message list
		}
		return $this->input;
	}
581798
private final Type getGenericType() {
        final Class<?> raw = getClass();
        final TypeVariable<?>[] typeParameters = raw.getTypeParameters();
        if (ArrayUtils.isEmpty(typeParameters)) {
            return raw;
        }
        final Type[] parameters = new Type[typeParameters.length];

        // use empty type variable map because we're relying on @BindTypeVariable functionality:
        final Map<TypeVariable<?>, Type> typeVariableMap = Collections.emptyMap();
        for (int i = 0; i < parameters.length; i++) {
            parameters[i] = Types.resolveAt(this, typeParameters[i], typeVariableMap);
        }
        return TypeUtils.parameterize(raw, parameters);
    }
449438
@Override
    public TYPE getType() {
        final IPortalUrlBuilder portalUrlBuilder = this.portletUrlBuilder.getPortalUrlBuilder();
        final UrlType urlType = portalUrlBuilder.getUrlType();
        return urlType.getPortletUrlType();
    }
910529
public function getType(): string
    {
        if (null === $this->type) {
            $success = true;

            $type = $this->getItem('browscap.type', false, $success);

            if (null !== $type && $success) {
                $this->type = $type;
            }
        }

        return $this->type;
    }
1318721
public function getInput() {
		if (!isset($this->input)) {
			switch ($this->method) {
			case 'POST':
				switch ($this->getContentType()) {
				case 'application/x-www-form-urlencoded':
				case 'multipart/form-data':
					$this->input = $_POST;
					break;

				default:
					$this->input = $this->getParamsFromInput();
					break;
				}
				break;

			case 'PUT':
			case 'DELETE':
				$this->input = $this->getParamsFromInput();
				break;

			default:
				$this->input = [];
				break;
			}
		}

		return $this->input;
	}
935550
public function outputType()
    {
        if ($this->outputType === null) {
            if ($this->inputType === false && $this->displayType === false) {
                throw new LogicException('Form property widget requires an "input_type" or a "display_type"');
            }

            $type = null;

            if ($this->inputType === false || is_string($this->displayType)) {
                $type = static::PROPERTY_DISPLAY;
            }

            if ($this->displayType === false || is_string($this->inputType)) {
                $type = static::PROPERTY_CONTROL;
            }

            $this->outputType = $type;
        }

        return $this->outputType;
    }
845408
public Class<?> getBoxedType() {
        if (mBoxedType == null) {
            mBoxedType = TypeDesc.forClass(getType()).toObjectType().toClass();
        }
        return mBoxedType;
    }
90203
public java.util.List<Type> getType() {  
		if (myType == null) {
			myType = new java.util.ArrayList<Type>();
		}
		return myType;
	}