**********  Common  ******************
343971
function resolveConfigFilePath(cracoConfig, fileName) {
    return require.resolve(path.join(cracoConfig.reactScriptsVersion, "config", fileName), { paths: [projectRoot] });
}
887644
def _common(ret, name, service_name, kwargs):
    '''
    
    '''
    if 'interface' not in kwargs and 'public_url' not in kwargs:
        kwargs['interface'] = name
    service = __salt__['keystoneng.service_get'](name_or_id=service_name)

    if not service:
        ret['comment'] = 'Cannot find service'
        ret['result'] = False
        return (False, ret)

    filters = kwargs.copy()
    filters.pop('enabled', None)
    filters.pop('url', None)
    filters['service_id'] = service.id
    kwargs['service_name_or_id'] = service.id
    endpoints = __salt__['keystoneng.endpoint_search'](filters=filters)

    if len(endpoints) > 1:
        ret['comment'] = "Multiple endpoints match criteria"
        ret['result'] = False
        return ret
    endpoint = endpoints[0] if endpoints else None
    return (True, endpoint)
733384
public static Map<String, String> commonTags() {
    final Map<String, String> commonTags = new HashMap<>();
    put(commonTags, "nf.app", Env.app());
    put(commonTags, "nf.cluster", Env.cluster());
    put(commonTags, "nf.asg", Env.asg());
    put(commonTags, "nf.stack", Env.stack());
    put(commonTags, "nf.zone", Env.zone());
    put(commonTags, "nf.vmtype", Env.vmtype());
    put(commonTags, "nf.node", Env.instanceId());
    put(commonTags, "nf.region", Env.region());
    put(commonTags, "nf.account", Env.accountId());
    put(commonTags, "nf.task", Env.task());
    put(commonTags, "nf.job", Env.job());
    return commonTags;
  }
967851
protected static CommonContent transformCommonContent(CSNodeWrapper node) {
        final CommonContent commonContent;
        if (node.getNodeType() == CommonConstants.CS_NODE_COMMON_CONTENT) {
            commonContent = new CommonContent(node.getTitle());
        } else {
            throw new IllegalArgumentException("The passed node is not a Comment");
        }

        commonContent.setUniqueId(node.getId() == null ? null : node.getId().toString());

        return commonContent;
    }
373631
private void maybeAddWatermarkInputs(ComponentCommon common, IRichBolt bolt) {
        if (bolt instanceof WindowedBoltExecutor) {
            Set<String> comps = new HashSet<>();
            for (GlobalStreamId globalStreamId : common.get_inputs().keySet()) {
                comps.add(globalStreamId.get_componentId());
            }

            for (String comp : comps) {
                common.put_to_inputs(
                        new GlobalStreamId(comp, Common.WATERMARK_STREAM_ID),
                        Grouping.all(new NullStruct()));
            }
        }
    }
196308
function(context, request, callback){
		if ((context.indexOf('node_modules') !== -1) || (request.indexOf('.') !== 0)) {
			callback(null, 'commonjs ' + request);
		}
		else {
			callback();
		}
	}
147902
def _common_prefix(names):
    """"""
    if not names:
        return ''
    prefix = names[0]
    for name in names:
        i = 0
        while i < len(prefix) and i < len(name) and prefix[i] == name[i]:
            i += 1
        prefix = prefix[:i]
    return prefix
426950
public function common_terms(string $field, string $query, float $cutoffFrequency): Common
    {
        return new Common($field, $query, $cutoffFrequency);
    }
631485
function CommonTransport( logger , config = {} ) {
	this.logger = null ;
	this.monitoring = false ;
	this.minLevel = 0 ;
	this.maxLevel = 7 ;
	this.messageFormatter = logger.messageFormatter.text ;
	this.timeFormatter = logger.timeFormatter.dateTime ;

	Object.defineProperty( this , 'logger' , { value: logger } ) ;

	if ( config.monitoring !== undefined ) { this.monitoring = !! config.monitoring ; }

	if ( config.minLevel !== undefined ) {
		if ( typeof config.minLevel === 'number' ) { this.minLevel = config.minLevel ; }
		else if ( typeof config.minLevel === 'string' ) { this.minLevel = this.logger.levelHash[ config.minLevel ] ; }
	}

	if ( config.maxLevel !== undefined ) {
		if ( typeof config.maxLevel === 'number' ) { this.maxLevel = config.maxLevel ; }
		else if ( typeof config.maxLevel === 'string' ) { this.maxLevel = this.logger.levelHash[ config.maxLevel ] ; }
	}

	if ( config.messageFormatter ) {
		if ( typeof config.messageFormatter === 'function' ) { this.messageFormatter = config.messageFormatter ; }
		else { this.messageFormatter = this.logger.messageFormatter[ config.messageFormatter ] ; }
	}

	if ( config.timeFormatter ) {
		if ( typeof config.timeFormatter === 'function' ) { this.timeFormatter = config.timeFormatter ; }
		else { this.timeFormatter = this.logger.timeFormatter[ config.timeFormatter ] ; }
	}
}
1157824
function common_end(params, configs) {
      params.code = params.code || configs.compiler.compile(params);
      if (typeof params.attach == "object") {
        for (var i in params.attach) {
          params.data[i] = params.attach[i];
        }
      } else if (typeof params.attach == "function") {
        var ret = params.attach(params.data);
        params.data = (ret) ? ret : params.data;
      }
      params.result = params.result || configs.compiler.run(params);
      /* execute end functions */
      for (var i in configs.end) {
        configs.end[i].call(configs, params);
      }
      return params.result;
    }
55578
def same_types(self, index1, index2):
        """"""
        try:
            same = self.table[index1].type == self.table[index2].type != SharedData.TYPES.NO_TYPE
        except Exception:
            self.error()
        return same
734462
private Map<Feature, Feature> diffFeatures(List<Feature> pcm1Features, List<Feature> pcm2Features, PCMElementComparator comparator, DiffResult result) {
        List<Feature> commonFeatures = new ArrayList<Feature>();
        List<Feature> featuresOnlyInPCM1 = new ArrayList<Feature>();
        List<Feature> featuresOnlyInPCM2 = new ArrayList<Feature>(pcm2Features);

        Map<Feature, Feature> equivalentFeatures = new HashMap<Feature, Feature>();

        for (Feature f1 : pcm1Features) {
            boolean similarFeature = false;
            for (Feature f2 : pcm2Features) {
                similarFeature = comparator.similarFeature(f1, f2);
                if (similarFeature) {
                    commonFeatures.add(f1);
                    featuresOnlyInPCM2.remove(f2);
                    equivalentFeatures.put(f1, f2);
                    break;
                }
            }

            if (!similarFeature) {
                featuresOnlyInPCM1.add(f1);
            }
        }

        result.setCommonFeatures(commonFeatures);
        result.setFeaturesOnlyInPCM1(featuresOnlyInPCM1);
        result.setFeaturesOnlyInPCM2(featuresOnlyInPCM2);

        return equivalentFeatures;
    }
179433
public LinkedList<Map.Entry<String, V>> commonPrefixSearchWithValue(String key)
    {
        char[] chars = key.toCharArray();
        return commonPrefixSearchWithValue(chars, 0);
    }
843585
def common(self, other):
		'''
			
		'''
		if self.multiplicand == other.multiplicand:
			return mult(self.multiplicand, self.multiplier.common(other.multiplier))

		# Multiplicands disagree, no common part at all.
		return mult(nothing, zero)
756186
def get_common(self, filename):
        '''  '''
        word_list = []
        words = open(filename)
        for word in words.readlines():
            word_list.append(word.strip())
        return word_list
1018416
final protected Object common_put(Object key, Object value) {
        EntryInfo ei = entryInfoPool.allocate(key, DistributedObjectCacheAdapter.NULL_DEPIDs, DistributedObjectCacheAdapter.NULL_DEPIDs);
        ei.setTimeLimit(this.timeToLive);
        ei.setSharingPolicy(this.sharingPolicy);
        Object retValue = cache.invalidateAndSet(ei, value, cache.getCacheConfig().isEnableCacheReplication());

        ei.returnToPool();
        return retValue;
    }
708378
public function on_common()
	{
		if (substr($GLOBALS['request']->server('SCRIPT_NAME'), -7) === 'app.php')
		{
			return;
		}

		try {
			$this->request_stack->push($this->symfony_request);

			$this->dispatcher->dispatch(KernelEvents::REQUEST,
				new GetResponseEvent(
					$this->http_kernel,
					$this->request_stack->getCurrentRequest(),
					HttpKernelInterface::MASTER_REQUEST
				));
		}
		catch (\Exception $e)
		{
		}
	}