text:
package proxy;
/**
 * @author JUANJUAN
 * @version 2017年8月6日下午9:18:11
*/
public class ProxyImage implements Image{
	private RealImage realImage;
	private String fileName;
	public ProxyImage(String fileName){
		this.fileName = fileName;
	}

	@Override
	public void display() {
		// TODO Auto-generated method stub
		if(realImage == null){
			realImage = new RealImage(fileName);
		}
		realImage.display();
	}

}

redpajama_set_name: RedPajamaGithub


text:
package io.renren.utils;

import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;

/**
 *

 * 高效GUID产生算法(sequence),基于Snowflake实现64位自增ID算法。

 * 优化开源项目 http://git.oschina.net/yu120/sequence
 *

 *
 * @author hubin
 * @since 2016-08-01
 */
public class IdWorker {

    /**
     * 主机和进程的机器码
     */
    private static Sequence WORKER = new Sequence();

    public static long getId() {
        return WORKER.nextId();
    }

    public static String getIdStr() {
        return String.valueOf(WORKER.nextId());
    }

    /**
     *

     * 有参构造器
     *

     *
     * @param workerId     工作机器 ID
     * @param datacenterId 序列号
     */
    public static void initSequence(long workerId, long datacenterId) {
        WORKER = new Sequence(workerId, datacenterId);
    }

    /**
     *

     * 使用ThreadLocalRandom获取UUID获取更优的效果 去掉"-"
     *

     */
    public static String get32UUID() {
        ThreadLocalRandom random = ThreadLocalRandom.current();
        return new UUID(random.nextLong(), random.nextLong()).toString().replace(StringPool.DASH, StringPool.EMPTY);
    }

}


text:
package count.ly.messaging;

import android.app.Activity;
import android.content.Context;
import android.util.Log;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * This class is the public API for the Countly Android SDK.
 * Get more details here.
 */
public class Countly {

    /**
     * Current version of the Count.ly Android SDK as a displayable string.
     */
    public static final String COUNTLY_SDK_VERSION_STRING = "15.06";
    /**
     * Default string used in the begin session metrics if the
     * app version cannot be found.
     */
    public static final String DEFAULT_APP_VERSION = "1.0";
    /**
     * Tag used in all logging in the Count.ly SDK.
     */
    public static final String TAG = "Countly";

    /**
     * Determines how many custom events can be queued locally before
     * an attempt is made to submit them to a Count.ly server.
     */
    private static final int EVENT_QUEUE_SIZE_THRESHOLD = 10;
    /**
     * How often onTimer() is called.
     */
    private static final long TIMER_DELAY_IN_SECONDS = 60;

    protected static List<String> publicKeyPinCertificates;

    /**
     * Enum used in Countly.initMessaging() method which controls what kind of
     * app installation it is. Later (in Countly Dashboard or when calling Countly API method),
     * you'll be able to choose whether you want to send a message to test devices,
     * or to production ones.
     */
    public static enum CountlyMessagingMode {
        TEST,
        PRODUCTION,
    }

    // see http://stackoverflow.com/questions/7048198/thread-safe-singletons-in-java
    private static class SingletonHolder {
        static final Countly instance = new Countly();
    }

    private ConnectionQueue connectionQueue_;
    @SuppressWarnings("FieldCanBeLocal")
    private ScheduledExecutorService timerService_;
    private EventQueue eventQueue_;
    private DeviceId deviceId_Manager_;
    private long prevSessionDurationStartTime_;
    private int activityCount_;
    private boolean disableUpdateSessionRequests_;
    private boolean enableLogging_;
    private Countly.CountlyMessagingMode messagingMode_;
    private Context context_;

    /**
     * Returns the Countly singleton.
     */
    public static Countly sharedInstance() {
        return SingletonHolder.instance;
    }

    /**
     * Constructs a Countly object.
     * Creates a new ConnectionQueue and initializes the session timer.
     */
    Countly() {
        connectionQueue_ = new ConnectionQueue();
        timerService_ = Executors.newSingleThreadScheduledExecutor();
        timerService_.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                onTimer();
            }
        }, TIMER_DELAY_IN_SECONDS, TIMER_DELAY_IN_SECONDS, TimeUnit.SECONDS);
    }

    /**
     * Initializes the Countly SDK. Call from your main Activity's onCreate() method.
     * Must be called before other SDK methods can be used.
     * Device ID is supplied by OpenUDID service if available, otherwise Advertising ID is used.
     * BE CAUTIOUS!!!! If neither OpenUDID, nor Advertising ID is available, Countly will ignore this user.
     * @param context application context
     * @param serverURL URL of the Countly server to submit data to; use "https://cloud.count.ly" for Countly Cloud
     * @param appKey app key for the application being tracked; find in the Countly Dashboard under Management > Applications
     * @return Countly instance for easy method chaining
     * @throws java.lang.IllegalArgumentException if context, serverURL, appKey, or deviceID are invalid
     * @throws java.lang.IllegalStateException if the Countly SDK has already been initialized
     */
    public Countly init(final Context context, final String serverURL, final String appKey) {
        return init(context, serverURL, appKey, null, OpenUDIDAdapter.isOpenUDIDAvailable() ? DeviceId.Type.OPEN_UDID : DeviceId.Type.ADVERTISING_ID);
    }

    /**
     * Initializes the Countly SDK. Call from your main Activity's onCreate() method.
     * Must be called before other SDK methods can be used.
     * @param context application context
     * @param serverURL URL of the Countly server to submit data to; use "https://cloud.count.ly" for Countly Cloud
     * @param appKey app key for the application being tracked; find in the Countly Dashboard under Management > Applications
     * @param deviceID unique ID for the device the app is running on; note that null in deviceID means that Countly will fall back to OpenUDID, then, if it's not available, to Google Advertising ID
     * @return Countly instance for easy method chaining
     * @throws IllegalArgumentException if context, serverURL, appKey, or deviceID are invalid
     * @throws IllegalStateException if init has previously been called with different values during the same application instance
     */
    public Countly init(final Context context, final String serverURL, final String appKey, final String deviceID) {
        return init(context, serverURL, appKey, deviceID, null);
    }

    /**
     * Initializes the Countly SDK. Call from your main Activity's onCreate() method.
     * Must be called before other SDK methods can be used.
     * @param context application context
     * @param serverURL URL of the Countly server to submit data to; use "https://cloud.count.ly" for Countly Cloud
     * @param appKey app key for the application being tracked; find in the Countly Dashboard under Management > Applications
     * @param deviceID unique ID for the device the app is running on; note that null in deviceID means that Countly will fall back to OpenUDID, then, if it's not available, to Google Advertising ID
     * @param idMode enum value specifying which device ID generation strategy Countly should use: OpenUDID or Google Advertising ID
     * @return Countly instance for easy method chaining
     * @throws IllegalArgumentException if context, serverURL, appKey, or deviceID are invalid
     * @throws IllegalStateException if init has previously been called with different values during the same application instance
     */
    public synchronized Countly init(final Context context, final String serverURL, final String appKey, final String deviceID, DeviceId.Type idMode) {
        if (context == null) {
            throw new IllegalArgumentException("valid context is required");
        }
        if (!isValidURL(serverURL)) {
            throw new IllegalArgumentException("valid serverURL is required");
        }
        if (appKey == null || appKey.length() == 0) {
            throw new IllegalArgumentException("valid appKey is required");
        }
        if (deviceID != null && deviceID.length() == 0) {
            throw new IllegalArgumentException("valid deviceID is required");
        }
        if (deviceID == null && idMode == null) {
            if (OpenUDIDAdapter.isOpenUDIDAvailable()) idMode = DeviceId.Type.OPEN_UDID;
            else if (AdvertisingIdAdapter.isAdvertisingIdAvailable()) idMode = DeviceId.Type.ADVERTISING_ID;
        }
        if (deviceID == null && idMode == DeviceId.Type.OPEN_UDID && !OpenUDIDAdapter.isOpenUDIDAvailable()) {
            throw new IllegalArgumentException("valid deviceID is required because OpenUDID is not available");
        }
        if (deviceID == null && idMode == DeviceId.Type.ADVERTISING_ID && !AdvertisingIdAdapter.isAdvertisingIdAvailable()) {
            throw new IllegalArgumentException("valid deviceID is required because Advertising ID is not available (you need to include Google Play services 4.0+ into your project)");
        }
        if (eventQueue_ != null && (!connectionQueue_.getServerURL().equals(serverURL) ||
                                    !connectionQueue_.getAppKey().equals(appKey) ||
                                    !DeviceId.deviceIDEqualsNullSafe(deviceID, idMode, connectionQueue_.getDeviceId()) )) {
            throw new IllegalStateException("Countly cannot be reinitialized with different values");
        }

        // In some cases CountlyMessaging does some background processing, so it needs a way
        // to start Countly on itself
        if (MessagingAdapter.isMessagingAvailable()) {
            MessagingAdapter.storeConfiguration(context, serverURL, appKey, deviceID, idMode);
        }

        // if we get here and eventQueue_ != null, init is being called again with the same values,
        // so there is nothing to do, because we are already initialized with those values
        if (eventQueue_ == null) {
            DeviceId deviceIdInstance;
            if (deviceID != null) {
                deviceIdInstance = new DeviceId(deviceID);
            } else {
                deviceIdInstance = new DeviceId(idMode);
            }

            final CountlyStore countlyStore = new CountlyStore(context);

            deviceIdInstance.init(context, countlyStore, true);

            connectionQueue_.setServerURL(serverURL);
            connectionQueue_.setAppKey(appKey);
            connectionQueue_.setCountlyStore(countlyStore);
            connectionQueue_.setDeviceId(deviceIdInstance);

            eventQueue_ = new EventQueue(countlyStore);
        }

        context_ = context;

        // context is allowed to be changed on the second init call
        connectionQueue_.setContext(context);

        return this;
    }

    /**
     * Checks whether Countly.init has been already called.
     * @return true if Countly is ready to use
     */
    public synchronized boolean isInitialized() {
        return eventQueue_ != null;
    }

    /**
     * Initializes the Countly MessagingSDK. Call from your main Activity's onCreate() method.
     * @param activity application activity which acts as a final destination for notifications
     * @param activityClass application activity class which acts as a final destination for notifications
     * @param projectID ProjectID for this app from Google API Console
     * @param mode whether this app installation is a test release or production
     * @return Countly instance for easy method chaining
     * @throws IllegalStateException if no CountlyMessaging class is found (you need to use countly-messaging-sdk-android library instead of countly-sdk-android)
     */
    public Countly initMessaging(Activity activity, Class<? extends Activity> activityClass, String projectID, Countly.CountlyMessagingMode mode) {
        return initMessaging(activity, activityClass, projectID, null, mode);
    }
    /**
     * Initializes the Countly MessagingSDK. Call from your main Activity's onCreate() method.
     * @param activity application activity which acts as a final destination for notifications
     * @param activityClass application activity class which acts as a final destination for notifications
     * @param projectID ProjectID for this app from Google API Console
     * @param buttonNames Strings to use when displaying Dialogs (uses new String[]{"Open", "Review"} by default)
     * @param mode whether this app installation is a test release or production
     * @return Countly instance for easy method chaining
     * @throws IllegalStateException if no CountlyMessaging class is found (you need to use countly-messaging-sdk-android library instead of countly-sdk-android)
     */
    public synchronized Countly initMessaging(Activity activity, Class<? extends Activity> activityClass, String projectID, String[] buttonNames, Countly.CountlyMessagingMode mode) {
        if (mode != null && !MessagingAdapter.isMessagingAvailable()) {
            throw new IllegalStateException("you need to include countly-messaging-sdk-android library instead of countly-sdk-android if you want to use Countly Messaging");
        } else {
            if (!MessagingAdapter.init(activity, activityClass, projectID, buttonNames)) {
                throw new IllegalStateException("couldn't initialize Countly Messaging");
            }
        }
        messagingMode_ = mode;

        if (MessagingAdapter.isMessagingAvailable()) {
            MessagingAdapter.storeConfiguration(connectionQueue_.getContext(), connectionQueue_.getServerURL(), connectionQueue_.getAppKey(), connectionQueue_.getDeviceId().getId(), connectionQueue_.getDeviceId().getType());
        }

        return this;
    }

    /**
     * Immediately disables session & event tracking and clears any stored session & event data.
     * This API is useful if your app has a tracking opt-out switch, and you want to immediately
     * disable tracking when a user opts out. The onStart/onStop/recordEvent methods will throw
     * IllegalStateException after calling this until Countly is reinitialized by calling init
     * again.
     */
    public synchronized void halt() {
        eventQueue_ = null;
        final CountlyStore countlyStore = connectionQueue_.getCountlyStore();
        if (countlyStore != null) {
            countlyStore.clear();
        }
        connectionQueue_.setContext(null);
        connectionQueue_.setServerURL(null);
        connectionQueue_.setAppKey(null);
        connectionQueue_.setCountlyStore(null);
        prevSessionDurationStartTime_ = 0;
        activityCount_ = 0;
    }

    /**
     * Tells the Countly SDK that an Activity has started. Since Android does not have an
     * easy way to determine when an application instance starts and stops, you must call this
     * method from every one of your Activity's onStart methods for accurate application
     * session tracking.
     * @throws IllegalStateException if Countly SDK has not been initialized
     */
    public synchronized void onStart() {
        if (eventQueue_ == null) {
            throw new IllegalStateException("init must be called before onStart");
        }

        ++activityCount_;
        if (activityCount_ == 1) {
            onStartHelper();
        }

        //check if there is an install referrer data
        String referrer = ReferrerReceiver.getReferrer(context_);
        if (Countly.sharedInstance().isLoggingEnabled()) {
            Log.d(Countly.TAG, "Checking referrer: " + referrer);
        }
        if(referrer != null){
            connectionQueue_.sendReferrerData(referrer);
            ReferrerReceiver.deleteReferrer(context_);
        }

        CrashDetails.inForeground();
    }

    /**
     * Called when the first Activity is started. Sends a begin session event to the server
     * and initializes application session tracking.
     */
    void onStartHelper() {
        prevSessionDurationStartTime_ = System.nanoTime();
        connectionQueue_.beginSession();
    }

    /**
     * Tells the Countly SDK that an Activity has stopped. Since Android does not have an
     * easy way to determine when an application instance starts and stops, you must call this
     * method from every one of your Activity's onStop methods for accurate application
     * session tracking.
     * @throws IllegalStateException if Countly SDK has not been initialized, or if
     *                               unbalanced calls to onStart/onStop are detected
     */
    public synchronized void onStop() {
        if (eventQueue_ == null) {
            throw new IllegalStateException("init must be called before onStop");
        }
        if (activityCount_ == 0) {
            throw new IllegalStateException("must call onStart before onStop");
        }

        --activityCount_;
        if (activityCount_ == 0) {
            onStopHelper();
        }

        CrashDetails.inBackground();
    }

    /**
     * Called when final Activity is stopped. Sends an end session event to the server,
     * also sends any unsent custom events.
     */
    void onStopHelper() {
        connectionQueue_.endSession(roundedSecondsSinceLastSessionDurationUpdate());
        prevSessionDurationStartTime_ = 0;

        if (eventQueue_.size() > 0) {
            connectionQueue_.recordEvents(eventQueue_.events());
        }
    }

    /**
     * Called when GCM Registration ID is received. Sends a token session event to the server.
     */
    public void onRegistrationId(String registrationId) {
        connectionQueue_.tokenSession(registrationId, messagingMode_);
    }

    /**
     * Records a custom event with no segmentation values, a count of one and a sum of zero.
     * @param key name of the custom event, required, must not be the empty string
     * @throws IllegalStateException if Countly SDK has not been initialized
     * @throws IllegalArgumentException if key is null or empty
     */
    public void recordEvent(final String key) {
        recordEvent(key, null, 1, 0);
    }

    /**
     * Records a custom event with no segmentation values, the specified count, and a sum of zero.
     * @param key name of the custom event, required, must not be the empty string
     * @param count count to associate with the event, should be more than zero
     * @throws IllegalStateException if Countly SDK has not been initialized
     * @throws IllegalArgumentException if key is null or empty
     */
    public void recordEvent(final String key, final int count) {
        recordEvent(key, null, count, 0);
    }

    /**
     * Records a custom event with no segmentation values, and the specified count and sum.
     * @param key name of the custom event, required, must not be the empty string
     * @param count count to associate with the event, should be more than zero
     * @param sum sum to associate with the event
     * @throws IllegalStateException if Countly SDK has not been initialized
     * @throws IllegalArgumentException if key is null or empty
     */
    public void recordEvent(final String key, final int count, final double sum) {
        recordEvent(key, null, count, sum);
    }

    /**
     * Records a custom event with the specified segmentation values and count, and a sum of zero.
     * @param key name of the custom event, required, must not be the empty string
     * @param segmentation segmentation dictionary to associate with the event, can be null
     * @param count count to associate with the event, should be more than zero
     * @throws IllegalStateException if Countly SDK has not been initialized
     * @throws IllegalArgumentException if key is null or empty
     */
    public void recordEvent(final String key, final Map<String, String> segmentation, final int count) {
        recordEvent(key, segmentation, count, 0);
    }

    /**
     * Records a custom event with the specified values.
     * @param key name of the custom event, required, must not be the empty string
     * @param segmentation segmentation dictionary to associate with the event, can be null
     * @param count count to associate with the event, should be more than zero
     * @param sum sum to associate with the event
     * @throws IllegalStateException if Countly SDK has not been initialized
     * @throws IllegalArgumentException if key is null or empty, count is less than 1, or if
     *                                  segmentation contains null or empty keys or values
     */
    public synchronized void recordEvent(final String key, final Map<String, String> segmentation, final int count, final double sum) {
        if (!isInitialized()) {
            throw new IllegalStateException("Countly.sharedInstance().init must be called before recordEvent");
        }
        if (key == null || key.length() == 0) {
            throw new IllegalArgumentException("Valid Countly event key is required");
        }
        if (count < 1) {
            throw new IllegalArgumentException("Countly event count should be greater than zero");
        }
        if (segmentation != null) {
            for (String k : segmentation.keySet()) {
                if (k == null || k.length() == 0) {
                    throw new IllegalArgumentException("Countly event segmentation key cannot be null or empty");
                }
                if (segmentation.get(k) == null || segmentation.get(k).length() == 0) {
                    throw new IllegalArgumentException("Countly event segmentation value cannot be null or empty");
                }
            }
        }

        eventQueue_.recordEvent(key, segmentation, count, sum);
        sendEventsIfNeeded();
    }

    /**
     * Sets information about user. Possible keys are:
     *

     *

     * name - (String) providing user's full name
     *

     *

     * username - (String) providing user's nickname
     *

     *

     * email - (String) providing user's email address
     *

     *

     * organization - (String) providing user's organization's name where user works
     *

     *

     * phone - (String) providing user's phone number
     *

     *

     * picture - (String) providing WWW URL to user's avatar or profile picture
     *

     *

     * picturePath - (String) providing local path to user's avatar or profile picture
     *

     *

     * gender - (String) providing user's gender as M for male and F for female
     *

     *

     * byear - (int) providing user's year of birth as integer
     *

     *

     * @param data Map<String, String> with user data
     */
    public synchronized Countly setUserData(Map<String, String> data) {
        return setUserData(data, null);
    }

    /**
     * Sets information about user with custom properties.
     * In custom properties you can provide any string key values to be stored with user
     * Possible keys are:
     *

     *

     * name - (String) providing user's full name
     *

     *

     * username - (String) providing user's nickname
     *

     *

     * email - (String) providing user's email address
     *

     *

     * organization - (String) providing user's organization's name where user works
     *

     *

     * phone - (String) providing user's phone number
     *

     *

     * picture - (String) providing WWW URL to user's avatar or profile picture
     *

     *

     * picturePath - (String) providing local path to user's avatar or profile picture
     *

     *

     * gender - (String) providing user's gender as M for male and F for female
     *

     *

     * byear - (int) providing user's year of birth as integer
     *

     *

     * @param data Map<String, String> with user data
     * @param customdata Map<String, String> with custom key values for this user
     */
    public synchronized Countly setUserData(Map<String, String> data, Map<String, String> customdata) {
        UserData.setData(data);
        if(customdata != null)
            UserData.setCustomData(customdata);
        connectionQueue_.sendUserData();
        return this;
    }

    /**
     * Sets custom properties.
     * In custom properties you can provide any string key values to be stored with user
     * @param customdata Map<String, String> with custom key values for this user
     */
    public synchronized Countly setCustomUserData(Map<String, String> customdata) {
        if(customdata != null)
            UserData.setCustomData(customdata);
        connectionQueue_.sendUserData();
        return this;
    }

    /**
     * Set user location.
     *
     * Countly detects user location based on IP address. But for geolocation-enabled apps,
     * it's better to supply exact location of user.
     * Allows sending messages to a custom segment of users located in a particular area.
     *
     * @param lat Latitude
     * @param lon Longitude
     */
    public synchronized Countly setLocation(double lat, double lon) {
        connectionQueue_.getCountlyStore().setLocation(lat, lon);

        if (disableUpdateSessionRequests_) {
            connectionQueue_.updateSession(roundedSecondsSinceLastSessionDurationUpdate());
        }

        return this;
    }

    /**
     * Sets custom segments to be reported with crash reports
     * In custom segments you can provide any string key values to segments crashes by
     * @param segments Map<String, String> key segments and their values
     */
    public synchronized Countly setCustomCrashSegments(Map<String, String> segments) {
        if(segments != null)
            CrashDetails.setCustomSegments(segments);
        return this;
    }

    /**
     * Add crash breadcrumb like log record to the log that will be send together with crash report
     * @param record String a bread crumb for the crash report
     */
    public synchronized Countly addCrashLog(String record) {
        CrashDetails.addLog(record);
        return this;
    }

    /**
     * Log handled exception to report it to server as non fatal crash
     * @param exception Exception to log
     */
    public synchronized Countly logException(Exception exception) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        exception.printStackTrace(pw);
        connectionQueue_.sendCrashReport(sw.toString(), true);
        return this;
    }

    /**
     * Log Javascript unhandled exception to report it to server as fatal crash
     * @param string Exception to log
     */
    public synchronized Countly logJavascriptFatalException(String exception) {
        connectionQueue_.sendCrashReport(exception, false);
        return this;
    }

    /**
     * Log Javascript handled exception to report it to server as non fatal crash
     * @param string Exception to log
     */
    public synchronized Countly logJavascriptNonFatalException(String exception) {
        connectionQueue_.sendCrashReport(exception, true);
        return this;
    }

    /**
     * Enable crash reporting to send unhandled crash reports to server
     */
    public synchronized Countly enableCrashReporting() {
        //get default handler
        final Thread.UncaughtExceptionHandler oldHandler = Thread.getDefaultUncaughtExceptionHandler();

        Thread.UncaughtExceptionHandler handler = new Thread.UncaughtExceptionHandler() {

            @Override
            public void uncaughtException(Thread t, Throwable e) {
                StringWriter sw = new StringWriter();
                PrintWriter pw = new PrintWriter(sw);
                e.printStackTrace(pw);
                connectionQueue_.sendCrashReport(sw.toString(), false);

                //if there was another handler before
                if(oldHandler != null){
                    //notify it also
                    oldHandler.uncaughtException(t,e);
                }
            }
        };

        Thread.setDefaultUncaughtExceptionHandler(handler);
        return this;
    }

    /**
     * Disable periodic session time updates.
     * By default, Countly will send a request to the server each 30 seconds with a small update
     * containing session duration time. This method allows you to disable such behavior.
     * Note that event updates will still be sent every 10 events or 30 seconds after event recording.
     * @param disable whether or not to disable session time updates
     * @return Countly instance for easy method chaining
     */
    public synchronized Countly setDisableUpdateSessionRequests(final boolean disable) {
        disableUpdateSessionRequests_ = disable;
        return this;
    }

    /**
     * Sets whether debug logging is turned on or off. Logging is disabled by default.
     * @param enableLogging true to enable logging, false to disable logging
     * @return Countly instance for easy method chaining
     */
    public synchronized Countly setLoggingEnabled(final boolean enableLogging) {
        enableLogging_ = enableLogging;
        return this;
    }

    public synchronized boolean isLoggingEnabled() {
        return enableLogging_;
    }

    /**
     * Submits all of the locally queued events to the server if there are more than 10 of them.
     */
    void sendEventsIfNeeded() {
        if (eventQueue_.size() >= EVENT_QUEUE_SIZE_THRESHOLD) {
            connectionQueue_.recordEvents(eventQueue_.events());
        }
    }

    /**
     * Called every 60 seconds to send a session heartbeat to the server. Does nothing if there
     * is not an active application session.
     */
    synchronized void onTimer() {
        final boolean hasActiveSession = activityCount_ > 0;
        if (hasActiveSession) {
            if (!disableUpdateSessionRequests_) {
                connectionQueue_.updateSession(roundedSecondsSinceLastSessionDurationUpdate());
            }
            if (eventQueue_.size() > 0) {
                connectionQueue_.recordEvents(eventQueue_.events());
            }
        }
    }

    /**
     * Calculates the unsent session duration in seconds, rounded to the nearest int.
     */
    int roundedSecondsSinceLastSessionDurationUpdate() {
        final long currentTimestampInNanoseconds = System.nanoTime();
        final long unsentSessionLengthInNanoseconds = currentTimestampInNanoseconds - prevSessionDurationStartTime_;
        prevSessionDurationStartTime_ = currentTimestampInNanoseconds;
        return (int) Math.round(unsentSessionLengthInNanoseconds / 1000000000.0d);
    }

    /**
     * Utility method to return a current timestamp that can be used in the Count.ly API.
     */
    static int currentTimestamp() {
        return ((int)(System.currentTimeMillis() / 1000l));
    }

    /**
     * Utility method for testing validity of a URL.
     */
    static boolean isValidURL(final String urlStr) {
        boolean validURL = false;
        if (urlStr != null && urlStr.length() > 0) {
            try {
                new URL(urlStr);
                validURL = true;
            }
            catch (MalformedURLException e) {
                validURL = false;
            }
        }
        return validURL;
    }

    /**
     * Allows public key pinning.
     * Supply list of SSL certificates (base64-encoded strings between "-----BEGIN CERTIFICATE-----" and "-----END CERTIFICATE-----" without end-of-line)
     * along with server URL starting with "https://". Countly will only accept connections to the server
     * if public key of SSL certificate provided by the server matches one provided to this method.
     * @param certificates List of SSL certificates
     * @return Countly instance
     */
    public static Countly enablePublicKeyPinning(List<String> certificates) {
        publicKeyPinCertificates = certificates;
        return Countly.sharedInstance();
    }

    /**
     * Get Device OUDID and return
     */
    public String getOUDID() {

    	String device_udid =  OpenUDIDAdapter.getOpenUDID();

    	return device_udid;
    }

    // for unit testing
    ConnectionQueue getConnectionQueue() { return connectionQueue_; }
    void setConnectionQueue(final ConnectionQueue connectionQueue) { connectionQueue_ = connectionQueue; }
    ExecutorService getTimerService() { return timerService_; }
    EventQueue getEventQueue() { return eventQueue_; }
    void setEventQueue(final EventQueue eventQueue) { eventQueue_ = eventQueue; }
    long getPrevSessionDurationStartTime() { return prevSessionDurationStartTime_; }
    void setPrevSessionDurationStartTime(final long prevSessionDurationStartTime) { prevSessionDurationStartTime_ = prevSessionDurationStartTime; }
    int getActivityCount() { return activityCount_; }
    boolean getDisableUpdateSessionRequests() { return disableUpdateSessionRequests_; }
}


text:
<?php

namespace Rylai\Analyzers;

use Rylai\Reflection\File;

interface AnalyzerInterface
{
    public function analyze(File $file);

    public function getName();
}


text:
{% load staticfiles %}

                Further Education and Training Institute

                    <form id="form-search" method="get"
                          action="/"
                          class="navbar-form">

                            <input dir="ltr" maxlength="250"
                                   id="search-terms"
                                   name="search_terms"
                                   value="{{ search_terms }}"
                                   type="text"
                                   placeholder="Search"/>

                        <input type="submit" value="FIND"/>
                    </form>

                {% if user.is_authenticated %}

                        Project Team Admin

                        Logout

                {% else %}

                        Project Team Login

                {% endif %}


text:
using System.Linq;
using System.Collections.Generic;

public class Note
{
    public Note(Semitone semitone, int octave, float duration = 0.125f)
    {
        Semitone = semitone;
        Octave = octave;
        Duration = duration;
    }

    public Semitone Semitone;
    public int Octave;
    public float Duration;
}

public class Melody
{
    public string Name;
    public Note[] Notes;
    public int Tempo = 130;

    public override string ToString()
    {
        return Name;
    }
}

public delegate bool RuleDelegate(PianoIndicator pianoIndicator, KMBombInfo bombInfo);
public delegate Melody MelodyDelegate(KMBombInfo bombInfo);
public delegate IEnumerable<Note> TransformationDelegate(IEnumerable<Note> sourceMelody, KMBombInfo bombInfo);
public delegate string SequenceStringDelegate(KMBombInfo bombInfo);

public static class NoteExtensions
{
    public static IEnumerable<Note> Retrograde(this IEnumerable<Note> sequence)
    {
        return sequence.Reverse();
    }

    public static IEnumerable<Note> Inversion(this IEnumerable<Note> sequence)
    {
        int currentValue = -1;
        int lastSourceValue = -1;

        foreach(Note note in sequence)
        {
            int thisSourceValue = (int)note.Semitone;

            if (lastSourceValue != -1)
            {
                int inversionDifference = lastSourceValue - thisSourceValue;
                currentValue += inversionDifference;
                while (currentValue < 0)
                {
                    currentValue += 12;
                }
                currentValue %= 12;
            }
            else
            {
                currentValue = thisSourceValue;
            }

            lastSourceValue = thisSourceValue;

            yield return new Note((Semitone)currentValue, note.Octave);
        }
    }

    public static IEnumerable<Note> Transpose(this IEnumerable<Note> sequence, int shift)
    {
        foreach(Note note in sequence)
        {
            int currentValue = ((int)note.Semitone) + shift;
            while(currentValue < 0)
            {
                currentValue += 12;
            }
            currentValue %= 12;

            yield return new Note((Semitone)currentValue, note.Octave);
        }
    }
}

public class Decision
{
    public MelodyDelegate MelodyHandler;
    public RuleDelegate RuleHandler;
    public TransformationDelegate TransformationHandler;
    public string RequiredSymbolsString;
    public string FurtherRequirementsString;
    public SequenceStringDelegate SequenceStringHandler;

    public bool IsValidDecision(PianoIndicator pianoIndicator, KMBombInfo bombInfo)
    {
        return RuleHandler(pianoIndicator, bombInfo);
    }

    public IEnumerable<Note> GetNotes(KMBombInfo bombInfo)
    {
        return TransformationHandler(MelodyHandler(bombInfo).Notes, bombInfo);
    }
}


text:
<menu xmlns:android="http://schemas.android.com/apk/res/android">

    <item
        android:id="@+id/tweet_clear"
        android:orderInCategory="100"
        android:showAsAction="never"
        android:title="@string/tweet_clear" />

    <item
        android:id="@+id/tweet_battery"
        android:orderInCategory="100"
        android:showAsAction="never"
        android:title="@string/tweet_battery" />
</menu>


text:
package.path = "./src/?.lua;./src/?/init.lua;"..package.path

local pegasus = require 'pegasus'

local server = pegasus:new({
  port = '9090',
})

local printTable = function(table)
  for k, v in pairs(table) do
    print(k, '=', v)
  end
end

server:start(function (req, res)
  printTable(req['querystring'])
  res:addHeader('Content-Type', 'text/html'):write('hello pegasus world!')
end)


text:
package hdf.hdf5lib.exceptions;

public class HDF5ReferenceException extends HDF5LibraryException {
    /**
     * Constructs an HDF5ReferenceException with no specified
     * detail message.
     */
    public HDF5ReferenceException() {
        super();
    }

    /**
     * Constructs an HDF5ReferenceException with the specified
     * detail message.
     *
     * @param s
     *            the detail message.
     */
    public HDF5ReferenceException(String s) {
        super(s);
    }
}


text:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<feed><tipo>Rua</tipo><logradouro>Dez</logradouro><bairro>Melvi</bairro><cidade>Praia Grande</cidade><uf>SP</uf><cep>11712280</cep></feed>


text:
package com.zsw.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

/**
 * AdminWebSecurityConfig
 *
 * @author ZhangShaowei on 2018/5/25 16:15
 **/
@Configuration
@EnableWebSecurity
public class AdminWebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/login.html", "/**/*.css", "/img/**", "/third-party/**", "/api/**").permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin().loginPage("/login.html").loginProcessingUrl("/login").permitAll()
                .and()
                .logout().logoutUrl("/logout")
                .and()
                .csrf().disable()
                .httpBasic();
    }

}


text:
package com.microsoft.bingads.v12.reporting;

import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
import javax.xml.bind.annotation.XmlType;

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

 *

 * <simpleType name="GeographicPerformanceReportColumn">
 *   <restriction base="{http://www.w3.org/2001/XMLSchema}string">
 *     <enumeration value="AccountName"/>
 *     <enumeration value="AccountNumber"/>
 *     <enumeration value="AccountId"/>
 *     <enumeration value="TimePeriod"/>
 *     <enumeration value="CampaignName"/>
 *     <enumeration value="CampaignId"/>
 *     <enumeration value="AdGroupName"/>
 *     <enumeration value="AdGroupId"/>
 *     <enumeration value="Country"/>
 *     <enumeration value="State"/>
 *     <enumeration value="MetroArea"/>
 *     <enumeration value="City"/>
 *     <enumeration value="CurrencyCode"/>
 *     <enumeration value="AdDistribution"/>
 *     <enumeration value="Impressions"/>
 *     <enumeration value="Clicks"/>
 *     <enumeration value="Ctr"/>
 *     <enumeration value="AverageCpc"/>
 *     <enumeration value="Spend"/>
 *     <enumeration value="AveragePosition"/>
 *     <enumeration value="ProximityTargetLocation"/>
 *     <enumeration value="Radius"/>
 *     <enumeration value="Language"/>
 *     <enumeration value="BidMatchType"/>
 *     <enumeration value="DeliveredMatchType"/>
 *     <enumeration value="Network"/>
 *     <enumeration value="TopVsOther"/>
 *     <enumeration value="DeviceType"/>
 *     <enumeration value="DeviceOS"/>
 *     <enumeration value="Assists"/>
 *     <enumeration value="Conversions"/>
 *     <enumeration value="ConversionRate"/>
 *     <enumeration value="Revenue"/>
 *     <enumeration value="ReturnOnAdSpend"/>
 *     <enumeration value="CostPerConversion"/>
 *     <enumeration value="CostPerAssist"/>
 *     <enumeration value="RevenuePerConversion"/>
 *     <enumeration value="RevenuePerAssist"/>
 *     <enumeration value="LocationType"/>
 *     <enumeration value="MostSpecificLocation"/>
 *     <enumeration value="AccountStatus"/>
 *     <enumeration value="CampaignStatus"/>
 *     <enumeration value="AdGroupStatus"/>
 *     <enumeration value="County"/>
 *     <enumeration value="PostalCode"/>
 *     <enumeration value="LocationId"/>
 *   </restriction>
 * </simpleType>
 *

 *
 */
@XmlType(name = "GeographicPerformanceReportColumn")
@XmlEnum
public enum GeographicPerformanceReportColumn {

    @XmlEnumValue("AccountName")
    ACCOUNT_NAME("AccountName"),
    @XmlEnumValue("AccountNumber")
    ACCOUNT_NUMBER("AccountNumber"),
    @XmlEnumValue("AccountId")
    ACCOUNT_ID("AccountId"),
    @XmlEnumValue("TimePeriod")
    TIME_PERIOD("TimePeriod"),
    @XmlEnumValue("CampaignName")
    CAMPAIGN_NAME("CampaignName"),
    @XmlEnumValue("CampaignId")
    CAMPAIGN_ID("CampaignId"),
    @XmlEnumValue("AdGroupName")
    AD_GROUP_NAME("AdGroupName"),
    @XmlEnumValue("AdGroupId")
    AD_GROUP_ID("AdGroupId"),
    @XmlEnumValue("Country")
    COUNTRY("Country"),
    @XmlEnumValue("State")
    STATE("State"),
    @XmlEnumValue("MetroArea")
    METRO_AREA("MetroArea"),
    @XmlEnumValue("City")
    CITY("City"),
    @XmlEnumValue("CurrencyCode")
    CURRENCY_CODE("CurrencyCode"),
    @XmlEnumValue("AdDistribution")
    AD_DISTRIBUTION("AdDistribution"),
    @XmlEnumValue("Impressions")
    IMPRESSIONS("Impressions"),
    @XmlEnumValue("Clicks")
    CLICKS("Clicks"),
    @XmlEnumValue("Ctr")
    CTR("Ctr"),
    @XmlEnumValue("AverageCpc")
    AVERAGE_CPC("AverageCpc"),
    @XmlEnumValue("Spend")
    SPEND("Spend"),
    @XmlEnumValue("AveragePosition")
    AVERAGE_POSITION("AveragePosition"),
    @XmlEnumValue("ProximityTargetLocation")
    PROXIMITY_TARGET_LOCATION("ProximityTargetLocation"),
    @XmlEnumValue("Radius")
    RADIUS("Radius"),
    @XmlEnumValue("Language")
    LANGUAGE("Language"),
    @XmlEnumValue("BidMatchType")
    BID_MATCH_TYPE("BidMatchType"),
    @XmlEnumValue("DeliveredMatchType")
    DELIVERED_MATCH_TYPE("DeliveredMatchType"),
    @XmlEnumValue("Network")
    NETWORK("Network"),
    @XmlEnumValue("TopVsOther")
    TOP_VS_OTHER("TopVsOther"),
    @XmlEnumValue("DeviceType")
    DEVICE_TYPE("DeviceType"),
    @XmlEnumValue("DeviceOS")
    DEVICE_OS("DeviceOS"),
    @XmlEnumValue("Assists")
    ASSISTS("Assists"),
    @XmlEnumValue("Conversions")
    CONVERSIONS("Conversions"),
    @XmlEnumValue("ConversionRate")
    CONVERSION_RATE("ConversionRate"),
    @XmlEnumValue("Revenue")
    REVENUE("Revenue"),
    @XmlEnumValue("ReturnOnAdSpend")
    RETURN_ON_AD_SPEND("ReturnOnAdSpend"),
    @XmlEnumValue("CostPerConversion")
    COST_PER_CONVERSION("CostPerConversion"),
    @XmlEnumValue("CostPerAssist")
    COST_PER_ASSIST("CostPerAssist"),
    @XmlEnumValue("RevenuePerConversion")
    REVENUE_PER_CONVERSION("RevenuePerConversion"),
    @XmlEnumValue("RevenuePerAssist")
    REVENUE_PER_ASSIST("RevenuePerAssist"),
    @XmlEnumValue("LocationType")
    LOCATION_TYPE("LocationType"),
    @XmlEnumValue("MostSpecificLocation")
    MOST_SPECIFIC_LOCATION("MostSpecificLocation"),
    @XmlEnumValue("AccountStatus")
    ACCOUNT_STATUS("AccountStatus"),
    @XmlEnumValue("CampaignStatus")
    CAMPAIGN_STATUS("CampaignStatus"),
    @XmlEnumValue("AdGroupStatus")
    AD_GROUP_STATUS("AdGroupStatus"),
    @XmlEnumValue("County")
    COUNTY("County"),
    @XmlEnumValue("PostalCode")
    POSTAL_CODE("PostalCode"),
    @XmlEnumValue("LocationId")
    LOCATION_ID("LocationId");
    private final String value;

    GeographicPerformanceReportColumn(String v) {
        value = v;
    }

    public String value() {
        return value;
    }

    public static GeographicPerformanceReportColumn fromValue(String v) {
        for (GeographicPerformanceReportColumn c: GeographicPerformanceReportColumn.values()) {
            if (c.value.equals(v)) {
                return c;
            }
        }
        throw new IllegalArgumentException(v);
    }

}


text:
using GalaSoft.MvvmLight.Threading;
using System;
using System.Threading;
using System.Threading.Tasks;
using Trippit.Helpers;
using Windows.Devices.Geolocation;
using Windows.Devices.Sensors;
using static Trippit.Services.GeolocationService;

namespace Trippit.Services
{
    public interface IGeolocationService
    {
        Task<GenericResult<Geoposition>> GetCurrentLocationAsync();
        LiveGeolocationToken BeginLiveUpdates();
        event GeolocatorPositionChangedHandler PositionChanged;
        event CompassHeadingChangedHandler HeadingChanged;
    }

    public class GeolocationService : IGeolocationService
    {
        private const uint InactiveUpdateInterval = 10000;
        private const uint ActiveUpdateInterval = 1000;
        private volatile bool _isUpdatingLive = false;

        private readonly Geolocator _geolocator;
        private readonly Compass _compass;
        private LiveGeolocationToken _token;

        public delegate void GeolocatorPositionChangedHandler(PositionChangedEventArgs args);
        public event GeolocatorPositionChangedHandler PositionChanged;

        public delegate void CompassHeadingChangedHandler(CompassReadingChangedEventArgs args);
        public event CompassHeadingChangedHandler HeadingChanged;

        public GeolocationService()
        {
            _geolocator = new Geolocator
            {
                ReportInterval = InactiveUpdateInterval
            };

            _compass = Compass.GetDefault();
        }

        /// <summary>
        /// Gets the user's current Geoposition, and prompts for access if necessary. Returns null on failure.
        /// </summary>
        /// <returns></returns>
        public async Task<GenericResult<Geoposition>> GetCurrentLocationAsync()
        {
            CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
            if(await GetAccessStatus(cts.Token) == GeolocationAccessStatus.Allowed)
            {
                try
                {
                    return new GenericResult<Geoposition>(await _geolocator.GetGeopositionAsync(TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(10)));
                }
                catch(Exception ex)
                {
                    //todo: log exception?
                    return GenericResult<Geoposition>.Fail;
                }
            }
            else
            {
                //todo: pop up a reason explaining why it didn't work.
                return GenericResult<Geoposition>.Fail;
            }
        }

        public LiveGeolocationToken BeginLiveUpdates()
        {
            if(_token != null)
            {
                EndLiveUpdates();
            }
            _isUpdatingLive = true;
            _geolocator.ReportInterval = ActiveUpdateInterval;
            _geolocator.PositionChanged += Geolocator_PositionChanged;
            if(_compass != null)
            {
                _compass.ReadingChanged += Compass_ReadingChanged;
            }

            _token = new LiveGeolocationToken(this);
            return _token;
        }

        public void EndLiveUpdates()
        {
            if (_isUpdatingLive)
            {
                _geolocator.ReportInterval = InactiveUpdateInterval;
                _geolocator.PositionChanged -= Geolocator_PositionChanged;
                if(_compass != null)
                {
                    _compass.ReadingChanged -= Compass_ReadingChanged;
                }
                _isUpdatingLive = false;
                _token.Dispose(); //In case this method is called directly, we still need to handle disposing.
            }
        }

        private async Task<GeolocationAccessStatus> GetAccessStatus(CancellationToken timeoutToken)
        {
            GeolocationAccessStatus accessStatus = GeolocationAccessStatus.Unspecified;
            TaskCompletionSource<bool> resultRetrieved = new TaskCompletionSource<bool>();

            DispatcherHelper.CheckBeginInvokeOnUI(
                async () =>
                {
                    try
                    {
                        accessStatus = await Geolocator.RequestAccessAsync().AsTask(timeoutToken);
                    }
                    catch(OperationCanceledException ex)
                    {
                        System.Diagnostics.Debug.WriteLine("Request access call timed out. Seems to be a CU only bug?");
                        accessStatus = GeolocationAccessStatus.Denied;
                    }
                    finally
                    {
                        resultRetrieved.SetResult(true);
                    }
                });

            await resultRetrieved.Task;
            return accessStatus;
        }

        private void Geolocator_PositionChanged(Geolocator sender, PositionChangedEventArgs args)
        {
            DispatcherHelper.CheckBeginInvokeOnUI(() => PositionChanged?.Invoke(args));
        }

        private void Compass_ReadingChanged(Compass sender, CompassReadingChangedEventArgs args)
        {
            DispatcherHelper.CheckBeginInvokeOnUI(() => HeadingChanged?.Invoke(args));
        }
    }
}


text:
package com.netflix.ribbon.examples;

import java.net.URI;
import java.util.List;
import java.util.concurrent.Future;

import com.google.common.reflect.TypeToken;
import com.netflix.client.AsyncClient;
import com.netflix.client.http.AsyncBufferingHttpClient;
import com.netflix.client.http.AsyncHttpClientBuilder;
import com.netflix.client.http.BufferedHttpResponseCallback;
import com.netflix.client.http.HttpRequest;
import com.netflix.client.http.HttpResponse;
import com.netflix.ribbon.examples.server.ServerResources.Person;

/**
 * An example that shows how deserialization work on the {@link AsyncClient}
 *
 * @author awang
 *
 */
public class GetWithDeserialization extends ExampleAppWithLocalResource {

    @edu.umd.cs.findbugs.annotations.SuppressWarnings("SE_BAD_FIELD")
    @SuppressWarnings("serial")
    @Override
    public void run() throws Exception {
        URI uri = new URI(SERVICE_URI + "testAsync/person");
        HttpRequest request = HttpRequest.newBuilder().uri(uri).build();
        AsyncBufferingHttpClient client = AsyncHttpClientBuilder.withApacheAsyncClient().buildBufferingClient();
        try {
            Future<HttpResponse> future = client.execute(request, new BufferedHttpResponseCallback() {
                @Override
                public void failed(Throwable e) {
                }

                @Override
                public void completed(HttpResponse response) {
                    try {
                        System.out.println(response.getEntity(Person.class));
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        response.close();
                    }
                }

                @Override
                public void cancelled() {
                }
            });
            future.get();
            request = HttpRequest.newBuilder().uri(SERVICE_URI + "testAsync/persons").build();
            future = client.execute(request, new BufferedHttpResponseCallback() {
                @Override
                public void failed(Throwable e) {
                }

                @Override
                public void completed(HttpResponse response) {
                    try {
                        System.out.println(response.getEntity(new TypeToken<List<Person>>(){}));
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        response.close();
                    }
                }

                @Override
                public void cancelled() {
                }
            });
            future.get();
        } finally {
            client.close();
        }
    }

    public static void main(String[] args) throws Exception {
        GetWithDeserialization app = new GetWithDeserialization();
        app.runApp();
    }
}


text:
package devops_rdc

//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.
//
// Code generated by Alibaba Cloud SDK Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

import (
	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
)

// GetTaskListFilter invokes the devops_rdc.GetTaskListFilter API synchronously
func (client *Client) GetTaskListFilter(request *GetTaskListFilterRequest) (response *GetTaskListFilterResponse, err error) {
	response = CreateGetTaskListFilterResponse()
	err = client.DoAction(request, response)
	return
}

// GetTaskListFilterWithChan invokes the devops_rdc.GetTaskListFilter API asynchronously
func (client *Client) GetTaskListFilterWithChan(request *GetTaskListFilterRequest) (<-chan *GetTaskListFilterResponse, <-chan error) {
	responseChan := make(chan *GetTaskListFilterResponse, 1)
	errChan := make(chan error, 1)
	err := client.AddAsyncTask(func() {
		defer close(responseChan)
		defer close(errChan)
		response, err := client.GetTaskListFilter(request)
		if err != nil {
			errChan <- err
		} else {
			responseChan <- response
		}
	})
	if err != nil {
		errChan <- err
		close(responseChan)
		close(errChan)
	}
	return responseChan, errChan
}

// GetTaskListFilterWithCallback invokes the devops_rdc.GetTaskListFilter API asynchronously
func (client *Client) GetTaskListFilterWithCallback(request *GetTaskListFilterRequest, callback func(response *GetTaskListFilterResponse, err error)) <-chan int {
	result := make(chan int, 1)
	err := client.AddAsyncTask(func() {
		var response *GetTaskListFilterResponse
		var err error
		defer close(result)
		response, err = client.GetTaskListFilter(request)
		callback(response, err)
		result <- 1
	})
	if err != nil {
		defer close(result)
		callback(nil, err)
		result <- 0
	}
	return result
}

// GetTaskListFilterRequest is the request struct for api GetTaskListFilter
type GetTaskListFilterRequest struct {
	*requests.RpcRequest
	InvolveMembers        string           `position:"Body" name:"InvolveMembers"`
	ExecutorId            string           `position:"Body" name:"ExecutorId"`
	OrderCondition        string           `position:"Body" name:"OrderCondition"`
	SprintId              string           `position:"Body" name:"SprintId"`
	Extra                 string           `position:"Body" name:"Extra"`
	PageSize              requests.Integer `position:"Body" name:"PageSize"`
	ScenarioFieldConfigId string           `position:"Body" name:"ScenarioFieldConfigId"`
	IsDone                requests.Boolean `position:"Body" name:"IsDone"`
	ObjectType            string           `position:"Body" name:"ObjectType"`
	ProjectId             string           `position:"Body" name:"ProjectId"`
	PageToken             string           `position:"Body" name:"PageToken"`
	Order                 string           `position:"Body" name:"Order"`
	TagId                 string           `position:"Body" name:"TagId"`
	TaskFlowStatusId      string           `position:"Body" name:"TaskFlowStatusId"`
	DueDateStart          string           `position:"Body" name:"DueDateStart"`
	CreatorId             string           `position:"Body" name:"CreatorId"`
	Priority              string           `position:"Body" name:"Priority"`
	DueDateEnd            string           `position:"Body" name:"DueDateEnd"`
	OrgId                 string           `position:"Body" name:"OrgId"`
	Name                  string           `position:"Body" name:"Name"`
}

// GetTaskListFilterResponse is the response struct for api GetTaskListFilter
type GetTaskListFilterResponse struct {
	*responses.BaseResponse
	ErrorMsg   string `json:"ErrorMsg" xml:"ErrorMsg"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
	ErrorCode  string `json:"ErrorCode" xml:"ErrorCode"`
	Successful string `json:"Successful" xml:"Successful"`
	Object     Object `json:"Object" xml:"Object"`
}

// CreateGetTaskListFilterRequest creates a request to invoke GetTaskListFilter API
func CreateGetTaskListFilterRequest() (request *GetTaskListFilterRequest) {
	request = &GetTaskListFilterRequest{
		RpcRequest: &requests.RpcRequest{},
	}
	request.InitWithApiInfo("devops-rdc", "2020-03-03", "GetTaskListFilter", "", "")
	request.Method = requests.POST
	return
}

// CreateGetTaskListFilterResponse creates a response to parse from GetTaskListFilter response
func CreateGetTaskListFilterResponse() (response *GetTaskListFilterResponse) {
	response = &GetTaskListFilterResponse{
		BaseResponse: &responses.BaseResponse{},
	}
	return
}


text:
<?php

namespace LINE\Tests\LINEBot;

use LINE\LINEBot\Response;
use PHPUnit\Framework\TestCase;

class ResponseTest extends TestCase
{
    public function testGetHeader()
    {
        $response = new Response(200, '{"body":"text"}', [
            'Content-Type' => 'application/json',
            'Content-Length' => '15',
        ]);
        $this->assertEquals('application/json', $response->getHeader('Content-Type'));
        $this->assertEquals('15', $response->getHeader('Content-Length'));
        $this->assertNull($response->getHeader('Not-Exists'));
    }

    public function testGetHeaders()
    {
        $response = new Response(200, '{"body":"text"}', [
            'Content-Type' => 'application/json',
            'Content-Length' => '15',
        ]);
        $headers = $response->getHeaders();
        $this->assertEquals(2, count($headers));
        $this->assertEquals('application/json', $headers['Content-Type']);
        $this->assertEquals('15', $headers['Content-Length']);
    }

    public function testIsSucceeded()
    {
        $response = new Response(200, '{"body":"text"}', [
            'Content-Type' => 'application/json',
            'Content-Length' => '15',
        ]);
        $this->assertEquals(true, $response->isSucceeded());

        $response = new Response(202, '{"body":"text"}', [
            'Content-Type' => 'application/json',
            'Content-Length' => '15',
        ]);
        $this->assertEquals(true, $response->isSucceeded());

        $response = new Response(299, '{"body":"text"}', [
            'Content-Type' => 'application/json',
            'Content-Length' => '15',
        ]);
        $this->assertEquals(true, $response->isSucceeded());

        $response = new Response(199, '{"body":"text"}', [
            'Content-Type' => 'application/json',
            'Content-Length' => '15',
        ]);
        $this->assertEquals(false, $response->isSucceeded());

        $response = new Response(300, '{"body":"text"}', [
            'Content-Type' => 'application/json',
            'Content-Length' => '15',
        ]);
        $this->assertEquals(false, $response->isSucceeded());
    }
}


text:
namespace System.Data.OleDb
{
    public sealed partial class OleDbCommand : System.Data.Common.DbCommand, System.Data.IDbCommand, System.ICloneable, System.IDisposable
    {
        public OleDbCommand() { }
        public OleDbCommand(string cmdText) { }
        public OleDbCommand(string cmdText, System.Data.OleDb.OleDbConnection connection) { }
        public OleDbCommand(string cmdText, System.Data.OleDb.OleDbConnection connection, System.Data.OleDb.OleDbTransaction transaction) { }
        [System.ComponentModel.DefaultValueAttribute("")]
        [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
        public override string CommandText { get { throw null; } set { } }
        public override int CommandTimeout { get { throw null; } set { } }
        [System.ComponentModel.DefaultValueAttribute(System.Data.CommandType.Text)]
        [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
        public override System.Data.CommandType CommandType { get { throw null; } set { } }
        [System.ComponentModel.DefaultValueAttribute(null)]
        public new System.Data.OleDb.OleDbConnection Connection { get { throw null; } set { } }
        protected override System.Data.Common.DbConnection DbConnection { get { throw null; } set { } }
        protected override System.Data.Common.DbParameterCollection DbParameterCollection { get { throw null; } }
        protected override System.Data.Common.DbTransaction DbTransaction { get { throw null; } set { } }
        [System.ComponentModel.BrowsableAttribute(false)]
        [System.ComponentModel.DefaultValueAttribute(true)]
        [System.ComponentModel.DesignOnlyAttribute(true)]
        public override bool DesignTimeVisible { get { throw null; } set { } }
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public new System.Data.OleDb.OleDbParameterCollection Parameters { get { throw null; } }
        [System.ComponentModel.BrowsableAttribute(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
        public new System.Data.OleDb.OleDbTransaction Transaction { get { throw null; } set { } }
        [System.ComponentModel.DefaultValueAttribute(System.Data.UpdateRowSource.Both)]
        public override System.Data.UpdateRowSource UpdatedRowSource { get { throw null; } set { } }
        public override void Cancel() { }
        public System.Data.OleDb.OleDbCommand Clone() { throw null; }
        protected override System.Data.Common.DbParameter CreateDbParameter() { throw null; }
        public new System.Data.OleDb.OleDbParameter CreateParameter() { throw null; }
        protected override void Dispose(bool disposing) { }
        protected override System.Data.Common.DbDataReader ExecuteDbDataReader(System.Data.CommandBehavior behavior) { throw null; }
        public override int ExecuteNonQuery() { throw null; }
        public new System.Data.OleDb.OleDbDataReader ExecuteReader() { throw null; }
        public new System.Data.OleDb.OleDbDataReader ExecuteReader(System.Data.CommandBehavior behavior) { throw null; }
        public override object ExecuteScalar() { throw null; }
        public override void Prepare() { }
        public void ResetCommandTimeout() { }
        System.Data.IDataReader System.Data.IDbCommand.ExecuteReader() { throw null; }
        System.Data.IDataReader System.Data.IDbCommand.ExecuteReader(System.Data.CommandBehavior behavior) { throw null; }
        object System.ICloneable.Clone() { throw null; }
    }
    public sealed partial class OleDbCommandBuilder : System.Data.Common.DbCommandBuilder
    {
        public OleDbCommandBuilder() { }
        public OleDbCommandBuilder(System.Data.OleDb.OleDbDataAdapter adapter) { }
        [System.ComponentModel.DefaultValueAttribute(null)]
        public new System.Data.OleDb.OleDbDataAdapter DataAdapter { get { throw null; } set { } }
        protected override void ApplyParameterInfo(System.Data.Common.DbParameter parameter, System.Data.DataRow datarow, System.Data.StatementType statementType, bool whereClause) { }
        public static void DeriveParameters(System.Data.OleDb.OleDbCommand command) { }
        public new System.Data.OleDb.OleDbCommand GetDeleteCommand() { throw null; }
        public new System.Data.OleDb.OleDbCommand GetDeleteCommand(bool useColumnsForParameterNames) { throw null; }
        public new System.Data.OleDb.OleDbCommand GetInsertCommand() { throw null; }
        public new System.Data.OleDb.OleDbCommand GetInsertCommand(bool useColumnsForParameterNames) { throw null; }
        protected override string GetParameterName(int parameterOrdinal) { throw null; }
        protected override string GetParameterName(string parameterName) { throw null; }
        protected override string GetParameterPlaceholder(int parameterOrdinal) { throw null; }
        public new System.Data.OleDb.OleDbCommand GetUpdateCommand() { throw null; }
        public new System.Data.OleDb.OleDbCommand GetUpdateCommand(bool useColumnsForParameterNames) { throw null; }
        public override string QuoteIdentifier(string unquotedIdentifier) { throw null; }
        public string QuoteIdentifier(string unquotedIdentifier, System.Data.OleDb.OleDbConnection connection) { throw null; }
        protected override void SetRowUpdatingHandler(System.Data.Common.DbDataAdapter adapter) { }
        public override string UnquoteIdentifier(string quotedIdentifier) { throw null; }
        public string UnquoteIdentifier(string quotedIdentifier, System.Data.OleDb.OleDbConnection connection) { throw null; }
    }
    [System.ComponentModel.DefaultEventAttribute("InfoMessage")]
    public sealed partial class OleDbConnection : System.Data.Common.DbConnection, System.Data.IDbConnection, System.ICloneable, System.IDisposable
    {
        public OleDbConnection() { }
        public OleDbConnection(string connectionString) { }
        [System.ComponentModel.DefaultValueAttribute("")]
        [System.ComponentModel.RecommendedAsConfigurableAttribute(true)]
        [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
        [System.ComponentModel.SettingsBindableAttribute(true)]
        public override string ConnectionString { get { throw null; } set { } }
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
        public override int ConnectionTimeout { get { throw null; } }
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
        public override string Database { get { throw null; } }
        [System.ComponentModel.BrowsableAttribute(true)]
        public override string DataSource { get { throw null; } }
        [System.ComponentModel.BrowsableAttribute(true)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
        public string Provider { get { throw null; } }
        public override string ServerVersion { get { throw null; } }
        [System.ComponentModel.BrowsableAttribute(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
        public override System.Data.ConnectionState State { get { throw null; } }
        public event System.Data.OleDb.OleDbInfoMessageEventHandler InfoMessage { add { } remove { } }
        protected override System.Data.Common.DbTransaction BeginDbTransaction(System.Data.IsolationLevel isolationLevel) { throw null; }
        public new System.Data.OleDb.OleDbTransaction BeginTransaction() { throw null; }
        public new System.Data.OleDb.OleDbTransaction BeginTransaction(System.Data.IsolationLevel isolationLevel) { throw null; }
        public override void ChangeDatabase(string value) { }
        public override void Close() { }
        public new System.Data.OleDb.OleDbCommand CreateCommand() { throw null; }
        protected override System.Data.Common.DbCommand CreateDbCommand() { throw null; }
        protected override void Dispose(bool disposing) { }
        public override void EnlistTransaction(System.Transactions.Transaction transaction) { }
        public System.Data.DataTable GetOleDbSchemaTable(System.Guid schema, object[] restrictions) { throw null; }
        public override System.Data.DataTable GetSchema() { throw null; }
        public override System.Data.DataTable GetSchema(string collectionName) { throw null; }
        public override System.Data.DataTable GetSchema(string collectionName, string[] restrictionValues) { throw null; }
        public override void Open() { }
        public static void ReleaseObjectPool() { }
        public void ResetState() { }
        object System.ICloneable.Clone() { throw null; }
    }
    [System.ComponentModel.DefaultPropertyAttribute("Provider")]
    [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
    public sealed partial class OleDbConnectionStringBuilder : System.Data.Common.DbConnectionStringBuilder
    {
        public OleDbConnectionStringBuilder() { }
        public OleDbConnectionStringBuilder(string connectionString) { }
        [System.ComponentModel.DisplayNameAttribute("Data Source")]
        [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
        public string DataSource { get { throw null; } set { } }
        [System.ComponentModel.DisplayNameAttribute("File Name")]
        [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
        public string FileName { get { throw null; } set { } }
        public override object this[string keyword] { get { throw null; } set { } }
        public override System.Collections.ICollection Keys { get { throw null; } }
        [System.ComponentModel.DisplayNameAttribute("Persist Security Info")]
        [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
        public bool PersistSecurityInfo { get { throw null; } set { } }
        public override void Clear() { }
        public override bool ContainsKey(string keyword) { throw null; }
        public override bool Remove(string keyword) { throw null; }
        public override bool TryGetValue(string keyword, out object value) { throw null; }
    }
    public sealed partial class OleDbDataAdapter : System.Data.Common.DbDataAdapter, System.Data.IDataAdapter, System.Data.IDbDataAdapter, System.ICloneable
    {
        public OleDbDataAdapter() { }
        public OleDbDataAdapter(System.Data.OleDb.OleDbCommand selectCommand) { }
        public OleDbDataAdapter(string selectCommandText, System.Data.OleDb.OleDbConnection selectConnection) { }
        public OleDbDataAdapter(string selectCommandText, string selectConnectionString) { }
        [System.ComponentModel.DefaultValueAttribute(null)]
        public new System.Data.OleDb.OleDbCommand DeleteCommand { get { throw null; } set { } }
        [System.ComponentModel.DefaultValueAttribute(null)]
        public new System.Data.OleDb.OleDbCommand InsertCommand { get { throw null; } set { } }
        [System.ComponentModel.DefaultValueAttribute(null)]
        public new System.Data.OleDb.OleDbCommand SelectCommand { get { throw null; } set { } }
        System.Data.IDbCommand System.Data.IDbDataAdapter.DeleteCommand { get { throw null; } set { } }
        System.Data.IDbCommand System.Data.IDbDataAdapter.InsertCommand { get { throw null; } set { } }
        System.Data.IDbCommand System.Data.IDbDataAdapter.SelectCommand { get { throw null; } set { } }
        System.Data.IDbCommand System.Data.IDbDataAdapter.UpdateCommand { get { throw null; } set { } }
        [System.ComponentModel.DefaultValueAttribute(null)]
        public new System.Data.OleDb.OleDbCommand UpdateCommand { get { throw null; } set { } }
        public event System.Data.OleDb.OleDbRowUpdatedEventHandler RowUpdated { add { } remove { } }
        public event System.Data.OleDb.OleDbRowUpdatingEventHandler RowUpdating { add { } remove { } }
        protected override System.Data.Common.RowUpdatedEventArgs CreateRowUpdatedEvent(System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping) { throw null; }
        protected override System.Data.Common.RowUpdatingEventArgs CreateRowUpdatingEvent(System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping) { throw null; }
        public int Fill(System.Data.DataSet dataSet, object ADODBRecordSet, string srcTable) { throw null; }
        public int Fill(System.Data.DataTable dataTable, object ADODBRecordSet) { throw null; }
        protected override void OnRowUpdated(System.Data.Common.RowUpdatedEventArgs value) { }
        protected override void OnRowUpdating(System.Data.Common.RowUpdatingEventArgs value) { }
        object System.ICloneable.Clone() { throw null; }
    }
    public sealed partial class OleDbDataReader : System.Data.Common.DbDataReader
    {
        internal OleDbDataReader() { }
        public override int Depth { get { throw null; } }
        public override int FieldCount { get { throw null; } }
        public override bool HasRows { get { throw null; } }
        public override bool IsClosed { get { throw null; } }
        public override object this[int index] { get { throw null; } }
        public override object this[string name] { get { throw null; } }
        public override int RecordsAffected { get { throw null; } }
        public override int VisibleFieldCount { get { throw null; } }
        public override void Close() { }
        public override bool GetBoolean(int ordinal) { throw null; }
        public override byte GetByte(int ordinal) { throw null; }
        public override long GetBytes(int ordinal, long dataIndex, byte[] buffer, int bufferIndex, int length) { throw null; }
        public override char GetChar(int ordinal) { throw null; }
        public override long GetChars(int ordinal, long dataIndex, char[] buffer, int bufferIndex, int length) { throw null; }
        public new System.Data.OleDb.OleDbDataReader GetData(int ordinal) { throw null; }
        public override string GetDataTypeName(int index) { throw null; }
        public override System.DateTime GetDateTime(int ordinal) { throw null; }
        protected override System.Data.Common.DbDataReader GetDbDataReader(int ordinal) { throw null; }
        public override decimal GetDecimal(int ordinal) { throw null; }
        public override double GetDouble(int ordinal) { throw null; }
        public override System.Collections.IEnumerator GetEnumerator() { throw null; }
        public override System.Type GetFieldType(int index) { throw null; }
        public override float GetFloat(int ordinal) { throw null; }
        public override System.Guid GetGuid(int ordinal) { throw null; }
        public override short GetInt16(int ordinal) { throw null; }
        public override int GetInt32(int ordinal) { throw null; }
        public override long GetInt64(int ordinal) { throw null; }
        public override string GetName(int index) { throw null; }
        public override int GetOrdinal(string name) { throw null; }
        public override System.Data.DataTable GetSchemaTable() { throw null; }
        public override string GetString(int ordinal) { throw null; }
        public System.TimeSpan GetTimeSpan(int ordinal) { throw null; }
        public override object GetValue(int ordinal) { throw null; }
        public override int GetValues(object[] values) { throw null; }
        public override bool IsDBNull(int ordinal) { throw null; }
        public override bool NextResult() { throw null; }
        public override bool Read() { throw null; }
    }
    public sealed partial class OleDbEnumerator
    {
        public OleDbEnumerator() { }
        public System.Data.DataTable GetElements() { throw null; }
        public static System.Data.OleDb.OleDbDataReader GetEnumerator(System.Type type) { throw null; }
        public static System.Data.OleDb.OleDbDataReader GetRootEnumerator() { throw null; }
    }
    public sealed partial class OleDbError
    {
        internal OleDbError() { }
        public string Message { get { throw null; } }
        public int NativeError { get { throw null; } }
        public string Source { get { throw null; } }
        public string SQLState { get { throw null; } }
        public override string ToString() { throw null; }
    }
    [System.ComponentModel.ListBindableAttribute(false)]
    public sealed partial class OleDbErrorCollection : System.Collections.ICollection, System.Collections.IEnumerable
    {
        internal OleDbErrorCollection() { }
        public int Count { get { throw null; } }
        public System.Data.OleDb.OleDbError this[int index] { get { throw null; } }
        bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
        object System.Collections.ICollection.SyncRoot { get { throw null; } }
        public void CopyTo(System.Array array, int index) { }
        public void CopyTo(System.Data.OleDb.OleDbError[] array, int index) { }
        public System.Collections.IEnumerator GetEnumerator() { throw null; }
    }
    public sealed partial class OleDbException : System.Data.Common.DbException
    {
        internal OleDbException() { }
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public System.Data.OleDb.OleDbErrorCollection Errors { get { throw null; } }
        public override void GetObjectData(System.Runtime.Serialization.SerializationInfo si, System.Runtime.Serialization.StreamingContext context) { }
    }
    public sealed partial class OleDbFactory : System.Data.Common.DbProviderFactory
    {
        internal OleDbFactory() { }
        public static readonly System.Data.OleDb.OleDbFactory Instance;
        public override System.Data.Common.DbCommand CreateCommand() { throw null; }
        public override System.Data.Common.DbCommandBuilder CreateCommandBuilder() { throw null; }
        public override System.Data.Common.DbConnection CreateConnection() { throw null; }
        public override System.Data.Common.DbConnectionStringBuilder CreateConnectionStringBuilder() { throw null; }
        public override System.Data.Common.DbDataAdapter CreateDataAdapter() { throw null; }
        public override System.Data.Common.DbParameter CreateParameter() { throw null; }
    }
    public sealed partial class OleDbInfoMessageEventArgs : System.EventArgs
    {
        internal OleDbInfoMessageEventArgs() { }
        public int ErrorCode { get { throw null; } }
        public System.Data.OleDb.OleDbErrorCollection Errors { get { throw null; } }
        public string Message { get { throw null; } }
        public string Source { get { throw null; } }
        public override string ToString() { throw null; }
    }
    public delegate void OleDbInfoMessageEventHandler(object sender, System.Data.OleDb.OleDbInfoMessageEventArgs e);
    public enum OleDbLiteral
    {
        Invalid = 0,
        Binary_Literal = 1,
        Catalog_Name = 2,
        Catalog_Separator = 3,
        Char_Literal = 4,
        Column_Alias = 5,
        Column_Name = 6,
        Correlation_Name = 7,
        Cursor_Name = 8,
        Escape_Percent_Prefix = 9,
        Escape_Underscore_Prefix = 10,
        Index_Name = 11,
        Like_Percent = 12,
        Like_Underscore = 13,
        Procedure_Name = 14,
        Quote_Prefix = 15,
        Schema_Name = 16,
        Table_Name = 17,
        Text_Command = 18,
        User_Name = 19,
        View_Name = 20,
        Cube_Name = 21,
        Dimension_Name = 22,
        Hierarchy_Name = 23,
        Level_Name = 24,
        Member_Name = 25,
        Property_Name = 26,
        Schema_Separator = 27,
        Quote_Suffix = 28,
        Escape_Percent_Suffix = 29,
        Escape_Underscore_Suffix = 30,
    }
    public static partial class OleDbMetaDataCollectionNames
    {
        public static readonly string Catalogs;
        public static readonly string Collations;
        public static readonly string Columns;
        public static readonly string Indexes;
        public static readonly string ProcedureColumns;
        public static readonly string ProcedureParameters;
        public static readonly string Procedures;
        public static readonly string Tables;
        public static readonly string Views;
    }
    public static partial class OleDbMetaDataColumnNames
    {
        public static readonly string BooleanFalseLiteral;
        public static readonly string BooleanTrueLiteral;
        public static readonly string DateTimeDigits;
        public static readonly string NativeDataType;
    }
    public sealed partial class OleDbParameter : System.Data.Common.DbParameter, System.Data.IDataParameter, System.Data.IDbDataParameter, System.ICloneable
    {
        public OleDbParameter() { }
        public OleDbParameter(string name, System.Data.OleDb.OleDbType dataType) { }
        public OleDbParameter(string name, System.Data.OleDb.OleDbType dataType, int size) { }
        public OleDbParameter(string parameterName, System.Data.OleDb.OleDbType dbType, int size, System.Data.ParameterDirection direction, bool isNullable, byte precision, byte scale, string srcColumn, System.Data.DataRowVersion srcVersion, object value) { }
        public OleDbParameter(string parameterName, System.Data.OleDb.OleDbType dbType, int size, System.Data.ParameterDirection direction, byte precision, byte scale, string sourceColumn, System.Data.DataRowVersion sourceVersion, bool sourceColumnNullMapping, object value) { }
        public OleDbParameter(string name, System.Data.OleDb.OleDbType dataType, int size, string srcColumn) { }
        public OleDbParameter(string name, object value) { }
        public override System.Data.DbType DbType { get { throw null; } set { } }
        [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
        public override System.Data.ParameterDirection Direction { get { throw null; } set { } }
        public override bool IsNullable { get { throw null; } set { } }
        [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
        [System.Data.Common.DbProviderSpecificTypePropertyAttribute(true)]
        public System.Data.OleDb.OleDbType OleDbType { get { throw null; } set { } }
        public override string ParameterName { get { throw null; } set { } }
        [System.ComponentModel.DefaultValueAttribute((byte)0)]
        public new byte Precision { get { throw null; } set { } }
        [System.ComponentModel.DefaultValueAttribute((byte)0)]
        public new byte Scale { get { throw null; } set { } }
        public override int Size { get { throw null; } set { } }
        public override string SourceColumn { get { throw null; } set { } }
        public override bool SourceColumnNullMapping { get { throw null; } set { } }
        public override System.Data.DataRowVersion SourceVersion { get { throw null; } set { } }
        [System.ComponentModel.RefreshPropertiesAttribute(System.ComponentModel.RefreshProperties.All)]
        [System.ComponentModel.TypeConverterAttribute(typeof(System.ComponentModel.StringConverter))]
        public override object Value { get { throw null; } set { } }
        public override void ResetDbType() { }
        public void ResetOleDbType() { }
        object System.ICloneable.Clone() { throw null; }
        public override string ToString() { throw null; }
    }
    public sealed partial class OleDbParameterCollection : System.Data.Common.DbParameterCollection
    {
        internal OleDbParameterCollection() { }
        public override int Count { get { throw null; } }
        public override bool IsFixedSize { get { throw null; } }
        public override bool IsReadOnly { get { throw null; } }
        public override bool IsSynchronized { get { throw null; } }
        [System.ComponentModel.BrowsableAttribute(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
        public new System.Data.OleDb.OleDbParameter this[int index] { get { throw null; } set { } }
        [System.ComponentModel.BrowsableAttribute(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Hidden)]
        public new System.Data.OleDb.OleDbParameter this[string parameterName] { get { throw null; } set { } }
        public override object SyncRoot { get { throw null; } }
        public System.Data.OleDb.OleDbParameter Add(System.Data.OleDb.OleDbParameter value) { throw null; }
        public override int Add(object value) { throw null; }
        public System.Data.OleDb.OleDbParameter Add(string parameterName, System.Data.OleDb.OleDbType oleDbType) { throw null; }
        public System.Data.OleDb.OleDbParameter Add(string parameterName, System.Data.OleDb.OleDbType oleDbType, int size) { throw null; }
        public System.Data.OleDb.OleDbParameter Add(string parameterName, System.Data.OleDb.OleDbType oleDbType, int size, string sourceColumn) { throw null; }
        public System.Data.OleDb.OleDbParameter Add(string parameterName, object value) { throw null; }
        public override void AddRange(System.Array values) { }
        public void AddRange(System.Data.OleDb.OleDbParameter[] values) { }
        public System.Data.OleDb.OleDbParameter AddWithValue(string parameterName, object value) { throw null; }
        public override void Clear() { }
        public bool Contains(System.Data.OleDb.OleDbParameter value) { throw null; }
        public override bool Contains(object value) { throw null; }
        public override bool Contains(string value) { throw null; }
        public override void CopyTo(System.Array array, int index) { }
        public void CopyTo(System.Data.OleDb.OleDbParameter[] array, int index) { }
        public override System.Collections.IEnumerator GetEnumerator() { throw null; }
        protected override System.Data.Common.DbParameter GetParameter(int index) { throw null; }
        protected override System.Data.Common.DbParameter GetParameter(string parameterName) { throw null; }
        public int IndexOf(System.Data.OleDb.OleDbParameter value) { throw null; }
        public override int IndexOf(object value) { throw null; }
        public override int IndexOf(string parameterName) { throw null; }
        public void Insert(int index, System.Data.OleDb.OleDbParameter value) { }
        public override void Insert(int index, object value) { }
        public void Remove(System.Data.OleDb.OleDbParameter value) { }
        public override void Remove(object value) { }
        public override void RemoveAt(int index) { }
        public override void RemoveAt(string parameterName) { }
        protected override void SetParameter(int index, System.Data.Common.DbParameter value) { }
        protected override void SetParameter(string parameterName, System.Data.Common.DbParameter value) { }
    }
    public sealed partial class OleDbRowUpdatedEventArgs : System.Data.Common.RowUpdatedEventArgs
    {
        public OleDbRowUpdatedEventArgs(System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping) : base (default(System.Data.DataRow), default(System.Data.IDbCommand), default(System.Data.StatementType), default(System.Data.Common.DataTableMapping)) { }
        public new System.Data.OleDb.OleDbCommand Command { get { throw null; } }
    }
    public delegate void OleDbRowUpdatedEventHandler(object sender, System.Data.OleDb.OleDbRowUpdatedEventArgs e);
    public sealed partial class OleDbRowUpdatingEventArgs : System.Data.Common.RowUpdatingEventArgs
    {
        public OleDbRowUpdatingEventArgs(System.Data.DataRow dataRow, System.Data.IDbCommand command, System.Data.StatementType statementType, System.Data.Common.DataTableMapping tableMapping) : base (default(System.Data.DataRow), default(System.Data.IDbCommand), default(System.Data.StatementType), default(System.Data.Common.DataTableMapping)) { }
        protected override System.Data.IDbCommand BaseCommand { get { throw null; } set { } }
        public new System.Data.OleDb.OleDbCommand Command { get { throw null; } set { } }
    }
    public delegate void OleDbRowUpdatingEventHandler(object sender, System.Data.OleDb.OleDbRowUpdatingEventArgs e);
    public sealed partial class OleDbSchemaGuid
    {
        public static readonly System.Guid Assertions;
        public static readonly System.Guid Catalogs;
        public static readonly System.Guid Character_Sets;
        public static readonly System.Guid Check_Constraints;
        public static readonly System.Guid Check_Constraints_By_Table;
        public static readonly System.Guid Collations;
        public static readonly System.Guid Columns;
        public static readonly System.Guid Column_Domain_Usage;
        public static readonly System.Guid Column_Privileges;
        public static readonly System.Guid Constraint_Column_Usage;
        public static readonly System.Guid Constraint_Table_Usage;
        public static readonly System.Guid DbInfoKeywords;
        public static readonly System.Guid DbInfoLiterals;
        public static readonly System.Guid Foreign_Keys;
        public static readonly System.Guid Indexes;
        public static readonly System.Guid Key_Column_Usage;
        public static readonly System.Guid Primary_Keys;
        public static readonly System.Guid Procedures;
        public static readonly System.Guid Procedure_Columns;
        public static readonly System.Guid Procedure_Parameters;
        public static readonly System.Guid Provider_Types;
        public static readonly System.Guid Referential_Constraints;
        public static readonly System.Guid SchemaGuids;
        public static readonly System.Guid Schemata;
        public static readonly System.Guid Sql_Languages;
        public static readonly System.Guid Statistics;
        public static readonly System.Guid Tables;
        public static readonly System.Guid Tables_Info;
        public static readonly System.Guid Table_Constraints;
        public static readonly System.Guid Table_Privileges;
        public static readonly System.Guid Table_Statistics;
        public static readonly System.Guid Translations;
        public static readonly System.Guid Trustee;
        public static readonly System.Guid Usage_Privileges;
        public static readonly System.Guid Views;
        public static readonly System.Guid View_Column_Usage;
        public static readonly System.Guid View_Table_Usage;
        public OleDbSchemaGuid() { }
    }
    public sealed partial class OleDbTransaction : System.Data.Common.DbTransaction
    {
        internal OleDbTransaction() { }
        public new System.Data.OleDb.OleDbConnection Connection { get { throw null; } }
        protected override System.Data.Common.DbConnection DbConnection { get { throw null; } }
        public override System.Data.IsolationLevel IsolationLevel { get { throw null; } }
        public System.Data.OleDb.OleDbTransaction Begin() { throw null; }
        public System.Data.OleDb.OleDbTransaction Begin(System.Data.IsolationLevel isolevel) { throw null; }
        public override void Commit() { }
        protected override void Dispose(bool disposing) { }
        public override void Rollback() { }
    }
    public enum OleDbType
    {
        Empty = 0,
        SmallInt = 2,
        Integer = 3,
        Single = 4,
        Double = 5,
        Currency = 6,
        Date = 7,
        BSTR = 8,
        IDispatch = 9,
        Error = 10,
        Boolean = 11,
        Variant = 12,
        IUnknown = 13,
        Decimal = 14,
        TinyInt = 16,
        UnsignedTinyInt = 17,
        UnsignedSmallInt = 18,
        UnsignedInt = 19,
        BigInt = 20,
        UnsignedBigInt = 21,
        Filetime = 64,
        Guid = 72,
        Binary = 128,
        Char = 129,
        WChar = 130,
        Numeric = 131,
        DBDate = 133,
        DBTime = 134,
        DBTimeStamp = 135,
        PropVariant = 138,
        VarNumeric = 139,
        VarChar = 200,
        LongVarChar = 201,
        VarWChar = 202,
        LongVarWChar = 203,
        VarBinary = 204,
        LongVarBinary = 205,
    }
}


text:
package si.gos.transpiler.ui.controller;

import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.graphics.Image;

import si.gos.transpiler.core.model.PathEntry;
import si.gos.transpiler.ui.TranspilerUIPluginImages;

public class PathEntryController extends LabelProvider implements
		IStructuredContentProvider, ITableLabelProvider {

	protected List<PathEntry> paths;

	private Image file = TranspilerUIPluginImages.FILE.createImage();
	private Image folder = TranspilerUIPluginImages.FOLDER.createImage();

	@SuppressWarnings("unchecked")
	@Override
	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		paths = (List<PathEntry>) newInput;
	}

	@Override
	public Object[] getElements(Object inputElement) {
		return paths.toArray();
	}

	public int indexOf(PathEntry entry) {
		return paths.indexOf(entry);
	}

	public void add(PathEntry entry) {
		paths.add(entry);
	}

	public void remove(PathEntry entry) {
		paths.remove(entry);
	}

	public void update(int index, PathEntry entry) {
		paths.set(index, entry);
	}

	@Override
	public String getText(Object element) {
		if (element instanceof IResource) {
			return ((IResource)element).getProjectRelativePath().toString();
		}
		return super.getText(element);
	}

	@Override
	public Image getImage(Object element) {
		if (element instanceof IFolder) {
			return folder;
		} else if (element instanceof IFile) {
			return file;
		}
		return super.getImage(element);
	}

	@Override
	public Image getColumnImage(Object element, int columnIndex) {
		switch (columnIndex) {
		case 0:
			return getImage(((PathEntry)element).getSource());

		case 1:
			return getImage(((PathEntry)element).getDestination());
		}

		return super.getImage(element);
	}

	@Override
	public String getColumnText(Object element, int columnIndex) {
		switch (columnIndex) {
		case 0:
			return getText(((PathEntry)element).getSource());

		case 1:
			return getText(((PathEntry)element).getDestination());
		}

		return super.getText(element);
	}

}


text:
using Stashbox.Utils.Data;
using System.Linq.Expressions;
using System.Reflection.Emit;

namespace Stashbox.Expressions.Compile
{
    internal class CompilerContext
    {
        public readonly ExpandableArray<Expression> DefinedVariables;

        public readonly bool HasCapturedVariablesArgument;

        public readonly bool IsNestedLambda;

        public readonly ExpandableArray<object> Constants;

        public readonly ExpandableArray<Expression> CapturedArguments;

        public readonly Closure? Target;

        public LocalBuilder[]? LocalBuilders;

        public LocalBuilder? CapturedArgumentsHolderVariable;

        public readonly ExpandableArray<LambdaExpression, NestedLambda> NestedLambdas;

        public readonly bool HasClosure;

        public CompilerContext(Closure? target,
            ExpandableArray<object> constants,
            ExpandableArray<Expression> definedVariables,
            ExpandableArray<Expression> capturedArguments,
            ExpandableArray<LambdaExpression, NestedLambda> nestedLambdas)
        {
            this.Target = target;
            this.Constants = constants;
            this.DefinedVariables = definedVariables;
            this.CapturedArguments = capturedArguments;
            this.NestedLambdas = nestedLambdas;
            this.HasClosure = target != null;
            this.HasCapturedVariablesArgument = capturedArguments.Length > 0;
        }

        private CompilerContext(ExpandableArray<Expression> definedVariables,
            bool hasCapturedVariablesArgument,
            bool isNestedLambda,
            ExpandableArray<object> constants,
            ExpandableArray<Expression> capturedArguments,
            Closure? target,
            LocalBuilder[]? localBuilders,
            LocalBuilder? capturedArgumentsHolderVariable,
            ExpandableArray<LambdaExpression, NestedLambda> nestedLambdas,
            bool hasClosure)
        {
            DefinedVariables = definedVariables;
            HasCapturedVariablesArgument = hasCapturedVariablesArgument;
            IsNestedLambda = isNestedLambda;
            Constants = constants;
            CapturedArguments = capturedArguments;
            Target = target;
            LocalBuilders = localBuilders;
            CapturedArgumentsHolderVariable = capturedArgumentsHolderVariable;
            NestedLambdas = nestedLambdas;
            HasClosure = hasClosure;
        }

        public CompilerContext Clone(ExpandableArray<Expression> definedVariables, bool isNestedLambda, bool hasCapturedArgument) =>
            new(definedVariables,
                hasCapturedArgument,
                isNestedLambda,
                this.Constants,
                this.CapturedArguments,
                this.Target,
                this.LocalBuilders,
                this.CapturedArgumentsHolderVariable,
                this.NestedLambdas,
                this.HasClosure);
    }
}