Returns the system type for this record, i.e., the {@code rdf:type} URI under the
{@code ks:} namespace, if any.

@return the system type or null if not set
@throws IllegalArgumentException
in case multiple system types are bound to the record
432243
@Nullable
    public synchronized URI getSystemType() throws IllegalArgumentException {
        URI result = null;
        for (final URI type : get(RDF.TYPE, URI.class)) {
            if (type.getNamespace().equals(KS.NAMESPACE)) {
                Preconditions.checkArgument(result == null, "Multiple system types: " + result
                        + ", " + type);
                result = type;
            }
        }
        return result;
    }
931688
@Override
   public String getContentType()
   {
      try
      {
         if (!connected)
         {
            connect();
         }

         return nodeRepresentation.getMediaType();
      }
      catch (IOException e)
      {
         if (LOG.isTraceEnabled())
         {
            LOG.trace("An exception occurred: " + e.getMessage());
         }
      }
      catch (RepositoryException e)
      {
         if (LOG.isTraceEnabled())
         {
            LOG.trace("An exception occurred: " + e.getMessage());
         }
      }
      return null;
   }
717478
@ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
    @JoinColumn(name="REPOSITORY_TYPE_ID", nullable = false)
	public RepositoryType getRepositoryType() 
	{
		return repositoryType;
	}
949712
@Override
    public String getType(Uri uri) {
        if (!controller.hasPreinitialized()) {
            throw new IllegalStateException("Controller has not been initialized.");
        }

        int patternCode = controller.getUriMatcher().match(uri);
        MatcherPattern pattern = controller.findMatcherPattern(patternCode);
        if (pattern == null) {
            throw new IllegalArgumentException("unknown uri : " + uri.toString());
        }
        return pattern.getMimeTypeVndString();
    }
342439
public String getGeometryType() {
      String geometryType = null;
      if (getParameters().length > 0 && getParameters()[0] != null) {
         geometryType = getParameters()[0].toString();
      }
      return geometryType;
   }
745367
public IType getType()
  {
    IType type = getTypeImpl();
    if (TypeSystem.isDeleted(type)) {
      type = TypeSystem.getErrorType();
    }
    return type;
  }
966795
public static Integer lookup(String type) throws IllegalArgumentException {
    checkNotNull(type, "resource type was null");
    checkArgument(lookup.containsKey(type), "%s do not include %s; types: %s",
                  ResourceTypes.class.getSimpleName(),
                  type, EnumSet.allOf(ResourceTypes.class));
    return lookup.get(type);
  }
405016
public String type() {
		try {
			if(isCluster(groupName)){
				return getBinaryJedisClusterCommands(groupName).type(keyBytes);
			}
			return getBinaryJedisCommands(groupName).type(keyBytes);
		} finally {
			getJedisProvider(groupName).release();
		}

	}
716529
public HeadedSyntacticCategory getArgumentType() {
    SyntacticCategory argumentSyntax = syntacticCategory.getArgument();
    int[] argumentSemantics = ArrayUtils.copyOfRange(semanticVariables, rootIndex + 1, semanticVariables.length);
    int argumentRoot = argumentSyntax.getNumReturnSubcategories();
    return new HeadedSyntacticCategory(argumentSyntax, argumentSemantics, argumentRoot);
  }
199154
public alluxio.grpc.ServiceType getServiceType() {
    alluxio.grpc.ServiceType result = alluxio.grpc.ServiceType.valueOf(serviceType_);
    return result == null ? alluxio.grpc.ServiceType.UNKNOWN_SERVICE : result;
  }
1289117
public String getSchemaNodeSourceType() {

		final SchemaNode sourceNode = getSourceNode();
		if (sourceNode != null) {

			return sourceNode.getProperty(SchemaNode.name);
		}

		return null;
	}
842490
public DatabaseType getDatabaseType() {
        if (lexer instanceof H2Lexer) {
            return DatabaseType.H2;
        }
        if (lexer instanceof MySQLLexer) {
            return DatabaseType.MySQL;
        }
        if (lexer instanceof OracleLexer) {
            return DatabaseType.Oracle;
        }
        if (lexer instanceof SQLServerLexer) {
            return DatabaseType.SQLServer;
        }
        if (lexer instanceof PostgreSQLLexer) {
            return DatabaseType.PostgreSQL;
        }
        throw new UnsupportedOperationException(String.format("Cannot support lexer class: %s", lexer.getClass().getCanonicalName()));
    }
815331
@Override
    public String getNamespaceURI(String prefix){
        if(prefix==null)
            throw new IllegalArgumentException("prefix is null");

        return get(prefix);
    }
825478
public static @Nullable String getExistingResourceType(@NotNull ResourceResolver resourceResolver, @NotNull String @NotNull... resourceTypes) {
    for (String path : resourceTypes) {
      if (resourceResolver.getResource(path) != null) {
        return path;
      }
    }
    return null;
  }
1245835
def type(namespace, name)
      if @allow_abstract_types
        @types.fetch([namespace, name]) { abstract_type(namespace, name) }
      else
        @types.fetch([namespace, name]) { NullType.new }
      end
    end
1361278
public com.google.api.ads.adwords.axis.v201809.cm.OperatingSystemVersionOperatorType getOperatorType() {
        return operatorType;
    }
609092
public Class<?> getType() {
        Class<?> tmp = parameterClassCache;
        if (null == tmp) {
            tmp = executable.getParameterTypes()[index];
            parameterClassCache = tmp;
        }
        return tmp;
    }