Set evercookie value to session
 == Examples:
   set_evercookie(:key, :value)
433247
def set_evercookie(key, value)
      session[Evercookie.hash_name_for_saved] = {} unless
        session[Evercookie.hash_name_for_saved].present?
      session[Evercookie.hash_name_for_saved][key] = value
    end
1279421
def add(self, value, session=None, **kwargs):
        ''''''
        s, instance = self.session_instance('add', value, session, **kwargs)
        return s.add(instance)
526007
def save
      if data = session[Evercookie.hash_name_for_get]
        if data[:key] && cookies[data[:key]]
          session[Evercookie.hash_name_for_saved] =
              { data[:key] => cookies[data[:key]] }
        end
      end
      render nothing: true
    end
1213061
def set_session_data(self, session_data):
        '''
        
        '''
        if session_data:
            for field in self._fields:
                if isinstance(field, (Container, Dynamic)):
                    field.set_session_data(session_data)
1357939
def set_value(self, arr, key, value):
        
        self._engine.set_value(com.values_from_object(arr),
                               com.values_from_object(key), value)
873812
def set(self, name, value, domain, **kwargs):
        

        if domain == 'localhost':
            domain = ''

        self.cookiejar.set_cookie(create_cookie(name, value, domain, **kwargs))
142965
def var_set(self, session, **kwargs):
        
        if not kwargs:
            session.write_line(
                self._utils.make_table(
                    ("Name", "Value"), session.variables.items()
                )
            )
        else:
            for name, value in kwargs.items():
                name = name.strip()
                session.set(name, value)
                session.write_line("{0}={1}", name, value)
1100140
def set(key, value)
      method_name = "validate_#{key}"
      send(method_name.to_sym, value) if respond_to?(method_name.to_sym)
      @data[key.to_s] = value
    end
203633
def set key, value
      # capture new value in instance
      send("#{key}=", value)
      attributes.merge!(key => value)
      # and store it
      File.write UserConfig.config_path, YAML.dump(attributes)
    end
1321356
def set(self, key, value=None, dir=False, refresh=False, ttl=None,
            prev_value=None, prev_index=None, prev_exist=None, timeout=None):
        """"""
        url = self.make_key_url(key)
        data = self.build_args({
            'value': (six.text_type, value),
            'dir': (bool, dir or None),
            'refresh': (bool, refresh or None),
            'ttl': (int, ttl),
            'prevValue': (six.text_type, prev_value),
            'prevIndex': (int, prev_index),
            'prevExist': (bool, prev_exist),
        })
        try:
            res = self.session.put(url, data=data, timeout=timeout)
        except:
            self.erred()
        return self.wrap_response(res)
1252268
def set_session(self, headers=None):
        
        if headers is None:
            headers = {
                'User-Agent':
                ('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_3)'
                 ' AppleWebKit/537.36 (KHTML, like Gecko) '
                 'Chrome/48.0.2564.116 Safari/537.36')
            }
        elif not isinstance(headers, dict):
            raise TypeError('"headers" must be a dict object')

        self.session = Session(self.proxy_pool)
        self.session.headers.update(headers)
694927
def set(self, instance, value, **kw):
        
        return self._set(instance, value, **kw)
695153
def set_uservar(self, user, name, value):
        
        self._session.set(user, {name: value})
701076
def set_attributes(self, session_key, attributes):
        
        session = self._lookup_required_session(session_key)
        session.set_attributes(attributes)
        self.session_handler.on_change(session)
895359
def createSessionForKey(self, key, user):
        
        PersistentSession(
            store=self.store,
            sessionKey=key,
            authenticatedAs=user)
615605
def set(self, key, value):
        
        logger.debug("Settings %s -> %s" % (key, value))
        if key in self.DEFAULTS:
            vtype = type(self.DEFAULTS[key])
        else:
            vtype = type(value)

        if vtype not in self.VALID_KEY_TYPES:
            logger.warn("Invalid key type: %s" % vtype)
            return False

        #for gconf refer to the full key path
        key = self._fix_key(key)

        if vtype is bool:
            self._client.set_bool(key, value)
        elif vtype is str:
            self._client.set_string(key, value)
        elif vtype is int:
            self._client.set_int(key, value)
        elif vtype in (list, tuple):
            #Save every value as a string
            strvalues = [str(i) for i in value]
            #self._client.set_list(key, gconf.VALUE_STRING, strvalues)

        return True
518063
def save_value(self, name, value):
        """"""
        session_name = 'list_{}_{}_{}'.format(self.kwargs.get('app'), self.kwargs.get('model'), name)
        self.request.session[session_name] = value
        setattr(self, name, value)
        return value