private service methods
168234
private void processComponents(MAPDialogImpl mapDialogImpl, Component[] components) {

        // Now let us decode the Components
        for (Component c : components) {

            doProcessComponent(mapDialogImpl, c);
        }
    }
449739
function (key) {
      if (!supported) {
        try {
          return privateMethods.parseValue($cookieStore.get(key));
        } catch (e) {
          return null;
        }
      }
      var item = storage.getItem(key);
      return privateMethods.parseValue(item);
    }
103477
function decorate(service, serviceName) {
  var logger = _config.loggerFactory(serviceName, _config);
  _lodash2.default.map(service, function (method, name) {
    method.methodName = name;
    if (!method.params) {
      method.params = (0, _getParameterNames2.default)(method);
    }
    service[name] = log(validate(method), logger, method);
  });
}
47154
@Override
    protected void initService() {
        RESTService.instance().registerCommands(Arrays.asList(LogServiceAppCmd.class));
        RESTService.instance().registerCommands(cmdClasses, this);
    }
920561
@SuppressWarnings("unchecked")
    @Override
    public <T> T onSingletonServiceInit(T service, Object context) {
        if (context == null) {
            return null;
        }
        Map<Class<?>, ManagedObject<?>> newContext = (Map<Class<?>, ManagedObject<?>>) (context);
        if (newContext.isEmpty()) {
            return null;
        }

        ManagedObject<?> managedObject = newContext.get(service.getClass());
        Object newServiceObject = null;
        if (managedObject == null) {
            newServiceObject = getInstanceFromManagedObject(service, context);
        } else {
            newServiceObject = managedObject.getObject();
        }
        return (T) newServiceObject;
    }
403271
function renderOtherServiceField() {
		$this->renderField(
			[
				'id' => 'otherservice',
				'name' => $this->getSlug(),
				'option' => 'otherservice',
				'value' => ( isset( $this->options['otherservice'] ) ) ? $this->options['otherservice'] : '',
				'type' => 'url',
				'class' => 'regular-text code',
			]
		);
	}
1190711
function(name, service) {
  this.name = name;
  this.groups = {};       // group map for uids. key: sid, value: [uid]
  this.records = {};      // member records. key: uid
  this.__channelService__ = service;
  this.state = ST_INITED;
  this.userAmount =0;
}
864404
public void registerService(Object service)
    {
    	this.setService(service);
    	String serviceClass = getInterfaceClassName(); 

    	if (service != null)
    		serviceRegistration = context.registerService(serviceClass, this.service, properties);
    }
225944
public void putService(K serviceName, V service){
        if(cache.containsKey(serviceName)){
            cache.remove(serviceName);
        }
        cache.put(serviceName, service);
    }
524288
public void service(PageContext pContext)
            throws ServletException, IOException {
        JspWriter writer = pContext.getOut();
        writer.print(value);
    }
297190
@Override
  public ServiceRefAmp bind(ServiceRefAmp service, String address)
  {
    return delegate().bind(service, address);
  }
226747
@Override
  public void bind()
  {
    if (_ownerProvider == null) {
      _ownerBinding.bind();
      
      _ownerProvider = _ownerBinding.provider(); 

      _program = _manager.program(_method.getParameters());
    }
  }
359527
private void initFromSPIServiceLoader() {

        String property = System.getProperty("druid.load.spifilter.skip");
        if (property != null) {
            return;
        }

        ServiceLoader<Filter> druidAutoFilterLoader = ServiceLoader.load(Filter.class);

        for (Filter autoFilter : druidAutoFilterLoader) {
            AutoLoad autoLoad = autoFilter.getClass().getAnnotation(AutoLoad.class);
            if (autoLoad != null && autoLoad.value()) {
                if (LOG.isInfoEnabled()) {
                    LOG.info("load filter from spi :" + autoFilter.getClass().getName());
                }
                addFilter(autoFilter);
            }
        }
    }
628249
@Override
    protected S addService(S service, ServiceProperties props) {
        if (reference.compareAndSet(null, service)) {
            return service;
        }
        return null;
    }
819380
function(service) {
      return {
        compose: _.uniq(app.composeCore),
        project: app.name,
        opts: {
          app: app,
          services: [service]
        }
      };
    }
1089666
@Override public void bindServices(@NonNull Services.Binder services) {
    Object key = services.getKey();
    if (key.equals(new ContactsUiKey())) {
      // Setting up the ContactsUiKey means providing storage for Contacts.
      services.bind(CONTACTS_STORAGE, new ContactsStorage());
    } else if (key instanceof EditContactKey) {
      // Setting up the EditContactKey key means providing an editor for the contact.
      // This editor can be shared among any keys that have the EditContactKey as parent/ancestor!
      final String contactId = ((EditContactKey) key).contactId;
      ContactsStorage storage = services.getService(CONTACTS_STORAGE);
      Contact contact = storage.getContact(contactId);
      services.bind(CONTACT_EDITOR, new ContactEditor(contact));
    }
  }
236245
function newService()
    {
        $service = $this->service;

        $argsAvailable = \Poirot\Std\cast($this->optsData())->toArray();

        // TODO Code Clone of \Poirot\Std\Invokable\resolveArgsForReflection()
        $arguments = array();
        foreach ($argsAvailable as $key => $val) {
            if (is_string($key)) {
                // Create Map Of "field_name" to "fieldName" and "FieldName" to Resolve To Callable
                $res = (string) \Poirot\Std\cast($key)->camelCase();
                if (!isset($parameters[$res]))
                    $arguments[strtolower($res)] = $val;

                $arguments[strtolower($key)] = $val;
            }

            $arguments[$key] = $val;
        }

        $argsAvailable = $arguments;

        // Resolve Callable By Given Arguments or From Services Equal To Arg. Name
        if (is_callable($service)) {
            $reflect = \Poirot\Std\Invokable\reflectCallable($service);

            // Resolve Arguments to constructor and create new instance
            $argsAsService = \Poirot\Ioc\resolveServicesAsArgumentForFunc($reflect, $argsAvailable);
            $argsAvailable = array_merge($argsAsService, $argsAvailable);

            // TODO we can resolve argument from services and create a function with behind argument and let it play!
            //      it can be implemented something like dispatcher
            
            if (! empty($argsAvailable) ) {
                $service = \Poirot\Std\Invokable\resolveCallableWithArgs($service, $argsAvailable);
            }
        }
        elseif (is_string($service)) {

            if ( class_exists($service) )
            {
                $rClass        = new \ReflectionClass($service);

                if ($rClass->hasMethod('__construct'))
                {
                    // Resolve Arguments to constructor and create new instance
                    $argsAsService = $this->_resolveServicesAsArgument($rClass, $argsAvailable);

                    $argsAvailable = array_merge($argsAsService, $argsAvailable);

                    $rMethod  = $rClass->getMethod('__construct');
                    $resolved = \Poirot\Std\Invokable\resolveArgsForReflection($rMethod, $argsAvailable);
                    $service  = $rClass->newInstanceArgs($resolved);

                }
                else
                {
                    // service without constructor
                    $service = new $service;

                }

                // let remind options used as features like configurable
                if (isset($resolved)) {
                    foreach ($resolved as $key => $_) {
                        // Remove Resolved From Available Arguments
                        $key = (string) \Poirot\Std\cast($key)->under_score();
                        if (!isset($argsAvailable[$key])) continue;

                        unset($argsAvailable[$key]);
                    }
                }

            }
            elseif ($this->services()->has($service)) {
                $service = $this->services()->fresh($service, $argsAvailable);
                $argsAvailable = null;
            } else {
                throw new exContainerNoService(sprintf(
                    'Service with name (%s) not found.'
                    , $service
                ));
            }
        }


        if ($service instanceof instance)
            $service = \Poirot\Ioc\newInitIns( $service, $this->services() );

        // TODO can be removed
        if ($argsAvailable) {
            if ($service instanceof ipConfigurable)
                ## using Pact Options Provider Contract
                $service->with($argsAvailable, false);
            elseif ($service instanceof iData)
                $service->import($argsAvailable);
        }

        return $service;
    }