text:
"use strict";
if (process.cwd().endsWith('install'))
	process.chdir('..');
const CWD = process.cwd();
//*/

const fs = require('fs');
const ReadLine = require('readline');
const Crypto = require('crypto');
const Config = require('../config');

/*/

import * as fs from 'fs';
import ReadLine from 'readline';
import Crypto from 'crypto';
import Config from '../config';
//*/

var cfg = Config.cfg;
const pgp = Config.pgp;
const db = Config.db;
const yml = Config.yml;
const yn = /^y(?:es)?/i;

(async()=>{
	const sql = (file) => pgp.QueryFile(path(file),{debug: true, minify: false});
	// Parse options
	var opt,CLO = {s:{},l:{}};
	do {
		let x=-1, targs = process.argv.slice(2);
		while (++x < targs.length){
			if (targs[x].indexOf('--') == 0){
				let y = targs[x].slice(2).split('=');
				CLO.l[y.shift()] = y.join('=')||true;
			} else if (targs[x].indexOf('-') == 0){
				let y = targs[x].slice(1).split();
				CLO.s[y] = targs[x+1]||true;
			}
		}
	} while(0);

	const ask = async function(prompt, stdinout){
		if (!stdinout)
			stdinout = ReadLine.createInterface({
				input: process.stdin,
				output: process.stdout,
				terminal: false
			});
		return new Promise((res,rej)=>{
			stdinout.question(prompt.toString(),(input)=>{res(input)});
		});
	};

	const prompt = async function prompt(question,validate,notempty) {
		const rl = ReadLine.createInterface({
			input: process.stdin,
			output: process.stdout,
			terminal: false
		});
		var res;
		if (validate && !validate instanceof RegExp) validate = new RegExp(validate.toString());
		do {
			if (res !== undefined) {
				if (notempty && res === '') console.log('Input cannot be empty.');
				else console.log('Invalid input.');
				res = undefined;
			}
			res = await ask(question);
		} while ((notempty && res === '') || (validate && !validate.test(res)));
		rl.close();
		if (/^\d+$/i.test(res)) return parseInt(res,10);
		if (/^\d+\.\d+$/i.test(res)) return parseFloat(res,10);
		else return res;
	};

	function updatable(stale,fresh) {
		stale = stale.split('.');
		fresh = fresh.split('.');
		let i = -1, maxlength = (stale.length < fresh.length ? fresh.length : stale.length);
		while (++i < maxlength) {
			if (stale[i] === undefined) stale[i] = 0;
			if (fresh[i] === undefined) fresh[i] = 0;
			if (parseInt(fresh[i],10) > parseInt(stale[i],10)) return true;
		}
		return false;
	}

	function exists(_path) {
		try {
			fs.statSync(path(_path));
			return true;
		} catch (e) {
			return false;
		}
	}
	function mkdir(_path){
		if (exists(_path)) return;
		let i=-1, dirs = _path.split('/');
		while (++i < dirs.length) {
			if (dirs[i] == '' || dirs[i] == '.') {
				dirs.splice(i,1);
				--i; continue;
			}
			let p = CWD+'/'+dirs.slice(0,i+1).join('/');
			try { fs.statSync(p); }
			catch (e) { fs.mkdirSync(p); }
		}
	}
	function path(_path){
		let i=-1, dirs = _path.split('/');
		let absolute = dirs[0] == '';
		while (++i < dirs.length) {
			if (dirs[i] == '' || dirs[i] == '.') {
				dirs.splice(i,1);
				--i; continue;
			}
		}
		if (absolute)
			return CWD+'/'+dirs.slice(0,i+1).join('/');
		else
			return __dirname+'/'+dirs.slice(0,i+1).join('/');
	}

	const dcfg = yml.read.sync(path('/install/default.yml'));

	if (!exists('/assets/_/media')) mkdir('/assets/_/media');
	if (!exists('/cache/uploads')) mkdir('/cache/uploads');
	if (!exists('/conf')) mkdir('/conf');

	if (exists('/conf/config.yml')) cfg = yml.read.sync(path('/conf/config.yml'));
	else {
		console.log('Missing config. Creating file and generating new site secret value.');
		cfg = yml.read.sync(path('/install/default.yml'));
		cfg.secret = Crypto.createHash('sha256').update(Math.random().toString()).digest('hex');
		yml.write.sync(path('/conf/config.yml'),cfg);
	}
	if ((opt = CLO.s.h || CLO.l.host) instanceof String) cfg.database.host = opt;
	if (parseInt(opt = CLO.s.p || CLO.l.port,10) instanceof Number) cfg.database.port = opt;
	if ((opt = CLO.s.d || CLO.l.database) instanceof String) cfg.database.database = opt;
	if ((opt = CLO.s.u || CLO.l.username) instanceof String) cfg.database.username = opt;
	if ((opt = CLO.s.p || CLO.l.password) instanceof String) cfg.database.password = opt;
	if ((opt = CLO.s.c || CLO.l.conn) instanceof String) {
		let x = opt.split("@");
		if (x.length > 1) {
			let y = x.shift().split(':');
			if (y.length > 1) cfg.database.password = y.pop();
			cfg.database.username = y.pop();
		}
		x = x[0].split('/');
		if (x.length > 1){
			cfg.database.database = x.pop();
		}
		x = x[0].split(':');
		if (x.length > 1){
			cfg.database.port = x.pop();
		}
		cfg.database.host = x.pop();
	}

	const VERSION = {stale: cfg.version, fresh: dcfg.version};

	if (!CLO.s.q && yn.test(await prompt('Configure the database connection? (y/n): '))) {
		let tdb = {};
		do {
			console.log('Please fill out the following information.  (Leave empty for existing value)');
			console.log('');
			tdb.host = tdb.host || cfg.database.host || 'localhost';
			tdb.host = await prompt('hostname/address ('+tdb.host+'): ') || tdb.host;
			tdb.port = tdb.port || cfg.database.port || '5433';
			tdb.port = await prompt('port number ('+tdb.port+'): ') || tdb.port;
			tdb.database = tdb.database || cfg.database.database || 'tauchan';
			tdb.database = await prompt('database name ('+tdb.database+'): ') || tdb.database;
			tdb.user = tdb.user || cfg.database.user || 'tauchan';
			tdb.user = await prompt('database user ('+tdb.user+'): ') || tdb.user;
			tdb.password = tdb.password || cfg.database.password || 'tauchan';
			tdb.password = await prompt('database user password ('+tdb.password+'): ') || tdb.password;
			console.log('Database connection reconfigured as: '+ tdb.user+':'+tdb.password+'@'+tdb.host+':'+tdb.port+'/'+tdb.database);
		} while (!yn.test(await prompt('Is this configuration correct? (y/n): ')));
		cfg.database = tdb;
		yml.write.sync(path('/conf/config.yml'),cfg);
	}

	if (!cfg.database) return pgp.end(),console.log('Unable to load database configuration. Please check the config file for errors. Exiting.');

	if (!exists('/conf/installed') || CLO.s.q || yn.test(await prompt('Do you want to configure the database? (y/n): '))) {
		let versions = fs.readdirSync(path('/install')).filter((cur)=>{
			let c = cur.split('/'), ver = /update\.(\d+\.\d+\.\d+)\.sql$/.exec(c[c.length-1]);
			if (ver !== null) console.log(VERSION.stale,ver[1],updatable(VERSION.stale,ver[1]));
			return (ver !== null && updatable(VERSION.stale,ver[1]));
		});
		if (exists('/conf/installed') && versions.length) {
			if (CLO.s.q || yn.test(await prompt('Updates are available. Would you like to update the site database? (y/n): '))) {
				try {
					await db.tx((self)=>{
						return self.batch(versions.map((cur)=>{return self.none(sql(__dirname+'/'+cur));}));
					});
					console.log('Success');
				} catch(e){
					pgp.end();
					console.log('Database update failed. Exiting.');
					return;
				}
			}
			cfg.version = VERSION.fresh;
		}
		else if (!exists('/conf/installed') || !CLO.s.q || yn.test(await prompt('App is already installed. Do you want to factory reset the database? (y/n): '))) {
			if (!CLO.s.q && !cfg.devmode && exists('/conf/installed')) {
				console.log('These operations are destructive. Please enter the site secret from the config file to continue: ');
				if (await prompt('Secret: ',/\w+/) != cfg.secret) return pgp.end(),console.log('Secret mismatch. Exiting.');
				console.log('Secret matched. Proceeding.');
			}

			console.log('Checking Postgres version...');
			let dbname, pgversion = false;
			try {
				let data = await db.one('SELECT version();');
				dbname = data.version.split(' ')[0];
				pgversion = data.version.split(',')[0].split(' ')[1];
			} catch(err) {
				console.log(err);
				pgp.end();
				console.log('Postgres version check failed. Exiting.');
				return;
			}
			if (!dbname || dbname != 'PostgreSQL')
				return pgp.end(),console.log('Connection is not a postgres database. Please make sure you have postgres 9.6.0 or greater installed and running.');
			let pgv = pgversion.split('.');
			if (parseInt(pgv[0],10) < 9 && parseInt(pgv[1],10) < 6 && parseInt(pgv[2],10) < 0)
				return pgp.end(),console.log('Postgres version mismatch. Connection is running '+pgversion+', please upgrade to at least 9.6.0. Exiting.');
			console.log('Version check passed.');
			console.log();
			console.log('Wiping the database...');
			try {
				await db.none(sql('/install/wipe.sql'));
				console.log('Success');
			} catch(err) {
				console.log(err);
				pgp.end();
				console.log('Wipe failed. Exiting.');
				return;
			}

			console.log('Installing the database...');
			try {
				await db.tx((self) => {
					return self.batch([
						self.none(sql('/install/tables.sql')),
						self.none(sql('/install/functions.sql'))
					]);
				});
				console.log('Success');
			} catch(err) {
				console.log(err);
				pgp.end();
				console.log('Install failed. Exiting.');
				return;
			}

			console.log('Database has been installed.');
		}
		yml.write.sync(path('/conf/config.yml'),cfg);
	}

	// ----   Move this functionality into the global settings editor  ----
	//
	// cfg.site.name = CLO.s.q?cfg.site.name:await prompt("What do you want the site's name to be? (Leave empty for existing value '"+cfg.site.name+"'): ") || cfg.site.name;

	// function consolidateKeys(stale,fresh) {
	// 	for (var key in stale.options) if (fresh.options.hasOwnProperty(key)) {
	// 		if (!stale.options.hasOwnProperty(key))
	// 			stale.options[key] = fresh.options[key];
	// 		else if (typeof fresh.options[key] === 'object' && !(fresh.options[key] instanceof Array))
	// 			consolidateKeys(stale.options[key],fresh.options[key]);
	// 	}
	// }
	// consolidateKeys(cfg,dcfg);
	// if (!CLO.s.q && yn.test(await prompt('Do you want to configure the additional boolean options available for the app? (y/n): '))) {
	// 	console.log('Answer the following questions with either a yes or no. (y/n is fine as well)');
	// 	let questions = yml.read.sync(__dirname+'/options.yml'), options = dcfg.options, missed = [];
	// 	for (var key in options) { if (options.hasOwnProperty(key)) {
	// 		if (questions.hasOwnProperty(key)) {
	// 			if (questions[key]) cfg.options[key] = yn.test(await prompt(questions[key]+': ',null,true));
	// 		} else missed.push(key);
	// 	}}
	// 	yml.write.sync(__dirname+'/../conf/config.yml',cfg);
	// 	console.log('Option configuration complete.' + (missed.length ? ' (This configuration has not covered all the available options. Please see /conf/config.yml for the full list.)':''));
	// }

	console.log("Application installation completed. You can start the app by running 'nodejs app.js' from the app's root directory.");

	pgp.end();

	fs.writeFileSync(path('/conf/installed'),VERSION.fresh);

})().catch(err=>{console.log(err); pgp.end();});


text: Spree.user_class = "Spree::User"

redpajama_set_name: RedPajamaGithub


text:
namespace autowiring {

/// <summary>
/// Implements a thread pool using the STL as a final fallback
/// </summary>
/// <remarks>
/// This implementation avoids using std::async to achieve thread pooling because some systems
/// do not attempt to reuse threads to run operations enqueued by std::async, resulting in very
/// poor performance.
/// </remarks>
class SystemThreadPoolStl:
  public SystemThreadPool
{
public:
  SystemThreadPoolStl(void);
  ~SystemThreadPoolStl(void);

private:
  // Thunks awaiting execution
  DispatchQueue m_toBeDone;

  // The current number of outstanding workers
  std::atomic<size_t> m_outstanding{0};

  /// <summary>
  /// Creates a new worker thread to process the dispatch queue
  /// </summary>
  void AddWorkerThreadUnsafe(void);

  // ThreadPool overrides
  void OnStartUnsafe(void) override;
  void OnStop(void) override;

public:
  void SuggestThreadPoolSize(size_t nThreads) override;
  bool Submit(std::unique_ptr<DispatchThunkBase>&& thunk) override;
};

}


text:
{% extends "base.html" %}

{% block title %}Page unavailable{% endblock %}

{% block content %}

Page unavailable

{% endblock %}


text:
/*! \file
    \brief Type traits for common CUDA types
*/

#pragma once

#include <cublas_v2.h>
#include <cuda_fp16.h>
#include <stdint.h>

#include "half.h"
#include "cutlass/vector.h"
#include "cutlass/util/complex.h"

namespace cutlass {
struct half_t;

template <typename T>
struct TypeTraits {
  typedef T host_type;
  typedef T device_type;
  static inline T remove_negative_zero(T x) { return x; }
  static inline T to_print(T x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits<Vector<bin1_t, 32> > {
  static cudaDataType_t const cublas_type = CUDA_R_32I;
  typedef Vector<bin1_t, 32> host_type;
  typedef Vector<bin1_t, 32> device_type;
  typedef uint32_t integer_type;
  typedef uint32_t unsigned_type;
  static inline uint32_t remove_negative_zero(uint32_t x) { return x; }
  static inline uint32_t to_print(uint32_t x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits< Vector<int4_t, 8> > {
  static cudaDataType_t const cublas_type = CUDA_R_32I;
  typedef Vector<int4_t, 8> host_type;
  typedef Vector<int4_t, 8> device_type;
  typedef uint32_t integer_type;
  typedef uint32_t unsigned_type;
  static inline uint32_t remove_negative_zero(uint32_t x) { return x; }
  static inline uint32_t to_print(uint32_t x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits< Vector<uint4_t, 8> > {
  static cudaDataType_t const cublas_type = CUDA_R_32I;
  typedef Vector<uint4_t, 8> host_type;
  typedef Vector<uint4_t, 8> device_type;
  typedef uint32_t integer_type;
  typedef uint32_t unsigned_type;
  static inline uint32_t remove_negative_zero(uint32_t x) { return x; }
  static inline uint32_t to_print(uint32_t x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits<int8_t> {
  static cudaDataType_t const cublas_type = CUDA_R_8I;
  typedef int8_t host_type;
  typedef int8_t device_type;
  typedef int8_t integer_type;
  typedef uint8_t unsigned_type;
  static inline int8_t remove_negative_zero(int8_t x) { return x; }
  static inline int to_print(int8_t x) { return (int)x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits<uint8_t> {
  static cudaDataType_t const cublas_type = CUDA_R_8I;
  typedef uint8_t host_type;
  typedef uint8_t device_type;
  typedef uint8_t integer_type;
  typedef uint8_t unsigned_type;
  static inline uint8_t remove_negative_zero(uint8_t x) { return x; }
  static inline uint32_t to_print(uint8_t x) { return (uint32_t)x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits<int> {
  static cudaDataType_t const cublas_type = CUDA_R_32I;
  typedef int host_type;
  typedef int device_type;
  typedef int32_t integer_type;
  typedef uint32_t unsigned_type;
  static inline int32_t remove_negative_zero(int32_t x) { return x; }
  static inline int to_print(int x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits<unsigned> {
  static cudaDataType_t const cublas_type = CUDA_R_32I;
  typedef unsigned host_type;
  typedef unsigned device_type;
  typedef uint32_t integer_type;
  typedef uint32_t unsigned_type;
  static inline uint32_t remove_negative_zero(uint32_t x) { return x; }
  static inline uint32_t to_print(uint32_t x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits<half> {
  static cudaDataType_t const cublas_type = CUDA_R_16F;
  typedef half_t host_type;
  typedef half device_type;
  typedef int16_t integer_type;
  typedef uint16_t unsigned_type;
  static inline half remove_negative_zero(half x) {
    integer_type h_int = reinterpret_cast<integer_type const&>(x);
    if (h_int == 0x8000) {
      h_int = 0;
    }
    x = reinterpret_cast<half const&>(h_int);
    return x;
  }
  static inline half to_print(half x) { return x; }
  static inline device_type to_device(half x) { return reinterpret_cast<device_type const &>(x); }
};

template <>
struct TypeTraits<int64_t> {
  static cudaDataType_t const cublas_type = CUDA_R_8I;
  typedef int64_t host_type;
  typedef int64_t device_type;
  typedef int64_t integer_type;
  typedef uint64_t unsigned_type;
  static inline int64_t remove_negative_zero(int64_t x) { return x; }
  static inline int64_t to_print(int64_t x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits<uint64_t> {
  static cudaDataType_t const cublas_type = CUDA_R_8I;
  typedef uint64_t host_type;
  typedef uint64_t device_type;
  typedef uint64_t integer_type;
  typedef uint64_t unsigned_type;
  static inline uint64_t remove_negative_zero(uint64_t x) { return x; }
  static inline uint64_t to_print(uint64_t x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits<cutlass::half_t> {
  static cudaDataType_t const cublas_type = CUDA_R_16F;
  typedef half_t host_type;
  typedef half device_type;
  typedef int16_t integer_type;
  typedef uint16_t unsigned_type;
  static inline half_t remove_negative_zero(half_t x) {
    return (x.raw() == 0x8000 ? half_t::bitcast(0) : x);
  }
  static inline half_t to_print(half_t x) { return x; }
  static inline device_type to_device(cutlass::half_t x) { return reinterpret_cast<device_type const &>(x); }
};

template <>
struct TypeTraits<float> {
  static cudaDataType_t const cublas_type = CUDA_R_32F;
  typedef float host_type;
  typedef float device_type;
  typedef int32_t integer_type;
  typedef uint32_t unsigned_type;
  static inline float remove_negative_zero(float x) { return x == -0.f ? 0.f : x; }
  static inline float to_print(float x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

template <>
struct TypeTraits<double> {
  static cudaDataType_t const cublas_type = CUDA_R_64F;
  typedef double host_type;
  typedef double device_type;
  typedef int64_t integer_type;
  typedef uint64_t unsigned_type;
  static inline double remove_negative_zero(double x) { return x == -0.0 ? 0.0 : x; }
  static inline double to_print(double x) { return x; }
  static inline device_type to_device(host_type x) { return x; }
};

///////////////////////////////////////////////////////////////////////////////////////////////////
//
// Complex types
//
///////////////////////////////////////////////////////////////////////////////////////////////////

template <>
struct TypeTraits<platform::complex<half> > {
  static cudaDataType_t const cublas_type = CUDA_C_16F;
  typedef platform::complex<half_t> host_type;
  typedef platform::complex<half> device_type;
  typedef int16_t integer_type;
  typedef uint16_t unsigned_type;
  static inline device_type to_device(platform::complex<half> x) { return reinterpret_cast<device_type const &>(x); }
};

template <>
struct TypeTraits<platform::complex<half_t> > {
  static cudaDataType_t const cublas_type = CUDA_C_16F;
  typedef platform::complex<half_t> host_type;
  typedef platform::complex<half> device_type;
  typedef int16_t integer_type;
  typedef uint16_t unsigned_type;
  static inline platform::complex<half_t> remove_negative_zero(platform::complex<half_t> x) {
    return platform::complex<half_t>(
      real(x) == -0.f ? half_t(0) : real(x),
      imag(x) == -0.f ? half_t(0) : imag(x)
    );
  }
  static inline platform::complex<half_t> to_print(platform::complex<half_t> x) { return x; }
  static inline device_type to_device(platform::complex<half_t> x) { return reinterpret_cast<device_type const &>(x); }
};

template <>
struct TypeTraits<platform::complex<float> > {

  static cudaDataType_t const cublas_type = CUDA_C_32F;
  typedef platform::complex<float> host_type;
  typedef platform::complex<float> device_type;
  typedef int64_t integer_type;
  typedef uint64_t unsigned_type;

  static inline platform::complex<float> remove_negative_zero(platform::complex<float> x) {
    return platform::complex<float>(
      real(x) == -0.f ? 0.f : real(x),
      imag(x) == -0.f ? 0.f : imag(x)
    );
  }

  static inline platform::complex<float> to_print(platform::complex<float> x) { return x; }
  static inline device_type to_device(platform::complex<float> x) { return reinterpret_cast<device_type const &>(x); }
};

template <>
struct TypeTraits<platform::complex<double> > {
  static cudaDataType_t const cublas_type = CUDA_C_64F;
  typedef platform::complex<double> host_type;
  typedef platform::complex<double> device_type;
  struct integer_type { int64_t real, imag; };
  struct unsigned_type { uint64_t real, imag; };
  static inline platform::complex<double> remove_negative_zero(platform::complex<double> x) {
    return platform::complex<double>(
      real(x) == -0.0 ? 0.0 : real(x),
      imag(x) == -0.0 ? 0.0 : imag(x)
    );
  }
  static inline platform::complex<double> to_print(platform::complex<double> x) { return x; }
  static inline device_type to_device(platform::complex<double> x) { return reinterpret_cast<device_type const &>(x); }
};

///////////////////////////////////////////////////////////////////////////////////////////////////

}  // namespace cutlass


text:
package org.lwjgl.opengl;

import org.lwjgl.system.*;
import org.lwjgl.system.libffi.*;

import static org.lwjgl.system.APIUtil.*;
import static org.lwjgl.system.MemoryUtil.*;
import static org.lwjgl.system.libffi.LibFFI.*;

/**
 * Instances of this interface may be passed to the {@link ARBDebugOutput#glDebugMessageCallbackARB DebugMessageCallbackARB} method.
 *
 *
Type

 *
 *

 * void (*{@link #invoke}) (
 *     GLenum source,
 *     GLenum type,
 *     GLuint id,
 *     GLenum severity,
 *     GLsizei length,
 *     GLchar const *message,
 *     void const *userParam
 * )

 */
@FunctionalInterface
@NativeType("GLDEBUGPROCARB")
public interface GLDebugMessageARBCallbackI extends CallbackI {

    FFICIF CIF = apiCreateCIF(
        apiStdcall(),
        ffi_type_void,
        ffi_type_uint32, ffi_type_uint32, ffi_type_uint32, ffi_type_uint32, ffi_type_sint32, ffi_type_pointer, ffi_type_pointer
    );

    @Override
    default FFICIF getCallInterface() { return CIF; }

    @Override
    default void callback(long ret, long args) {
        invoke(
            memGetInt(memGetAddress(args)),
            memGetInt(memGetAddress(args + POINTER_SIZE)),
            memGetInt(memGetAddress(args + 2 * POINTER_SIZE)),
            memGetInt(memGetAddress(args + 3 * POINTER_SIZE)),
            memGetInt(memGetAddress(args + 4 * POINTER_SIZE)),
            memGetAddress(memGetAddress(args + 5 * POINTER_SIZE)),
            memGetAddress(memGetAddress(args + 6 * POINTER_SIZE))
        );
    }

    /**
     * Will be called when a debug message is generated.
     *
     * @param source    the message source
     * @param type      the message type
     * @param id        the message ID
     * @param severity  the message severity
     * @param length    the message length, excluding the null-terminator
     * @param message   a pointer to the message string representation
     * @param userParam the user-specified value that was passed when calling {@link ARBDebugOutput#glDebugMessageCallbackARB DebugMessageCallbackARB}
     */
    void invoke(@NativeType("GLenum") int source, @NativeType("GLenum") int type, @NativeType("GLuint") int id, @NativeType("GLenum") int severity, @NativeType("GLsizei") int length, @NativeType("GLchar const *") long message, @NativeType("void const *") long userParam);

}


text:
//
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.8-b130911.1802
// See http://java.sun.com/xml/jaxb
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2016.10.09 at 10:10:23 AM CST
//

package com.elong.nb.model.elong;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import java.util.List;
import com.alibaba.fastjson.annotation.JSONField;
import javax.xml.bind.annotation.XmlType;

/**
 *
Java class for SingleHotel complex type.
 *
 *
The following schema fragment specifies the expected content contained within this class.
 *
 *

 * <complexType name="SingleHotel">
 *   <complexContent>
 *     <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       <sequence>
 *         <element name="Detail" type="{}HotelBaseInfo" minOccurs="0"/>
 *         <element name="Rooms" type="{}ArrayOfHotelRoom" minOccurs="0"/>
 *         <element name="Images" type="{}ArrayOfHotelImg" minOccurs="0"/>
 *         <element name="Review" type="{}Review" minOccurs="0"/>
 *       </sequence>
 *       <attribute name="Id" type="{http://www.w3.org/2001/XMLSchema}string" />
 *     </restriction>
 *   </complexContent>
 * </complexType>
 *

 *
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "SingleHotel", propOrder = {
    "detail",
    "rooms",
    "images",
    "review"
})
public class SingleHotel {

    @JSONField(name = "Detail")
    protected HotelBaseInfo detail;
    @JSONField(name = "Rooms")
    protected List<HotelRoom> rooms;
    @JSONField(name = "Images")
    protected List<HotelImg> images;
    @JSONField(name = "Review")
    protected Review review;
    @XmlAttribute(name = "Id")
    protected String id;

    /**
     * Gets the value of the detail property.
     *
     * @return
     *     possible object is
     *     {@link HotelBaseInfo }
     *
     */
    public HotelBaseInfo getDetail() {
        return detail;
    }

    /**
     * Sets the value of the detail property.
     *
     * @param value
     *     allowed object is
     *     {@link HotelBaseInfo }
     *
     */
    public void setDetail(HotelBaseInfo value) {
        this.detail = value;
    }

    /**
     * Gets the value of the rooms property.
     *
     * @return
     *     possible object is
     *     {@link List<HotelRoom> }
     *
     */
    public List<HotelRoom> getRooms() {
        return rooms;
    }

    /**
     * Sets the value of the rooms property.
     *
     * @param value
     *     allowed object is
     *     {@link List<HotelRoom> }
     *
     */
    public void setRooms(List<HotelRoom> value) {
        this.rooms = value;
    }

    /**
     * Gets the value of the images property.
     *
     * @return
     *     possible object is
     *     {@link List<HotelImg> }
     *
     */
    public List<HotelImg> getImages() {
        return images;
    }

    /**
     * Sets the value of the images property.
     *
     * @param value
     *     allowed object is
     *     {@link List<HotelImg> }
     *
     */
    public void setImages(List<HotelImg> value) {
        this.images = value;
    }

    /**
     * Gets the value of the review property.
     *
     * @return
     *     possible object is
     *     {@link Review }
     *
     */
    public Review getReview() {
        return review;
    }

    /**
     * Sets the value of the review property.
     *
     * @param value
     *     allowed object is
     *     {@link Review }
     *
     */
    public void setReview(Review value) {
        this.review = value;
    }

    /**
     * Gets the value of the id property.
     *
     * @return
     *     possible object is
     *     {@link String }
     *
     */
    public String getId() {
        return id;
    }

    /**
     * Sets the value of the id property.
     *
     * @param value
     *     allowed object is
     *     {@link String }
     *
     */
    public void setId(String value) {
        this.id = value;
    }

}