Joins the channel

 @param [String] key the channel key, if any. If none is
   specified but @key is set, @key will be used
 @return [void]
327273
def join(key = nil)
      if key.nil? and self.key != true
        key = self.key
      end
      @bot.irc.send "JOIN #{[@name, key].compact.join(" ")}"
    end
1180625
def add(key, value)
    if @env.has_key?(key)
      @env[key] += value
    else
      set(key,value)
    end
  end
1269289
function (key) {
                    this._initializeKeys();
                    var args = copyargs(arguments);
                    args[0] = this._keys.indexOf(key);
                    return this.splice.apply(this, args);
                }
890744
public void join(SelectableChannel ch1, SelectableChannel ch2) throws IOException
    {
        join(ch1, ch2, (ByteChannel)ch1, (ByteChannel)ch2);
    }
894700
def has_key?(key)
      if :hash == self.type
        self.children.any? { |pair_node| pair_node.key.to_value == key }
      else
        raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.debug_info}"
      end
    end
177679
def join(self, timeout=None):
        
        self._server.join(timeout)
        if self._handler_thread:
            self._handler_thread.join(timeout)
490885
def join(self, target, key=None):
        
        chantypes = self.server.features.get("CHANTYPES", "#")
        if not target or target[0] not in chantypes:
            # Among other things, this prevents accidentally sending the
            # "JOIN 0" command which actually removes you from all channels
            _log.warning("Refusing to join channel that does not start "
                         "with one of '%s': %s", chantypes, target)
            return False

        if self.server.in_channel(target):
            _log.warning("Ignoring request to join channel '%s' because we "
                         "are already in that channel.", target)
            return False

        _log.info("Joining channel %s ...", target)
        self.send("JOIN", target, *([key] if key else []))
        return True
82579
def join_channel(self, channel):
        
        self.s.send(('JOIN #%s\r\n' % channel).encode('utf-8'))
        if self.verbose:
            print('JOIN #%s\r\n' % channel)
69279
def set(key, value, overwrite: true)
      result = if overwrite
        self.connection.hset(@key, key, value)
      else
        self.connection.hsetnx(@key, key, value)
      end

      return coerce_bool(result)
    end
1250487
def bind_key(key, kcb=nil, &bl)
      kcb = bl if kcb.nil? && !bl.nil?

      cb = lambda do |cdktype, widget, component, key|
        kcb.call component, key
      end

      component.bind(:ENTRY, key, cb, self)
    end
1090408
def proxy_writer(key, *args)
      meth = "#{key}="
      if self.respond_to? meth
        self.send(meth, *args)
      else
        object.send(meth, *args)
      end
    end
206607
def join(room)
      room_object = find_room(room)

      if room_object
        redis.sadd("persisted_rooms", room_object.id)
        adapter.join(room_object.id)
      else
        adapter.join(room)
      end
    end
1162599
def start
      queue = ::Queue.new

      @thread = Thread.start do
        @listener_redis.subscribe(@channel, @my_channel) do |on|
          on.subscribe do |channel|
            queue.push(:subscribed) if channel == @channel
          end

          on.message do |channel, message|
            handle_message(channel, message)
          end
        end
      end

      queue.pop
    end
1113254
def join(self):
        
        if self.thread:
            self.thread.join()
            self.thread = None
        else:
            logger.debug("Cannot join {0}, as the state hasn't been started, yet or is already finished!".format(self))
275851
def assigned_key(key)
      return @key_assignments[key] if @key_assignments[key]
      available_keys = @input_values.keys - @key_assignments.values
      return nil if available_keys.empty?
      if available_keys.include?(key)
        @key_assignments[key] = key
      else
        @key_assignments[key] = available_keys[rand(available_keys.length)]
      end
      @key_assignments[key]
    end
838851
def follow_link(key, options = {})
      if link = links[key = key.to_s]
        response = API.send link[:method], link[:href], options[:body], options
        if resource_class = link[:resource_class]
          response = resource_class.from_response response
          response.attributes[self.class.member_name] = self
        end
        response
      end
    rescue Recurly::API::NotFound
      raise unless resource_class
    end
1152421
def add(channel, client)
      @lock.synchronize do
        _remove(client) if @clients.include? client and @clients[client] != channel
        debug { "Adding #{client} to #{channel}." }
        @clients[client] = channel
        @channels[channel] = @channels[channel] ? @channels[channel] + 1 : 1
      end
    end