generate the array dictionary for <data> component for the App Link intent filter
8742
function getAppLinkIntentFilterDictionary(linkDomain, androidPrefix) {
    const scheme = "https";
    const output = {
      $: {
        "android:host": linkDomain,
        "android:scheme": scheme
      }
    };

    if (androidPrefix) {
      output.$["android:pathPrefix"] = androidPrefix;
    }

    return output;
  }
1252033
def _map_intent_to_view_func(self, intent):
        """"""
        if intent.name in self._intent_view_funcs:
            view_func = self._intent_view_funcs[intent.name]
        elif self._default_intent_view_func is not None:
            view_func = self._default_intent_view_func
        else:
            raise NotImplementedError('Intent "{}" not found and no default intent specified.'.format(intent.name))

        PY3 = sys.version_info[0] == 3
        if PY3:
            argspec = inspect.getfullargspec(view_func)
        else:
            argspec = inspect.getargspec(view_func)
            
        arg_names = argspec.args
        arg_values = self._map_params_to_view_args(intent.name, arg_names)

        return partial(view_func, *arg_values)
162043
function getUserDictionary(){
    
    const userDict = {};

    if (!userId){

        userDict['userId'] = deviceData.getDeviceId();

    } else {

        userDict['userId'] = userId;

    }

    for (let key in extraInfo){
        
        userDict[key] = extraInfo[key];
    
    }

    return userDict;

}
770903
function(data) {
            var paramArray = [],
                key, value;
        // TODO: use `object` module
            for (key in data) {
                value = data[key];
                key = ENCODE_URI_COMPONENT(key);
                paramArray.push((value === null) ? key : (key + '=' + ENCODE_URI_COMPONENT(value)));
            }
            console.log(NAME, '_toQueryString --> '+paramArray.join('&'));
            return paramArray.join('&');
        }
148251
def to_array(self):
        
        array = super(InlineQueryResultLocation, self).to_array()
        # 'type' and 'id' given by superclass
        array['latitude'] = float(self.latitude)  # type float
        array['longitude'] = float(self.longitude)  # type float
        array['title'] = u(self.title)  # py2: type unicode, py3: type str
        if self.live_period is not None:
            array['live_period'] = int(self.live_period)  # type int
        if self.reply_markup is not None:
            array['reply_markup'] = self.reply_markup.to_array()  # type InlineKeyboardMarkup
        if self.input_message_content is not None:
            array['input_message_content'] = self.input_message_content.to_array()  # type InputMessageContent
        if self.thumb_url is not None:
            array['thumb_url'] = u(self.thumb_url)  # py2: type unicode, py3: type str
        if self.thumb_width is not None:
            array['thumb_width'] = int(self.thumb_width)  # type int
        if self.thumb_height is not None:
            array['thumb_height'] = int(self.thumb_height)  # type int
        return array
1101364
function () {
    var items = [];
    for (var i = 0, length = this.getFilteredItemCount(); i < length; i++) {
      items.push(this.items[this.convertViewIndexToModel(i)]);
    }
    return items;
  }
195040
def as_dict(self):
        '''
        
        '''
        data = {}
        if settings.JS_CONTEXT_ENABLED:
            for context in RequestContext(self.request):
                for key, value in six.iteritems(context):
                    if settings.JS_CONTEXT and key not in settings.JS_CONTEXT:
                        continue
                    if settings.JS_CONTEXT_EXCLUDE and key in settings.JS_CONTEXT_EXCLUDE:
                        continue
                    handler_name = 'process_%s' % key
                    if hasattr(self, handler_name):
                        handler = getattr(self, handler_name)
                        data[key] = handler(value, data)
                    elif isinstance(value, SERIALIZABLE_TYPES):
                        data[key] = value
        if settings.JS_USER_ENABLED:
            self.handle_user(data)
        return data
1221331
def _viewdata_to_view(self, p_data):
        
        sorter = Sorter(p_data['sortexpr'], p_data['groupexpr'])
        filters = []

        if not p_data['show_all']:
            filters.append(DependencyFilter(self.todolist))
            filters.append(RelevanceFilter())
            filters.append(HiddenTagFilter())

        filters += get_filter_list(p_data['filterexpr'].split())

        return UIView(sorter, filters, self.todolist, p_data)
310456
private void parseExtras(Bundle icicle){

        Intent intent = getIntent();
        if(intent != null){
            mConfigResId = intent.getIntExtra(EXTRA_CONFIG, -1);
        }

        if(icicle != null){
            mConfigResId = icicle.getInt(EXTRA_CONFIG, -1);
        }

        if(mConfigResId == -1){
            finish();
            return;
        }

        // Parse configuration
        RecyclerView recycler = Winds.draft(this, mConfigResId);

        FrameLayout.LayoutParams params =
                new FrameLayout.LayoutParams(
                        ViewGroup.LayoutParams.MATCH_PARENT,
                        ViewGroup.LayoutParams.MATCH_PARENT);

        mContainer.addView(recycler, params);
    }
365403
def to_dict(self):
        ''''''
        d = {'sequence': self.sequence,
                'targetComponent': self.target_component.to_dict()}
        props = []
        for name in self.properties:
            p = {'name': name}
            if self.properties[name]:
                p['value'] = str(self.properties[name])
            props.append(p)
        if props:
            d[RTS_EXT_NS_YAML + 'properties'] = props
        return d
1074484
function _fnNameArray (context, iterable, filterContext) {
    var html = '',
        object, ref, length, key, i;

    length = iterable.length;
    for (i = 0; i < length; i++) {
      object = iterable[i];
      if (!object) {
        continue;
      }
      _body;
    }


    return html;
  }
885944
def to_dict(self):
        ''''''
        d = {'connectorId': self.connector_id,
                'name': self.name,
                'dataType': self.data_type,
                'interfaceType': self.interface_type,
                'dataflowType': self.data_flow_type,
                'sourceDataPort': self.source_data_port.to_dict(),
                'targetDataPort': self.target_data_port.to_dict()}
        if self.visible != True:
            d[RTS_EXT_NS_YAML + 'visible'] = self.visible
        if self.subscription_type:
            d['subscriptionType'] = self.subscription_type
        if self.push_interval:
            d['pushInterval'] = self.push_interval
        if self.comment:
            d[RTS_EXT_NS_YAML + 'comment'] = self.comment
        props = []
        for name in self.properties:
            p = {'name': name}
            if self.properties[name]:
                p['value'] = str(self.properties[name])
            props.append(p)
        if props:
            d[RTS_EXT_NS_YAML + 'properties'] = props
        return d
85843
function getData(file) {
		var relativePath, pathData;

		relativePath = path.relative(projectConfig.paths.src.views.layouts, file.path);
		relativePath = relativePath.replace('.' + taskConfig.extension, '');

		pathData = dataSource.getDataForPath(relativePath);
		pathData = defaultData.apply(pathData);

		return pathData;
	}
1160109
def to_array(self):
        
        array = super(CallbackQuery, self).to_array()
        array['id'] = u(self.id)  # py2: type unicode, py3: type str
        array['from'] = self.from_peer.to_array()  # type User
        array['chat_instance'] = u(self.chat_instance)  # py2: type unicode, py3: type str
        if self.message is not None:
            array['message'] = self.message.to_array()  # type Message
        if self.inline_message_id is not None:
            array['inline_message_id'] = u(self.inline_message_id)  # py2: type unicode, py3: type str
        if self.data is not None:
            array['data'] = u(self.data)  # py2: type unicode, py3: type str
        if self.game_short_name is not None:
            array['game_short_name'] = u(self.game_short_name)  # py2: type unicode, py3: type str
        return array
293358
def get_url_array(self):
        
        urlarray = []
        for urlobjects in self.__json_object["base_urls"]:
            urlarray.append(urlobjects["url"])
        return urlarray
1307966
def _get_filter(sdk_filter, attr_map):
    
    if not isinstance(sdk_filter, dict):
        raise CloudValueError('filter value must be a dictionary, was %r' % (sdk_filter,))
    custom = sdk_filter.pop('custom_attributes', {})
    new_filter = _normalise_key_values(filter_obj=sdk_filter, attr_map=attr_map)
    new_filter.update({
        'custom_attributes__%s' % k: v for k, v in _normalise_key_values(filter_obj=custom).items()
    })
    return new_filter
986002
def app_intents(self):
        """"""
        from_app = []
        for intent_name in self.assist._intent_action_funcs:
            intent = self.build_intent(intent_name)
            from_app.append(intent)
        return from_app