text:
<!DOCTYPE html>

	<meta charset="UTF-8">
	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
	<meta name="viewport" content="width=device-width, initial-scale=1">
	<title>Document</title>

Home

News

Register

Contract

    <input type="radio" name="gallery" id="img-1" checked />
    <input type="radio" name="gallery" id="img-2" />
    <input type="radio" name="gallery" id="img-3" />
    <input type="radio" name="gallery" id="img-4" />
    <input type="radio" name="gallery" id="img-5" />

<image src="tung.jpg" style="width:120%;height:155%;">

<image src="chang.jpg" style="width:120%;height:155%;">

<image src="poo.jpg" style="width:120%;height:155%;">

<image src="doy.jpg" style="width:120%;height:155%;">

<image src="ang.jpg" style="width:120%;height:155%;">

6/8/2559 : Review Samed island

7/8/2559 : Review Samui island

8/8/2559 : Review  Arun temple

- Mr . Pittaya Chamchoi

- Faculty Of Science

- king mongkut's university of technology thonburi
- department of mathematics

<audio controls autoplay="">
  <source src="daimaidaow.mp3" type="audio/mpeg">
</audio>

redpajama_set_name: RedPajamaGithub


text:
package main

import (
	"fmt"
	"net"
	"os"

	"github.com/dstotijn/go-bunq"
)

func main() {
	client := bunq.NewClient()
	client.APIKey = os.Getenv("BUNQ_API_KEY")
	client.BaseURL = "https://sandbox.public.api.bunq.com"

	file, err := os.Open("/Users/david/.keys/bunq.key")
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(1)
	}
	if err := client.SetPrivateKey(file); err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(1)
	}

	fmt.Printf("* Creating installation...\n\n")
	installation, err := client.CreateInstallation()
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Created installation: %#v\n", installation)

	fmt.Printf("\n* Creating DeviceServer...\n\n")
	client.Token = installation.Token.Token
	deviceServer, err := client.CreateDeviceServer("Foobar", []net.IP{})
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Created DeviceServer: %#v\n", deviceServer)

	fmt.Printf("\n* Getting DeviceServer...\n\n")
	deviceServer, err = client.GetDeviceServer(deviceServer.ID)
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Retrieved DeviceServer: %#v\n", deviceServer)

	fmt.Printf("\n* Creating Session...\n\n")
	session, err := client.CreateSession()
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Created Session: %#v\n", session)
}


text:
package org.helenus.commons.lang3;

import java.util.Collection;
import java.util.Map;
import java.util.regex.Pattern;

import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.Logger;

/**
 * The Validate class extends the class
 * {@link org.apache.commons.lang3.Validate} to provide support for logging
 * exceptions thrown out.
 *
 * @copyright 2015-2015 The Helenus Driver Project Authors
 *
 * @author  The Helenus Driver Project Authors
 * @version 1 - Jan 15, 2015 - paouelle - Creation
 *
 * @since 1.0
 */
public class Validate {
  /**
   *
Validate that the argument condition is {@code true}; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *
Validate.isTrue(i > 0.0, "The value must be greater than zero: %d", i);

   *
   *
For performance reasons, the long value is passed as a separate parameter and
   * appended to the exception message only in the case of an error.

   *
   * @param logger  the logger via which to log the exception
   * @param expression  the boolean expression to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param value  the value to append to the message when invalid
   * @throws IllegalArgumentException if expression is {@code false}
   *
   * @see #isTrue(Logger, boolean)
   * @see #isTrue(Logger, boolean, String, double)
   * @see #isTrue(Logger, boolean, String, Object...)
   */
  public static void isTrue(Logger logger, boolean expression, String message, long value) {
    try {
      org.apache.commons.lang3.Validate.isTrue(expression, message, value);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the argument condition is {@code true}; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *
Validate.isTrue(i > 0.0, "The value must be greater than zero: %d", i);

   *
   *
For performance reasons, the long value is passed as a separate parameter and
   * appended to the exception message only in the case of an error.

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param expression  the boolean expression to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param value  the value to append to the message when invalid
   * @throws IllegalArgumentException if expression is {@code false}
   *
   * @see #isTrue(Logger, boolean)
   * @see #isTrue(Logger, boolean, String, double)
   * @see #isTrue(Logger, boolean, String, Object...)
   */
  public static void isTrue(Logger logger, Level level, boolean expression, String message, long value) {
    try {
      org.apache.commons.lang3.Validate.isTrue(expression, message, value);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the argument condition is {@code true}; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *
Validate.isTrue(d > 0.0, "The value must be greater than zero: %s", d);

   *
   *
For performance reasons, the double value is passed as a separate parameter and
   * appended to the exception message only in the case of an error.

   *
   * @param logger  the logger via which to log the exception
   * @param expression  the boolean expression to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param value  the value to append to the message when invalid
   * @throws IllegalArgumentException if expression is {@code false}
   *
   * @see #isTrue(Logger, boolean)
   * @see #isTrue(Logger, boolean, String, long)
   * @see #isTrue(Logger, boolean, String, Object...)
   */
  public static void isTrue(Logger logger, boolean expression, String message, double value) {
    try {
      org.apache.commons.lang3.Validate.isTrue(expression, message, value);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the argument condition is {@code true}; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *
Validate.isTrue(d > 0.0, "The value must be greater than zero: %s", d);

   *
   *
For performance reasons, the double value is passed as a separate parameter and
   * appended to the exception message only in the case of an error.

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param expression  the boolean expression to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param value  the value to append to the message when invalid
   * @throws IllegalArgumentException if expression is {@code false}
   *
   * @see #isTrue(Logger, boolean)
   * @see #isTrue(Logger, boolean, String, long)
   * @see #isTrue(Logger, boolean, String, Object...)
   */
  public static void isTrue(Logger logger, Level level, boolean expression, String message, double value) {
    try {
      org.apache.commons.lang3.Validate.isTrue(expression, message, value);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the argument condition is {@code true}; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *

   * Validate.isTrue(i >= min & i <= max, "The value must be between %d and %d", min, max);
   * Validate.isTrue(myObject.isOk(), "The object is not okay");

   *
   * @param logger  the logger via which to log the exception
   * @param expression  the boolean expression to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if expression is {@code false}
   *
   * @see #isTrue(Logger, boolean)
   * @see #isTrue(Logger, boolean, String, long)
   * @see #isTrue(Logger, boolean, String, double)
   */
  public static void isTrue(Logger logger, boolean expression, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.isTrue(expression, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the argument condition is {@code true}; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *

   * Validate.isTrue(i >= min & i <= max, "The value must be between %d and %d", min, max);
   * Validate.isTrue(myObject.isOk(), "The object is not okay");

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param expression  the boolean expression to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if expression is {@code false}
   *
   * @see #isTrue(Logger, boolean)
   * @see #isTrue(Logger, boolean, String, long)
   * @see #isTrue(Logger, boolean, String, double)
   */
  public static void isTrue(Logger logger, Level level, boolean expression, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.isTrue(expression, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the argument condition is {@code true}; otherwise
   * throwing an exception. This method is useful when validating according
   * to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *

   * Validate.isTrue(i > 0);
   * Validate.isTrue(myObject.isOk());

   *
   *
The message of the exception is "The validated expression is
   * false".

   *
   * @param logger  the logger via which to log the exception
   * @param expression  the boolean expression to check
   * @throws IllegalArgumentException if expression is {@code false}
   *
   * @see #isTrue(Logger, boolean, String, long)
   * @see #isTrue(Logger, boolean, String, double)
   * @see #isTrue(Logger, boolean, String, Object...)
   */
  public static void isTrue(Logger logger, boolean expression) {
    try {
      org.apache.commons.lang3.Validate.isTrue(expression);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the argument condition is {@code true}; otherwise
   * throwing an exception. This method is useful when validating according
   * to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *

   * Validate.isTrue(i > 0);
   * Validate.isTrue(myObject.isOk());

   *
   *
The message of the exception is "The validated expression is
   * false".

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param expression  the boolean expression to check
   * @throws IllegalArgumentException if expression is {@code false}
   *
   * @see #isTrue(Logger, boolean, String, long)
   * @see #isTrue(Logger, boolean, String, double)
   * @see #isTrue(Logger, boolean, String, Object...)
   */
  public static void isTrue(Logger logger, Level level, boolean expression) {
    try {
      org.apache.commons.lang3.Validate.isTrue(expression);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument is not {@code null};
   * otherwise throwing an exception.
   *
   *
Validate.notNull(myObject, "The object must not be null");

   *
   *
The message of the exception is "The validated object is
   * null".

   *
   * @param <T> the object type
   * @param logger  the logger via which to log the exception
   * @param object  the object to check
   * @return the validated object (never {@code null} for method chaining)
   * @throws NullPointerException if the object is {@code null}
   *
   * @see #notNull(Logger, Object, String, Object...)
   */
  public static <T> T notNull(Logger logger, T object) {
    try {
      return org.apache.commons.lang3.Validate.notNull(object);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument is not {@code null};
   * otherwise throwing an exception.
   *
   *
Validate.notNull(myObject, "The object must not be null");

   *
   *
The message of the exception is "The validated object is
   * null".

   *
   * @param <T> the object type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param object  the object to check
   * @return the validated object (never {@code null} for method chaining)
   * @throws NullPointerException if the object is {@code null}
   *
   * @see #notNull(Logger, Object, String, Object...)
   */
  public static <T> T notNull(Logger logger, Level level, T object) {
    try {
      return org.apache.commons.lang3.Validate.notNull(object);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument is not {@code null};
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.notNull(myObject, "The object must not be null");

   *
   * @param <T> the object type
   * @param logger  the logger via which to log the exception
   * @param object  the object to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message
   * @return the validated object (never {@code null} for method chaining)
   * @throws NullPointerException if the object is {@code null}
   *
   * @see #notNull(Logger, Object)
   */
  public static <T> T notNull(Logger logger, T object, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notNull(object, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument is not {@code null};
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.notNull(myObject, "The object must not be null");

   *
   * @param <T> the object type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param object  the object to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message
   * @return the validated object (never {@code null} for method chaining)
   * @throws NullPointerException if the object is {@code null}
   *
   * @see #notNull(Logger, Object)
   */
  public static <T> T notNull(Logger logger, Level level, T object, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notNull(object, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument array is neither {@code null}
   * nor a length of zero (no elements); otherwise throwing an exception
   * with the specified message.
   *
   *
Validate.notEmpty(myArray, "The array must not be empty");

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param array  the array to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated array (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if the array is empty
   *
   * @see #notEmpty(Logger, Object[])
   */
  public static <T> T[] notEmpty(Logger logger, T[] array, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(array, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument array is neither {@code null}
   * nor a length of zero (no elements); otherwise throwing an exception
   * with the specified message.
   *
   *
Validate.notEmpty(myArray, "The array must not be empty");

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param array  the array to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated array (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if the array is empty
   *
   * @see #notEmpty(Logger, Object[])
   */
  public static <T> T[] notEmpty(Logger logger, Level level, T[] array, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(array, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument array is neither {@code null}
   * nor a length of zero (no elements); otherwise throwing an exception.
   *
   *
Validate.notEmpty(myArray);

   *
   *
The message in the exception is "The validated array is
   * empty".
   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param array  the array to check, validated not null by this method
   * @return the validated array (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if the array is empty
   *
   * @see #notEmpty(Logger, Object[], String, Object...)
   */
  public static <T> T[] notEmpty(Logger logger, T[] array) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(array);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument array is neither {@code null}
   * nor a length of zero (no elements); otherwise throwing an exception.
   *
   *
Validate.notEmpty(myArray);

   *
   *
The message in the exception is "The validated array is
   * empty".
   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param array  the array to check, validated not null by this method
   * @return the validated array (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if the array is empty
   *
   * @see #notEmpty(Logger, Object[], String, Object...)
   */
  public static <T> T[] notEmpty(Logger logger, Level level, T[] array) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(array);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument collection is neither {@code null}
   * nor a size of zero (no elements); otherwise throwing an exception
   * with the specified message.
   *
   *
Validate.notEmpty(myCollection, "The collection must not be empty");

   *
   * @param <T> the collection type
   * @param logger  the logger via which to log the exception
   * @param collection  the collection to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated collection (never {@code null} method for chaining)
   * @throws NullPointerException if the collection is {@code null}
   * @throws IllegalArgumentException if the collection is empty
   *
   * @see #notEmpty(Logger, Object[])
   */
  public static <T extends Collection<?>> T notEmpty(Logger logger, T collection, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(collection, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument collection is neither {@code null}
   * nor a size of zero (no elements); otherwise throwing an exception
   * with the specified message.
   *
   *
Validate.notEmpty(myCollection, "The collection must not be empty");

   *
   * @param <T> the collection type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param collection  the collection to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated collection (never {@code null} method for chaining)
   * @throws NullPointerException if the collection is {@code null}
   * @throws IllegalArgumentException if the collection is empty
   *
   * @see #notEmpty(Logger, Object[])
   */
  public static <T extends Collection<?>> T notEmpty(Logger logger, Level level, T collection, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(collection, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument collection is neither {@code null}
   * nor a size of zero (no elements); otherwise throwing an exception.
   *
   *
Validate.notEmpty(myCollection);

   *
   *
The message in the exception is "The validated collection is
   * empty".

   *
   * @param <T> the collection type
   * @param logger  the logger via which to log the exception
   * @param collection  the collection to check, validated not null by this method
   * @return the validated collection (never {@code null} method for chaining)
   * @throws NullPointerException if the collection is {@code null}
   * @throws IllegalArgumentException if the collection is empty
   *
   * @see #notEmpty(Logger, Collection, String, Object...)
   */
  public static <T extends Collection<?>> T notEmpty(Logger logger, T collection) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(collection);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument collection is neither {@code null}
   * nor a size of zero (no elements); otherwise throwing an exception.
   *
   *
Validate.notEmpty(myCollection);

   *
   *
The message in the exception is "The validated collection is
   * empty".

   *
   * @param <T> the collection type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param collection  the collection to check, validated not null by this method
   * @return the validated collection (never {@code null} method for chaining)
   * @throws NullPointerException if the collection is {@code null}
   * @throws IllegalArgumentException if the collection is empty
   *
   * @see #notEmpty(Logger, Collection, String, Object...)
   */
  public static <T extends Collection<?>> T notEmpty(Logger logger, Level level, T collection) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(collection);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument map is neither {@code null}
   * nor a size of zero (no elements); otherwise throwing an exception
   * with the specified message.
   *
   *
Validate.notEmpty(myMap, "The map must not be empty");

   *
   * @param <T> the map type
   * @param logger  the logger via which to log the exception
   * @param map  the map to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated map (never {@code null} method for chaining)
   * @throws NullPointerException if the map is {@code null}
   * @throws IllegalArgumentException if the map is empty
   *
   * @see #notEmpty(Logger, Object[])
   */
  public static <T extends Map<?, ?>> T notEmpty(Logger logger, T map, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(map, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument map is neither {@code null}
   * nor a size of zero (no elements); otherwise throwing an exception
   * with the specified message.
   *
   *
Validate.notEmpty(myMap, "The map must not be empty");

   *
   * @param <T> the map type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param map  the map to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated map (never {@code null} method for chaining)
   * @throws NullPointerException if the map is {@code null}
   * @throws IllegalArgumentException if the map is empty
   *
   * @see #notEmpty(Logger, Object[])
   */
  public static <T extends Map<?, ?>> T notEmpty(Logger logger, Level level, T map, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(map, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument map is neither {@code null}
   * nor a size of zero (no elements); otherwise throwing an exception.
   *
   *
Validate.notEmpty(myMap);

   *
   *
The message in the exception is "The validated map is
   * empty".

   *
   * @param <T> the map type
   * @param logger  the logger via which to log the exception
   * @param map  the map to check, validated not null by this method
   * @return the validated map (never {@code null} method for chaining)
   * @throws NullPointerException if the map is {@code null}
   * @throws IllegalArgumentException if the map is empty
   *
   * @see #notEmpty(Logger, Map, String, Object...)
   */
  public static <T extends Map<?, ?>> T notEmpty(Logger logger, T map) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(map);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument map is neither {@code null}
   * nor a size of zero (no elements); otherwise throwing an exception.
   *
   *
Validate.notEmpty(myMap);

   *
   *
The message in the exception is "The validated map is
   * empty".

   *
   * @param <T> the map type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param map  the map to check, validated not null by this method
   * @return the validated map (never {@code null} method for chaining)
   * @throws NullPointerException if the map is {@code null}
   * @throws IllegalArgumentException if the map is empty
   *
   * @see #notEmpty(Logger, Map, String, Object...)
   */
  public static <T extends Map<?, ?>> T notEmpty(Logger logger, Level level, T map) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(map);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument character sequence is
   * neither {@code null} nor a length of zero (no characters);
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.notEmpty(myString, "The string must not be empty");

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated character sequence (never {@code null} method for chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IllegalArgumentException if the character sequence is empty
   *
   * @see #notEmpty(Logger, CharSequence)
   */
  public static <T extends CharSequence> T notEmpty(Logger logger, T chars, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(chars, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument character sequence is
   * neither {@code null} nor a length of zero (no characters);
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.notEmpty(myString, "The string must not be empty");

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated character sequence (never {@code null} method for chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IllegalArgumentException if the character sequence is empty
   *
   * @see #notEmpty(Logger, CharSequence)
   */
  public static <T extends CharSequence> T notEmpty(Logger logger, Level level, T chars, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(chars, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument character sequence is
   * neither {@code null} nor a length of zero (no characters);
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.notEmpty(myString);

   *
   *
The message in the exception is "The validated
   * character sequence is empty".

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @return the validated character sequence (never {@code null} method for chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IllegalArgumentException if the character sequence is empty
   *
   * @see #notEmpty(Logger, CharSequence, String, Object...)
   */
  public static <T extends CharSequence> T notEmpty(Logger logger, T chars) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(chars);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument character sequence is
   * neither {@code null} nor a length of zero (no characters);
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.notEmpty(myString);

   *
   *
The message in the exception is "The validated
   * character sequence is empty".

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @return the validated character sequence (never {@code null} method for chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IllegalArgumentException if the character sequence is empty
   *
   * @see #notEmpty(Logger, CharSequence, String, Object...)
   */
  public static <T extends CharSequence> T notEmpty(Logger logger, Level level, T chars) {
    try {
      return org.apache.commons.lang3.Validate.notEmpty(chars);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument character sequence is
   * neither {@code null}, a length of zero (no characters), empty
   * nor whitespace; otherwise throwing an exception with the specified
   * message.
   *
   *
Validate.notBlank(myString, "The string must not be blank");

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated character sequence (never {@code null} method for chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IllegalArgumentException if the character sequence is blank
   *
   * @see #notBlank(Logger, CharSequence)
   */
  public static <T extends CharSequence> T notBlank(Logger logger, T chars, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notBlank(chars, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument character sequence is
   * neither {@code null}, a length of zero (no characters), empty
   * nor whitespace; otherwise throwing an exception with the specified
   * message.
   *
   *
Validate.notBlank(myString, "The string must not be blank");

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated character sequence (never {@code null} method for chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IllegalArgumentException if the character sequence is blank
   *
   * @see #notBlank(Logger, CharSequence)
   */
  public static <T extends CharSequence> T notBlank(Logger logger, Level level, T chars, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.notBlank(chars, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument character sequence is
   * neither {@code null}, a length of zero (no characters), empty
   * nor whitespace; otherwise throwing an exception.
   *
   *
Validate.notBlank(myString);

   *
   *
The message in the exception is "The validated character
   * sequence is blank".

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @return the validated character sequence (never {@code null} method for chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IllegalArgumentException if the character sequence is blank
   *
   * @see #notBlank(Logger, CharSequence, String, Object...)
   */
  public static <T extends CharSequence> T notBlank(Logger logger, T chars) {
    try {
      return org.apache.commons.lang3.Validate.notBlank(chars);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument character sequence is
   * neither {@code null}, a length of zero (no characters), empty
   * nor whitespace; otherwise throwing an exception.
   *
   *
Validate.notBlank(myString);

   *
   *
The message in the exception is "The validated character
   * sequence is blank".

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @return the validated character sequence (never {@code null} method for chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IllegalArgumentException if the character sequence is blank
   *
   * @see #notBlank(Logger, CharSequence, String, Object...)
   */
  public static <T extends CharSequence> T notBlank(Logger logger, Level level, T chars) {
    try {
      return org.apache.commons.lang3.Validate.notBlank(chars);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument array is neither
   * {@code null} nor contains any elements that are {@code null};
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.noNullElements(myArray, "The array contain null at position %d");

   *
   *
If the array is {@code null}, then the message in the exception
   * is "The validated object is null".

   *
   *
If the array has a {@code null} element, then the iteration
   * index of the invalid element is appended to the {@code values}
   * argument.

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param array  the array to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated array (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if an element is {@code null}
   *
   * @see #noNullElements(Logger, Object[])
   */
  public static <T> T[] noNullElements(Logger logger, T[] array, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.noNullElements(array, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument array is neither
   * {@code null} nor contains any elements that are {@code null};
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.noNullElements(myArray, "The array contain null at position %d");

   *
   *
If the array is {@code null}, then the message in the exception
   * is "The validated object is null".

   *
   *
If the array has a {@code null} element, then the iteration
   * index of the invalid element is appended to the {@code values}
   * argument.

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param array  the array to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated array (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if an element is {@code null}
   *
   * @see #noNullElements(Logger, Object[])
   */
  public static <T> T[] noNullElements(Logger logger, Level level, T[] array, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.noNullElements(array, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument array is neither
   * {@code null} nor contains any elements that are {@code null};
   * otherwise throwing an exception.
   *
   *
Validate.noNullElements(myArray);

   *
   *
If the array is {@code null}, then the message in the exception
   * is "The validated object is null".

   *
   *
If the array has a {@code null} element, then the message in the
   * exception is "The validated array contains null element at index:
   * " followed by the index.

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param array  the array to check, validated not null by this method
   * @return the validated array (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if an element is {@code null}
   *
   * @see #noNullElements(Logger, Object[], String, Object...)
   */
  public static <T> T[] noNullElements(Logger logger, T[] array) {
    try {
      return org.apache.commons.lang3.Validate.noNullElements(array);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument array is neither
   * {@code null} nor contains any elements that are {@code null};
   * otherwise throwing an exception.
   *
   *
Validate.noNullElements(myArray);

   *
   *
If the array is {@code null}, then the message in the exception
   * is "The validated object is null".

   *
   *
If the array has a {@code null} element, then the message in the
   * exception is "The validated array contains null element at index:
   * " followed by the index.

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param array  the array to check, validated not null by this method
   * @return the validated array (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if an element is {@code null}
   *
   * @see #noNullElements(Logger, Object[], String, Object...)
   */
  public static <T> T[] noNullElements(Logger logger, Level level, T[] array) {
    try {
      return org.apache.commons.lang3.Validate.noNullElements(array);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument iterable is neither
   * {@code null} nor contains any elements that are {@code null};
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.noNullElements(myCollection, "The collection contains null at position %d");

   *
   *
If the iterable is {@code null}, then the message in the exception
   * is "The validated object is null".

   *
   *
If the iterable has a {@code null} element, then the iteration
   * index of the invalid element is appended to the {@code values}
   * argument.

   *
   * @param <T> the iterable type
   * @param logger  the logger via which to log the exception
   * @param iterable  the iterable to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated iterable (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if an element is {@code null}
   *
   * @see #noNullElements(Logger, Iterable)
   */
  public static <T extends Iterable<?>> T noNullElements(Logger logger, T iterable, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.noNullElements(iterable, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument iterable is neither
   * {@code null} nor contains any elements that are {@code null};
   * otherwise throwing an exception with the specified message.
   *
   *
Validate.noNullElements(myCollection, "The collection contains null at position %d");

   *
   *
If the iterable is {@code null}, then the message in the exception
   * is "The validated object is null".

   *
   *
If the iterable has a {@code null} element, then the iteration
   * index of the invalid element is appended to the {@code values}
   * argument.

   *
   * @param <T> the iterable type
   * @param level  the level at which to log the exception
   * @param logger  the logger via which to log the exception
   * @param iterable  the iterable to check, validated not null by this method
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated iterable (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if an element is {@code null}
   *
   * @see #noNullElements(Logger, Iterable)
   */
  public static <T extends Iterable<?>> T noNullElements(Logger logger, Level level, T iterable, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.noNullElements(iterable, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument iterable is neither
   * {@code null} nor contains any elements that are {@code null};
   * otherwise throwing an exception.
   *
   *
Validate.noNullElements(myCollection);

   *
   *
If the iterable is {@code null}, then the message in the exception
   * is "The validated object is null".

   *
   *
If the array has a {@code null} element, then the message in the
   * exception is "The validated iterable contains null element at index:
   * " followed by the index.

   *
   * @param <T> the iterable type
   * @param logger  the logger via which to log the exception
   * @param iterable  the iterable to check, validated not null by this method
   * @return the validated iterable (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if an element is {@code null}
   *
   * @see #noNullElements(Logger, Iterable, String, Object...)
   */
  public static <T extends Iterable<?>> T noNullElements(Logger logger, T iterable) {
    try {
      return org.apache.commons.lang3.Validate.noNullElements(iterable);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument iterable is neither
   * {@code null} nor contains any elements that are {@code null};
   * otherwise throwing an exception.
   *
   *
Validate.noNullElements(myCollection);

   *
   *
If the iterable is {@code null}, then the message in the exception
   * is "The validated object is null".

   *
   *
If the array has a {@code null} element, then the message in the
   * exception is "The validated iterable contains null element at index:
   * " followed by the index.

   *
   * @param <T> the iterable type
   * @param level  the level at which to log the exception
   * @param logger  the logger via which to log the exception
   * @param iterable  the iterable to check, validated not null by this method
   * @return the validated iterable (never {@code null} method for chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IllegalArgumentException if an element is {@code null}
   *
   * @see #noNullElements(Logger, Iterable, String, Object...)
   */
  public static <T extends Iterable<?>> T noNullElements(Logger logger, Level level, T iterable) {
    try {
      return org.apache.commons.lang3.Validate.noNullElements(iterable);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validates that the index is within the bounds of the argument
   * array; otherwise throwing an exception with the specified message.

   *
   *
Validate.validIndex(myArray, 2, "The array index is invalid: ");

   *
   *
If the array is {@code null}, then the message of the exception
   * is "The validated object is null".

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param array  the array to check, validated not null by this method
   * @param index  the index to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated array (never {@code null} for method chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, Object[], int)
   */
  public static <T> T[] validIndex(Logger logger, T[] array, int index, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(array, index, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validates that the index is within the bounds of the argument
   * array; otherwise throwing an exception with the specified message.

   *
   *
Validate.validIndex(myArray, 2, "The array index is invalid: ");

   *
   *
If the array is {@code null}, then the message of the exception
   * is "The validated object is null".

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param array  the array to check, validated not null by this method
   * @param index  the index to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated array (never {@code null} for method chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, Object[], int)
   */
  public static <T> T[] validIndex(Logger logger, Level level, T[] array, int index, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(array, index, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validates that the index is within the bounds of the argument
   * array; otherwise throwing an exception.

   *
   *
Validate.validIndex(myArray, 2);

   *
   *
If the array is {@code null}, then the message of the exception
   * is "The validated object is null".

   *
   *
If the index is invalid, then the message of the exception is
   * "The validated array index is invalid: " followed by the
   * index.

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param array  the array to check, validated not null by this method
   * @param index  the index to check
   * @return the validated array (never {@code null} for method chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, Object[], int, String, Object...)
   */
  public static <T> T[] validIndex(Logger logger, T[] array, int index) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(array, index);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validates that the index is within the bounds of the argument
   * array; otherwise throwing an exception.

   *
   *
Validate.validIndex(myArray, 2);

   *
   *
If the array is {@code null}, then the message of the exception
   * is "The validated object is null".

   *
   *
If the index is invalid, then the message of the exception is
   * "The validated array index is invalid: " followed by the
   * index.

   *
   * @param <T> the array type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param array  the array to check, validated not null by this method
   * @param index  the index to check
   * @return the validated array (never {@code null} for method chaining)
   * @throws NullPointerException if the array is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, Object[], int, String, Object...)
   */
  public static <T> T[] validIndex(Logger logger, Level level, T[] array, int index) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(array, index);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validates that the index is within the bounds of the argument
   * collection; otherwise throwing an exception with the specified message.

   *
   *
Validate.validIndex(myCollection, 2, "The collection index is invalid: ");

   *
   *
If the collection is {@code null}, then the message of the
   * exception is "The validated object is null".

   *
   * @param <T> the collection type
   * @param logger  the logger via which to log the exception
   * @param collection  the collection to check, validated not null by this method
   * @param index  the index to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated collection (never {@code null} for chaining)
   * @throws NullPointerException if the collection is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, Collection, int)
   */
  public static <T extends Collection<?>> T validIndex(Logger logger, T collection, int index, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(collection, index, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validates that the index is within the bounds of the argument
   * collection; otherwise throwing an exception with the specified message.

   *
   *
Validate.validIndex(myCollection, 2, "The collection index is invalid: ");

   *
   *
If the collection is {@code null}, then the message of the
   * exception is "The validated object is null".

   *
   * @param <T> the collection type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param collection  the collection to check, validated not null by this method
   * @param index  the index to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated collection (never {@code null} for chaining)
   * @throws NullPointerException if the collection is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, Collection, int)
   */
  public static <T extends Collection<?>> T validIndex(Logger logger, Level level, T collection, int index, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(collection, index, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validates that the index is within the bounds of the argument
   * collection; otherwise throwing an exception.

   *
   *
Validate.validIndex(myCollection, 2);

   *
   *
If the index is invalid, then the message of the exception
   * is "The validated collection index is invalid: "
   * followed by the index.

   *
   * @param <T> the collection type
   * @param logger  the logger via which to log the exception
   * @param collection  the collection to check, validated not null by this method
   * @param index  the index to check
   * @return the validated collection (never {@code null} for method chaining)
   * @throws NullPointerException if the collection is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, Collection, int, String, Object...)
   */
  public static <T extends Collection<?>> T validIndex(Logger logger, T collection, int index) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(collection, index);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validates that the index is within the bounds of the argument
   * collection; otherwise throwing an exception.

   *
   *
Validate.validIndex(myCollection, 2);

   *
   *
If the index is invalid, then the message of the exception
   * is "The validated collection index is invalid: "
   * followed by the index.

   *
   * @param <T> the collection type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param collection  the collection to check, validated not null by this method
   * @param index  the index to check
   * @return the validated collection (never {@code null} for method chaining)
   * @throws NullPointerException if the collection is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, Collection, int, String, Object...)
   */
  public static <T extends Collection<?>> T validIndex(Logger logger, Level level, T collection, int index) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(collection, index);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validates that the index is within the bounds of the argument
   * character sequence; otherwise throwing an exception with the
   * specified message.

   *
   *
Validate.validIndex(myStr, 2, "The string index is invalid: ");

   *
   *
If the character sequence is {@code null}, then the message
   * of the exception is "The validated object is null".

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @param index  the index to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated character sequence (never {@code null} for method chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, CharSequence, int)
   */
  public static <T extends CharSequence> T validIndex(Logger logger, T chars, int index, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(chars, index, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validates that the index is within the bounds of the argument
   * character sequence; otherwise throwing an exception with the
   * specified message.

   *
   *
Validate.validIndex(myStr, 2, "The string index is invalid: ");

   *
   *
If the character sequence is {@code null}, then the message
   * of the exception is "The validated object is null".

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @param index  the index to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @return the validated character sequence (never {@code null} for method chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, CharSequence, int)
   */
  public static <T extends CharSequence> T validIndex(Logger logger, Level level, T chars, int index, String message, Object... values) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(chars, index, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validates that the index is within the bounds of the argument
   * character sequence; otherwise throwing an exception.

   *
   *
Validate.validIndex(myStr, 2);

   *
   *
If the character sequence is {@code null}, then the message
   * of the exception is "The validated object is
   * null".

   *
   *
If the index is invalid, then the message of the exception
   * is "The validated character sequence index is invalid: "
   * followed by the index.

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @param index  the index to check
   * @return the validated character sequence (never {@code null} for method chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, CharSequence, int, String, Object...)
   */
  public static <T extends CharSequence> T validIndex(Logger logger, T chars, int index) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(chars, index);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validates that the index is within the bounds of the argument
   * character sequence; otherwise throwing an exception.

   *
   *
Validate.validIndex(myStr, 2);

   *
   *
If the character sequence is {@code null}, then the message
   * of the exception is "The validated object is
   * null".

   *
   *
If the index is invalid, then the message of the exception
   * is "The validated character sequence index is invalid: "
   * followed by the index.

   *
   * @param <T> the character sequence type
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param chars  the character sequence to check, validated not null by this method
   * @param index  the index to check
   * @return the validated character sequence (never {@code null} for method chaining)
   * @throws NullPointerException if the character sequence is {@code null}
   * @throws IndexOutOfBoundsException if the index is invalid
   *
   * @see #validIndex(Logger, CharSequence, int, String, Object...)
   */
  public static <T extends CharSequence> T validIndex(Logger logger, Level level, T chars, int index) {
    try {
      return org.apache.commons.lang3.Validate.validIndex(chars, index);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the stateful condition is {@code true}; otherwise
   * throwing an exception. This method is useful when validating according
   * to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *

   * Validate.validState(field > 0);
   * Validate.validState(this.isOk());

   *
   *
The message of the exception is "The validated state is
   * false".

   *
   * @param logger  the logger via which to log the exception
   * @param expression  the boolean expression to check
   * @throws IllegalStateException if expression is {@code false}
   *
   * @see #validState(Logger, boolean, String, Object...)
   */
  public static void validState(Logger logger, boolean expression) {
    try {
      org.apache.commons.lang3.Validate.validState(expression);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the stateful condition is {@code true}; otherwise
   * throwing an exception. This method is useful when validating according
   * to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *

   * Validate.validState(field > 0);
   * Validate.validState(this.isOk());

   *
   *
The message of the exception is "The validated state is
   * false".

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param expression  the boolean expression to check
   * @throws IllegalStateException if expression is {@code false}
   *
   * @see #validState(Logger, boolean, String, Object...)
   */
  public static void validState(Logger logger, Level level, boolean expression) {
    try {
      org.apache.commons.lang3.Validate.validState(expression);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the stateful condition is {@code true}; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *
Validate.validState(this.isOk(), "The state is not OK: %s", myObject);

   *
   * @param logger  the logger via which to log the exception
   * @param expression  the boolean expression to check
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalStateException if expression is {@code false}
   *
   * @see #validState(Logger, boolean)
   */
  public static void validState(Logger logger, boolean expression, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.validState(expression, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the stateful condition is {@code true}; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary boolean expression, such as validating a
   * primitive number or using your own custom validation expression.

   *
   *
Validate.validState(this.isOk(), "The state is not OK: %s", myObject);

   *
   * @param logger  the logger via which to log the exception
   * @param expression  the boolean expression to check
   * @param level  the level at which to log the exception
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalStateException if expression is {@code false}
   *
   * @see #validState(Logger, boolean)
   */
  public static void validState(Logger logger, Level level, boolean expression, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.validState(expression, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument character sequence matches the specified regular
   * expression pattern; otherwise throwing an exception.

   *
   *
Validate.matchesPattern("hi", "[a-z]*");

   *
   *
The syntax of the pattern is the one used in the {@link Pattern} class.

   *
   * @param logger  the logger via which to log the exception
   * @param input  the character sequence to validate, not null
   * @param pattern  the regular expression pattern, not null
   * @throws IllegalArgumentException if the character sequence does not match the pattern
   *
   * @see #matchesPattern(Logger, CharSequence, String, String, Object...)
   */
  public static void matchesPattern(Logger logger, CharSequence input, String pattern) {
    try {
      org.apache.commons.lang3.Validate.matchesPattern(input, pattern);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument character sequence matches the specified regular
   * expression pattern; otherwise throwing an exception.

   *
   *
Validate.matchesPattern("hi", "[a-z]*");

   *
   *
The syntax of the pattern is the one used in the {@link Pattern} class.

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param input  the character sequence to validate, not null
   * @param pattern  the regular expression pattern, not null
   * @throws IllegalArgumentException if the character sequence does not match the pattern
   *
   * @see #matchesPattern(Logger, CharSequence, String, String, Object...)
   */
  public static void matchesPattern(Logger logger, Level level, CharSequence input, String pattern) {
    try {
      org.apache.commons.lang3.Validate.matchesPattern(input, pattern);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument character sequence matches the specified regular
   * expression pattern; otherwise throwing an exception with the specified message.

   *
   *
Validate.matchesPattern("hi", "[a-z]*", "%s does not match %s", "hi" "[a-z]*");

   *
   *
The syntax of the pattern is the one used in the {@link Pattern} class.

   *
   * @param logger  the logger via which to log the exception
   * @param input  the character sequence to validate, not null
   * @param pattern  the regular expression pattern, not null
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if the character sequence does not match the pattern
   *
   * @see #matchesPattern(Logger, CharSequence, String)
   */
  public static void matchesPattern(Logger logger, CharSequence input, String pattern, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.matchesPattern(input, pattern, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument character sequence matches the specified regular
   * expression pattern; otherwise throwing an exception with the specified message.

   *
   *
Validate.matchesPattern("hi", "[a-z]*", "%s does not match %s", "hi" "[a-z]*");

   *
   *
The syntax of the pattern is the one used in the {@link Pattern} class.

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param input  the character sequence to validate, not null
   * @param pattern  the regular expression pattern, not null
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if the character sequence does not match the pattern
   *
   * @see #matchesPattern(Logger, CharSequence, String)
   */
  public static void matchesPattern(Logger logger, Level level, CharSequence input, String pattern, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.matchesPattern(input, pattern, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument object fall between the two
   * inclusive values specified; otherwise, throws an exception.

   *
   *
Validate.inclusiveBetween(0, 2, 1);

   *
   * @param <T> the type of the argument object
   * @param logger  the logger via which to log the exception
   * @param start  the inclusive start value, not null
   * @param end  the inclusive end value, not null
   * @param value  the object to validate, not null
   * @throws IllegalArgumentException if the value falls out of the boundaries
   *
   * @see #inclusiveBetween(Logger, Object, Object, Comparable, String, Object...)
   */
  public static <T> void inclusiveBetween(Logger logger, T start, T end, Comparable<T> value) {
    try {
      org.apache.commons.lang3.Validate.inclusiveBetween(start, end, value);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument object fall between the two
   * inclusive values specified; otherwise, throws an exception.

   *
   *
Validate.inclusiveBetween(0, 2, 1);

   *
   * @param <T> the type of the argument object
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param start  the inclusive start value, not null
   * @param end  the inclusive end value, not null
   * @param value  the object to validate, not null
   * @throws IllegalArgumentException if the value falls out of the boundaries
   *
   * @see #inclusiveBetween(Logger, Object, Object, Comparable, String, Object...)
   */
  public static <T> void inclusiveBetween(Logger logger, Level level, T start, T end, Comparable<T> value) {
    try {
      org.apache.commons.lang3.Validate.inclusiveBetween(start, end, value);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument object fall between the two
   * inclusive values specified; otherwise, throws an exception with the
   * specified message.

   *
   *
Validate.inclusiveBetween(0, 2, 1, "Not in boundaries");

   *
   * @param <T> the type of the argument object
   * @param logger  the logger via which to log the exception
   * @param start  the inclusive start value, not null
   * @param end  the inclusive end value, not null
   * @param value  the object to validate, not null
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if the value falls out of the boundaries
   *
   * @see #inclusiveBetween(Logger, Object, Object, Comparable)
   */
  public static <T> void inclusiveBetween(Logger logger, T start, T end, Comparable<T> value, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.inclusiveBetween(start, end, value, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument object fall between the two
   * inclusive values specified; otherwise, throws an exception with the
   * specified message.

   *
   *
Validate.inclusiveBetween(0, 2, 1, "Not in boundaries");

   *
   * @param <T> the type of the argument object
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param start  the inclusive start value, not null
   * @param end  the inclusive end value, not null
   * @param value  the object to validate, not null
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if the value falls out of the boundaries
   *
   * @see #inclusiveBetween(Logger, Object, Object, Comparable)
   */
  public static <T> void inclusiveBetween(Logger logger, Level level, T start, T end, Comparable<T> value, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.inclusiveBetween(start, end, value, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument object fall between the two
   * exclusive values specified; otherwise, throws an exception.

   *
   *
Validate.inclusiveBetween(0, 2, 1);

   *
   * @param <T> the type of the argument object
   * @param logger  the logger via which to log the exception
   * @param start  the exclusive start value, not null
   * @param end  the exclusive end value, not null
   * @param value  the object to validate, not null
   * @throws IllegalArgumentException if the value falls out of the boundaries
   *
   * @see #exclusiveBetween(Logger, Object, Object, Comparable, String, Object...)
   */
  public static <T> void exclusiveBetween(Logger logger, T start, T end, Comparable<T> value) {
    try {
      org.apache.commons.lang3.Validate.exclusiveBetween(start, end, value);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument object fall between the two
   * exclusive values specified; otherwise, throws an exception.

   *
   *
Validate.inclusiveBetween(0, 2, 1);

   *
   * @param <T> the type of the argument object
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param start  the exclusive start value, not null
   * @param end  the exclusive end value, not null
   * @param value  the object to validate, not null
   * @throws IllegalArgumentException if the value falls out of the boundaries
   *
   * @see #exclusiveBetween(Logger, Object, Object, Comparable, String, Object...)
   */
  public static <T> void exclusiveBetween(Logger logger, Level level, T start, T end, Comparable<T> value) {
    try {
      org.apache.commons.lang3.Validate.exclusiveBetween(start, end, value);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the specified argument object fall between the two
   * exclusive values specified; otherwise, throws an exception with the
   * specified message.

   *
   *
Validate.inclusiveBetween(0, 2, 1, "Not in boundaries");

   *
   * @param <T> the type of the argument object
   * @param logger  the logger via which to log the exception
   * @param start  the exclusive start value, not null
   * @param end  the exclusive end value, not null
   * @param value  the object to validate, not null
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if the value falls out of the boundaries
   *
   * @see #exclusiveBetween(Logger, Object, Object, Comparable)
   */
  public static <T> void exclusiveBetween(Logger logger, T start, T end, Comparable<T> value, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.exclusiveBetween(start, end, value, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the specified argument object fall between the two
   * exclusive values specified; otherwise, throws an exception with the
   * specified message.

   *
   *
Validate.inclusiveBetween(0, 2, 1, "Not in boundaries");

   *
   * @param <T> the type of the argument object
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param start  the exclusive start value, not null
   * @param end  the exclusive end value, not null
   * @param value  the object to validate, not null
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if the value falls out of the boundaries
   *
   * @see #exclusiveBetween(Logger, Object, Object, Comparable)
   */
  public static <T> void exclusiveBetween(Logger logger, Level level, T start, T end, Comparable<T> value, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.exclusiveBetween(start, end, value, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   * Validates that the argument is an instance of the specified class, if not throws an exception.
   *
   *
This method is useful when validating according to an arbitrary class

   *
   *
Validate.isInstanceOf(OkClass.class, object);

   *
   *
The message of the exception is "Expected type: {type}, actual: {obj_type}"

   *
   * @param logger  the logger via which to log the exception
   * @param type  the class the object must be validated against, not null
   * @param obj  the object to check, null throws an exception
   * @throws IllegalArgumentException if argument is not of specified class
   *
   * @see #isInstanceOf(Logger, Class, Object, String, Object...)
   */
  public static void isInstanceOf(Logger logger, Class<?> type, Object obj) {
    try {
      org.apache.commons.lang3.Validate.isInstanceOf(type, obj);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   * Validates that the argument is an instance of the specified class, if not throws an exception.
   *
   *
This method is useful when validating according to an arbitrary class

   *
   *
Validate.isInstanceOf(OkClass.class, object);

   *
   *
The message of the exception is "Expected type: {type}, actual: {obj_type}"

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param type  the class the object must be validated against, not null
   * @param obj  the object to check, null throws an exception
   * @throws IllegalArgumentException if argument is not of specified class
   *
   * @see #isInstanceOf(Logger, Class, Object, String, Object...)
   */
  public static void isInstanceOf(Logger logger, Level level, Class<?> type, Object obj) {
    try {
      org.apache.commons.lang3.Validate.isInstanceOf(type, obj);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   *
Validate that the argument is an instance of the specified class; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary class

   *
   *
Validate.isInstanceOf(OkClass.classs, object, "Wrong class, object is of class %s",
   *   object.getClass().getName());

   *
   * @param logger  the logger via which to log the exception
   * @param type  the class the object must be validated against, not null
   * @param obj  the object to check, null throws an exception
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if argument is not of specified class
   *
   * @see #isInstanceOf(Logger, Class, Object)
   */
  public static void isInstanceOf(Logger logger, Class<?> type, Object obj, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.isInstanceOf(type, obj, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   *
Validate that the argument is an instance of the specified class; otherwise
   * throwing an exception with the specified message. This method is useful when
   * validating according to an arbitrary class

   *
   *
Validate.isInstanceOf(OkClass.classs, object, "Wrong class, object is of class %s",
   *   object.getClass().getName());

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param type  the class the object must be validated against, not null
   * @param obj  the object to check, null throws an exception
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if argument is not of specified class
   *
   * @see #isInstanceOf(Logger, Class, Object)
   */
  public static void isInstanceOf(Logger logger, Level level, Class<?> type, Object obj, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.isInstanceOf(type, obj, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   * Validates that the argument can be converted to the specified class, if not, throws an exception.
   *
   *
This method is useful when validating that there will be no casting errors.

   *
   *
Validate.isAssignableFrom(SuperClass.class, object.getClass());

   *
   *
The message format of the exception is "Cannot assign {type} to {superType}"

   *
   * @param logger  the logger via which to log the exception
   * @param superType  the class the class must be validated against, not null
   * @param type  the class to check, not null
   * @throws IllegalArgumentException if type argument is not assignable to the specified superType
   *
   * @see #isAssignableFrom(Logger, Class, Class, String, Object...)
   */
  public static void isAssignableFrom(Logger logger, Class<?> superType, Class<?> type) {
    try {
      org.apache.commons.lang3.Validate.isAssignableFrom(superType, type);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   * Validates that the argument can be converted to the specified class, if not, throws an exception.
   *
   *
This method is useful when validating that there will be no casting errors.

   *
   *
Validate.isAssignableFrom(SuperClass.class, object.getClass());

   *
   *
The message format of the exception is "Cannot assign {type} to {superType}"

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param superType  the class the class must be validated against, not null
   * @param type  the class to check, not null
   * @throws IllegalArgumentException if type argument is not assignable to the specified superType
   *
   * @see #isAssignableFrom(Logger, Class, Class, String, Object...)
   */
  public static void isAssignableFrom(Logger logger, Level level, Class<?> superType, Class<?> type) {
    try {
      org.apache.commons.lang3.Validate.isAssignableFrom(superType, type);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }

  /**
   * Validates that the argument can be converted to the specified class, if not throws an exception.
   *
   *
This method is useful when validating if there will be no casting errors.

   *
   *
Validate.isAssignableFrom(SuperClass.class, object.getClass());

   *
   *
The message of the exception is "The validated object can not be converted to the"
   * followed by the name of the class and "class"

   *
   * @param logger  the logger via which to log the exception
   * @param superType  the class the class must be validated against, not null
   * @param type  the class to check, not null
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if argument can not be converted to the specified class
   *
   * @see #isAssignableFrom(Logger, Class, Class)
   */
  public static void isAssignableFrom(Logger logger, Class<?> superType, Class<?> type, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.isAssignableFrom(superType, type, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(e);
    }
  }
  /**
   * Validates that the argument can be converted to the specified class, if not throws an exception.
   *
   *
This method is useful when validating if there will be no casting errors.

   *
   *
Validate.isAssignableFrom(SuperClass.class, object.getClass());

   *
   *
The message of the exception is "The validated object can not be converted to the"
   * followed by the name of the class and "class"

   *
   * @param logger  the logger via which to log the exception
   * @param level  the level at which to log the exception
   * @param superType  the class the class must be validated against, not null
   * @param type  the class to check, not null
   * @param message  the {@link String#format(String, Object...)} exception message if invalid, not null
   * @param values  the optional values for the formatted exception message, null array not recommended
   * @throws IllegalArgumentException if argument can not be converted to the specified class
   *
   * @see #isAssignableFrom(Logger, Class, Class)
   */
  public static void isAssignableFrom(Logger logger, Level level, Class<?> superType, Class<?> type, String message, Object... values) {
    try {
      org.apache.commons.lang3.Validate.isAssignableFrom(superType, type, message, values);
    } catch (RuntimeException e) {
      throw logger.throwing(level, e);
    }
  }
}


text:
/* CSS Document */

html{
	background: url(/assets/backgroud-pic-1366.png) no-repeat center center fixed;
	-webkit-background-size: cover;
	-moz-background-size: cover;
 	-o-background-size: cover;
 	background-size: cover;
 	filter: progid:DXImageTransform.Microsoft.AlphaImageLoader(src='.backgroud-pic-1366.png', sizingMethod='scale');
	-ms-filter: "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='backgroud-pic-1366.png', sizingMethod='scale')";
}

#logo{
	position:absolute;
	top:0px;
	left:0px;
}


text:
/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.flowable.cmmn.engine.impl.job;

import org.flowable.cmmn.engine.CmmnEngineConfiguration;
import org.flowable.cmmn.engine.impl.persistence.entity.PlanItemInstanceEntity;
import org.flowable.cmmn.engine.impl.util.CmmnLoggingSessionUtil;
import org.flowable.cmmn.engine.impl.util.CommandContextUtil;
import org.flowable.common.engine.api.FlowableException;
import org.flowable.common.engine.impl.interceptor.CommandContext;
import org.flowable.common.engine.impl.logging.CmmnLoggingSessionConstants;
import org.flowable.job.service.JobHandler;
import org.flowable.job.service.impl.persistence.entity.JobEntity;
import org.flowable.variable.api.delegate.VariableScope;

/**
 * @author Joram Barrez
 */
public class AsyncActivatePlanItemInstanceJobHandler implements JobHandler {

    public static final String TYPE = "cmmn-async-activate-plan-item-instance";

    @Override
    public String getType() {
        return TYPE;
    }

    @Override
    public void execute(JobEntity job, String configuration, VariableScope variableScope, CommandContext commandContext) {
        if (variableScope instanceof PlanItemInstanceEntity) {
            PlanItemInstanceEntity planItemInstanceEntity = (PlanItemInstanceEntity) variableScope;
            CmmnEngineConfiguration cmmnEngineConfiguration = CommandContextUtil.getCmmnEngineConfiguration(commandContext);
            if (cmmnEngineConfiguration.isLoggingSessionEnabled()) {
                CmmnLoggingSessionUtil.addAsyncActivityLoggingData("Executing async job for " + planItemInstanceEntity.getPlanItemDefinitionId() + ", with job id " + job.getId(),
                        CmmnLoggingSessionConstants.TYPE_SERVICE_TASK_EXECUTE_ASYNC_JOB, job, planItemInstanceEntity.getPlanItemDefinition(),
                        planItemInstanceEntity, cmmnEngineConfiguration.getObjectMapper());
            }

            CommandContextUtil.getAgenda(commandContext).planActivatePlanItemInstanceOperation((PlanItemInstanceEntity) variableScope, configuration); // configuration == entryCriterionId

        } else {
            throw new FlowableException("Invalid usage of " + TYPE + " job handler, variable scope is of type " + variableScope.getClass());
        }
    }

}


text:
"""
.. module:: dj-stripe.tests.test_invoiceitem
   :synopsis: dj-stripe InvoiceItem Model Tests.

.. moduleauthor:: Alex Kavanaugh (@kavdev)

"""

from copy import deepcopy

from django.contrib.auth import get_user_model
from django.test.testcases import TestCase
from mock import patch

from djstripe.models import Customer, InvoiceItem, Account
from tests import (FAKE_INVOICEITEM, FAKE_INVOICE_II, FAKE_CHARGE_II, FAKE_CUSTOMER_II, FAKE_SUBSCRIPTION_III,
                   FAKE_PLAN_II)

class InvoiceItemTest(TestCase):

    def setUp(self):
        self.account = Account.objects.create()

        user = get_user_model().objects.create_user(username="pydanny", email="pydanny@gmail.com")
        Customer.objects.create(subscriber=user, stripe_id=FAKE_CUSTOMER_II["id"], livemode=False)

    @patch("djstripe.models.Account.get_default_account")
    @patch("stripe.Subscription.retrieve", return_value=deepcopy(FAKE_SUBSCRIPTION_III))
    @patch("stripe.Customer.retrieve", return_value=deepcopy(FAKE_CUSTOMER_II))
    @patch("stripe.Charge.retrieve", return_value=deepcopy(FAKE_CHARGE_II))
    @patch("stripe.Invoice.retrieve", return_value=deepcopy(FAKE_INVOICE_II))
    def test_str(self, invoice_retrieve_mock, charge_retrieve_mock, customer_retrieve_mock, subscription_retrieve_mock,
                 default_account_mock):
        default_account_mock.return_value = self.account

        invoiceitem_data = deepcopy(FAKE_INVOICEITEM)
        invoiceitem = InvoiceItem.sync_from_stripe_data(invoiceitem_data)
        self.assertEqual(invoiceitem.get_stripe_dashboard_url(), invoiceitem.invoice.get_stripe_dashboard_url())

        self.assertEqual(str(invoiceitem), "<amount={amount}, date={date}, stripe_id={stripe_id}>".format(
            amount=invoiceitem.amount,
            date=invoiceitem.date,
            stripe_id=invoiceitem_data["id"]
        ))

    @patch("djstripe.models.Account.get_default_account")
    @patch("stripe.Subscription.retrieve", return_value=deepcopy(FAKE_SUBSCRIPTION_III))
    @patch("stripe.Customer.retrieve", return_value=deepcopy(FAKE_CUSTOMER_II))
    @patch("stripe.Charge.retrieve", return_value=deepcopy(FAKE_CHARGE_II))
    @patch("stripe.Invoice.retrieve", return_value=deepcopy(FAKE_INVOICE_II))
    def test_sync_with_subscription(self, invoice_retrieve_mock, charge_retrieve_mock, customer_retrieve_mock,
                                    subscription_retrieve_mock, default_account_mock):
        default_account_mock.return_value = self.account

        invoiceitem_data = deepcopy(FAKE_INVOICEITEM)
        invoiceitem_data.update({"subscription": FAKE_SUBSCRIPTION_III["id"]})
        invoiceitem = InvoiceItem.sync_from_stripe_data(invoiceitem_data)

        self.assertEqual(FAKE_SUBSCRIPTION_III["id"], invoiceitem.subscription.stripe_id)

    @patch("djstripe.models.Account.get_default_account")
    @patch("stripe.Plan.retrieve", return_value=deepcopy(FAKE_PLAN_II))
    @patch("stripe.Subscription.retrieve", return_value=deepcopy(FAKE_SUBSCRIPTION_III))
    @patch("stripe.Customer.retrieve", return_value=deepcopy(FAKE_CUSTOMER_II))
    @patch("stripe.Charge.retrieve", return_value=deepcopy(FAKE_CHARGE_II))
    @patch("stripe.Invoice.retrieve", return_value=deepcopy(FAKE_INVOICE_II))
    def test_sync_proration(self, invoice_retrieve_mock, charge_retrieve_mock, customer_retrieve_mock,
                            subscription_retrieve_mock, plan_retrieve_mock, default_account_mock):
        default_account_mock.return_value = self.account

        invoiceitem_data = deepcopy(FAKE_INVOICEITEM)
        invoiceitem_data.update({"proration": True, "plan": FAKE_PLAN_II["id"]})
        invoiceitem = InvoiceItem.sync_from_stripe_data(invoiceitem_data)

        self.assertEqual(FAKE_PLAN_II["id"], invoiceitem.plan.stripe_id)