All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.viaoa.sync.OASyncDelegate Maven / Gradle / Ivy

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

import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.viaoa.hub.Hub;
import com.viaoa.hub.HubDetailDelegate;
import com.viaoa.object.OALinkInfo;
import com.viaoa.object.OAObject;
import com.viaoa.object.OAObjectDelegate;
import com.viaoa.object.OAThreadLocalDelegate;
import com.viaoa.remote.multiplexer.OARemoteThreadDelegate;
import com.viaoa.remote.multiplexer.info.RequestInfo;
import com.viaoa.sync.remote.*;

/**
 * OASync is a group of classes that use OAObject/Hub (observable) and RemoteMultiplexer classes
 * (distributed) to perform remote updating.
 *
 * Used for the OA distributed, synchronization that keeps OAObject/Models/Hubs/etc in sync across
 * multiple servers.
 * 
 * This is used to: determine if an app is a client or server, to know it's connection information, used
 * by OAObject for prop changes, etc, used by Hub for add/remove/etc changes, to know if the current
 * thread is an OARemoteThread that is processing a sync message, to get the current RequestInfo, which
 * is the currently executing remote method call
 *
 * This is internally used by OA to keep application models synchronized between the server and 0 or
 * more clients.
 * 
 * @author vvia
 */
public class OASyncDelegate {
    private static Logger LOG = Logger.getLogger(OASyncDelegate.class.getName());

    public static final Package ObjectPackage = Object.class.getPackage();

    /**
     * Used client to communicate with server.
     */
    private static final ConcurrentHashMap hmRemoteServer = new ConcurrentHashMap();
    private static RemoteServerInterface remoteServerInterface;

    /**
     * Used by OAObject/Hub CS methods to keep the model objects in sync across servers.
     */
    private static final ConcurrentHashMap hmRemoteSync = new ConcurrentHashMap();
    private static RemoteSyncInterface remoteSyncInterface;
    
    /**
     * Client side session methods.
     */
    private static final ConcurrentHashMap hmRemoteSession = new ConcurrentHashMap();
    private static RemoteSessionInterface remoteSessionInterface;

    /**
     * used to get data from the server.
     */
    private static final ConcurrentHashMap hmRemoteClient = new ConcurrentHashMap();
    private static RemoteClientInterface remoteClientInterface;

    /**
     * Sync client that connects to the server and allows OAModels (OAObjects, Hub) to be automatically
     * in sync.
     */
    private static final ConcurrentHashMap hmSyncClient = new ConcurrentHashMap();
    private static OASyncClient oaSyncClient;

    /**
     * Sync server that allows client connections, so that OAModels (OAObjects, Hub) are automatically
     * in sync.
     */
    private static final ConcurrentHashMap hmSyncServer = new ConcurrentHashMap();
    private static OASyncServer oaSyncServer;

    private static final ConcurrentHashMap hmClassPackage = new ConcurrentHashMap();

    public static Package getPackage(Class c) {
        Package p;
        if (c == null) p = ObjectPackage;
        else {
            p = hmClassPackage.get(c);
            if (p == null) {
                p = c.getPackage();
                hmClassPackage.put(c, p);
            }
        }
        return p;
    }

    // ========= SyncServer ============
    public static OASyncServer getSyncServer() {
        if (oaSyncServer != null) return oaSyncServer;
        return getSyncServer(getPackage(null));
    }
    public static OASyncServer getSyncServer(Class c) {
        if (oaSyncServer != null) return oaSyncServer;
        return getSyncServer(getPackage(c));
    }
    public static OASyncServer getSyncServer(OAObject obj) {
        if (oaSyncServer != null) return oaSyncServer;
        Class c = obj == null ? null : obj.getClass();
        return getSyncServer(getPackage(c));
    }
    public static OASyncServer getSyncServer(Hub h) {
        if (oaSyncServer != null) return oaSyncServer;
        Class c;
        if (h != null) c = h.getObjectClass();
        else c = null;
        return getSyncServer(getPackage(c));
    }
    public static OASyncServer getSyncServer(Package p) {
        if (oaSyncServer != null) return oaSyncServer;
        if (p == null) p = ObjectPackage;
        OASyncServer ss = hmSyncServer.get(p);
        if (ss == null && p != ObjectPackage) ss = hmSyncServer.get(ObjectPackage);
        return ss;
    }
    public static void setSyncServer(OASyncServer ss) {
        setSyncServer(null, ss);
    }
    public static void setSyncServer(Package p, OASyncServer ss) {
        if (p != null && p != ObjectPackage) {
            if (ss != null) {
                hmSyncServer.put(p, ss);
                if (hmSyncServer.get(ObjectPackage) == null) hmSyncServer.put(ObjectPackage, ss);
                if (oaSyncServer == null) oaSyncServer = ss; 
                else if (oaSyncServer != ss) oaSyncServer = null;
            }
            else {
                OASyncServer ssx = hmSyncServer.remove(p);
                if (hmSyncServer.get(ObjectPackage) == ssx) hmSyncServer.remove(ObjectPackage);
                if (oaSyncServer == ssx) oaSyncServer = null;
            }
        }
        else {
            p = ObjectPackage;
            if (ss != null) {
                if (oaSyncServer == null) oaSyncServer = ss; 
                else if (oaSyncServer != ss) oaSyncServer = null;
                hmSyncServer.put(p, ss);
            }
            else {
                OASyncServer ssx = hmSyncServer.remove(p);
                if (oaSyncServer == ssx) oaSyncServer = null;
            }
        }
    }

    // ========= SyncClient ============
    public static OASyncClient getSyncClient() {
        if (oaSyncClient != null) return oaSyncClient;
        return getSyncClient(getPackage(null));
    }
    public static OASyncClient getSyncClient(Class c) {
        if (oaSyncClient != null) return oaSyncClient;
        return getSyncClient(getPackage(c));
    }
    public static OASyncClient getSyncClient(OAObject obj) {
        if (oaSyncClient != null) return oaSyncClient;
        Class c = obj == null ? null : obj.getClass();
        return getSyncClient(getPackage(c));
    }
    public static OASyncClient getSyncClient(Hub h) {
        if (oaSyncClient != null) return oaSyncClient;
        Class c;
        if (h != null) c = h.getObjectClass();
        else c = null;
        return getSyncClient(getPackage(c));
    }
    public static OASyncClient getSyncClient(Package p) {
        if (oaSyncClient != null) return oaSyncClient;
        if (p == null) p = ObjectPackage;
        OASyncClient sc = hmSyncClient.get(p);
        if (sc == null && p != ObjectPackage) sc = hmSyncClient.get(ObjectPackage);
        return sc;
    }
    public static void setSyncClient(OASyncClient sc) {
        setSyncClient(null, sc);
    }
    public static void setSyncClient(Package p, OASyncClient sc) {
        if (p != null && p != ObjectPackage) {
            if (sc != null) {
                hmSyncClient.put(p, sc);
                if (hmSyncClient.get(ObjectPackage) == null) hmSyncClient.put(ObjectPackage, sc);
                if (oaSyncClient == null) oaSyncClient = sc; 
                else if (oaSyncClient != sc) oaSyncClient = null;
            }
            else {
                OASyncClient ssx = hmSyncClient.remove(p);
                if (hmSyncClient.get(ObjectPackage) == ssx) hmSyncClient.remove(ObjectPackage);
                if (oaSyncClient == sc) oaSyncClient = null;
            }
        }
        else {
            p = ObjectPackage;
            if (sc != null) {
                if (oaSyncClient == null) oaSyncClient = sc; 
                else if (oaSyncClient != sc) oaSyncClient = null;
                hmSyncClient.put(p, sc);
            }
            else {
                OASyncClient scx = hmSyncClient.remove(p);
                if (oaSyncClient == scx) oaSyncClient = null;
            }
        }
    }

    // ========= RemoteServerInterface ============
    public static RemoteServerInterface getRemoteServer() {
        if (remoteServerInterface != null) return remoteServerInterface;
        return getRemoteServer(getPackage(null));
    }
    public static RemoteServerInterface getRemoteServer(Class c) {
        if (remoteServerInterface != null) return remoteServerInterface;
        return getRemoteServer(getPackage(c));
    }
    public static RemoteServerInterface getRemoteServer(OAObject obj) {
        if (remoteServerInterface != null) return remoteServerInterface;
        Class c = obj == null ? null : obj.getClass();
        return getRemoteServer(getPackage(c));
    }
    public static RemoteServerInterface getRemoteServer(Hub h) {
        if (remoteServerInterface != null) return remoteServerInterface;
        Class c;
        if (h != null) c = h.getObjectClass();
        else c = null;
        return getRemoteServer(getPackage(c));
    }
    public static RemoteServerInterface getRemoteServer(Package p) {
        if (remoteServerInterface != null) return remoteServerInterface;
        if (p == null) p = ObjectPackage;
        RemoteServerInterface rs = hmRemoteServer.get(p);
        if (rs == null && p != ObjectPackage) rs = hmRemoteServer.get(ObjectPackage);
        return rs;
    }
    public static void setRemoteServer(RemoteServerInterface rs) {
        setRemoteServer(null, rs);
    }
    public static void setRemoteServer(Package p, RemoteServerInterface rs) {
        if (p != null && p != ObjectPackage) {
            if (rs != null) {
                hmRemoteServer.put(p, rs);
                if (hmRemoteServer.get(ObjectPackage) == null) hmRemoteServer.put(ObjectPackage, rs);
                if (remoteServerInterface == null) remoteServerInterface = rs; 
                else if (remoteServerInterface != rs) remoteServerInterface = null;
            }
            else {
                RemoteServerInterface rsx = hmRemoteServer.remove(p);
                if (hmRemoteServer.get(ObjectPackage) == rsx) hmRemoteServer.remove(ObjectPackage);
                if (remoteServerInterface == rsx) remoteServerInterface = null;
            }
        }
        else {
            p = ObjectPackage;
            if (rs != null) {
                hmRemoteServer.put(p, rs);
                if (remoteServerInterface == null) remoteServerInterface = rs; 
                else if (remoteServerInterface != rs) remoteServerInterface = null;
            }
            else {
                RemoteServerInterface rsx = hmRemoteServer.remove(p);
                if (remoteServerInterface == rsx) remoteServerInterface = null;
            }
        }
    }
    
    
    
    // ========= RemoteSessionInterface ============
    public static RemoteSessionInterface getRemoteSession() {
        if (remoteSessionInterface != null) return remoteSessionInterface;
        return getRemoteSession(getPackage(null));
    }
    public static RemoteSessionInterface getRemoteSession(Class c) {
        if (remoteSessionInterface != null) return remoteSessionInterface;
        return getRemoteSession(getPackage(c));
    }
    public static RemoteSessionInterface getRemoteSession(OAObject obj) {
        if (remoteSessionInterface != null) return remoteSessionInterface;
        Class c = obj == null ? null : obj.getClass();
        return getRemoteSession(getPackage(c));
    }
    public static RemoteSessionInterface getRemoteSession(Hub h) {
        if (remoteSessionInterface != null) return remoteSessionInterface;
        Class c;
        if (h != null) c = h.getObjectClass();
        else c = null;
        return getRemoteSession(getPackage(c));
    }
    public static RemoteSessionInterface getRemoteSession(Package p) {
        if (remoteSessionInterface != null) return remoteSessionInterface;
        if (p == null) p = ObjectPackage;
        RemoteSessionInterface rs = hmRemoteSession.get(p);
        if (rs == null && p != ObjectPackage) rs = hmRemoteSession.get(ObjectPackage);
        return rs;
    }
    public static void setRemoteSession(RemoteSessionInterface rs) {
        setRemoteSession(null, rs);
    }
    public static void setRemoteSession(Package p, RemoteSessionInterface rs) {
        if (p != null && p != ObjectPackage) {
            if (rs != null) {
                hmRemoteSession.put(p, rs);
                if (hmRemoteSession.get(ObjectPackage) == null) hmRemoteSession.put(ObjectPackage, rs);
                if (remoteSessionInterface == null) remoteSessionInterface = rs; 
                else if (remoteSessionInterface != rs) remoteSessionInterface = null;
            }
            else {
                RemoteSessionInterface rsx = hmRemoteSession.remove(p);
                if (hmRemoteSession.get(ObjectPackage) == rsx) hmRemoteSession.remove(ObjectPackage);
                if (remoteSessionInterface == rsx) remoteSessionInterface = null;
            }
        }
        else {
            p = ObjectPackage;
            if (rs != null) {
                hmRemoteSession.put(p, rs);
                if (remoteSessionInterface == null) remoteSessionInterface = rs; 
                else if (remoteSessionInterface != rs) remoteSessionInterface = null;
            }
            else {
                RemoteSessionInterface rsx = hmRemoteSession.remove(p);
                if (remoteSessionInterface == rsx) remoteSessionInterface = null;
            }
        }
    }

    // ========= RemoteClientInterface ============
    public static RemoteClientInterface getRemoteClient() {
        if (remoteClientInterface != null) return remoteClientInterface;
        return getRemoteClient(getPackage(null));
    }
    public static RemoteClientInterface getRemoteClient(Class c) {
        if (remoteClientInterface != null) return remoteClientInterface;
        return getRemoteClient(getPackage(c));
    }
    public static RemoteClientInterface getRemoteClient(OAObject obj) {
        if (remoteClientInterface != null) return remoteClientInterface;
        Class c = obj == null ? null : obj.getClass();
        return getRemoteClient(getPackage(c));
    }
    public static RemoteClientInterface getRemoteClient(Hub h) {
        if (remoteClientInterface != null) return remoteClientInterface;
        Class c;
        if (h != null) c = h.getObjectClass();
        else c = null;
        return getRemoteClient(getPackage(c));
    }
    public static RemoteClientInterface getRemoteClient(Package p) {
        if (remoteClientInterface != null) return remoteClientInterface;
        if (p == null) p = ObjectPackage;
        RemoteClientInterface rs = hmRemoteClient.get(p);
        if (rs == null && p != ObjectPackage) rs = hmRemoteClient.get(ObjectPackage);
        return rs;
    }
    public static void setRemoteClient(RemoteClientInterface rc) {
        setRemoteClient(null, rc);
    }
    public static void setRemoteClient(Package p, RemoteClientInterface rc) {
        if (p != null && p != ObjectPackage) {
            if (rc != null) {
                hmRemoteClient.put(p, rc);
                if (hmRemoteClient.get(ObjectPackage) == null) hmRemoteClient.put(ObjectPackage, rc);
                if (remoteClientInterface == null) remoteClientInterface = rc; 
                else if (remoteClientInterface != rc) remoteClientInterface = null;
                
            }
            else {
                RemoteClientInterface rcx = hmRemoteClient.remove(p);
                if (hmRemoteClient.get(ObjectPackage) == rcx) hmRemoteClient.remove(ObjectPackage);
                if (remoteClientInterface == rcx) remoteClientInterface = null;
            }
        }
        else {
            p = ObjectPackage;
            if (rc != null) {
                hmRemoteClient.put(p, rc);
                if (remoteClientInterface == null) remoteClientInterface = rc; 
                else if (remoteClientInterface != rc) remoteClientInterface = null;
            }
            else {
                RemoteClientInterface rcx = hmRemoteClient.remove(p);
                if (remoteClientInterface == rcx) remoteClientInterface = null;
            }
        }
    }


    // ========= RemoteSyncInterface ============
    public static RemoteSyncInterface getRemoteSync() {
        if (remoteSyncInterface != null) return remoteSyncInterface;
        return getRemoteSync(getPackage(null));
    }
    public static RemoteSyncInterface getRemoteSync(Class c) {
        if (remoteSyncInterface != null) return remoteSyncInterface;
        return getRemoteSync(getPackage(c));
    }
    public static RemoteSyncInterface getRemoteSync(OAObject obj) {
        if (remoteSyncInterface != null) return remoteSyncInterface;
        Class c = obj == null ? null : obj.getClass();
        return getRemoteSync(getPackage(c));
    }
    public static RemoteSyncInterface getRemoteSync(Hub h) {
        if (remoteSyncInterface != null) return remoteSyncInterface;
        Class c;
        if (h != null) c = h.getObjectClass();
        else c = null;
        return getRemoteSync(getPackage(c));
    }
    public static RemoteSyncInterface getRemoteSync(Package p) {
        if (remoteSyncInterface != null) return remoteSyncInterface;
        if (p == null) p = ObjectPackage;
        RemoteSyncInterface rs = hmRemoteSync.get(p);
        if (rs == null && p != ObjectPackage) rs = hmRemoteSync.get(ObjectPackage);
        return rs;
    }
    public static void setRemoteSync(RemoteSyncInterface rs) {
        setRemoteSync(null, rs);
    }
    public static void setRemoteSync(Package p, RemoteSyncInterface rs) {
        if (p != null && p != ObjectPackage) {
            if (rs != null) {
                hmRemoteSync.put(p, rs);
                if (hmRemoteSync.get(ObjectPackage) == null) hmRemoteSync.put(ObjectPackage, rs);
                if (remoteSyncInterface == null) remoteSyncInterface = rs; 
                else if (remoteSyncInterface != rs) remoteSyncInterface = null;
            }
            else {
                RemoteSyncInterface rsx = hmRemoteSync.remove(p);
                if (hmRemoteSync.get(ObjectPackage) == rsx) hmRemoteSync.remove(ObjectPackage);
                if (remoteSyncInterface == rsx) remoteSyncInterface = null;
            }
        }
        else {
            p = ObjectPackage;
            if (rs != null) {
                hmRemoteSync.put(p, rs);
                if (remoteSyncInterface == null) remoteSyncInterface = rs; 
                else if (remoteSyncInterface != rs) remoteSyncInterface = null;
            }
            else {
                RemoteSyncInterface rsx = hmRemoteSync.remove(p);
                if (remoteSyncInterface == rsx) remoteSyncInterface = null;
            }
        }
    }

    /**
     * The connectionId (multiplexer)
     */
    public static int getConnectionId(Package p) {
        if (p == null) p = ObjectPackage;
        OASyncClient sc = getSyncClient(p);
        if (sc == null) return -1;
        return sc.getConnectionId();
    }

    public static int getConnectionId() {
        return getConnectionId((Package) null);
    }

    /**
     * @return if OASyncServer has been created.
     */
    public static boolean isServer() {
        if (oaSyncServer != null) return true;
        return isServer((Class) null);
    }

    public static boolean isServer(Class c) {
        if (c == null) return isServer((Package) null);
        return isServer(getPackage(c));
    }

    public static boolean isServer(OAObject obj) {
        if (obj == null) return isServer((Package) null);
        return isServer(getPackage(obj.getClass()));
    }

    public static boolean isServer(Hub h) {
        if (h != null) {
            Class c = h.getObjectClass();
            if (c != null) {
                return isServer(getPackage(c));
            }
        }
        return isServer((Package) null);
    }

    public static boolean isServer(Package p) {
        if (p == null) p = ObjectPackage;
        OASyncServer ss = getSyncServer(p);
        OASyncClient sc = getSyncClient(p);
        return (ss != null) || (sc == null);
    }

    /**
     * @return if OASyncClient has been created.
     */
    public static boolean isClient(Class c) {
        if (c == null) return isClient((Package) null);
        return isClient(getPackage(c));
    }

    public static boolean isClient(Package p) {
        if (p == null) p = ObjectPackage;
        OASyncServer ss = getSyncServer(p);
        OASyncClient sc = getSyncClient(p);
        return (ss == null && sc != null);
    }

    public static boolean isClient(OAObject obj) {
        if (obj == null) return isClient((Package) null);
        return isClient(getPackage(obj.getClass()));
    }

    public static boolean isSingleUser() {
        return isSingleUser((Class) null);
    }
    public static boolean isSingleUser(Class c) {
        return isSingleUser(getPackage(c));
    }
    public static boolean isSingleUser(Hub h) {
        return isSingleUser(getPackage(h==null?null:h.getObjectClass()));
    }
    public static boolean isSingleUser(Package p) {
        if (p == null) p = ObjectPackage;
        OASyncServer ss = getSyncServer(p);
        OASyncClient sc = getSyncClient(p);
        return (ss == null && sc == null);
    }

    public static boolean isConnected() {
        return isConnected((Package)null);
    }
    public static boolean isConnected(Class c) {
        return isConnected(getPackage(c));
    }
    public static boolean isConnected(OAObject obj) {
        return isConnected(getPackage(obj==null?null:obj.getClass()));
    }

    /**
     * @return true if OASyncClient has been created and is connected to the server.
     */
    public static boolean isConnected(Package p) {
        if (p == null) p = ObjectPackage;
        OASyncClient sc = getSyncClient(p);

        if (sc == null) {
            OASyncServer ss = getSyncServer(p);
            return (ss != null);
        }
        return sc.isConnected();
    }

    private final static Object NextGuidLock = new Object();
    private static int nextGuid;
    private static int maxNextGuid;

    /**
     * Used by OAObject so that object guid is created/managed on the server.
     */
    public static int getObjectGuid(Class c) {
        if (c == null) return getObjectGuid((Package) null);
        return getObjectGuid(getPackage(c));
    }

    public static int getObjectGuid(Package p) {
        if (p == null) p = ObjectPackage;
        if (isServer(p)) {
            return OAObjectDelegate.getNextGuid();
        }
        int x;
        synchronized (NextGuidLock) {
            if (nextGuid == maxNextGuid) {
                try {
                    nextGuid = getRemoteServer(p).getNextFiftyObjectGuids();
                    maxNextGuid = nextGuid + 50;
                }
                catch (Exception ex) {
                    LOG.log(Level.WARNING, "", ex);
                    throw new RuntimeException("OAClient.getObjectGuid Error:", ex);
                }
            }
            x = nextGuid++;
        }
        return x;
    }

    /**
     * If the currentThread is an OARemoteThead, then this is used to have sync changes (OAObject/Hub)
     * sent to other computers.
     * 
     * By default, all msgs processed by OARemoteThreads will not send out any sync changes to other
     * computers (since they will receive the same msg).
     * 
     * This will set a flag in the current OARemoteThread to allow any further changes during the
     * current msg processing to be sent to the server/other clients.
     * 
     * see OARemoteThread
     */
    public static boolean sendMessages() {
        return OARemoteThreadDelegate.sendMessages();
    }

    public static boolean sendMessages(boolean b) {
        return OARemoteThreadDelegate.sendMessages(b);
    }

    /**
     * Used to determine if the current thread is OARemoteThread, which is used to process sync
     * messages.
     */
    public static boolean isRemoteThread() {
        return OARemoteThreadDelegate.isRemoteThread();
    }

    /**
     * Checks to see if any sync changes will be sent to other computers. This will be true if the
     * current thread is not an OARemoteThread, or if sendMessages([true]) was set.
     */
    public static boolean shouldSendMessages() {
        return OARemoteThreadDelegate.shouldSendMessages();
    }

    public static void setSuppressCSMessages(boolean b) {
        OAThreadLocalDelegate.setSuppressCSMessages(b);
    }

    public static boolean getSuppressCSMessages() {
        return OAThreadLocalDelegate.isSuppressCSMessages();
    }

    /**
     * If the current thread is an OARemoteThread, then this will return information about the currently
     * processed sync message.
     */
    public static RequestInfo getRequestInfo() {
        return OARemoteThreadDelegate.getRequestInfo();
    }

    /**
     * If the current thread is an OARemoteThread, then this will return the connection Id of the
     * client. If not, then -1 is returned.
     */
    public static int getRequestConnectionId() {
        RequestInfo ri = OARemoteThreadDelegate.getRequestInfo();
        if (ri == null) return -1;
        return ri.connectionId;
    }

    /*
     * used to create a block of code that will only process on the server. Send messages if this is the
     * server.
     * 
     * example: if (!OASync.beginServerOnly()) return; ... OASync.endServerOnly();
     * 
     * @return true if this is the server, else false.
     * @see #endServerOnly()
     * 
     *      public static boolean beginServerOnly(Package p) { if (!isServer(p)) return false;
     *      sendMessages(true); return true; } / **
     * @see #beginServerOnly() / public static boolean endServerOnly(Package p) { if (!isServer(p))
     *      return false; sendMessages(false); return true; }
     */

    /* later private static OASyncCombinedClient syncCombinedClient; public static OASyncClient
     * getSyncClient() { if (syncCombinedClient != null) { OASyncClient sc =
     * syncCombinedClient.getCurrentThreadSyncClient(); if (sc != null) return sc; } return syncClient;
     * }
     * 
     * public static OASyncCombinedClient getSyncCombinedClient() { return syncCombinedClient; } public
     * static void setSyncCombinedClient(OASyncCombinedClient cc) { syncCombinedClient = cc; } */

    public static void setLoading() {
        OAThreadLocalDelegate.setLoading(true);
    }
    public static void setLoading(boolean b) {
        OAThreadLocalDelegate.setLoading(b);
    }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy