Returns an object that represents a Kontonummer.

@param kontonummer A String containing a Kontonummer
@return A Kontonummer instance
@throws IllegalArgumentException thrown if String contains an invalid Kontonummer
436795
public static Kontonummer getKontonummer(String kontonummer) throws IllegalArgumentException {
        validateSyntax(kontonummer);
        validateChecksum(kontonummer);
        return new Kontonummer(kontonummer);
    }
628068
Class<?> classOfPrimitiveFor(String primitiveType) {
        return ClassUtils.getPrimitiveType(primitiveType).orElseThrow(() -> new IllegalArgumentException("Unknown primitive type: " + primitiveType));
    }
261689
public Annotator getAnnotator(Class<? extends Annotator> clazz) {

        if (!Annotator.class.isAssignableFrom(clazz)) {
            throw new IllegalArgumentException("The class name given as a custom annotator (" + clazz.getName() + ") does not refer to a class that implements " + Annotator.class.getName());
        }

        try {
            try {
                Constructor<? extends Annotator> constructor = clazz.getConstructor(GenerationConfig.class);
                return constructor.newInstance(generationConfig);
            } catch (NoSuchMethodException e) {
                return clazz.newInstance();
            }
        } catch (InvocationTargetException | InstantiationException e) {
            throw new IllegalArgumentException("Failed to create a custom annotator from the given class. An exception was thrown on trying to create a new instance.", e.getCause());
        } catch (IllegalAccessException e) {
            throw new IllegalArgumentException("Failed to create a custom annotator from the given class. It appears that we do not have access to this class - is both the class and its no-arg constructor marked public?", e);
        }

    }
943682
@Override
  public int get(String symbol) {
    int id = symbolToId.getOrDefault(symbol, -1);
    if (id < 0) {
      throw new IllegalArgumentException("No symbol exists for key " + symbol);
    }
    return id;
  }
900475
public Namer getOneToManyIntermediateNamer(Namer fromEntityNamer, ColumnConfig pointsOnToEntity, Namer toEntityNamer) {
        // new configuration
        Namer result = getOneToManyNamerFromConf(pointsOnToEntity.getOneToManyConfig(), toEntityNamer);

        // fallback
        if (result == null) {
            // NOTE: we use the many to many fallback as it is totally complient with intermediate m2o fallback expectations.
            result = getManyToManyNamerFallBack(fromEntityNamer, pointsOnToEntity, toEntityNamer);
        }

        return result;
    }
588306
@Override
    public DynamicMBean getMBeanFor(Object object) throws IllegalStateException {
        JmxBean jmxBean = AnnotationUtils.getAnnotation(object.getClass(), JmxBean.class);
        if (jmxBean == null) {
            throw new IllegalArgumentException("Could not find annotation " + JmxBean.class + " on " + object.getClass());
        }
        try {
            ClassIntrospector classIntrospector = new ClassIntrospectorImpl(object.getClass());
            DynamicMBeanImpl mbean = new DynamicMBeanImpl(object);
            mbean.setmBeanInfo(getInfo(object, classIntrospector));
            Map<String, Method> getters = new HashMap<String, Method>();
            Map<String, Method> setters = new HashMap<String, Method>();
            resolveGettersAndSetters(classIntrospector, getters, setters);
            mbean.setGetters(getters);
            mbean.setSetters(setters);
            mbean.setOperations(getOperationsMap(classIntrospector));
            return mbean;
        } catch (Exception e) {
           throw new IllegalStateException("Could not create DynamicMBean for " + object, e);
        }
    }
1037016
@DefinedBy(Api.LANGUAGE_MODEL)
    public <A extends Annotation> A getAnnotation(Class<A> annoType) {

        if (!annoType.isAnnotation())
            throw new IllegalArgumentException("Not an annotation type: " + annoType);

        Attribute.Compound c = getAttribute(annoType);
        return c == null ? null : AnnotationProxyMaker.generateAnnotation(c, annoType);
    }
632828
public DTMAxisIterator cloneIterator()
  {

    try
    {
      final DTMAxisIteratorBase clone = (DTMAxisIteratorBase) super.clone();

      clone._isRestartable = false;

      // return clone.reset();
      return clone;
    }
    catch (CloneNotSupportedException e)
    {
      throw new org.apache.xml.utils.WrappedRuntimeException(e);
    }
  }
322896
public static String getSourceByClass(Class<?> koanClass) {

        File file = new File(getKoanFileLocation(koanClass));
   		StringBuilder contents = new StringBuilder();
   		BufferedReader reader = null;

   		try {
   			reader = new BufferedReader(new FileReader(file));
   			String text = null;

   			while ((text = reader.readLine()) != null) {
   				contents.append(text).append(System.lineSeparator());
   			}
   		} catch (IOException e) {
   			e.printStackTrace();
   		} finally {
   			try {
   				if (reader != null) {
   					reader.close();
   				}
   			} catch (IOException e) {
   				e.printStackTrace();
   			}
   		}
   		return contents.toString();
   	}
1055079
public <T extends Annotation> Optional<T> getAnnotation( String annotation ) {
        return CreatorUtils.getAnnotation( annotation, accessors );
    }
300916
public static DERUniversalString getInstance(
        Object  obj)
    {
        if (obj == null || obj instanceof DERUniversalString)
        {
            return (DERUniversalString)obj;
        }

        if (obj instanceof ASN1OctetString)
        {
            return new DERUniversalString(((ASN1OctetString)obj).getOctets());
        }

        throw new IllegalArgumentException("illegal object in getInstance: " + obj.getClass().getName());
    }
600940
public TypeSerializer<UK> getKeySerializer() {
		final TypeSerializer<Map<UK, UV>> rawSerializer = getSerializer();
		if (!(rawSerializer instanceof MapSerializer)) {
			throw new IllegalStateException("Unexpected serializer type.");
		}

		return ((MapSerializer<UK, UV>) rawSerializer).getKeySerializer();
	}
1347161
@SuppressWarnings("unchecked")
  private KeyEntitySchemaParser<?, ?> getSchemaParser(
      String schemaParserClassName) {
    if (schemaParsers.contains(schemaParserClassName)) {
      return schemaParsers.get(schemaParserClassName);
    } else {
      try {
        Class<KeyEntitySchemaParser<?, ?>> schemaParserClass = (Class<KeyEntitySchemaParser<?, ?>>) Class
            .forName(schemaParserClassName);
        KeyEntitySchemaParser<?, ?> schemaParser = schemaParserClass
            .getConstructor().newInstance();
        schemaParsers.putIfAbsent(schemaParserClassName, schemaParser);
        return schemaParser;
      } catch (Exception e) {
        throw new DatasetException(
            "Could not instantiate schema parser class: "
                + schemaParserClassName, e);
      }
    }
  }
571297
public static OtherwiseBuilder getBuilder( ConditionCol52 c ) {

        if ( c.getOperator().equals( "==" ) ) {
            return new EqualsOtherwiseBuilder();
        } else if ( c.getOperator().equals( "!=" ) ) {
            return new NotEqualsOtherwiseBuilder();
        }
        throw new IllegalArgumentException( "ConditionCol operator does not support Otherwise values" );
    }
1269132
@ArgumentsChecked
	@Throws(IllegalNullArgumentException.class)
	private static String format(@Nonnull final Class<? extends Annotation> annotation) {
		if (annotation == null) {
			throw new IllegalNullArgumentException("annotation");
		}
		return String.format(MESSAGE_WITH_ANNOTATION, annotation.getName());
	}
964849
public LockEntry getWriter(Object obj)
    {
        PersistenceBroker broker = getBroker();
        Identity oid = new Identity(obj, broker); 
        return getWriter(oid);
    }
843291
Class<?> classOfPrimitiveArrayFor(String primitiveType) {
        return ClassUtils.arrayTypeForPrimitive(primitiveType)
                    .orElseThrow(() -> new IllegalArgumentException("Unsupported primitive type " + primitiveType));
    }