docs: @SuppressWarnings({
  		"checkstyle:cyclomaticcomplexity",
  		"checkstyle:npathcomplexity",
  		"checkstyle:magicnumber",
  		"checkstyle:booleanexpressioncomplexity"})
  	public static long computeSerialVersionUID(JvmGenericType jvm) {
  		final StringBuilder serialVersionUIDBuffer = new StringBuilder();
  
  		serialVersionUIDBuffer.append(jvm.getQualifiedName());
  
  		BitSet bitset = new BitSet(32);
  		bitset.set(jvm.getVisibility().getValue());
  		if (jvm.isFinal()) {
  			bitset.set(4);
  		}
  		if (jvm.isAbstract()) {
  			bitset.set(5);
  		}
  		if (jvm.isInterface()) {
  			bitset.set(6);
  		}
  		serialVersionUIDBuffer.append(bitset.toByteArray());
  
  		final SortedSet<JvmTypeReference> superTypes = CollectionLiterals.newTreeSet(new JvmTypeReferenceComparator());
  		superTypes.addAll(jvm.getSuperTypes());
  
  		final SortedSet<JvmField> fields = CollectionLiterals.newTreeSet(new JvmIdentifiableComparator());
  		final SortedSet<JvmConstructor> constructors = CollectionLiterals.newTreeSet(new JvmIdentifiableComparator());
  		final SortedSet<JvmOperation> operations = CollectionLiterals.newTreeSet(new JvmIdentifiableComparator());
  		for (final JvmMember member : jvm.getMembers()) {
  			if (member instanceof JvmField) {
  				final JvmField field = (JvmField) member;
  				if ((field.getVisibility() != JvmVisibility.PRIVATE)
  						|| (!field.isStatic() && !field.isTransient())) {
  					fields.add(field);
  				}
  			} else if (member instanceof JvmConstructor) {
  				final JvmConstructor constructor = (JvmConstructor) member;
  				if (constructor.getVisibility() != JvmVisibility.PRIVATE) {
  					constructors.add(constructor);
  				}
  			} else if (member instanceof JvmOperation) {
  				final JvmOperation operation = (JvmOperation) member;
  				if (operation.getVisibility() != JvmVisibility.PRIVATE) {
  					operations.add(operation);
  				}
  			}
  		}
  
  		for (final JvmTypeReference superType : superTypes) {
  			serialVersionUIDBuffer.append(superType.getQualifiedName());
  		}
  
  		for (final JvmField field : fields) {
  			serialVersionUIDBuffer.append(field.getSimpleName());
  			bitset = new BitSet(32);
  			bitset.set(field.getVisibility().getValue());
  			if (field.isStatic()) {
  				bitset.set(4);
  			}
  			if (field.isFinal()) {
  				bitset.set(5);
  			}
  			if (field.isVolatile()) {
  				bitset.set(6);
  			}
  			if (field.isTransient()) {
  				bitset.set(7);
  			}
  			serialVersionUIDBuffer.append(bitset.toByteArray());
  			serialVersionUIDBuffer.append(field.getType().getIdentifier());
  		}
  
  		for (final JvmConstructor constructor : constructors) {
  			bitset = new BitSet(32);
  			bitset.set(constructor.getVisibility().getValue());
  			if (constructor.isStatic()) {
  				bitset.set(4);
  			}
  			if (constructor.isVarArgs()) {
  				bitset.set(5);
  			}
  			serialVersionUIDBuffer.append(bitset.toByteArray());
  			for (final JvmFormalParameter parameter : constructor.getParameters()) {
  				serialVersionUIDBuffer.append(parameter.getParameterType().getIdentifier());
  			}
  		}
  
  		for (final JvmOperation operation : operations) {
  			bitset = new BitSet(32);
  			bitset.set(operation.getVisibility().getValue());
  			if (operation.isStatic()) {
  				bitset.set(4);
  			}
  			if (operation.isFinal()) {
  				bitset.set(5);
  			}
  			if (operation.isSynchronized()) {
  				bitset.set(6);
  			}
  			if (operation.isNative()) {
  				bitset.set(7);
  			}
  			if (operation.isAbstract()) {
  				bitset.set(8);
  			}
  			if (operation.isStrictFloatingPoint()) {
  				bitset.set(9);
  			}
  			if (operation.isVarArgs()) {
  				bitset.set(10);
  			}
  			serialVersionUIDBuffer.append(bitset.toByteArray());
  			for (final JvmFormalParameter parameter : operation.getParameters()) {
  				serialVersionUIDBuffer.append(parameter.getParameterType().getIdentifier());
  			}
  		}
  
  		long key = 1L;
  		try {
  			final byte[] uniqueKey = serialVersionUIDBuffer.toString().getBytes();
  			final byte[] sha = MessageDigest.getInstance("SHA").digest(uniqueKey); //$NON-NLS-1$
  			key = ((sha[0] >>> 24) & 0xFF)
  					| ((sha[0] >>> 16) & 0xFF) << 8
  					| ((sha[0] >>> 8) & 0xFF) << 16
  					| ((sha[0] >>> 0) & 0xFF) << 24
  					| ((sha[1] >>> 24) & 0xFF) << 32
  					| ((sha[1] >>> 16) & 0xFF) << 40
  					| ((sha[1] >>> 8) & 0xFF) << 48
  					| ((sha[1] >>> 0) & 0xFF) << 56;
  		} catch (NoSuchAlgorithmException e) {
  			//
  		}
  
  		return key;
  	}