// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//

// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//

    int SYNCHRONIZE = 0x00100000; // 20
    /**
     * All generic permissions.
     */
    int GENERIC_ALL = 0x10000000; // 28
    /**
     * Generic execute permission.
     */
    int GENERIC_EXECUTE = 0x20000000; // 29
    /**
     * Generic write permission.
     */
    int GENERIC_WRITE = 0x40000000; // 30
    /**
     * Generic read permission.
     */
    int GENERIC_READ = 0x80000000; // 31

And then you won't have to worry about names like `Optional` and `Union`. 😎

#### Generic types { #generic-types }

These types that take type parameters in square brackets are called **Generic types** or **Generics**, for example:

//// tab | Python 3.10+

You can use the same builtin types as generics (with square brackets and types inside):

* `list`
* `tuple`
* `set`
* `dict`

                case 4:
                    throw new NullPointerException("Null pointer");
                default:
                    throw new RuntimeException("Generic error");
                }
            }
        };
        ComponentUtil.register(mockSearchLogHelper, "searchLogHelper");

        // First execution - success

                        || message.contains("host unreachable") || message.contains("timeout");
            }
            return true; // Generic socket errors might be recoverable
        }

        // Generic IO exceptions might be recoverable
        if (error instanceof IOException) {
            String message = error.getMessage();
            if (message != null) {

            fail("Constructor with RequestManager, UserMessagesCreator, and Class[] parameters should exist");
        }
    }

    public void test_classStructure() {
        // Verify the class is generic
        final java.lang.reflect.TypeVariable<?>[] typeParameters = FessActionValidator.class.getTypeParameters();
        assertEquals("Should have one type parameter", 1, typeParameters.length);

* **`400 - 499`** are for "Client error" responses. These are the second type you would probably use the most.
    * An example is `404`, for a "Not Found" response.
    * For generic errors from the client, you can just use `400`.

     * non-reified type or has bounds, {@code forDependants} is used to do further resolution, which
     * doesn't try to resolve any type variable on generic declarations that are already being
     * resolved.
     *
     * <p>Should only be called and overridden by {@link #resolve(TypeVariable)}.
     */

// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//