/*
///////////////////////////////////////////
Public API
///////////////////////////////////////////
504510
@Override
    public Attribute getAttributeByName(QName name)
    {
        if (mAttrs == null) {
            return null;
        }
        return mAttrs.get(name);
    }
704195
public char[] getPublicKey() throws GeneralSecurityException, IOException {
        if (publicKey != null) {
            return publicKey;
        }

        KeyPair keys = getKeyPair();
        EdDSAPublicKey pubKey = (EdDSAPublicKey) keys.getPublic();
        byte[] pubBytes = pubKey.getAbyte();

        return encode(this.type, pubBytes);
    }
485631
public void validatePublicVoidNoArg(boolean isStatic, List<Throwable> errors) {
        validatePublicVoid(isStatic, errors);
        if (method.getParameterTypes().length != 0) {
            errors.add(new Exception("Method " + method.getName() + " should have no parameters"));
        }
    }
737743
function arrayApi(input, opts, cb) {
    var fd = new FormData(), files = [];
    [].slice.call(input.files).forEach(function(file) {
      fd.append(opts.name, file, file.webkitRelativePath || file.name);
      files.push(file.webkitRelativePath || file.name);
    });
    cb(fd, files);
  }
841941
public static boolean isPublicAddress(final InetAddress ia) {
        // We define public addresses by what they're not.  A public address
        // cannot be any one of the following:
        return 
            !ia.isSiteLocalAddress() &&
            !ia.isLinkLocalAddress() &&
            !ia.isAnyLocalAddress() &&
            !ia.isLoopbackAddress() &&
            !ia.isMulticastAddress();
    }
777103
function access(cb, force){
						_this.login(function(login_result, login_accesskey){
							// console.log(login_result, login_accesskey);
							if( login_result === false && login_accesskey === false ){
								cb(null, false, 0, {});
								return;
							}
							_this.httpRequest(
								url,
								{
									'params': options ,
									'method': apiSettings.method
								},
								function(bin, status, responseHeaders){
									if( !status ){
										cb(false, false, 0, {});
										return;
									}
									try {
										bin = JSON.parse(bin);
									} catch (e) {
									}
									// console.log(bin);
									if( bin.return_code !== 0 ){
										if(force){
											cb(null, bin, status, responseHeaders);
											return;
										}
										setTimeout(function(){
											access(cb, true);
										}, 1000);
										return;
									}
									cb(bin.list, bin, status, responseHeaders);
									return;
								}
							);
						}, force);

					}
1270184
public List<PublicRenderParameterType<PortletAppType<T>>> getAllPublicRenderParameter()
   {
      List<PublicRenderParameterType<PortletAppType<T>>> list = new ArrayList<PublicRenderParameterType<PortletAppType<T>>>();
      List<Node> nodeList = childNode.get("public-render-parameter");
      for(Node node: nodeList)
      {
         PublicRenderParameterType<PortletAppType<T>>  type = new PublicRenderParameterTypeImpl<PortletAppType<T>>(this, "public-render-parameter", childNode, node);
         list.add(type);
      }
      return list;
   }
1045953
public JsonResponse apiPost(ApiAction action, Map<String, Object> data) throws IOException {
        return httpRequestJson(action, HttpRequestMethod.POST, data);
    }
60235
protected boolean isPublic() {
        Collection<Modifier> modifiers = _methodDecl.getModifiers();
        return modifiers.contains(Modifier.PUBLIC);
    }
43404
function RequestApi(constructorOptions) {

    LOG.debug('Instantiating new Request object');
    LOG.debug('Validating options');

    try {

        this.options =
            new requestOptions.Constructor().validate(constructorOptions);

    } catch (err) {

        LOG.error('Received error: %s', err);

        throw(
            err
        );

    }

    this.requests = [];
    this.batchId = 1;

}
866256
function(params, callback) {
                var keyId;

                if (params) {
                    if (params.keyId != 'undefined') {
                        keyId = params.keyId;
                    }
                }

                var httpRequestParams = {
                    url: SERVICE_ADDRESSES.SSO_ADDRESS + SERVICES_PATH.SSO_GET_KEY + keyId,
                    method: 'GET',
                    headers: {
                        'Authorization': 'Bearer ' + token
                    }
                };

                httpRequest(httpRequestParams, function(result) {
                    if (!result.hasError) {
                        try {
                            var response = JSON.parse(result.result.responseText);
                        }
                        catch (e) {
                            console.log(e);
                        }

                        callback && callback({
                            hasError: false,
                            secretKey: response.secretKey
                        });
                    }
                    else {
                        callback && callback({
                            hasError: true,
                            code: result.errorCode,
                            message: result.errorMessage
                        });

                        fireEvent('error', {
                            code: result.errorCode,
                            message: result.errorMessage,
                            error: result
                        });
                    }
                });
            }
54393
function(){
    // Initialize the API object
    if (this.mainView) {
      this.mainView.clear();
    }
    var url = this.options.url;
    if (url && url.indexOf('http') !== 0) {
      url = this.buildUrl(window.location.href.toString(), url);
    }
    if(this.api) {
      this.options.authorizations = this.api.clientAuthorizations.authz;
    }
    this.options.url = url;
    this.headerView.update(url);

    this.api = new SwaggerClient(this.options);
  }
994356
function(items, handler, userData) {
			if (this.choiceCallback) {
				return this.choiceCallback.call(handler, items, userData);
			}
			return null;
		}
609920
@Override
    Map<String, Object> constructParameterRequestArgs() {
        // The label needs to be the key and this object is the value. Unfortunately that means
        // whatever parent object calls this needs to know to use this label as the key.
        // We could fix this by changing RequestParameter's interface to take the outer Map<> as a
        // parameter, and then each RequestParameter would know whether to add a Map<> or a
        // Collection<> or just add a (K, V).
        Map<String, Object> subAnalysisInfo = new HashMap<String, Object>(4);

        subAnalysisInfo.put(KeenQueryConstants.ANALYSIS_TYPE, this.analysisType.toString());

        if (QueryType.COUNT != this.analysisType) {
            subAnalysisInfo.put(KeenQueryConstants.TARGET_PROPERTY, this.targetPropertyName);
        }

        if (QueryType.PERCENTILE == analysisType) {
            // Put the raw Double in here for JSON serialization for now
            subAnalysisInfo.put(KeenQueryConstants.PERCENTILE, this.percentile.asDouble());
        }

        return subAnalysisInfo;
    }
1298220
@Override
    public Object call(Context cx, Scriptable scope, Scriptable thisObj,
                       Object[] args)
    {
        return Undefined.instance;
    }
825432
public function isPublicEndpoint(): bool
    {

        // Public calls need no checking.
        if ($this->public_call || is_null($this->token) || $this->scope === 'public')
            return true;

        return false;
    }
1152702
public void init(
    AOStream parent,
    String selectionCriteriasAsString,
    ConsumableKey[] consumerKeys,
    long idleTimeout,
    MPAlarmManager am,
    SelectionCriteria[] selectionCriterias)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(
        tc,
        "init",
        new Object[] {
          parent,
          selectionCriteriasAsString,
          consumerKeys,
          Long.valueOf(idleTimeout),
          am,
          selectionCriterias });

    this.lock();
    try
    {
      this.parent = parent;
      this.selectionCriteriasAsString = selectionCriteriasAsString;
      this.cks = consumerKeys;
      this.ck = consumerKeys[0];
      this.selectionCriterias = selectionCriterias;

      this.isready = false;
      this.dispatcher = cks[0].getConsumerManager(); // all cks[i] have the same ConsumerDispatcher
      this.temporarilyStopped = !dispatcher.getDestination().isReceiveAllowed();
      this.closed = false;
      this.listOfRequests = new LinkedList();
      this.tableOfRequests = new HashMap<Long, AORequestedTick>();
      this.idleTimeout = idleTimeout;
      this.am = am;
      
      if (ck instanceof GatheringConsumerKey)
        this.gatherMessages = true;
      
      if (idleTimeout > 0)
        this.idleHandler = am.create(idleTimeout, this);
    }
    finally
    {
      this.unlock();
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "init");

  }