RDP client informations
@param extendedInfoConditional {boolean} true if RDP5+
@returns {type.Component}
165587
function rdpInfos(extendedInfoConditional) {
	var self = {
		codePage : new type.UInt32Le(),
        flag : new type.UInt32Le(InfoFlag.INFO_MOUSE | InfoFlag.INFO_UNICODE | InfoFlag.INFO_LOGONNOTIFY | InfoFlag.INFO_LOGONERRORS | InfoFlag.INFO_DISABLECTRLALTDEL | InfoFlag.INFO_ENABLEWINDOWSKEY),
        cbDomain : new type.UInt16Le(function() {
        	return self.domain.size() - 2;
        }),
        cbUserName : new type.UInt16Le(function() {
        	return self.userName.size() - 2;
        }),
        cbPassword : new type.UInt16Le(function() {
        	return self.password.size() - 2;
        }),
        cbAlternateShell : new type.UInt16Le(function() {
        	return self.alternateShell.size() - 2;
        }),
        cbWorkingDir : new type.UInt16Le(function() {
        	return self.workingDir.size() - 2;
        }),
        domain : new type.BinaryString(new Buffer('\x00', 'ucs2'),{ readLength : new type.CallableValue(function() {
        	return self.cbDomain.value + 2;
        })}),
        userName : new type.BinaryString(new Buffer('\x00', 'ucs2'), { readLength : new type.CallableValue(function() {
        	return self.cbUserName.value + 2;
        })}),
        password : new type.BinaryString(new Buffer('\x00', 'ucs2'), { readLength : new type.CallableValue(function () {
        	return self.cbPassword.value + 2;
        })}),
        alternateShell : new type.BinaryString(new Buffer('\x00', 'ucs2'), { readLength : new type.CallableValue(function() {
        	return self.cbAlternateShell.value + 2;
        })}),
        workingDir : new type.BinaryString(new Buffer('\x00', 'ucs2'), { readLength : new type.CallableValue(function() {
        	return self.cbWorkingDir.value + 2;
        })}),
        extendedInfo : rdpExtendedInfos({ conditional : extendedInfoConditional })
	};
	
	return new type.Component(self);
}
1263280
function fetchClientInformation() {
  return (dispatch) => {
    dispatch(requestClientInformation());

    if (!hasSGJavaScriptBridge()) {
      dispatch(receiveClientInformation(defaultClientInformation));
      return;
    }

    getWebStorageEntry({ name: 'clientInformation' })
      .then(response => dispatch(receiveClientInformation(response.value)))
      .catch((error) => {
        logger.error(error);
        dispatch(errorClientInformation());
      });
  };
}
544779
@SuppressWarnings("unused")
    private void initializeClientPolling(Component component) {

        if (component instanceof AbstractComponent) {
            AbstractComponent acomp = (AbstractComponent)component;
            for (Extension extension : acomp.getExtensions()) {
                if (extension instanceof CmsPollServerExtension) {
                    return;
                }
            }
            new CmsPollServerExtension((AbstractComponent)component);
        }
    }
773347
public  void showBooleanActionResultInTextInfo(String title, BooleanOWLResultSet result) throws OWLException {

		AskQueryInfoSetter alter_result_panel = new AskQueryInfoSetter(title, result);
		SwingUtilities.invokeLater(alter_result_panel);
	}
593284
public static ProxyCertInfo getProxyCertInfo(X509Extension ext)
	throws IOException {
	return ProxyCertInfo.getInstance(BouncyCastleUtil.getExtensionObject(ext));
    }
796160
function isExternalDirectCall (node) {
  return isMemberAccess(node, basicRegex.EXTERNALFUNCTIONTYPE, undefined, basicRegex.CONTRACTTYPE, undefined) && !isThisLocalCall(node) && !isSuperLocalCall(node)
}
72272
function findTypeForExtend(types, extend) {
  var orig = types.find(ea => ea.name === extend.name && ea.type !== "extend");
  if (!orig) throw new Error("Cannot find original for extension " + JSON.stringify(extend, null, 2));
  return orig;
}
451974
@Override
    public RepositoryInfo getRepositoryInfo(String repositoryId, ExtensionsData extension) {
        LOGGER.debug("-- getting repository info");
        RepositoryInfo info = jcrRepository(repositoryId).getRepositoryInfo(login(repositoryId));
        return new RepositoryInfoLocal(repositoryId, info);
    }
628482
public ExtendedSwidProcessor setExtendedInformation(final JAXBElement<Object>... extendedInformationList) {
        ExtendedInformationComplexType eict = new ExtendedInformationComplexType();
        if (extendedInformationList.length > 0) {
            for (JAXBElement<Object> extendedInformation : extendedInformationList) {
                eict.getAny().add(extendedInformation);
            }
        }
        swidTag.getExtendedInformation().add(eict);
        return this;
    }
980465
private static List<MediaType> getResourceMethodProducibleTypes(final ExtendedUriInfo extendedUriInfo) {
        if (extendedUriInfo.getMatchedResourceMethod() != null
                && !extendedUriInfo.getMatchedResourceMethod().getProducedTypes().isEmpty()) {
            return extendedUriInfo.getMatchedResourceMethod().getProducedTypes();
        }
        return Collections.singletonList(MediaType.WILDCARD_TYPE);
    }
796559
function getComponent(tn) {
        var cid = tn.toLowerCase()
        var compDef
        components.some(function (comp) {
            if (comp.hasOwnProperty(cid)) {
                compDef = comp[cid]
                return true
            }
        })
        return compDef
    }
1037786
public boolean contextInfoRequired(String eventType, long requestNumber) {

		boolean needContextInfo = false;

		List<ProbeExtension> probeExtnList = RequestProbeService
				.getProbeExtensions();

		for (int i = 0; i < probeExtnList.size(); i++) {
			ProbeExtension probeExtension = probeExtnList.get(i);
			if (requestNumber % probeExtension.getRequestSampleRate() == 0) {
				if (probeExtension.getContextInfoRequirement() == ContextInfoRequirement.ALL_EVENTS) {
					needContextInfo = true;
					break;

				} else if (probeExtension.getContextInfoRequirement() == ContextInfoRequirement.EVENTS_MATCHING_SPECIFIED_EVENT_TYPES
						&& (probeExtension.invokeForEventTypes() == null || probeExtension
								.invokeForEventTypes().contains(eventType))) {
					needContextInfo = true;
					break;
				}
			}
		}
		return needContextInfo;
	}
1158019
function getDNProp($propName, $dn = NULL, $withType = false)
    {
        if (!isset($dn)) {
            $dn = $this->dn;
        }

        if (empty($dn)) {
            return false;
        }

        if (($propName = $this->_translateDNProp($propName)) === false) {
            return false;
        }

        $dn = $dn['rdnSequence'];
        $result = array();
        $asn1 = new File_ASN1();
        for ($i = 0; $i < count($dn); $i++) {
            if ($dn[$i][0]['type'] == $propName) {
                $v = $dn[$i][0]['value'];
                if (!$withType && is_array($v)) {
                    foreach ($v as $type => $s) {
                        $type = array_search($type, $asn1->ANYmap, true);
                        if ($type !== false && isset($asn1->stringTypeSize[$type])) {
                            $s = $asn1->convert($s, $type);
                            if ($s !== false) {
                                $v = $s;
                                break;
                            }
                        }
                    }
                    if (is_array($v)) {
                        $v = array_pop($v); // Always strip data type.
                    }
                }
                $result[] = $v;
            }
        }

        return $result;
    }
350461
function hasCustomEndpoint(client) {
  //if set endpoint is set for specific client, enable endpoint discovery will raise an error.
  if (client._originalConfig && client._originalConfig.endpoint && client._originalConfig.endpointDiscoveryEnabled === true) {
    throw util.error(new Error(), {
      code: 'ConfigurationException',
      message: 'Custom endpoint is supplied; endpointDiscoveryEnabled must not be true.'
    });
  };
  var svcConfig = AWS.config[client.serviceIdentifier] || {};
  return Boolean(AWS.config.endpoint || svcConfig.endpoint || (client._originalConfig && client._originalConfig.endpoint));
}
807999
function showCompInfoFromPoint(e) {
      var x = e.clientX;
      var y = e.clientY;
      var el = Ext.dom.Element.fromPoint(x, y);

      window.tel = el;

      if (!el) {
        tiaEJ.showMsgBox('!Ext.dom.Element.fromPoint(x, y)', 'Error');
      }

      var extDomEl = Ext.dom.Element.get(el);
      if (!extDomEl) {
        tiaEJ.showMsgBox('!Ext.dom.Element.get(el)', 'Error');
      }

      var comp = Ext.Component.from(extDomEl);
      if (!comp) {
        tiaEJ.showMsgBox('!Ext.Component.from(extDomEl)', 'Error');
      }

      // console.log('COMP FOUND: ' + comp.getId());

      // boundlist
      //

      // fromPoint does not find disabled items, so let's hande this ourselves.
      if (comp.isContainer) {
        var newComp = null;
        comp.cascade(function (curComp) {
          if (curComp.isDisabled()) {
            var box = curComp.getBox();
            if (x >= box.left && x <= box.right && y >= box.top && y <= box.bottom) {
              newComp = curComp;
            }
          }
          return true;
        });
        if (newComp) {
          comp = newComp;
        }
      }

      // console.log('COMP after box handling: ' + comp.getId());

      if (!comp) {
        tiaEJ.showMsgBox('Error at box handling ', 'Error');
      }

      window.tcmp = comp;

      // var oldBorder = comp.getConfig().border;
      // var oldStyle = comp.getConfig().style;
      //
      // console.dir(oldBorder);
      // console.dir(oldStyle);
      //
      // comp.setConfig('border', 5)
      // comp.setConfig('style', {
      //   borderColor: 'red',
      //   borderStyle: 'solid'
      // });
      //
      // setTimeout(function () {
      //   comp.setConfig('border', oldBorder);
      //   comp.setConfig('style', oldStyle);
      // }, 10000);


      // comp.setBorder(5);
      // comp.setStyle({
      //   borderColor: 'red',
      //   borderStyle: 'solid'
      // });

      var record = null;
      var recordStr = 'Record info: ';

      try {
        record = comp.getRecord(extDomEl);
        recordStr += '\n' + tiaEJ.ctMisc.stringifyAllRecord(record, true);
        recordStr += '\n' + this.consts.bigSep;
      } catch (err) {
        recordStr += this.consts.nA;
        if (tia.debugMode) {
          console.log('Exp exc:' + err);
        }
      }

      if (tia.debugMode) {
        window.c1 = comp;
      }
      var outStr = this.getComponentAndParentsInfo(comp, false, extDomEl).join('\n') + '\n' + recordStr;

      tiaEJ.showMsgBox(outStr, 'Info about a component under mouse cursor');
      // console.log(outStr);
    }
701842
public <T> T getLocalExtension(Class<T> extensionType) {
        Object obj = extensions.get(extensionType);
        if (null != obj) {
            return extensionType.cast(obj);
        }
        return null;
    }
465780
function getDocClientWH(props) {
  var elmTarget = props.elmTarget,
      width = elmTarget.clientWidth,
      height = elmTarget.clientHeight;
  if (IS_TRIDENT || IS_EDGE) {
    var targetBodyCmpStyle = props.window.getComputedStyle(props.elmTargetBody, ''),
        wMode = targetBodyCmpStyle.writingMode || targetBodyCmpStyle['writing-mode'],
        // Trident bug
    direction = targetBodyCmpStyle.direction;
    return wMode === 'tb-rl' || wMode === 'bt-rl' || wMode === 'tb-lr' || wMode === 'bt-lr' || IS_EDGE && (direction === 'ltr' && (wMode === 'vertical-rl' || wMode === 'vertical-lr') || direction === 'rtl' && (wMode === 'vertical-rl' || wMode === 'vertical-lr')) ? { width: height, height: width } : // interchange
    { width: width, height: height };
  }
  return { width: width, height: height };
}