#ifndef java_util_concurrent_Executors_H
#define java_util_concurrent_Executors_H

#include "java/lang/Object.h"

namespace java {
  namespace lang {
    class Class;
    class Runnable;
  }
  namespace util {
    namespace concurrent {
      class Callable;
      class ThreadFactory;
      class ScheduledExecutorService;
      class ExecutorService;
    }
  }
}
template<class T> class JArray;

namespace java {
  namespace util {
    namespace concurrent {

      class Executors : public ::java::lang::Object {
       public:
        enum {
          mid_callable_e1b8320d53077dec,
          mid_callable_263c146eb7d5367d,
          mid_defaultThreadFactory_7e371abb539e5b2a,
          mid_newCachedThreadPool_100c4c83977311ef,
          mid_newCachedThreadPool_2cb877b29f1d17dc,
          mid_newFixedThreadPool_9ff9ecb1925ff09a,
          mid_newFixedThreadPool_017e34ce6a114fb9,
          mid_newScheduledThreadPool_9f62a76c4939cada,
          mid_newScheduledThreadPool_70fded9b767b1edf,
          mid_newSingleThreadExecutor_100c4c83977311ef,
          mid_newSingleThreadExecutor_2cb877b29f1d17dc,
          mid_newSingleThreadScheduledExecutor_d08b5e1b77dc6d82,
          mid_newSingleThreadScheduledExecutor_016d513bfce31546,
          mid_newWorkStealingPool_100c4c83977311ef,
          mid_newWorkStealingPool_9ff9ecb1925ff09a,
          mid_privilegedCallable_e82ebc381385aeac,
          mid_privilegedCallableUsingCurrentClassLoader_e82ebc381385aeac,
          mid_privilegedThreadFactory_7e371abb539e5b2a,
          mid_unconfigurableExecutorService_f56970db556c352e,
          mid_unconfigurableScheduledExecutorService_d2e61bb621b09ff2,
          max_mid
        };

        static ::java::lang::Class *class$;
        static jmethodID *mids$;
        static bool live$;
        static jclass initializeClass(bool);

        explicit Executors(jobject obj) : ::java::lang::Object(obj) {
          if (obj != NULL && mids$ == NULL)
            env->getClass(initializeClass);
        }
        Executors(const Executors& obj) : ::java::lang::Object(obj) {}

        static ::java::util::concurrent::Callable callable(const ::java::lang::Runnable &);
        static ::java::util::concurrent::Callable callable(const ::java::lang::Runnable &, const ::java::lang::Object &);
        static ::java::util::concurrent::ThreadFactory defaultThreadFactory();
        static ::java::util::concurrent::ExecutorService newCachedThreadPool();
        static ::java::util::concurrent::ExecutorService newCachedThreadPool(const ::java::util::concurrent::ThreadFactory &);
        static ::java::util::concurrent::ExecutorService newFixedThreadPool(jint);
        static ::java::util::concurrent::ExecutorService newFixedThreadPool(jint, const ::java::util::concurrent::ThreadFactory &);
        static ::java::util::concurrent::ScheduledExecutorService newScheduledThreadPool(jint);
        static ::java::util::concurrent::ScheduledExecutorService newScheduledThreadPool(jint, const ::java::util::concurrent::ThreadFactory &);
        static ::java::util::concurrent::ExecutorService newSingleThreadExecutor();
        static ::java::util::concurrent::ExecutorService newSingleThreadExecutor(const ::java::util::concurrent::ThreadFactory &);
        static ::java::util::concurrent::ScheduledExecutorService newSingleThreadScheduledExecutor();
        static ::java::util::concurrent::ScheduledExecutorService newSingleThreadScheduledExecutor(const ::java::util::concurrent::ThreadFactory &);
        static ::java::util::concurrent::ExecutorService newWorkStealingPool();
        static ::java::util::concurrent::ExecutorService newWorkStealingPool(jint);
        static ::java::util::concurrent::Callable privilegedCallable(const ::java::util::concurrent::Callable &);
        static ::java::util::concurrent::Callable privilegedCallableUsingCurrentClassLoader(const ::java::util::concurrent::Callable &);
        static ::java::util::concurrent::ThreadFactory privilegedThreadFactory();
        static ::java::util::concurrent::ExecutorService unconfigurableExecutorService(const ::java::util::concurrent::ExecutorService &);
        static ::java::util::concurrent::ScheduledExecutorService unconfigurableScheduledExecutorService(const ::java::util::concurrent::ScheduledExecutorService &);
      };
    }
  }
}

#include <Python.h>

namespace java {
  namespace util {
    namespace concurrent {
      extern PyType_Def PY_TYPE_DEF(Executors);
      extern PyTypeObject *PY_TYPE(Executors);

      class t_Executors {
      public:
        PyObject_HEAD
        Executors object;
        static PyObject *wrap_Object(const Executors&);
        static PyObject *wrap_jobject(const jobject&);
        static void install(PyObject *module);
        static void initialize(PyObject *module);
      };
    }
  }
}

#endif