id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
11,700 | briandowns/openweathermap | current.go | NewCurrent | func NewCurrent(unit, lang, key string, options ...Option) (*CurrentWeatherData, error) {
unitChoice := strings.ToUpper(unit)
langChoice := strings.ToUpper(lang)
c := &CurrentWeatherData{
Settings: NewSettings(),
}
if ValidDataUnit(unitChoice) {
c.Unit = DataUnits[unitChoice]
} else {
return nil, errUnitUnavailable
}
if ValidLangCode(langChoice) {
c.Lang = langChoice
} else {
return nil, errLangUnavailable
}
var err error
c.Key, err = setKey(key)
if err != nil {
return nil, err
}
if err := setOptions(c.Settings, options); err != nil {
return nil, err
}
return c, nil
} | go | func NewCurrent(unit, lang, key string, options ...Option) (*CurrentWeatherData, error) {
unitChoice := strings.ToUpper(unit)
langChoice := strings.ToUpper(lang)
c := &CurrentWeatherData{
Settings: NewSettings(),
}
if ValidDataUnit(unitChoice) {
c.Unit = DataUnits[unitChoice]
} else {
return nil, errUnitUnavailable
}
if ValidLangCode(langChoice) {
c.Lang = langChoice
} else {
return nil, errLangUnavailable
}
var err error
c.Key, err = setKey(key)
if err != nil {
return nil, err
}
if err := setOptions(c.Settings, options); err != nil {
return nil, err
}
return c, nil
} | [
"func",
"NewCurrent",
"(",
"unit",
",",
"lang",
",",
"key",
"string",
",",
"options",
"...",
"Option",
")",
"(",
"*",
"CurrentWeatherData",
",",
"error",
")",
"{",
"unitChoice",
":=",
"strings",
".",
"ToUpper",
"(",
"unit",
")",
"\n",
"langChoice",
":=",
"strings",
".",
"ToUpper",
"(",
"lang",
")",
"\n\n",
"c",
":=",
"&",
"CurrentWeatherData",
"{",
"Settings",
":",
"NewSettings",
"(",
")",
",",
"}",
"\n\n",
"if",
"ValidDataUnit",
"(",
"unitChoice",
")",
"{",
"c",
".",
"Unit",
"=",
"DataUnits",
"[",
"unitChoice",
"]",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"errUnitUnavailable",
"\n",
"}",
"\n\n",
"if",
"ValidLangCode",
"(",
"langChoice",
")",
"{",
"c",
".",
"Lang",
"=",
"langChoice",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"errLangUnavailable",
"\n",
"}",
"\n",
"var",
"err",
"error",
"\n",
"c",
".",
"Key",
",",
"err",
"=",
"setKey",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"setOptions",
"(",
"c",
".",
"Settings",
",",
"options",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] | // NewCurrent returns a new CurrentWeatherData pointer with the supplied parameters | [
"NewCurrent",
"returns",
"a",
"new",
"CurrentWeatherData",
"pointer",
"with",
"the",
"supplied",
"parameters"
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/current.go#L47-L76 |
11,701 | briandowns/openweathermap | current.go | CurrentByName | func (w *CurrentWeatherData) CurrentByName(location string) error {
response, err := w.client.Get(fmt.Sprintf(fmt.Sprintf(baseURL, "appid=%s&q=%s&units=%s&lang=%s"), w.Key, url.QueryEscape(location), w.Unit, w.Lang))
if err != nil {
return err
}
defer response.Body.Close()
if err := json.NewDecoder(response.Body).Decode(&w); err != nil {
return err
}
return nil
} | go | func (w *CurrentWeatherData) CurrentByName(location string) error {
response, err := w.client.Get(fmt.Sprintf(fmt.Sprintf(baseURL, "appid=%s&q=%s&units=%s&lang=%s"), w.Key, url.QueryEscape(location), w.Unit, w.Lang))
if err != nil {
return err
}
defer response.Body.Close()
if err := json.NewDecoder(response.Body).Decode(&w); err != nil {
return err
}
return nil
} | [
"func",
"(",
"w",
"*",
"CurrentWeatherData",
")",
"CurrentByName",
"(",
"location",
"string",
")",
"error",
"{",
"response",
",",
"err",
":=",
"w",
".",
"client",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"fmt",
".",
"Sprintf",
"(",
"baseURL",
",",
"\"",
"\"",
")",
",",
"w",
".",
"Key",
",",
"url",
".",
"QueryEscape",
"(",
"location",
")",
",",
"w",
".",
"Unit",
",",
"w",
".",
"Lang",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"response",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"response",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"w",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CurrentByName will provide the current weather with the provided
// location name. | [
"CurrentByName",
"will",
"provide",
"the",
"current",
"weather",
"with",
"the",
"provided",
"location",
"name",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/current.go#L80-L92 |
11,702 | briandowns/openweathermap | current.go | CurrentByCoordinates | func (w *CurrentWeatherData) CurrentByCoordinates(location *Coordinates) error {
response, err := w.client.Get(fmt.Sprintf(fmt.Sprintf(baseURL, "appid=%s&lat=%f&lon=%f&units=%s&lang=%s"), w.Key, location.Latitude, location.Longitude, w.Unit, w.Lang))
if err != nil {
return err
}
defer response.Body.Close()
if err = json.NewDecoder(response.Body).Decode(&w); err != nil {
return err
}
return nil
} | go | func (w *CurrentWeatherData) CurrentByCoordinates(location *Coordinates) error {
response, err := w.client.Get(fmt.Sprintf(fmt.Sprintf(baseURL, "appid=%s&lat=%f&lon=%f&units=%s&lang=%s"), w.Key, location.Latitude, location.Longitude, w.Unit, w.Lang))
if err != nil {
return err
}
defer response.Body.Close()
if err = json.NewDecoder(response.Body).Decode(&w); err != nil {
return err
}
return nil
} | [
"func",
"(",
"w",
"*",
"CurrentWeatherData",
")",
"CurrentByCoordinates",
"(",
"location",
"*",
"Coordinates",
")",
"error",
"{",
"response",
",",
"err",
":=",
"w",
".",
"client",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"fmt",
".",
"Sprintf",
"(",
"baseURL",
",",
"\"",
"\"",
")",
",",
"w",
".",
"Key",
",",
"location",
".",
"Latitude",
",",
"location",
".",
"Longitude",
",",
"w",
".",
"Unit",
",",
"w",
".",
"Lang",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"response",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"response",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"w",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CurrentByCoordinates will provide the current weather with the
// provided location coordinates. | [
"CurrentByCoordinates",
"will",
"provide",
"the",
"current",
"weather",
"with",
"the",
"provided",
"location",
"coordinates",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/current.go#L96-L108 |
11,703 | briandowns/openweathermap | current.go | CurrentByID | func (w *CurrentWeatherData) CurrentByID(id int) error {
response, err := w.client.Get(fmt.Sprintf(fmt.Sprintf(baseURL, "appid=%s&id=%d&units=%s&lang=%s"), w.Key, id, w.Unit, w.Lang))
if err != nil {
return err
}
defer response.Body.Close()
if err = json.NewDecoder(response.Body).Decode(&w); err != nil {
return err
}
return nil
} | go | func (w *CurrentWeatherData) CurrentByID(id int) error {
response, err := w.client.Get(fmt.Sprintf(fmt.Sprintf(baseURL, "appid=%s&id=%d&units=%s&lang=%s"), w.Key, id, w.Unit, w.Lang))
if err != nil {
return err
}
defer response.Body.Close()
if err = json.NewDecoder(response.Body).Decode(&w); err != nil {
return err
}
return nil
} | [
"func",
"(",
"w",
"*",
"CurrentWeatherData",
")",
"CurrentByID",
"(",
"id",
"int",
")",
"error",
"{",
"response",
",",
"err",
":=",
"w",
".",
"client",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"fmt",
".",
"Sprintf",
"(",
"baseURL",
",",
"\"",
"\"",
")",
",",
"w",
".",
"Key",
",",
"id",
",",
"w",
".",
"Unit",
",",
"w",
".",
"Lang",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"response",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"response",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"w",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CurrentByID will provide the current weather with the
// provided location ID. | [
"CurrentByID",
"will",
"provide",
"the",
"current",
"weather",
"with",
"the",
"provided",
"location",
"ID",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/current.go#L112-L124 |
11,704 | briandowns/openweathermap | current.go | CurrentByZip | func (w *CurrentWeatherData) CurrentByZip(zip int, countryCode string) error {
response, err := w.client.Get(fmt.Sprintf(fmt.Sprintf(baseURL, "appid=%s&zip=%d,%s&units=%s&lang=%s"), w.Key, zip, countryCode, w.Unit, w.Lang))
if err != nil {
return err
}
defer response.Body.Close()
if err = json.NewDecoder(response.Body).Decode(&w); err != nil {
return err
}
return nil
} | go | func (w *CurrentWeatherData) CurrentByZip(zip int, countryCode string) error {
response, err := w.client.Get(fmt.Sprintf(fmt.Sprintf(baseURL, "appid=%s&zip=%d,%s&units=%s&lang=%s"), w.Key, zip, countryCode, w.Unit, w.Lang))
if err != nil {
return err
}
defer response.Body.Close()
if err = json.NewDecoder(response.Body).Decode(&w); err != nil {
return err
}
return nil
} | [
"func",
"(",
"w",
"*",
"CurrentWeatherData",
")",
"CurrentByZip",
"(",
"zip",
"int",
",",
"countryCode",
"string",
")",
"error",
"{",
"response",
",",
"err",
":=",
"w",
".",
"client",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"fmt",
".",
"Sprintf",
"(",
"baseURL",
",",
"\"",
"\"",
")",
",",
"w",
".",
"Key",
",",
"zip",
",",
"countryCode",
",",
"w",
".",
"Unit",
",",
"w",
".",
"Lang",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"response",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"response",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"w",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CurrentByZip will provide the current weather for the
// provided zip code. | [
"CurrentByZip",
"will",
"provide",
"the",
"current",
"weather",
"for",
"the",
"provided",
"zip",
"code",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/current.go#L128-L139 |
11,705 | briandowns/openweathermap | forecast.go | NewForecast | func NewForecast(forecastType, unit, lang, key string, options ...Option) (*ForecastWeatherData, error) {
unitChoice := strings.ToUpper(unit)
langChoice := strings.ToUpper(lang)
if forecastType != "16" && forecastType != "5" {
return nil, errForecastUnavailable
}
if !ValidDataUnit(unitChoice) {
return nil, errUnitUnavailable
}
if !ValidLangCode(langChoice) {
return nil, errLangUnavailable
}
settings := NewSettings()
if err := setOptions(settings, options); err != nil {
return nil, err
}
var err error
k, err := setKey(key)
if err != nil {
return nil, err
}
forecastData := ForecastWeatherData{
Unit: DataUnits[unitChoice],
Lang: langChoice,
Key: k,
Settings: settings,
}
if forecastType == "16" {
forecastData.baseURL = forecast16Base
forecastData.ForecastWeatherJson = &Forecast16WeatherData{}
} else {
forecastData.baseURL = forecast5Base
forecastData.ForecastWeatherJson = &Forecast5WeatherData{}
}
return &forecastData, nil
} | go | func NewForecast(forecastType, unit, lang, key string, options ...Option) (*ForecastWeatherData, error) {
unitChoice := strings.ToUpper(unit)
langChoice := strings.ToUpper(lang)
if forecastType != "16" && forecastType != "5" {
return nil, errForecastUnavailable
}
if !ValidDataUnit(unitChoice) {
return nil, errUnitUnavailable
}
if !ValidLangCode(langChoice) {
return nil, errLangUnavailable
}
settings := NewSettings()
if err := setOptions(settings, options); err != nil {
return nil, err
}
var err error
k, err := setKey(key)
if err != nil {
return nil, err
}
forecastData := ForecastWeatherData{
Unit: DataUnits[unitChoice],
Lang: langChoice,
Key: k,
Settings: settings,
}
if forecastType == "16" {
forecastData.baseURL = forecast16Base
forecastData.ForecastWeatherJson = &Forecast16WeatherData{}
} else {
forecastData.baseURL = forecast5Base
forecastData.ForecastWeatherJson = &Forecast5WeatherData{}
}
return &forecastData, nil
} | [
"func",
"NewForecast",
"(",
"forecastType",
",",
"unit",
",",
"lang",
",",
"key",
"string",
",",
"options",
"...",
"Option",
")",
"(",
"*",
"ForecastWeatherData",
",",
"error",
")",
"{",
"unitChoice",
":=",
"strings",
".",
"ToUpper",
"(",
"unit",
")",
"\n",
"langChoice",
":=",
"strings",
".",
"ToUpper",
"(",
"lang",
")",
"\n\n",
"if",
"forecastType",
"!=",
"\"",
"\"",
"&&",
"forecastType",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errForecastUnavailable",
"\n",
"}",
"\n\n",
"if",
"!",
"ValidDataUnit",
"(",
"unitChoice",
")",
"{",
"return",
"nil",
",",
"errUnitUnavailable",
"\n",
"}",
"\n\n",
"if",
"!",
"ValidLangCode",
"(",
"langChoice",
")",
"{",
"return",
"nil",
",",
"errLangUnavailable",
"\n",
"}",
"\n\n",
"settings",
":=",
"NewSettings",
"(",
")",
"\n",
"if",
"err",
":=",
"setOptions",
"(",
"settings",
",",
"options",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"k",
",",
"err",
":=",
"setKey",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"forecastData",
":=",
"ForecastWeatherData",
"{",
"Unit",
":",
"DataUnits",
"[",
"unitChoice",
"]",
",",
"Lang",
":",
"langChoice",
",",
"Key",
":",
"k",
",",
"Settings",
":",
"settings",
",",
"}",
"\n\n",
"if",
"forecastType",
"==",
"\"",
"\"",
"{",
"forecastData",
".",
"baseURL",
"=",
"forecast16Base",
"\n",
"forecastData",
".",
"ForecastWeatherJson",
"=",
"&",
"Forecast16WeatherData",
"{",
"}",
"\n",
"}",
"else",
"{",
"forecastData",
".",
"baseURL",
"=",
"forecast5Base",
"\n",
"forecastData",
".",
"ForecastWeatherJson",
"=",
"&",
"Forecast5WeatherData",
"{",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"forecastData",
",",
"nil",
"\n",
"}"
] | // NewForecast returns a new HistoricalWeatherData pointer with
// the supplied arguments. | [
"NewForecast",
"returns",
"a",
"new",
"HistoricalWeatherData",
"pointer",
"with",
"the",
"supplied",
"arguments",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/forecast.go#L73-L115 |
11,706 | briandowns/openweathermap | forecast.go | DailyByName | func (f *ForecastWeatherData) DailyByName(location string, days int) error {
response, err := f.client.Get(fmt.Sprintf(f.baseURL, f.Key, fmt.Sprintf("%s=%s", "q", url.QueryEscape(location)), f.Unit, f.Lang, days))
if err != nil {
return err
}
defer response.Body.Close()
return f.ForecastWeatherJson.Decode(response.Body)
} | go | func (f *ForecastWeatherData) DailyByName(location string, days int) error {
response, err := f.client.Get(fmt.Sprintf(f.baseURL, f.Key, fmt.Sprintf("%s=%s", "q", url.QueryEscape(location)), f.Unit, f.Lang, days))
if err != nil {
return err
}
defer response.Body.Close()
return f.ForecastWeatherJson.Decode(response.Body)
} | [
"func",
"(",
"f",
"*",
"ForecastWeatherData",
")",
"DailyByName",
"(",
"location",
"string",
",",
"days",
"int",
")",
"error",
"{",
"response",
",",
"err",
":=",
"f",
".",
"client",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"f",
".",
"baseURL",
",",
"f",
".",
"Key",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"url",
".",
"QueryEscape",
"(",
"location",
")",
")",
",",
"f",
".",
"Unit",
",",
"f",
".",
"Lang",
",",
"days",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"response",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"return",
"f",
".",
"ForecastWeatherJson",
".",
"Decode",
"(",
"response",
".",
"Body",
")",
"\n",
"}"
] | // DailyByName will provide a forecast for the location given for the
// number of days given. | [
"DailyByName",
"will",
"provide",
"a",
"forecast",
"for",
"the",
"location",
"given",
"for",
"the",
"number",
"of",
"days",
"given",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/forecast.go#L119-L127 |
11,707 | briandowns/openweathermap | forecast.go | DailyByCoordinates | func (f *ForecastWeatherData) DailyByCoordinates(location *Coordinates, days int) error {
response, err := f.client.Get(fmt.Sprintf(f.baseURL, f.Key, fmt.Sprintf("lat=%f&lon=%f", location.Latitude, location.Longitude), f.Unit, f.Lang, days))
if err != nil {
return err
}
defer response.Body.Close()
return f.ForecastWeatherJson.Decode(response.Body)
} | go | func (f *ForecastWeatherData) DailyByCoordinates(location *Coordinates, days int) error {
response, err := f.client.Get(fmt.Sprintf(f.baseURL, f.Key, fmt.Sprintf("lat=%f&lon=%f", location.Latitude, location.Longitude), f.Unit, f.Lang, days))
if err != nil {
return err
}
defer response.Body.Close()
return f.ForecastWeatherJson.Decode(response.Body)
} | [
"func",
"(",
"f",
"*",
"ForecastWeatherData",
")",
"DailyByCoordinates",
"(",
"location",
"*",
"Coordinates",
",",
"days",
"int",
")",
"error",
"{",
"response",
",",
"err",
":=",
"f",
".",
"client",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"f",
".",
"baseURL",
",",
"f",
".",
"Key",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"location",
".",
"Latitude",
",",
"location",
".",
"Longitude",
")",
",",
"f",
".",
"Unit",
",",
"f",
".",
"Lang",
",",
"days",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"response",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"return",
"f",
".",
"ForecastWeatherJson",
".",
"Decode",
"(",
"response",
".",
"Body",
")",
"\n",
"}"
] | // DailyByCoordinates will provide a forecast for the coordinates ID give
// for the number of days given. | [
"DailyByCoordinates",
"will",
"provide",
"a",
"forecast",
"for",
"the",
"coordinates",
"ID",
"give",
"for",
"the",
"number",
"of",
"days",
"given",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/forecast.go#L131-L139 |
11,708 | briandowns/openweathermap | forecast.go | DailyByID | func (f *ForecastWeatherData) DailyByID(id, days int) error {
response, err := f.client.Get(fmt.Sprintf(f.baseURL, f.Key, fmt.Sprintf("%s=%s", "id", strconv.Itoa(id)), f.Unit, f.Lang, days))
if err != nil {
return err
}
defer response.Body.Close()
return f.ForecastWeatherJson.Decode(response.Body)
} | go | func (f *ForecastWeatherData) DailyByID(id, days int) error {
response, err := f.client.Get(fmt.Sprintf(f.baseURL, f.Key, fmt.Sprintf("%s=%s", "id", strconv.Itoa(id)), f.Unit, f.Lang, days))
if err != nil {
return err
}
defer response.Body.Close()
return f.ForecastWeatherJson.Decode(response.Body)
} | [
"func",
"(",
"f",
"*",
"ForecastWeatherData",
")",
"DailyByID",
"(",
"id",
",",
"days",
"int",
")",
"error",
"{",
"response",
",",
"err",
":=",
"f",
".",
"client",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"f",
".",
"baseURL",
",",
"f",
".",
"Key",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"id",
")",
")",
",",
"f",
".",
"Unit",
",",
"f",
".",
"Lang",
",",
"days",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"response",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"return",
"f",
".",
"ForecastWeatherJson",
".",
"Decode",
"(",
"response",
".",
"Body",
")",
"\n",
"}"
] | // DailyByID will provide a forecast for the location ID give for the
// number of days given. | [
"DailyByID",
"will",
"provide",
"a",
"forecast",
"for",
"the",
"location",
"ID",
"give",
"for",
"the",
"number",
"of",
"days",
"given",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/forecast.go#L143-L151 |
11,709 | briandowns/openweathermap | openweathermap.go | setKey | func setKey(key string) (string, error) {
if err := ValidAPIKey(key); err != nil {
return "", err
}
return key, nil
} | go | func setKey(key string) (string, error) {
if err := ValidAPIKey(key); err != nil {
return "", err
}
return key, nil
} | [
"func",
"setKey",
"(",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"ValidAPIKey",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"key",
",",
"nil",
"\n",
"}"
] | // return key
// } | [
"return",
"key",
"}"
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/openweathermap.go#L139-L144 |
11,710 | briandowns/openweathermap | openweathermap.go | ValidDataUnit | func ValidDataUnit(u string) bool {
for d := range DataUnits {
if u == d {
return true
}
}
return false
} | go | func ValidDataUnit(u string) bool {
for d := range DataUnits {
if u == d {
return true
}
}
return false
} | [
"func",
"ValidDataUnit",
"(",
"u",
"string",
")",
"bool",
"{",
"for",
"d",
":=",
"range",
"DataUnits",
"{",
"if",
"u",
"==",
"d",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // ValidDataUnit makes sure the string passed in is an accepted
// unit of measure to be used for the return data. | [
"ValidDataUnit",
"makes",
"sure",
"the",
"string",
"passed",
"in",
"is",
"an",
"accepted",
"unit",
"of",
"measure",
"to",
"be",
"used",
"for",
"the",
"return",
"data",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/openweathermap.go#L148-L155 |
11,711 | briandowns/openweathermap | openweathermap.go | ValidLangCode | func ValidLangCode(c string) bool {
for d := range LangCodes {
if c == d {
return true
}
}
return false
} | go | func ValidLangCode(c string) bool {
for d := range LangCodes {
if c == d {
return true
}
}
return false
} | [
"func",
"ValidLangCode",
"(",
"c",
"string",
")",
"bool",
"{",
"for",
"d",
":=",
"range",
"LangCodes",
"{",
"if",
"c",
"==",
"d",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // ValidLangCode makes sure the string passed in is an
// acceptable lang code. | [
"ValidLangCode",
"makes",
"sure",
"the",
"string",
"passed",
"in",
"is",
"an",
"acceptable",
"lang",
"code",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/openweathermap.go#L159-L166 |
11,712 | briandowns/openweathermap | openweathermap.go | ValidDataUnitSymbol | func ValidDataUnitSymbol(u string) bool {
for _, d := range DataUnits {
if u == d {
return true
}
}
return false
} | go | func ValidDataUnitSymbol(u string) bool {
for _, d := range DataUnits {
if u == d {
return true
}
}
return false
} | [
"func",
"ValidDataUnitSymbol",
"(",
"u",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"d",
":=",
"range",
"DataUnits",
"{",
"if",
"u",
"==",
"d",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // ValidDataUnitSymbol makes sure the string passed in is an
// acceptable data unit symbol. | [
"ValidDataUnitSymbol",
"makes",
"sure",
"the",
"string",
"passed",
"in",
"is",
"an",
"acceptable",
"data",
"unit",
"symbol",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/openweathermap.go#L170-L177 |
11,713 | briandowns/openweathermap | openweathermap.go | WithHttpClient | func WithHttpClient(c *http.Client) Option {
return func(s *Settings) error {
if c == nil {
return errInvalidHttpClient
}
s.client = c
return nil
}
} | go | func WithHttpClient(c *http.Client) Option {
return func(s *Settings) error {
if c == nil {
return errInvalidHttpClient
}
s.client = c
return nil
}
} | [
"func",
"WithHttpClient",
"(",
"c",
"*",
"http",
".",
"Client",
")",
"Option",
"{",
"return",
"func",
"(",
"s",
"*",
"Settings",
")",
"error",
"{",
"if",
"c",
"==",
"nil",
"{",
"return",
"errInvalidHttpClient",
"\n",
"}",
"\n",
"s",
".",
"client",
"=",
"c",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // WithHttpClient sets custom http client when creating a new Client. | [
"WithHttpClient",
"sets",
"custom",
"http",
"client",
"when",
"creating",
"a",
"new",
"Client",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/openweathermap.go#L206-L214 |
11,714 | briandowns/openweathermap | openweathermap.go | setOptions | func setOptions(settings *Settings, options []Option) error {
for _, option := range options {
if option == nil {
return errInvalidOption
}
err := option(settings)
if err != nil {
return err
}
}
return nil
} | go | func setOptions(settings *Settings, options []Option) error {
for _, option := range options {
if option == nil {
return errInvalidOption
}
err := option(settings)
if err != nil {
return err
}
}
return nil
} | [
"func",
"setOptions",
"(",
"settings",
"*",
"Settings",
",",
"options",
"[",
"]",
"Option",
")",
"error",
"{",
"for",
"_",
",",
"option",
":=",
"range",
"options",
"{",
"if",
"option",
"==",
"nil",
"{",
"return",
"errInvalidOption",
"\n",
"}",
"\n",
"err",
":=",
"option",
"(",
"settings",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // setOptions sets Optional client settings to the Settings pointer | [
"setOptions",
"sets",
"Optional",
"client",
"settings",
"to",
"the",
"Settings",
"pointer"
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/openweathermap.go#L217-L228 |
11,715 | briandowns/openweathermap | conditions.go | RetrieveIcon | func RetrieveIcon(destination, iconFile string) (int64, error) {
fullFilePath := fmt.Sprintf("%s/%s", destination, iconFile)
// Check to see if we've already gotten that icon file. If so, use it
// rather than getting it again.
if _, err := os.Stat(fullFilePath); err != nil {
response, err := http.Get(fmt.Sprintf(iconURL, iconFile))
if err != nil {
return 0, err
}
defer response.Body.Close()
// Create the icon file
out, err := os.Create(fullFilePath)
if err != nil {
return 0, err
}
defer out.Close()
// Fill the empty file with the actual content
n, err := io.Copy(out, response.Body)
if err != nil {
return 0, err
}
return n, nil
}
return 0, nil
} | go | func RetrieveIcon(destination, iconFile string) (int64, error) {
fullFilePath := fmt.Sprintf("%s/%s", destination, iconFile)
// Check to see if we've already gotten that icon file. If so, use it
// rather than getting it again.
if _, err := os.Stat(fullFilePath); err != nil {
response, err := http.Get(fmt.Sprintf(iconURL, iconFile))
if err != nil {
return 0, err
}
defer response.Body.Close()
// Create the icon file
out, err := os.Create(fullFilePath)
if err != nil {
return 0, err
}
defer out.Close()
// Fill the empty file with the actual content
n, err := io.Copy(out, response.Body)
if err != nil {
return 0, err
}
return n, nil
}
return 0, nil
} | [
"func",
"RetrieveIcon",
"(",
"destination",
",",
"iconFile",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"fullFilePath",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"destination",
",",
"iconFile",
")",
"\n\n",
"// Check to see if we've already gotten that icon file. If so, use it",
"// rather than getting it again.",
"if",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"fullFilePath",
")",
";",
"err",
"!=",
"nil",
"{",
"response",
",",
"err",
":=",
"http",
".",
"Get",
"(",
"fmt",
".",
"Sprintf",
"(",
"iconURL",
",",
"iconFile",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"defer",
"response",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"// Create the icon file",
"out",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"fullFilePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"defer",
"out",
".",
"Close",
"(",
")",
"\n\n",
"// Fill the empty file with the actual content",
"n",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"out",
",",
"response",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"n",
",",
"nil",
"\n",
"}",
"\n",
"return",
"0",
",",
"nil",
"\n",
"}"
] | // RetrieveIcon will get the specified icon from the API. | [
"RetrieveIcon",
"will",
"get",
"the",
"specified",
"icon",
"from",
"the",
"API",
"."
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/conditions.go#L40-L67 |
11,716 | briandowns/openweathermap | _examples/web/weatherweb.go | main | func main() {
http.HandleFunc("/here", hereHandler)
// Make sure we can serve our icon files once retrieved
http.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, r.URL.Path[1:])
})
http.ListenAndServe(":8888", nil)
} | go | func main() {
http.HandleFunc("/here", hereHandler)
// Make sure we can serve our icon files once retrieved
http.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, r.URL.Path[1:])
})
http.ListenAndServe(":8888", nil)
} | [
"func",
"main",
"(",
")",
"{",
"http",
".",
"HandleFunc",
"(",
"\"",
"\"",
",",
"hereHandler",
")",
"\n",
"// Make sure we can serve our icon files once retrieved",
"http",
".",
"HandleFunc",
"(",
"\"",
"\"",
",",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"http",
".",
"ServeFile",
"(",
"w",
",",
"r",
",",
"r",
".",
"URL",
".",
"Path",
"[",
"1",
":",
"]",
")",
"\n",
"}",
")",
"\n",
"http",
".",
"ListenAndServe",
"(",
"\"",
"\"",
",",
"nil",
")",
"\n",
"}"
] | // Run the app | [
"Run",
"the",
"app"
] | 5f41b7c9d92de5d74bf32f4486375c7547bc8a3c | https://github.com/briandowns/openweathermap/blob/5f41b7c9d92de5d74bf32f4486375c7547bc8a3c/_examples/web/weatherweb.go#L98-L105 |
11,717 | fluffle/goirc | client/commands.go | Privmsgf | func (conn *Conn) Privmsgf(t, format string, a ...interface{}) {
msg := fmt.Sprintf(format, a...)
conn.Privmsg(t, msg)
} | go | func (conn *Conn) Privmsgf(t, format string, a ...interface{}) {
msg := fmt.Sprintf(format, a...)
conn.Privmsg(t, msg)
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"Privmsgf",
"(",
"t",
",",
"format",
"string",
",",
"a",
"...",
"interface",
"{",
"}",
")",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"a",
"...",
")",
"\n",
"conn",
".",
"Privmsg",
"(",
"t",
",",
"msg",
")",
"\n",
"}"
] | // Privmsgf is the variadic version of Privmsg that formats the message
// that is sent to the target nick or channel t using the
// fmt.Sprintf function. | [
"Privmsgf",
"is",
"the",
"variadic",
"version",
"of",
"Privmsg",
"that",
"formats",
"the",
"message",
"that",
"is",
"sent",
"to",
"the",
"target",
"nick",
"or",
"channel",
"t",
"using",
"the",
"fmt",
".",
"Sprintf",
"function",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/commands.go#L182-L185 |
11,718 | fluffle/goirc | client/commands.go | Invite | func (conn *Conn) Invite(nick, channel string) {
conn.Raw(INVITE + " " + nick + " " + channel)
} | go | func (conn *Conn) Invite(nick, channel string) {
conn.Raw(INVITE + " " + nick + " " + channel)
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"Invite",
"(",
"nick",
",",
"channel",
"string",
")",
"{",
"conn",
".",
"Raw",
"(",
"INVITE",
"+",
"\"",
"\"",
"+",
"nick",
"+",
"\"",
"\"",
"+",
"channel",
")",
"\n",
"}"
] | // Invite sends an INVITE command to the server.
// INVITE nick channel | [
"Invite",
"sends",
"an",
"INVITE",
"command",
"to",
"the",
"server",
".",
"INVITE",
"nick",
"channel"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/commands.go#L275-L277 |
11,719 | fluffle/goirc | client/connection.go | SimpleClient | func SimpleClient(nick string, args ...string) *Conn {
conn := Client(NewConfig(nick, args...))
return conn
} | go | func SimpleClient(nick string, args ...string) *Conn {
conn := Client(NewConfig(nick, args...))
return conn
} | [
"func",
"SimpleClient",
"(",
"nick",
"string",
",",
"args",
"...",
"string",
")",
"*",
"Conn",
"{",
"conn",
":=",
"Client",
"(",
"NewConfig",
"(",
"nick",
",",
"args",
"...",
")",
")",
"\n",
"return",
"conn",
"\n",
"}"
] | // SimpleClient creates a new Conn, passing its arguments to NewConfig.
// If you don't need to change any client options and just want to get
// started quickly, this is a convenient shortcut. | [
"SimpleClient",
"creates",
"a",
"new",
"Conn",
"passing",
"its",
"arguments",
"to",
"NewConfig",
".",
"If",
"you",
"don",
"t",
"need",
"to",
"change",
"any",
"client",
"options",
"and",
"just",
"want",
"to",
"get",
"started",
"quickly",
"this",
"is",
"a",
"convenient",
"shortcut",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L149-L152 |
11,720 | fluffle/goirc | client/connection.go | Client | func Client(cfg *Config) *Conn {
if cfg == nil {
cfg = NewConfig("__idiot__")
}
if cfg.Me == nil || cfg.Me.Nick == "" || cfg.Me.Ident == "" {
cfg.Me = &state.Nick{Nick: "__idiot__"}
cfg.Me.Ident = "goirc"
cfg.Me.Name = "Powered by GoIRC"
}
dialer := new(net.Dialer)
dialer.Timeout = cfg.Timeout
dialer.DualStack = cfg.DualStack
if cfg.LocalAddr != "" {
if !hasPort(cfg.LocalAddr) {
cfg.LocalAddr += ":0"
}
local, err := net.ResolveTCPAddr("tcp", cfg.LocalAddr)
if err == nil {
dialer.LocalAddr = local
} else {
logging.Error("irc.Client(): Cannot resolve local address %s: %s", cfg.LocalAddr, err)
}
}
conn := &Conn{
cfg: cfg,
dialer: dialer,
intHandlers: handlerSet(),
fgHandlers: handlerSet(),
bgHandlers: handlerSet(),
stRemovers: make([]Remover, 0, len(stHandlers)),
lastsent: time.Now(),
}
conn.addIntHandlers()
return conn
} | go | func Client(cfg *Config) *Conn {
if cfg == nil {
cfg = NewConfig("__idiot__")
}
if cfg.Me == nil || cfg.Me.Nick == "" || cfg.Me.Ident == "" {
cfg.Me = &state.Nick{Nick: "__idiot__"}
cfg.Me.Ident = "goirc"
cfg.Me.Name = "Powered by GoIRC"
}
dialer := new(net.Dialer)
dialer.Timeout = cfg.Timeout
dialer.DualStack = cfg.DualStack
if cfg.LocalAddr != "" {
if !hasPort(cfg.LocalAddr) {
cfg.LocalAddr += ":0"
}
local, err := net.ResolveTCPAddr("tcp", cfg.LocalAddr)
if err == nil {
dialer.LocalAddr = local
} else {
logging.Error("irc.Client(): Cannot resolve local address %s: %s", cfg.LocalAddr, err)
}
}
conn := &Conn{
cfg: cfg,
dialer: dialer,
intHandlers: handlerSet(),
fgHandlers: handlerSet(),
bgHandlers: handlerSet(),
stRemovers: make([]Remover, 0, len(stHandlers)),
lastsent: time.Now(),
}
conn.addIntHandlers()
return conn
} | [
"func",
"Client",
"(",
"cfg",
"*",
"Config",
")",
"*",
"Conn",
"{",
"if",
"cfg",
"==",
"nil",
"{",
"cfg",
"=",
"NewConfig",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Me",
"==",
"nil",
"||",
"cfg",
".",
"Me",
".",
"Nick",
"==",
"\"",
"\"",
"||",
"cfg",
".",
"Me",
".",
"Ident",
"==",
"\"",
"\"",
"{",
"cfg",
".",
"Me",
"=",
"&",
"state",
".",
"Nick",
"{",
"Nick",
":",
"\"",
"\"",
"}",
"\n",
"cfg",
".",
"Me",
".",
"Ident",
"=",
"\"",
"\"",
"\n",
"cfg",
".",
"Me",
".",
"Name",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"dialer",
":=",
"new",
"(",
"net",
".",
"Dialer",
")",
"\n",
"dialer",
".",
"Timeout",
"=",
"cfg",
".",
"Timeout",
"\n",
"dialer",
".",
"DualStack",
"=",
"cfg",
".",
"DualStack",
"\n",
"if",
"cfg",
".",
"LocalAddr",
"!=",
"\"",
"\"",
"{",
"if",
"!",
"hasPort",
"(",
"cfg",
".",
"LocalAddr",
")",
"{",
"cfg",
".",
"LocalAddr",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"local",
",",
"err",
":=",
"net",
".",
"ResolveTCPAddr",
"(",
"\"",
"\"",
",",
"cfg",
".",
"LocalAddr",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"dialer",
".",
"LocalAddr",
"=",
"local",
"\n",
"}",
"else",
"{",
"logging",
".",
"Error",
"(",
"\"",
"\"",
",",
"cfg",
".",
"LocalAddr",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"conn",
":=",
"&",
"Conn",
"{",
"cfg",
":",
"cfg",
",",
"dialer",
":",
"dialer",
",",
"intHandlers",
":",
"handlerSet",
"(",
")",
",",
"fgHandlers",
":",
"handlerSet",
"(",
")",
",",
"bgHandlers",
":",
"handlerSet",
"(",
")",
",",
"stRemovers",
":",
"make",
"(",
"[",
"]",
"Remover",
",",
"0",
",",
"len",
"(",
"stHandlers",
")",
")",
",",
"lastsent",
":",
"time",
".",
"Now",
"(",
")",
",",
"}",
"\n",
"conn",
".",
"addIntHandlers",
"(",
")",
"\n",
"return",
"conn",
"\n",
"}"
] | // Client takes a Config struct and returns a new Conn ready to have
// handlers added and connect to a server. | [
"Client",
"takes",
"a",
"Config",
"struct",
"and",
"returns",
"a",
"new",
"Conn",
"ready",
"to",
"have",
"handlers",
"added",
"and",
"connect",
"to",
"a",
"server",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L156-L193 |
11,721 | fluffle/goirc | client/connection.go | Connected | func (conn *Conn) Connected() bool {
conn.mu.RLock()
defer conn.mu.RUnlock()
return conn.connected
} | go | func (conn *Conn) Connected() bool {
conn.mu.RLock()
defer conn.mu.RUnlock()
return conn.connected
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"Connected",
"(",
")",
"bool",
"{",
"conn",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"conn",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"conn",
".",
"connected",
"\n",
"}"
] | // Connected returns true if the client is successfully connected to
// an IRC server. It becomes true when the TCP connection is established,
// and false again when the connection is closed. | [
"Connected",
"returns",
"true",
"if",
"the",
"client",
"is",
"successfully",
"connected",
"to",
"an",
"IRC",
"server",
".",
"It",
"becomes",
"true",
"when",
"the",
"TCP",
"connection",
"is",
"established",
"and",
"false",
"again",
"when",
"the",
"connection",
"is",
"closed",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L198-L202 |
11,722 | fluffle/goirc | client/connection.go | Me | func (conn *Conn) Me() *state.Nick {
if conn.st != nil {
conn.cfg.Me = conn.st.Me()
}
return conn.cfg.Me
} | go | func (conn *Conn) Me() *state.Nick {
if conn.st != nil {
conn.cfg.Me = conn.st.Me()
}
return conn.cfg.Me
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"Me",
"(",
")",
"*",
"state",
".",
"Nick",
"{",
"if",
"conn",
".",
"st",
"!=",
"nil",
"{",
"conn",
".",
"cfg",
".",
"Me",
"=",
"conn",
".",
"st",
".",
"Me",
"(",
")",
"\n",
"}",
"\n",
"return",
"conn",
".",
"cfg",
".",
"Me",
"\n",
"}"
] | // Me returns a state.Nick that reflects the client's IRC nick at the
// time it is called. If state tracking is enabled, this comes from
// the tracker, otherwise it is equivalent to conn.cfg.Me. | [
"Me",
"returns",
"a",
"state",
".",
"Nick",
"that",
"reflects",
"the",
"client",
"s",
"IRC",
"nick",
"at",
"the",
"time",
"it",
"is",
"called",
".",
"If",
"state",
"tracking",
"is",
"enabled",
"this",
"comes",
"from",
"the",
"tracker",
"otherwise",
"it",
"is",
"equivalent",
"to",
"conn",
".",
"cfg",
".",
"Me",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L220-L225 |
11,723 | fluffle/goirc | client/connection.go | DisableStateTracking | func (conn *Conn) DisableStateTracking() {
conn.mu.Lock()
defer conn.mu.Unlock()
if conn.st != nil {
conn.cfg.Me = conn.st.Me()
conn.delSTHandlers()
conn.st.Wipe()
conn.st = nil
}
} | go | func (conn *Conn) DisableStateTracking() {
conn.mu.Lock()
defer conn.mu.Unlock()
if conn.st != nil {
conn.cfg.Me = conn.st.Me()
conn.delSTHandlers()
conn.st.Wipe()
conn.st = nil
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"DisableStateTracking",
"(",
")",
"{",
"conn",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"conn",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"conn",
".",
"st",
"!=",
"nil",
"{",
"conn",
".",
"cfg",
".",
"Me",
"=",
"conn",
".",
"st",
".",
"Me",
"(",
")",
"\n",
"conn",
".",
"delSTHandlers",
"(",
")",
"\n",
"conn",
".",
"st",
".",
"Wipe",
"(",
")",
"\n",
"conn",
".",
"st",
"=",
"nil",
"\n",
"}",
"\n",
"}"
] | // DisableStateTracking causes the client to stop tracking information
// about the channels and nicks it knows of. It will also wipe current
// state from the state tracker. | [
"DisableStateTracking",
"causes",
"the",
"client",
"to",
"stop",
"tracking",
"information",
"about",
"the",
"channels",
"and",
"nicks",
"it",
"knows",
"of",
".",
"It",
"will",
"also",
"wipe",
"current",
"state",
"from",
"the",
"state",
"tracker",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L257-L266 |
11,724 | fluffle/goirc | client/connection.go | initialise | func (conn *Conn) initialise() {
conn.io = nil
conn.sock = nil
conn.in = make(chan *Line, 32)
conn.out = make(chan string, 32)
conn.die = make(chan struct{})
if conn.st != nil {
conn.st.Wipe()
}
} | go | func (conn *Conn) initialise() {
conn.io = nil
conn.sock = nil
conn.in = make(chan *Line, 32)
conn.out = make(chan string, 32)
conn.die = make(chan struct{})
if conn.st != nil {
conn.st.Wipe()
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"initialise",
"(",
")",
"{",
"conn",
".",
"io",
"=",
"nil",
"\n",
"conn",
".",
"sock",
"=",
"nil",
"\n",
"conn",
".",
"in",
"=",
"make",
"(",
"chan",
"*",
"Line",
",",
"32",
")",
"\n",
"conn",
".",
"out",
"=",
"make",
"(",
"chan",
"string",
",",
"32",
")",
"\n",
"conn",
".",
"die",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"if",
"conn",
".",
"st",
"!=",
"nil",
"{",
"conn",
".",
"st",
".",
"Wipe",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Per-connection state initialisation. | [
"Per",
"-",
"connection",
"state",
"initialisation",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L269-L278 |
11,725 | fluffle/goirc | client/connection.go | internalConnect | func (conn *Conn) internalConnect() error {
conn.mu.Lock()
defer conn.mu.Unlock()
conn.initialise()
if conn.cfg.Server == "" {
return fmt.Errorf("irc.Connect(): cfg.Server must be non-empty")
}
if conn.connected {
return fmt.Errorf("irc.Connect(): Cannot connect to %s, already connected.", conn.cfg.Server)
}
if !hasPort(conn.cfg.Server) {
if conn.cfg.SSL {
conn.cfg.Server = net.JoinHostPort(conn.cfg.Server, "6697")
} else {
conn.cfg.Server = net.JoinHostPort(conn.cfg.Server, "6667")
}
}
if conn.cfg.Proxy != "" {
proxyURL, err := url.Parse(conn.cfg.Proxy)
if err != nil {
return err
}
conn.proxyDialer, err = proxy.FromURL(proxyURL, conn.dialer)
if err != nil {
return err
}
logging.Info("irc.Connect(): Connecting to %s.", conn.cfg.Server)
if s, err := conn.proxyDialer.Dial("tcp", conn.cfg.Server); err == nil {
conn.sock = s
} else {
return err
}
} else {
logging.Info("irc.Connect(): Connecting to %s.", conn.cfg.Server)
if s, err := conn.dialer.Dial("tcp", conn.cfg.Server); err == nil {
conn.sock = s
} else {
return err
}
}
if conn.cfg.SSL {
logging.Info("irc.Connect(): Performing SSL handshake.")
s := tls.Client(conn.sock, conn.cfg.SSLConfig)
if err := s.Handshake(); err != nil {
return err
}
conn.sock = s
}
conn.postConnect(true)
conn.connected = true
return nil
} | go | func (conn *Conn) internalConnect() error {
conn.mu.Lock()
defer conn.mu.Unlock()
conn.initialise()
if conn.cfg.Server == "" {
return fmt.Errorf("irc.Connect(): cfg.Server must be non-empty")
}
if conn.connected {
return fmt.Errorf("irc.Connect(): Cannot connect to %s, already connected.", conn.cfg.Server)
}
if !hasPort(conn.cfg.Server) {
if conn.cfg.SSL {
conn.cfg.Server = net.JoinHostPort(conn.cfg.Server, "6697")
} else {
conn.cfg.Server = net.JoinHostPort(conn.cfg.Server, "6667")
}
}
if conn.cfg.Proxy != "" {
proxyURL, err := url.Parse(conn.cfg.Proxy)
if err != nil {
return err
}
conn.proxyDialer, err = proxy.FromURL(proxyURL, conn.dialer)
if err != nil {
return err
}
logging.Info("irc.Connect(): Connecting to %s.", conn.cfg.Server)
if s, err := conn.proxyDialer.Dial("tcp", conn.cfg.Server); err == nil {
conn.sock = s
} else {
return err
}
} else {
logging.Info("irc.Connect(): Connecting to %s.", conn.cfg.Server)
if s, err := conn.dialer.Dial("tcp", conn.cfg.Server); err == nil {
conn.sock = s
} else {
return err
}
}
if conn.cfg.SSL {
logging.Info("irc.Connect(): Performing SSL handshake.")
s := tls.Client(conn.sock, conn.cfg.SSLConfig)
if err := s.Handshake(); err != nil {
return err
}
conn.sock = s
}
conn.postConnect(true)
conn.connected = true
return nil
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"internalConnect",
"(",
")",
"error",
"{",
"conn",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"conn",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"conn",
".",
"initialise",
"(",
")",
"\n\n",
"if",
"conn",
".",
"cfg",
".",
"Server",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"conn",
".",
"connected",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"conn",
".",
"cfg",
".",
"Server",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"hasPort",
"(",
"conn",
".",
"cfg",
".",
"Server",
")",
"{",
"if",
"conn",
".",
"cfg",
".",
"SSL",
"{",
"conn",
".",
"cfg",
".",
"Server",
"=",
"net",
".",
"JoinHostPort",
"(",
"conn",
".",
"cfg",
".",
"Server",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"conn",
".",
"cfg",
".",
"Server",
"=",
"net",
".",
"JoinHostPort",
"(",
"conn",
".",
"cfg",
".",
"Server",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"conn",
".",
"cfg",
".",
"Proxy",
"!=",
"\"",
"\"",
"{",
"proxyURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"conn",
".",
"cfg",
".",
"Proxy",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"conn",
".",
"proxyDialer",
",",
"err",
"=",
"proxy",
".",
"FromURL",
"(",
"proxyURL",
",",
"conn",
".",
"dialer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"logging",
".",
"Info",
"(",
"\"",
"\"",
",",
"conn",
".",
"cfg",
".",
"Server",
")",
"\n",
"if",
"s",
",",
"err",
":=",
"conn",
".",
"proxyDialer",
".",
"Dial",
"(",
"\"",
"\"",
",",
"conn",
".",
"cfg",
".",
"Server",
")",
";",
"err",
"==",
"nil",
"{",
"conn",
".",
"sock",
"=",
"s",
"\n",
"}",
"else",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"logging",
".",
"Info",
"(",
"\"",
"\"",
",",
"conn",
".",
"cfg",
".",
"Server",
")",
"\n",
"if",
"s",
",",
"err",
":=",
"conn",
".",
"dialer",
".",
"Dial",
"(",
"\"",
"\"",
",",
"conn",
".",
"cfg",
".",
"Server",
")",
";",
"err",
"==",
"nil",
"{",
"conn",
".",
"sock",
"=",
"s",
"\n",
"}",
"else",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"conn",
".",
"cfg",
".",
"SSL",
"{",
"logging",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"s",
":=",
"tls",
".",
"Client",
"(",
"conn",
".",
"sock",
",",
"conn",
".",
"cfg",
".",
"SSLConfig",
")",
"\n",
"if",
"err",
":=",
"s",
".",
"Handshake",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"conn",
".",
"sock",
"=",
"s",
"\n",
"}",
"\n\n",
"conn",
".",
"postConnect",
"(",
"true",
")",
"\n",
"conn",
".",
"connected",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] | // internalConnect handles the work of actually connecting to the server. | [
"internalConnect",
"handles",
"the",
"work",
"of",
"actually",
"connecting",
"to",
"the",
"server",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L315-L372 |
11,726 | fluffle/goirc | client/connection.go | postConnect | func (conn *Conn) postConnect(start bool) {
conn.io = bufio.NewReadWriter(
bufio.NewReader(conn.sock),
bufio.NewWriter(conn.sock))
if start {
conn.wg.Add(3)
go conn.send()
go conn.recv()
go conn.runLoop()
if conn.cfg.PingFreq > 0 {
conn.wg.Add(1)
go conn.ping()
}
}
} | go | func (conn *Conn) postConnect(start bool) {
conn.io = bufio.NewReadWriter(
bufio.NewReader(conn.sock),
bufio.NewWriter(conn.sock))
if start {
conn.wg.Add(3)
go conn.send()
go conn.recv()
go conn.runLoop()
if conn.cfg.PingFreq > 0 {
conn.wg.Add(1)
go conn.ping()
}
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"postConnect",
"(",
"start",
"bool",
")",
"{",
"conn",
".",
"io",
"=",
"bufio",
".",
"NewReadWriter",
"(",
"bufio",
".",
"NewReader",
"(",
"conn",
".",
"sock",
")",
",",
"bufio",
".",
"NewWriter",
"(",
"conn",
".",
"sock",
")",
")",
"\n",
"if",
"start",
"{",
"conn",
".",
"wg",
".",
"Add",
"(",
"3",
")",
"\n",
"go",
"conn",
".",
"send",
"(",
")",
"\n",
"go",
"conn",
".",
"recv",
"(",
")",
"\n",
"go",
"conn",
".",
"runLoop",
"(",
")",
"\n",
"if",
"conn",
".",
"cfg",
".",
"PingFreq",
">",
"0",
"{",
"conn",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"conn",
".",
"ping",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // postConnect performs post-connection setup, for ease of testing. | [
"postConnect",
"performs",
"post",
"-",
"connection",
"setup",
"for",
"ease",
"of",
"testing",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L375-L389 |
11,727 | fluffle/goirc | client/connection.go | recv | func (conn *Conn) recv() {
for {
s, err := conn.io.ReadString('\n')
if err != nil {
if err != io.EOF {
logging.Error("irc.recv(): %s", err.Error())
}
// We can't defer this, because Close() waits for it.
conn.wg.Done()
conn.Close()
return
}
s = strings.Trim(s, "\r\n")
logging.Debug("<- %s", s)
if line := ParseLine(s); line != nil {
line.Time = time.Now()
conn.in <- line
} else {
logging.Warn("irc.recv(): problems parsing line:\n %s", s)
}
}
} | go | func (conn *Conn) recv() {
for {
s, err := conn.io.ReadString('\n')
if err != nil {
if err != io.EOF {
logging.Error("irc.recv(): %s", err.Error())
}
// We can't defer this, because Close() waits for it.
conn.wg.Done()
conn.Close()
return
}
s = strings.Trim(s, "\r\n")
logging.Debug("<- %s", s)
if line := ParseLine(s); line != nil {
line.Time = time.Now()
conn.in <- line
} else {
logging.Warn("irc.recv(): problems parsing line:\n %s", s)
}
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"recv",
"(",
")",
"{",
"for",
"{",
"s",
",",
"err",
":=",
"conn",
".",
"io",
".",
"ReadString",
"(",
"'\\n'",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"io",
".",
"EOF",
"{",
"logging",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"// We can't defer this, because Close() waits for it.",
"conn",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"conn",
".",
"Close",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"s",
"=",
"strings",
".",
"Trim",
"(",
"s",
",",
"\"",
"\\r",
"\\n",
"\"",
")",
"\n",
"logging",
".",
"Debug",
"(",
"\"",
"\"",
",",
"s",
")",
"\n\n",
"if",
"line",
":=",
"ParseLine",
"(",
"s",
")",
";",
"line",
"!=",
"nil",
"{",
"line",
".",
"Time",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"conn",
".",
"in",
"<-",
"line",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\\n",
"\"",
",",
"s",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // recv is started as a goroutine after a connection is established.
// It receives "\r\n" terminated lines from the server, parses them into
// Lines, and sends them to the input channel. | [
"recv",
"is",
"started",
"as",
"a",
"goroutine",
"after",
"a",
"connection",
"is",
"established",
".",
"It",
"receives",
"\\",
"r",
"\\",
"n",
"terminated",
"lines",
"from",
"the",
"server",
"parses",
"them",
"into",
"Lines",
"and",
"sends",
"them",
"to",
"the",
"input",
"channel",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L422-L444 |
11,728 | fluffle/goirc | client/connection.go | ping | func (conn *Conn) ping() {
defer conn.wg.Done()
tick := time.NewTicker(conn.cfg.PingFreq)
for {
select {
case <-tick.C:
conn.Ping(fmt.Sprintf("%d", time.Now().UnixNano()))
case <-conn.die:
// control channel closed, bail out
tick.Stop()
return
}
}
} | go | func (conn *Conn) ping() {
defer conn.wg.Done()
tick := time.NewTicker(conn.cfg.PingFreq)
for {
select {
case <-tick.C:
conn.Ping(fmt.Sprintf("%d", time.Now().UnixNano()))
case <-conn.die:
// control channel closed, bail out
tick.Stop()
return
}
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"ping",
"(",
")",
"{",
"defer",
"conn",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"tick",
":=",
"time",
".",
"NewTicker",
"(",
"conn",
".",
"cfg",
".",
"PingFreq",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"tick",
".",
"C",
":",
"conn",
".",
"Ping",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
"\n",
"case",
"<-",
"conn",
".",
"die",
":",
"// control channel closed, bail out",
"tick",
".",
"Stop",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // ping is started as a goroutine after a connection is established, as
// long as Config.PingFreq >0. It pings the server every PingFreq seconds. | [
"ping",
"is",
"started",
"as",
"a",
"goroutine",
"after",
"a",
"connection",
"is",
"established",
"as",
"long",
"as",
"Config",
".",
"PingFreq",
">",
"0",
".",
"It",
"pings",
"the",
"server",
"every",
"PingFreq",
"seconds",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L448-L461 |
11,729 | fluffle/goirc | client/connection.go | runLoop | func (conn *Conn) runLoop() {
defer conn.wg.Done()
for {
select {
case line := <-conn.in:
conn.dispatch(line)
case <-conn.die:
// control channel closed, bail out
return
}
}
} | go | func (conn *Conn) runLoop() {
defer conn.wg.Done()
for {
select {
case line := <-conn.in:
conn.dispatch(line)
case <-conn.die:
// control channel closed, bail out
return
}
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"runLoop",
"(",
")",
"{",
"defer",
"conn",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"line",
":=",
"<-",
"conn",
".",
"in",
":",
"conn",
".",
"dispatch",
"(",
"line",
")",
"\n",
"case",
"<-",
"conn",
".",
"die",
":",
"// control channel closed, bail out",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // runLoop is started as a goroutine after a connection is established.
// It pulls Lines from the input channel and dispatches them to any
// handlers that have been registered for that IRC verb. | [
"runLoop",
"is",
"started",
"as",
"a",
"goroutine",
"after",
"a",
"connection",
"is",
"established",
".",
"It",
"pulls",
"Lines",
"from",
"the",
"input",
"channel",
"and",
"dispatches",
"them",
"to",
"any",
"handlers",
"that",
"have",
"been",
"registered",
"for",
"that",
"IRC",
"verb",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L466-L477 |
11,730 | fluffle/goirc | client/connection.go | write | func (conn *Conn) write(line string) error {
if !conn.cfg.Flood {
if t := conn.rateLimit(len(line)); t != 0 {
// sleep for the current line's time value before sending it
logging.Info("irc.rateLimit(): Flood! Sleeping for %.2f secs.",
t.Seconds())
<-time.After(t)
}
}
if _, err := conn.io.WriteString(line + "\r\n"); err != nil {
return err
}
if err := conn.io.Flush(); err != nil {
return err
}
if strings.HasPrefix(line, "PASS") {
line = "PASS **************"
}
logging.Debug("-> %s", line)
return nil
} | go | func (conn *Conn) write(line string) error {
if !conn.cfg.Flood {
if t := conn.rateLimit(len(line)); t != 0 {
// sleep for the current line's time value before sending it
logging.Info("irc.rateLimit(): Flood! Sleeping for %.2f secs.",
t.Seconds())
<-time.After(t)
}
}
if _, err := conn.io.WriteString(line + "\r\n"); err != nil {
return err
}
if err := conn.io.Flush(); err != nil {
return err
}
if strings.HasPrefix(line, "PASS") {
line = "PASS **************"
}
logging.Debug("-> %s", line)
return nil
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"write",
"(",
"line",
"string",
")",
"error",
"{",
"if",
"!",
"conn",
".",
"cfg",
".",
"Flood",
"{",
"if",
"t",
":=",
"conn",
".",
"rateLimit",
"(",
"len",
"(",
"line",
")",
")",
";",
"t",
"!=",
"0",
"{",
"// sleep for the current line's time value before sending it",
"logging",
".",
"Info",
"(",
"\"",
"\"",
",",
"t",
".",
"Seconds",
"(",
")",
")",
"\n",
"<-",
"time",
".",
"After",
"(",
"t",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
":=",
"conn",
".",
"io",
".",
"WriteString",
"(",
"line",
"+",
"\"",
"\\r",
"\\n",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"conn",
".",
"io",
".",
"Flush",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"line",
",",
"\"",
"\"",
")",
"{",
"line",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"logging",
".",
"Debug",
"(",
"\"",
"\"",
",",
"line",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // write writes a \r\n terminated line of output to the connected server,
// using Hybrid's algorithm to rate limit if conn.cfg.Flood is false. | [
"write",
"writes",
"a",
"\\",
"r",
"\\",
"n",
"terminated",
"line",
"of",
"output",
"to",
"the",
"connected",
"server",
"using",
"Hybrid",
"s",
"algorithm",
"to",
"rate",
"limit",
"if",
"conn",
".",
"cfg",
".",
"Flood",
"is",
"false",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L481-L502 |
11,731 | fluffle/goirc | client/connection.go | rateLimit | func (conn *Conn) rateLimit(chars int) time.Duration {
// Hybrid's algorithm allows for 2 seconds per line and an additional
// 1/120 of a second per character on that line.
linetime := 2*time.Second + time.Duration(chars)*time.Second/120
elapsed := time.Now().Sub(conn.lastsent)
if conn.badness += linetime - elapsed; conn.badness < 0 {
// negative badness times are badness...
conn.badness = 0
}
conn.lastsent = time.Now()
// If we've sent more than 10 second's worth of lines according to the
// calculation above, then we're at risk of "Excess Flood".
if conn.badness > 10*time.Second {
return linetime
}
return 0
} | go | func (conn *Conn) rateLimit(chars int) time.Duration {
// Hybrid's algorithm allows for 2 seconds per line and an additional
// 1/120 of a second per character on that line.
linetime := 2*time.Second + time.Duration(chars)*time.Second/120
elapsed := time.Now().Sub(conn.lastsent)
if conn.badness += linetime - elapsed; conn.badness < 0 {
// negative badness times are badness...
conn.badness = 0
}
conn.lastsent = time.Now()
// If we've sent more than 10 second's worth of lines according to the
// calculation above, then we're at risk of "Excess Flood".
if conn.badness > 10*time.Second {
return linetime
}
return 0
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"rateLimit",
"(",
"chars",
"int",
")",
"time",
".",
"Duration",
"{",
"// Hybrid's algorithm allows for 2 seconds per line and an additional",
"// 1/120 of a second per character on that line.",
"linetime",
":=",
"2",
"*",
"time",
".",
"Second",
"+",
"time",
".",
"Duration",
"(",
"chars",
")",
"*",
"time",
".",
"Second",
"/",
"120",
"\n",
"elapsed",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"conn",
".",
"lastsent",
")",
"\n",
"if",
"conn",
".",
"badness",
"+=",
"linetime",
"-",
"elapsed",
";",
"conn",
".",
"badness",
"<",
"0",
"{",
"// negative badness times are badness...",
"conn",
".",
"badness",
"=",
"0",
"\n",
"}",
"\n",
"conn",
".",
"lastsent",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"// If we've sent more than 10 second's worth of lines according to the",
"// calculation above, then we're at risk of \"Excess Flood\".",
"if",
"conn",
".",
"badness",
">",
"10",
"*",
"time",
".",
"Second",
"{",
"return",
"linetime",
"\n",
"}",
"\n",
"return",
"0",
"\n",
"}"
] | // rateLimit implements Hybrid's flood control algorithm for outgoing lines. | [
"rateLimit",
"implements",
"Hybrid",
"s",
"flood",
"control",
"algorithm",
"for",
"outgoing",
"lines",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L505-L521 |
11,732 | fluffle/goirc | client/connection.go | Close | func (conn *Conn) Close() error {
// Guard against double-call of Close() if we get an error in send()
// as calling sock.Close() will cause recv() to receive EOF in readstring()
conn.mu.Lock()
if !conn.connected {
conn.mu.Unlock()
return nil
}
logging.Info("irc.Close(): Disconnected from server.")
conn.connected = false
err := conn.sock.Close()
close(conn.die)
// Drain both in and out channels to avoid a deadlock if the buffers
// have filled. See TestSendDeadlockOnFullBuffer in connection_test.go.
conn.drainIn()
conn.drainOut()
conn.wg.Wait()
conn.mu.Unlock()
// Dispatch after closing connection but before reinit
// so event handlers can still access state information.
conn.dispatch(&Line{Cmd: DISCONNECTED, Time: time.Now()})
return err
} | go | func (conn *Conn) Close() error {
// Guard against double-call of Close() if we get an error in send()
// as calling sock.Close() will cause recv() to receive EOF in readstring()
conn.mu.Lock()
if !conn.connected {
conn.mu.Unlock()
return nil
}
logging.Info("irc.Close(): Disconnected from server.")
conn.connected = false
err := conn.sock.Close()
close(conn.die)
// Drain both in and out channels to avoid a deadlock if the buffers
// have filled. See TestSendDeadlockOnFullBuffer in connection_test.go.
conn.drainIn()
conn.drainOut()
conn.wg.Wait()
conn.mu.Unlock()
// Dispatch after closing connection but before reinit
// so event handlers can still access state information.
conn.dispatch(&Line{Cmd: DISCONNECTED, Time: time.Now()})
return err
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"Close",
"(",
")",
"error",
"{",
"// Guard against double-call of Close() if we get an error in send()",
"// as calling sock.Close() will cause recv() to receive EOF in readstring()",
"conn",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"!",
"conn",
".",
"connected",
"{",
"conn",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"logging",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"conn",
".",
"connected",
"=",
"false",
"\n",
"err",
":=",
"conn",
".",
"sock",
".",
"Close",
"(",
")",
"\n",
"close",
"(",
"conn",
".",
"die",
")",
"\n",
"// Drain both in and out channels to avoid a deadlock if the buffers",
"// have filled. See TestSendDeadlockOnFullBuffer in connection_test.go.",
"conn",
".",
"drainIn",
"(",
")",
"\n",
"conn",
".",
"drainOut",
"(",
")",
"\n",
"conn",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"conn",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"// Dispatch after closing connection but before reinit",
"// so event handlers can still access state information.",
"conn",
".",
"dispatch",
"(",
"&",
"Line",
"{",
"Cmd",
":",
"DISCONNECTED",
",",
"Time",
":",
"time",
".",
"Now",
"(",
")",
"}",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Close tears down all connection-related state. It is called when either
// the sending or receiving goroutines encounter an error.
// It may also be used to forcibly shut down the connection to the server. | [
"Close",
"tears",
"down",
"all",
"connection",
"-",
"related",
"state",
".",
"It",
"is",
"called",
"when",
"either",
"the",
"sending",
"or",
"receiving",
"goroutines",
"encounter",
"an",
"error",
".",
"It",
"may",
"also",
"be",
"used",
"to",
"forcibly",
"shut",
"down",
"the",
"connection",
"to",
"the",
"server",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L526-L548 |
11,733 | fluffle/goirc | client/connection.go | String | func (conn *Conn) String() string {
str := "GoIRC Connection\n"
str += "----------------\n\n"
if conn.Connected() {
str += "Connected to " + conn.cfg.Server + "\n\n"
} else {
str += "Not currently connected!\n\n"
}
str += conn.Me().String() + "\n"
if conn.st != nil {
str += conn.st.String() + "\n"
}
return str
} | go | func (conn *Conn) String() string {
str := "GoIRC Connection\n"
str += "----------------\n\n"
if conn.Connected() {
str += "Connected to " + conn.cfg.Server + "\n\n"
} else {
str += "Not currently connected!\n\n"
}
str += conn.Me().String() + "\n"
if conn.st != nil {
str += conn.st.String() + "\n"
}
return str
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"String",
"(",
")",
"string",
"{",
"str",
":=",
"\"",
"\\n",
"\"",
"\n",
"str",
"+=",
"\"",
"\\n",
"\\n",
"\"",
"\n",
"if",
"conn",
".",
"Connected",
"(",
")",
"{",
"str",
"+=",
"\"",
"\"",
"+",
"conn",
".",
"cfg",
".",
"Server",
"+",
"\"",
"\\n",
"\\n",
"\"",
"\n",
"}",
"else",
"{",
"str",
"+=",
"\"",
"\\n",
"\\n",
"\"",
"\n",
"}",
"\n",
"str",
"+=",
"conn",
".",
"Me",
"(",
")",
".",
"String",
"(",
")",
"+",
"\"",
"\\n",
"\"",
"\n",
"if",
"conn",
".",
"st",
"!=",
"nil",
"{",
"str",
"+=",
"conn",
".",
"st",
".",
"String",
"(",
")",
"+",
"\"",
"\\n",
"\"",
"\n",
"}",
"\n",
"return",
"str",
"\n",
"}"
] | // Dumps a load of information about the current state of the connection to a
// string for debugging state tracking and other such things. | [
"Dumps",
"a",
"load",
"of",
"information",
"about",
"the",
"current",
"state",
"of",
"the",
"connection",
"to",
"a",
"string",
"for",
"debugging",
"state",
"tracking",
"and",
"other",
"such",
"things",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/connection.go#L574-L587 |
11,734 | fluffle/goirc | client/state_handlers.go | h_STNICK | func (conn *Conn) h_STNICK(line *Line) {
// all nicks should be handled the same way, our own included
conn.st.ReNick(line.Nick, line.Args[0])
} | go | func (conn *Conn) h_STNICK(line *Line) {
// all nicks should be handled the same way, our own included
conn.st.ReNick(line.Nick, line.Args[0])
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_STNICK",
"(",
"line",
"*",
"Line",
")",
"{",
"// all nicks should be handled the same way, our own included",
"conn",
".",
"st",
".",
"ReNick",
"(",
"line",
".",
"Nick",
",",
"line",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"}"
] | // Handle NICK messages that need to update the state tracker | [
"Handle",
"NICK",
"messages",
"that",
"need",
"to",
"update",
"the",
"state",
"tracker"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L42-L45 |
11,735 | fluffle/goirc | client/state_handlers.go | h_JOIN | func (conn *Conn) h_JOIN(line *Line) {
ch := conn.st.GetChannel(line.Args[0])
nk := conn.st.GetNick(line.Nick)
if ch == nil {
// first we've seen of this channel, so should be us joining it
// NOTE this will also take care of nk == nil && ch == nil
if !conn.Me().Equals(nk) {
logging.Warn("irc.JOIN(): JOIN to unknown channel %s received "+
"from (non-me) nick %s", line.Args[0], line.Nick)
return
}
conn.st.NewChannel(line.Args[0])
// since we don't know much about this channel, ask server for info
// we get the channel users automatically in 353 and the channel
// topic in 332 on join, so we just need to get the modes
conn.Mode(line.Args[0])
// sending a WHO for the channel is MUCH more efficient than
// triggering a WHOIS on every nick from the 353 handler
conn.Who(line.Args[0])
}
if nk == nil {
// this is the first we've seen of this nick
conn.st.NewNick(line.Nick)
conn.st.NickInfo(line.Nick, line.Ident, line.Host, "")
// since we don't know much about this nick, ask server for info
conn.Who(line.Nick)
}
// this takes care of both nick and channel linking \o/
conn.st.Associate(line.Args[0], line.Nick)
} | go | func (conn *Conn) h_JOIN(line *Line) {
ch := conn.st.GetChannel(line.Args[0])
nk := conn.st.GetNick(line.Nick)
if ch == nil {
// first we've seen of this channel, so should be us joining it
// NOTE this will also take care of nk == nil && ch == nil
if !conn.Me().Equals(nk) {
logging.Warn("irc.JOIN(): JOIN to unknown channel %s received "+
"from (non-me) nick %s", line.Args[0], line.Nick)
return
}
conn.st.NewChannel(line.Args[0])
// since we don't know much about this channel, ask server for info
// we get the channel users automatically in 353 and the channel
// topic in 332 on join, so we just need to get the modes
conn.Mode(line.Args[0])
// sending a WHO for the channel is MUCH more efficient than
// triggering a WHOIS on every nick from the 353 handler
conn.Who(line.Args[0])
}
if nk == nil {
// this is the first we've seen of this nick
conn.st.NewNick(line.Nick)
conn.st.NickInfo(line.Nick, line.Ident, line.Host, "")
// since we don't know much about this nick, ask server for info
conn.Who(line.Nick)
}
// this takes care of both nick and channel linking \o/
conn.st.Associate(line.Args[0], line.Nick)
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_JOIN",
"(",
"line",
"*",
"Line",
")",
"{",
"ch",
":=",
"conn",
".",
"st",
".",
"GetChannel",
"(",
"line",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"nk",
":=",
"conn",
".",
"st",
".",
"GetNick",
"(",
"line",
".",
"Nick",
")",
"\n",
"if",
"ch",
"==",
"nil",
"{",
"// first we've seen of this channel, so should be us joining it",
"// NOTE this will also take care of nk == nil && ch == nil",
"if",
"!",
"conn",
".",
"Me",
"(",
")",
".",
"Equals",
"(",
"nk",
")",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"line",
".",
"Args",
"[",
"0",
"]",
",",
"line",
".",
"Nick",
")",
"\n",
"return",
"\n",
"}",
"\n",
"conn",
".",
"st",
".",
"NewChannel",
"(",
"line",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"// since we don't know much about this channel, ask server for info",
"// we get the channel users automatically in 353 and the channel",
"// topic in 332 on join, so we just need to get the modes",
"conn",
".",
"Mode",
"(",
"line",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"// sending a WHO for the channel is MUCH more efficient than",
"// triggering a WHOIS on every nick from the 353 handler",
"conn",
".",
"Who",
"(",
"line",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"if",
"nk",
"==",
"nil",
"{",
"// this is the first we've seen of this nick",
"conn",
".",
"st",
".",
"NewNick",
"(",
"line",
".",
"Nick",
")",
"\n",
"conn",
".",
"st",
".",
"NickInfo",
"(",
"line",
".",
"Nick",
",",
"line",
".",
"Ident",
",",
"line",
".",
"Host",
",",
"\"",
"\"",
")",
"\n",
"// since we don't know much about this nick, ask server for info",
"conn",
".",
"Who",
"(",
"line",
".",
"Nick",
")",
"\n",
"}",
"\n",
"// this takes care of both nick and channel linking \\o/",
"conn",
".",
"st",
".",
"Associate",
"(",
"line",
".",
"Args",
"[",
"0",
"]",
",",
"line",
".",
"Nick",
")",
"\n",
"}"
] | // Handle JOINs to channels to maintain state | [
"Handle",
"JOINs",
"to",
"channels",
"to",
"maintain",
"state"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L48-L77 |
11,736 | fluffle/goirc | client/state_handlers.go | h_PART | func (conn *Conn) h_PART(line *Line) {
conn.st.Dissociate(line.Args[0], line.Nick)
} | go | func (conn *Conn) h_PART(line *Line) {
conn.st.Dissociate(line.Args[0], line.Nick)
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_PART",
"(",
"line",
"*",
"Line",
")",
"{",
"conn",
".",
"st",
".",
"Dissociate",
"(",
"line",
".",
"Args",
"[",
"0",
"]",
",",
"line",
".",
"Nick",
")",
"\n",
"}"
] | // Handle PARTs from channels to maintain state | [
"Handle",
"PARTs",
"from",
"channels",
"to",
"maintain",
"state"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L80-L82 |
11,737 | fluffle/goirc | client/state_handlers.go | h_KICK | func (conn *Conn) h_KICK(line *Line) {
if !line.argslen(1) {
return
}
// XXX: this won't handle autorejoining channels on KICK
// it's trivial to do this in a seperate handler...
conn.st.Dissociate(line.Args[0], line.Args[1])
} | go | func (conn *Conn) h_KICK(line *Line) {
if !line.argslen(1) {
return
}
// XXX: this won't handle autorejoining channels on KICK
// it's trivial to do this in a seperate handler...
conn.st.Dissociate(line.Args[0], line.Args[1])
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_KICK",
"(",
"line",
"*",
"Line",
")",
"{",
"if",
"!",
"line",
".",
"argslen",
"(",
"1",
")",
"{",
"return",
"\n",
"}",
"\n",
"// XXX: this won't handle autorejoining channels on KICK",
"// it's trivial to do this in a seperate handler...",
"conn",
".",
"st",
".",
"Dissociate",
"(",
"line",
".",
"Args",
"[",
"0",
"]",
",",
"line",
".",
"Args",
"[",
"1",
"]",
")",
"\n",
"}"
] | // Handle KICKs from channels to maintain state | [
"Handle",
"KICKs",
"from",
"channels",
"to",
"maintain",
"state"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L85-L92 |
11,738 | fluffle/goirc | client/state_handlers.go | h_QUIT | func (conn *Conn) h_QUIT(line *Line) {
conn.st.DelNick(line.Nick)
} | go | func (conn *Conn) h_QUIT(line *Line) {
conn.st.DelNick(line.Nick)
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_QUIT",
"(",
"line",
"*",
"Line",
")",
"{",
"conn",
".",
"st",
".",
"DelNick",
"(",
"line",
".",
"Nick",
")",
"\n",
"}"
] | // Handle other people's QUITs | [
"Handle",
"other",
"people",
"s",
"QUITs"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L95-L97 |
11,739 | fluffle/goirc | client/state_handlers.go | h_311 | func (conn *Conn) h_311(line *Line) {
if !line.argslen(5) {
return
}
if nk := conn.st.GetNick(line.Args[1]); (nk != nil) && !conn.Me().Equals(nk) {
conn.st.NickInfo(line.Args[1], line.Args[2], line.Args[3], line.Args[5])
} else {
logging.Warn("irc.311(): received WHOIS info for unknown nick %s",
line.Args[1])
}
} | go | func (conn *Conn) h_311(line *Line) {
if !line.argslen(5) {
return
}
if nk := conn.st.GetNick(line.Args[1]); (nk != nil) && !conn.Me().Equals(nk) {
conn.st.NickInfo(line.Args[1], line.Args[2], line.Args[3], line.Args[5])
} else {
logging.Warn("irc.311(): received WHOIS info for unknown nick %s",
line.Args[1])
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_311",
"(",
"line",
"*",
"Line",
")",
"{",
"if",
"!",
"line",
".",
"argslen",
"(",
"5",
")",
"{",
"return",
"\n",
"}",
"\n",
"if",
"nk",
":=",
"conn",
".",
"st",
".",
"GetNick",
"(",
"line",
".",
"Args",
"[",
"1",
"]",
")",
";",
"(",
"nk",
"!=",
"nil",
")",
"&&",
"!",
"conn",
".",
"Me",
"(",
")",
".",
"Equals",
"(",
"nk",
")",
"{",
"conn",
".",
"st",
".",
"NickInfo",
"(",
"line",
".",
"Args",
"[",
"1",
"]",
",",
"line",
".",
"Args",
"[",
"2",
"]",
",",
"line",
".",
"Args",
"[",
"3",
"]",
",",
"line",
".",
"Args",
"[",
"5",
"]",
")",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"line",
".",
"Args",
"[",
"1",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // Handle 311 whois reply | [
"Handle",
"311",
"whois",
"reply"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L135-L145 |
11,740 | fluffle/goirc | client/state_handlers.go | h_324 | func (conn *Conn) h_324(line *Line) {
if !line.argslen(2) {
return
}
if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
conn.st.ChannelModes(line.Args[1], line.Args[2], line.Args[3:]...)
} else {
logging.Warn("irc.324(): received MODE settings for unknown channel %s",
line.Args[1])
}
} | go | func (conn *Conn) h_324(line *Line) {
if !line.argslen(2) {
return
}
if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
conn.st.ChannelModes(line.Args[1], line.Args[2], line.Args[3:]...)
} else {
logging.Warn("irc.324(): received MODE settings for unknown channel %s",
line.Args[1])
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_324",
"(",
"line",
"*",
"Line",
")",
"{",
"if",
"!",
"line",
".",
"argslen",
"(",
"2",
")",
"{",
"return",
"\n",
"}",
"\n",
"if",
"ch",
":=",
"conn",
".",
"st",
".",
"GetChannel",
"(",
"line",
".",
"Args",
"[",
"1",
"]",
")",
";",
"ch",
"!=",
"nil",
"{",
"conn",
".",
"st",
".",
"ChannelModes",
"(",
"line",
".",
"Args",
"[",
"1",
"]",
",",
"line",
".",
"Args",
"[",
"2",
"]",
",",
"line",
".",
"Args",
"[",
"3",
":",
"]",
"...",
")",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"line",
".",
"Args",
"[",
"1",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // Handle 324 mode reply | [
"Handle",
"324",
"mode",
"reply"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L148-L158 |
11,741 | fluffle/goirc | client/state_handlers.go | h_332 | func (conn *Conn) h_332(line *Line) {
if !line.argslen(2) {
return
}
if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
conn.st.Topic(line.Args[1], line.Args[2])
} else {
logging.Warn("irc.332(): received TOPIC value for unknown channel %s",
line.Args[1])
}
} | go | func (conn *Conn) h_332(line *Line) {
if !line.argslen(2) {
return
}
if ch := conn.st.GetChannel(line.Args[1]); ch != nil {
conn.st.Topic(line.Args[1], line.Args[2])
} else {
logging.Warn("irc.332(): received TOPIC value for unknown channel %s",
line.Args[1])
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_332",
"(",
"line",
"*",
"Line",
")",
"{",
"if",
"!",
"line",
".",
"argslen",
"(",
"2",
")",
"{",
"return",
"\n",
"}",
"\n",
"if",
"ch",
":=",
"conn",
".",
"st",
".",
"GetChannel",
"(",
"line",
".",
"Args",
"[",
"1",
"]",
")",
";",
"ch",
"!=",
"nil",
"{",
"conn",
".",
"st",
".",
"Topic",
"(",
"line",
".",
"Args",
"[",
"1",
"]",
",",
"line",
".",
"Args",
"[",
"2",
"]",
")",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"line",
".",
"Args",
"[",
"1",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // Handle 332 topic reply on join to channel | [
"Handle",
"332",
"topic",
"reply",
"on",
"join",
"to",
"channel"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L161-L171 |
11,742 | fluffle/goirc | client/state_handlers.go | h_352 | func (conn *Conn) h_352(line *Line) {
if !line.argslen(5) {
return
}
nk := conn.st.GetNick(line.Args[5])
if nk == nil {
logging.Warn("irc.352(): received WHO reply for unknown nick %s",
line.Args[5])
return
}
if conn.Me().Equals(nk) {
return
}
// XXX: do we care about the actual server the nick is on?
// or the hop count to this server?
// last arg contains "<hop count> <real name>"
a := strings.SplitN(line.Args[len(line.Args)-1], " ", 2)
conn.st.NickInfo(nk.Nick, line.Args[2], line.Args[3], a[1])
if !line.argslen(6) {
return
}
if idx := strings.Index(line.Args[6], "*"); idx != -1 {
conn.st.NickModes(nk.Nick, "+o")
}
if idx := strings.Index(line.Args[6], "B"); idx != -1 {
conn.st.NickModes(nk.Nick, "+B")
}
if idx := strings.Index(line.Args[6], "H"); idx != -1 {
conn.st.NickModes(nk.Nick, "+i")
}
} | go | func (conn *Conn) h_352(line *Line) {
if !line.argslen(5) {
return
}
nk := conn.st.GetNick(line.Args[5])
if nk == nil {
logging.Warn("irc.352(): received WHO reply for unknown nick %s",
line.Args[5])
return
}
if conn.Me().Equals(nk) {
return
}
// XXX: do we care about the actual server the nick is on?
// or the hop count to this server?
// last arg contains "<hop count> <real name>"
a := strings.SplitN(line.Args[len(line.Args)-1], " ", 2)
conn.st.NickInfo(nk.Nick, line.Args[2], line.Args[3], a[1])
if !line.argslen(6) {
return
}
if idx := strings.Index(line.Args[6], "*"); idx != -1 {
conn.st.NickModes(nk.Nick, "+o")
}
if idx := strings.Index(line.Args[6], "B"); idx != -1 {
conn.st.NickModes(nk.Nick, "+B")
}
if idx := strings.Index(line.Args[6], "H"); idx != -1 {
conn.st.NickModes(nk.Nick, "+i")
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_352",
"(",
"line",
"*",
"Line",
")",
"{",
"if",
"!",
"line",
".",
"argslen",
"(",
"5",
")",
"{",
"return",
"\n",
"}",
"\n",
"nk",
":=",
"conn",
".",
"st",
".",
"GetNick",
"(",
"line",
".",
"Args",
"[",
"5",
"]",
")",
"\n",
"if",
"nk",
"==",
"nil",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"line",
".",
"Args",
"[",
"5",
"]",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"conn",
".",
"Me",
"(",
")",
".",
"Equals",
"(",
"nk",
")",
"{",
"return",
"\n",
"}",
"\n",
"// XXX: do we care about the actual server the nick is on?",
"// or the hop count to this server?",
"// last arg contains \"<hop count> <real name>\"",
"a",
":=",
"strings",
".",
"SplitN",
"(",
"line",
".",
"Args",
"[",
"len",
"(",
"line",
".",
"Args",
")",
"-",
"1",
"]",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"conn",
".",
"st",
".",
"NickInfo",
"(",
"nk",
".",
"Nick",
",",
"line",
".",
"Args",
"[",
"2",
"]",
",",
"line",
".",
"Args",
"[",
"3",
"]",
",",
"a",
"[",
"1",
"]",
")",
"\n",
"if",
"!",
"line",
".",
"argslen",
"(",
"6",
")",
"{",
"return",
"\n",
"}",
"\n",
"if",
"idx",
":=",
"strings",
".",
"Index",
"(",
"line",
".",
"Args",
"[",
"6",
"]",
",",
"\"",
"\"",
")",
";",
"idx",
"!=",
"-",
"1",
"{",
"conn",
".",
"st",
".",
"NickModes",
"(",
"nk",
".",
"Nick",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"idx",
":=",
"strings",
".",
"Index",
"(",
"line",
".",
"Args",
"[",
"6",
"]",
",",
"\"",
"\"",
")",
";",
"idx",
"!=",
"-",
"1",
"{",
"conn",
".",
"st",
".",
"NickModes",
"(",
"nk",
".",
"Nick",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"idx",
":=",
"strings",
".",
"Index",
"(",
"line",
".",
"Args",
"[",
"6",
"]",
",",
"\"",
"\"",
")",
";",
"idx",
"!=",
"-",
"1",
"{",
"conn",
".",
"st",
".",
"NickModes",
"(",
"nk",
".",
"Nick",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // Handle 352 who reply | [
"Handle",
"352",
"who",
"reply"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L174-L204 |
11,743 | fluffle/goirc | client/state_handlers.go | h_353 | func (conn *Conn) h_353(line *Line) {
if !line.argslen(2) {
return
}
if ch := conn.st.GetChannel(line.Args[2]); ch != nil {
nicks := strings.Split(line.Args[len(line.Args)-1], " ")
for _, nick := range nicks {
// UnrealIRCd's coders are lazy and leave a trailing space
if nick == "" {
continue
}
switch c := nick[0]; c {
case '~', '&', '@', '%', '+':
nick = nick[1:]
fallthrough
default:
if conn.st.GetNick(nick) == nil {
// we don't know this nick yet!
conn.st.NewNick(nick)
}
if _, ok := conn.st.IsOn(ch.Name, nick); !ok {
// This nick isn't associated with this channel yet!
conn.st.Associate(ch.Name, nick)
}
switch c {
case '~':
conn.st.ChannelModes(ch.Name, "+q", nick)
case '&':
conn.st.ChannelModes(ch.Name, "+a", nick)
case '@':
conn.st.ChannelModes(ch.Name, "+o", nick)
case '%':
conn.st.ChannelModes(ch.Name, "+h", nick)
case '+':
conn.st.ChannelModes(ch.Name, "+v", nick)
}
}
}
} else {
logging.Warn("irc.353(): received NAMES list for unknown channel %s",
line.Args[2])
}
} | go | func (conn *Conn) h_353(line *Line) {
if !line.argslen(2) {
return
}
if ch := conn.st.GetChannel(line.Args[2]); ch != nil {
nicks := strings.Split(line.Args[len(line.Args)-1], " ")
for _, nick := range nicks {
// UnrealIRCd's coders are lazy and leave a trailing space
if nick == "" {
continue
}
switch c := nick[0]; c {
case '~', '&', '@', '%', '+':
nick = nick[1:]
fallthrough
default:
if conn.st.GetNick(nick) == nil {
// we don't know this nick yet!
conn.st.NewNick(nick)
}
if _, ok := conn.st.IsOn(ch.Name, nick); !ok {
// This nick isn't associated with this channel yet!
conn.st.Associate(ch.Name, nick)
}
switch c {
case '~':
conn.st.ChannelModes(ch.Name, "+q", nick)
case '&':
conn.st.ChannelModes(ch.Name, "+a", nick)
case '@':
conn.st.ChannelModes(ch.Name, "+o", nick)
case '%':
conn.st.ChannelModes(ch.Name, "+h", nick)
case '+':
conn.st.ChannelModes(ch.Name, "+v", nick)
}
}
}
} else {
logging.Warn("irc.353(): received NAMES list for unknown channel %s",
line.Args[2])
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_353",
"(",
"line",
"*",
"Line",
")",
"{",
"if",
"!",
"line",
".",
"argslen",
"(",
"2",
")",
"{",
"return",
"\n",
"}",
"\n",
"if",
"ch",
":=",
"conn",
".",
"st",
".",
"GetChannel",
"(",
"line",
".",
"Args",
"[",
"2",
"]",
")",
";",
"ch",
"!=",
"nil",
"{",
"nicks",
":=",
"strings",
".",
"Split",
"(",
"line",
".",
"Args",
"[",
"len",
"(",
"line",
".",
"Args",
")",
"-",
"1",
"]",
",",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"nick",
":=",
"range",
"nicks",
"{",
"// UnrealIRCd's coders are lazy and leave a trailing space",
"if",
"nick",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"switch",
"c",
":=",
"nick",
"[",
"0",
"]",
";",
"c",
"{",
"case",
"'~'",
",",
"'&'",
",",
"'@'",
",",
"'%'",
",",
"'+'",
":",
"nick",
"=",
"nick",
"[",
"1",
":",
"]",
"\n",
"fallthrough",
"\n",
"default",
":",
"if",
"conn",
".",
"st",
".",
"GetNick",
"(",
"nick",
")",
"==",
"nil",
"{",
"// we don't know this nick yet!",
"conn",
".",
"st",
".",
"NewNick",
"(",
"nick",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"conn",
".",
"st",
".",
"IsOn",
"(",
"ch",
".",
"Name",
",",
"nick",
")",
";",
"!",
"ok",
"{",
"// This nick isn't associated with this channel yet!",
"conn",
".",
"st",
".",
"Associate",
"(",
"ch",
".",
"Name",
",",
"nick",
")",
"\n",
"}",
"\n",
"switch",
"c",
"{",
"case",
"'~'",
":",
"conn",
".",
"st",
".",
"ChannelModes",
"(",
"ch",
".",
"Name",
",",
"\"",
"\"",
",",
"nick",
")",
"\n",
"case",
"'&'",
":",
"conn",
".",
"st",
".",
"ChannelModes",
"(",
"ch",
".",
"Name",
",",
"\"",
"\"",
",",
"nick",
")",
"\n",
"case",
"'@'",
":",
"conn",
".",
"st",
".",
"ChannelModes",
"(",
"ch",
".",
"Name",
",",
"\"",
"\"",
",",
"nick",
")",
"\n",
"case",
"'%'",
":",
"conn",
".",
"st",
".",
"ChannelModes",
"(",
"ch",
".",
"Name",
",",
"\"",
"\"",
",",
"nick",
")",
"\n",
"case",
"'+'",
":",
"conn",
".",
"st",
".",
"ChannelModes",
"(",
"ch",
".",
"Name",
",",
"\"",
"\"",
",",
"nick",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"line",
".",
"Args",
"[",
"2",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // Handle 353 names reply | [
"Handle",
"353",
"names",
"reply"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/state_handlers.go#L207-L249 |
11,744 | fluffle/goirc | state/channel.go | Channel | func (ch *channel) Channel() *Channel {
c := &Channel{
Name: ch.name,
Topic: ch.topic,
Modes: ch.modes.Copy(),
Nicks: make(map[string]*ChanPrivs),
}
for n, cp := range ch.nicks {
c.Nicks[n.nick] = cp.Copy()
}
return c
} | go | func (ch *channel) Channel() *Channel {
c := &Channel{
Name: ch.name,
Topic: ch.topic,
Modes: ch.modes.Copy(),
Nicks: make(map[string]*ChanPrivs),
}
for n, cp := range ch.nicks {
c.Nicks[n.nick] = cp.Copy()
}
return c
} | [
"func",
"(",
"ch",
"*",
"channel",
")",
"Channel",
"(",
")",
"*",
"Channel",
"{",
"c",
":=",
"&",
"Channel",
"{",
"Name",
":",
"ch",
".",
"name",
",",
"Topic",
":",
"ch",
".",
"topic",
",",
"Modes",
":",
"ch",
".",
"modes",
".",
"Copy",
"(",
")",
",",
"Nicks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"ChanPrivs",
")",
",",
"}",
"\n",
"for",
"n",
",",
"cp",
":=",
"range",
"ch",
".",
"nicks",
"{",
"c",
".",
"Nicks",
"[",
"n",
".",
"nick",
"]",
"=",
"cp",
".",
"Copy",
"(",
")",
"\n",
"}",
"\n",
"return",
"c",
"\n",
"}"
] | // Returns a copy of the internal tracker channel state at this time.
// Relies on tracker-level locking for concurrent access. | [
"Returns",
"a",
"copy",
"of",
"the",
"internal",
"tracker",
"channel",
"state",
"at",
"this",
"time",
".",
"Relies",
"on",
"tracker",
"-",
"level",
"locking",
"for",
"concurrent",
"access",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L118-L129 |
11,745 | fluffle/goirc | state/channel.go | addNick | func (ch *channel) addNick(nk *nick, cp *ChanPrivs) {
if _, ok := ch.nicks[nk]; !ok {
ch.nicks[nk] = cp
ch.lookup[nk.nick] = nk
} else {
logging.Warn("Channel.addNick(): %s already on %s.", nk.nick, ch.name)
}
} | go | func (ch *channel) addNick(nk *nick, cp *ChanPrivs) {
if _, ok := ch.nicks[nk]; !ok {
ch.nicks[nk] = cp
ch.lookup[nk.nick] = nk
} else {
logging.Warn("Channel.addNick(): %s already on %s.", nk.nick, ch.name)
}
} | [
"func",
"(",
"ch",
"*",
"channel",
")",
"addNick",
"(",
"nk",
"*",
"nick",
",",
"cp",
"*",
"ChanPrivs",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"ch",
".",
"nicks",
"[",
"nk",
"]",
";",
"!",
"ok",
"{",
"ch",
".",
"nicks",
"[",
"nk",
"]",
"=",
"cp",
"\n",
"ch",
".",
"lookup",
"[",
"nk",
".",
"nick",
"]",
"=",
"nk",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"nk",
".",
"nick",
",",
"ch",
".",
"name",
")",
"\n",
"}",
"\n",
"}"
] | // Associates a Nick with a Channel | [
"Associates",
"a",
"Nick",
"with",
"a",
"Channel"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L137-L144 |
11,746 | fluffle/goirc | state/channel.go | delNick | func (ch *channel) delNick(nk *nick) {
if _, ok := ch.nicks[nk]; ok {
delete(ch.nicks, nk)
delete(ch.lookup, nk.nick)
} else {
logging.Warn("Channel.delNick(): %s not on %s.", nk.nick, ch.name)
}
} | go | func (ch *channel) delNick(nk *nick) {
if _, ok := ch.nicks[nk]; ok {
delete(ch.nicks, nk)
delete(ch.lookup, nk.nick)
} else {
logging.Warn("Channel.delNick(): %s not on %s.", nk.nick, ch.name)
}
} | [
"func",
"(",
"ch",
"*",
"channel",
")",
"delNick",
"(",
"nk",
"*",
"nick",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"ch",
".",
"nicks",
"[",
"nk",
"]",
";",
"ok",
"{",
"delete",
"(",
"ch",
".",
"nicks",
",",
"nk",
")",
"\n",
"delete",
"(",
"ch",
".",
"lookup",
",",
"nk",
".",
"nick",
")",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"nk",
".",
"nick",
",",
"ch",
".",
"name",
")",
"\n",
"}",
"\n",
"}"
] | // Disassociates a Nick from a Channel. | [
"Disassociates",
"a",
"Nick",
"from",
"a",
"Channel",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L147-L154 |
11,747 | fluffle/goirc | state/channel.go | parseModes | func (ch *channel) parseModes(modes string, modeargs ...string) {
var modeop bool // true => add mode, false => remove mode
var modestr string
for i := 0; i < len(modes); i++ {
switch m := modes[i]; m {
case '+':
modeop = true
modestr = string(m)
case '-':
modeop = false
modestr = string(m)
case 'i':
ch.modes.InviteOnly = modeop
case 'm':
ch.modes.Moderated = modeop
case 'n':
ch.modes.NoExternalMsg = modeop
case 'p':
ch.modes.Private = modeop
case 'r':
ch.modes.Registered = modeop
case 's':
ch.modes.Secret = modeop
case 't':
ch.modes.ProtectedTopic = modeop
case 'z':
ch.modes.SSLOnly = modeop
case 'Z':
ch.modes.AllSSL = modeop
case 'O':
ch.modes.OperOnly = modeop
case 'k':
if modeop && len(modeargs) != 0 {
ch.modes.Key, modeargs = modeargs[0], modeargs[1:]
} else if !modeop {
ch.modes.Key = ""
} else {
logging.Warn("Channel.ParseModes(): not enough arguments to "+
"process MODE %s %s%c", ch.name, modestr, m)
}
case 'l':
if modeop && len(modeargs) != 0 {
ch.modes.Limit, _ = strconv.Atoi(modeargs[0])
modeargs = modeargs[1:]
} else if !modeop {
ch.modes.Limit = 0
} else {
logging.Warn("Channel.ParseModes(): not enough arguments to "+
"process MODE %s %s%c", ch.name, modestr, m)
}
case 'q', 'a', 'o', 'h', 'v':
if len(modeargs) != 0 {
if nk, ok := ch.lookup[modeargs[0]]; ok {
cp := ch.nicks[nk]
switch m {
case 'q':
cp.Owner = modeop
case 'a':
cp.Admin = modeop
case 'o':
cp.Op = modeop
case 'h':
cp.HalfOp = modeop
case 'v':
cp.Voice = modeop
}
modeargs = modeargs[1:]
} else {
logging.Warn("Channel.ParseModes(): untracked nick %s "+
"received MODE on channel %s", modeargs[0], ch.name)
}
} else {
logging.Warn("Channel.ParseModes(): not enough arguments to "+
"process MODE %s %s%c", ch.name, modestr, m)
}
default:
logging.Info("Channel.ParseModes(): unknown mode char %c", m)
}
}
} | go | func (ch *channel) parseModes(modes string, modeargs ...string) {
var modeop bool // true => add mode, false => remove mode
var modestr string
for i := 0; i < len(modes); i++ {
switch m := modes[i]; m {
case '+':
modeop = true
modestr = string(m)
case '-':
modeop = false
modestr = string(m)
case 'i':
ch.modes.InviteOnly = modeop
case 'm':
ch.modes.Moderated = modeop
case 'n':
ch.modes.NoExternalMsg = modeop
case 'p':
ch.modes.Private = modeop
case 'r':
ch.modes.Registered = modeop
case 's':
ch.modes.Secret = modeop
case 't':
ch.modes.ProtectedTopic = modeop
case 'z':
ch.modes.SSLOnly = modeop
case 'Z':
ch.modes.AllSSL = modeop
case 'O':
ch.modes.OperOnly = modeop
case 'k':
if modeop && len(modeargs) != 0 {
ch.modes.Key, modeargs = modeargs[0], modeargs[1:]
} else if !modeop {
ch.modes.Key = ""
} else {
logging.Warn("Channel.ParseModes(): not enough arguments to "+
"process MODE %s %s%c", ch.name, modestr, m)
}
case 'l':
if modeop && len(modeargs) != 0 {
ch.modes.Limit, _ = strconv.Atoi(modeargs[0])
modeargs = modeargs[1:]
} else if !modeop {
ch.modes.Limit = 0
} else {
logging.Warn("Channel.ParseModes(): not enough arguments to "+
"process MODE %s %s%c", ch.name, modestr, m)
}
case 'q', 'a', 'o', 'h', 'v':
if len(modeargs) != 0 {
if nk, ok := ch.lookup[modeargs[0]]; ok {
cp := ch.nicks[nk]
switch m {
case 'q':
cp.Owner = modeop
case 'a':
cp.Admin = modeop
case 'o':
cp.Op = modeop
case 'h':
cp.HalfOp = modeop
case 'v':
cp.Voice = modeop
}
modeargs = modeargs[1:]
} else {
logging.Warn("Channel.ParseModes(): untracked nick %s "+
"received MODE on channel %s", modeargs[0], ch.name)
}
} else {
logging.Warn("Channel.ParseModes(): not enough arguments to "+
"process MODE %s %s%c", ch.name, modestr, m)
}
default:
logging.Info("Channel.ParseModes(): unknown mode char %c", m)
}
}
} | [
"func",
"(",
"ch",
"*",
"channel",
")",
"parseModes",
"(",
"modes",
"string",
",",
"modeargs",
"...",
"string",
")",
"{",
"var",
"modeop",
"bool",
"// true => add mode, false => remove mode",
"\n",
"var",
"modestr",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"modes",
")",
";",
"i",
"++",
"{",
"switch",
"m",
":=",
"modes",
"[",
"i",
"]",
";",
"m",
"{",
"case",
"'+'",
":",
"modeop",
"=",
"true",
"\n",
"modestr",
"=",
"string",
"(",
"m",
")",
"\n",
"case",
"'-'",
":",
"modeop",
"=",
"false",
"\n",
"modestr",
"=",
"string",
"(",
"m",
")",
"\n",
"case",
"'i'",
":",
"ch",
".",
"modes",
".",
"InviteOnly",
"=",
"modeop",
"\n",
"case",
"'m'",
":",
"ch",
".",
"modes",
".",
"Moderated",
"=",
"modeop",
"\n",
"case",
"'n'",
":",
"ch",
".",
"modes",
".",
"NoExternalMsg",
"=",
"modeop",
"\n",
"case",
"'p'",
":",
"ch",
".",
"modes",
".",
"Private",
"=",
"modeop",
"\n",
"case",
"'r'",
":",
"ch",
".",
"modes",
".",
"Registered",
"=",
"modeop",
"\n",
"case",
"'s'",
":",
"ch",
".",
"modes",
".",
"Secret",
"=",
"modeop",
"\n",
"case",
"'t'",
":",
"ch",
".",
"modes",
".",
"ProtectedTopic",
"=",
"modeop",
"\n",
"case",
"'z'",
":",
"ch",
".",
"modes",
".",
"SSLOnly",
"=",
"modeop",
"\n",
"case",
"'Z'",
":",
"ch",
".",
"modes",
".",
"AllSSL",
"=",
"modeop",
"\n",
"case",
"'O'",
":",
"ch",
".",
"modes",
".",
"OperOnly",
"=",
"modeop",
"\n",
"case",
"'k'",
":",
"if",
"modeop",
"&&",
"len",
"(",
"modeargs",
")",
"!=",
"0",
"{",
"ch",
".",
"modes",
".",
"Key",
",",
"modeargs",
"=",
"modeargs",
"[",
"0",
"]",
",",
"modeargs",
"[",
"1",
":",
"]",
"\n",
"}",
"else",
"if",
"!",
"modeop",
"{",
"ch",
".",
"modes",
".",
"Key",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"ch",
".",
"name",
",",
"modestr",
",",
"m",
")",
"\n",
"}",
"\n",
"case",
"'l'",
":",
"if",
"modeop",
"&&",
"len",
"(",
"modeargs",
")",
"!=",
"0",
"{",
"ch",
".",
"modes",
".",
"Limit",
",",
"_",
"=",
"strconv",
".",
"Atoi",
"(",
"modeargs",
"[",
"0",
"]",
")",
"\n",
"modeargs",
"=",
"modeargs",
"[",
"1",
":",
"]",
"\n",
"}",
"else",
"if",
"!",
"modeop",
"{",
"ch",
".",
"modes",
".",
"Limit",
"=",
"0",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"ch",
".",
"name",
",",
"modestr",
",",
"m",
")",
"\n",
"}",
"\n",
"case",
"'q'",
",",
"'a'",
",",
"'o'",
",",
"'h'",
",",
"'v'",
":",
"if",
"len",
"(",
"modeargs",
")",
"!=",
"0",
"{",
"if",
"nk",
",",
"ok",
":=",
"ch",
".",
"lookup",
"[",
"modeargs",
"[",
"0",
"]",
"]",
";",
"ok",
"{",
"cp",
":=",
"ch",
".",
"nicks",
"[",
"nk",
"]",
"\n",
"switch",
"m",
"{",
"case",
"'q'",
":",
"cp",
".",
"Owner",
"=",
"modeop",
"\n",
"case",
"'a'",
":",
"cp",
".",
"Admin",
"=",
"modeop",
"\n",
"case",
"'o'",
":",
"cp",
".",
"Op",
"=",
"modeop",
"\n",
"case",
"'h'",
":",
"cp",
".",
"HalfOp",
"=",
"modeop",
"\n",
"case",
"'v'",
":",
"cp",
".",
"Voice",
"=",
"modeop",
"\n",
"}",
"\n",
"modeargs",
"=",
"modeargs",
"[",
"1",
":",
"]",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"modeargs",
"[",
"0",
"]",
",",
"ch",
".",
"name",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"ch",
".",
"name",
",",
"modestr",
",",
"m",
")",
"\n",
"}",
"\n",
"default",
":",
"logging",
".",
"Info",
"(",
"\"",
"\"",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Parses mode strings for a channel. | [
"Parses",
"mode",
"strings",
"for",
"a",
"channel",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L157-L236 |
11,748 | fluffle/goirc | state/channel.go | IsOn | func (ch *Channel) IsOn(nk string) (*ChanPrivs, bool) {
cp, ok := ch.Nicks[nk]
return cp, ok
} | go | func (ch *Channel) IsOn(nk string) (*ChanPrivs, bool) {
cp, ok := ch.Nicks[nk]
return cp, ok
} | [
"func",
"(",
"ch",
"*",
"Channel",
")",
"IsOn",
"(",
"nk",
"string",
")",
"(",
"*",
"ChanPrivs",
",",
"bool",
")",
"{",
"cp",
",",
"ok",
":=",
"ch",
".",
"Nicks",
"[",
"nk",
"]",
"\n",
"return",
"cp",
",",
"ok",
"\n",
"}"
] | // Returns true if the Nick is associated with the Channel | [
"Returns",
"true",
"if",
"the",
"Nick",
"is",
"associated",
"with",
"the",
"Channel"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L239-L242 |
11,749 | fluffle/goirc | state/channel.go | Equals | func (ch *Channel) Equals(other *Channel) bool {
return reflect.DeepEqual(ch, other)
} | go | func (ch *Channel) Equals(other *Channel) bool {
return reflect.DeepEqual(ch, other)
} | [
"func",
"(",
"ch",
"*",
"Channel",
")",
"Equals",
"(",
"other",
"*",
"Channel",
")",
"bool",
"{",
"return",
"reflect",
".",
"DeepEqual",
"(",
"ch",
",",
"other",
")",
"\n",
"}"
] | // Test Channel equality. | [
"Test",
"Channel",
"equality",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L245-L247 |
11,750 | fluffle/goirc | state/channel.go | Copy | func (cm *ChanMode) Copy() *ChanMode {
if cm == nil {
return nil
}
c := *cm
return &c
} | go | func (cm *ChanMode) Copy() *ChanMode {
if cm == nil {
return nil
}
c := *cm
return &c
} | [
"func",
"(",
"cm",
"*",
"ChanMode",
")",
"Copy",
"(",
")",
"*",
"ChanMode",
"{",
"if",
"cm",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"c",
":=",
"*",
"cm",
"\n",
"return",
"&",
"c",
"\n",
"}"
] | // Duplicates a ChanMode struct. | [
"Duplicates",
"a",
"ChanMode",
"struct",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L250-L256 |
11,751 | fluffle/goirc | state/channel.go | Equals | func (cm *ChanMode) Equals(other *ChanMode) bool {
return reflect.DeepEqual(cm, other)
} | go | func (cm *ChanMode) Equals(other *ChanMode) bool {
return reflect.DeepEqual(cm, other)
} | [
"func",
"(",
"cm",
"*",
"ChanMode",
")",
"Equals",
"(",
"other",
"*",
"ChanMode",
")",
"bool",
"{",
"return",
"reflect",
".",
"DeepEqual",
"(",
"cm",
",",
"other",
")",
"\n",
"}"
] | // Test ChanMode equality. | [
"Test",
"ChanMode",
"equality",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L259-L261 |
11,752 | fluffle/goirc | state/channel.go | Copy | func (cp *ChanPrivs) Copy() *ChanPrivs {
if cp == nil {
return nil
}
c := *cp
return &c
} | go | func (cp *ChanPrivs) Copy() *ChanPrivs {
if cp == nil {
return nil
}
c := *cp
return &c
} | [
"func",
"(",
"cp",
"*",
"ChanPrivs",
")",
"Copy",
"(",
")",
"*",
"ChanPrivs",
"{",
"if",
"cp",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"c",
":=",
"*",
"cp",
"\n",
"return",
"&",
"c",
"\n",
"}"
] | // Duplicates a ChanPrivs struct. | [
"Duplicates",
"a",
"ChanPrivs",
"struct",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L264-L270 |
11,753 | fluffle/goirc | state/channel.go | Equals | func (cp *ChanPrivs) Equals(other *ChanPrivs) bool {
return reflect.DeepEqual(cp, other)
} | go | func (cp *ChanPrivs) Equals(other *ChanPrivs) bool {
return reflect.DeepEqual(cp, other)
} | [
"func",
"(",
"cp",
"*",
"ChanPrivs",
")",
"Equals",
"(",
"other",
"*",
"ChanPrivs",
")",
"bool",
"{",
"return",
"reflect",
".",
"DeepEqual",
"(",
"cp",
",",
"other",
")",
"\n",
"}"
] | // Test ChanPrivs equality. | [
"Test",
"ChanPrivs",
"equality",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/channel.go#L273-L275 |
11,754 | fluffle/goirc | state/nick.go | Nick | func (nk *nick) Nick() *Nick {
n := &Nick{
Nick: nk.nick,
Ident: nk.ident,
Host: nk.host,
Name: nk.name,
Modes: nk.modes.Copy(),
Channels: make(map[string]*ChanPrivs),
}
for c, cp := range nk.chans {
n.Channels[c.name] = cp.Copy()
}
return n
} | go | func (nk *nick) Nick() *Nick {
n := &Nick{
Nick: nk.nick,
Ident: nk.ident,
Host: nk.host,
Name: nk.name,
Modes: nk.modes.Copy(),
Channels: make(map[string]*ChanPrivs),
}
for c, cp := range nk.chans {
n.Channels[c.name] = cp.Copy()
}
return n
} | [
"func",
"(",
"nk",
"*",
"nick",
")",
"Nick",
"(",
")",
"*",
"Nick",
"{",
"n",
":=",
"&",
"Nick",
"{",
"Nick",
":",
"nk",
".",
"nick",
",",
"Ident",
":",
"nk",
".",
"ident",
",",
"Host",
":",
"nk",
".",
"host",
",",
"Name",
":",
"nk",
".",
"name",
",",
"Modes",
":",
"nk",
".",
"modes",
".",
"Copy",
"(",
")",
",",
"Channels",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"ChanPrivs",
")",
",",
"}",
"\n",
"for",
"c",
",",
"cp",
":=",
"range",
"nk",
".",
"chans",
"{",
"n",
".",
"Channels",
"[",
"c",
".",
"name",
"]",
"=",
"cp",
".",
"Copy",
"(",
")",
"\n",
"}",
"\n",
"return",
"n",
"\n",
"}"
] | // Returns a copy of the internal tracker nick state at this time.
// Relies on tracker-level locking for concurrent access. | [
"Returns",
"a",
"copy",
"of",
"the",
"internal",
"tracker",
"nick",
"state",
"at",
"this",
"time",
".",
"Relies",
"on",
"tracker",
"-",
"level",
"locking",
"for",
"concurrent",
"access",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/nick.go#L67-L80 |
11,755 | fluffle/goirc | state/nick.go | addChannel | func (nk *nick) addChannel(ch *channel, cp *ChanPrivs) {
if _, ok := nk.chans[ch]; !ok {
nk.chans[ch] = cp
nk.lookup[ch.name] = ch
} else {
logging.Warn("Nick.addChannel(): %s already on %s.", nk.nick, ch.name)
}
} | go | func (nk *nick) addChannel(ch *channel, cp *ChanPrivs) {
if _, ok := nk.chans[ch]; !ok {
nk.chans[ch] = cp
nk.lookup[ch.name] = ch
} else {
logging.Warn("Nick.addChannel(): %s already on %s.", nk.nick, ch.name)
}
} | [
"func",
"(",
"nk",
"*",
"nick",
")",
"addChannel",
"(",
"ch",
"*",
"channel",
",",
"cp",
"*",
"ChanPrivs",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"nk",
".",
"chans",
"[",
"ch",
"]",
";",
"!",
"ok",
"{",
"nk",
".",
"chans",
"[",
"ch",
"]",
"=",
"cp",
"\n",
"nk",
".",
"lookup",
"[",
"ch",
".",
"name",
"]",
"=",
"ch",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"nk",
".",
"nick",
",",
"ch",
".",
"name",
")",
"\n",
"}",
"\n",
"}"
] | // Associates a Channel with a Nick. | [
"Associates",
"a",
"Channel",
"with",
"a",
"Nick",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/nick.go#L88-L95 |
11,756 | fluffle/goirc | state/nick.go | delChannel | func (nk *nick) delChannel(ch *channel) {
if _, ok := nk.chans[ch]; ok {
delete(nk.chans, ch)
delete(nk.lookup, ch.name)
} else {
logging.Warn("Nick.delChannel(): %s not on %s.", nk.nick, ch.name)
}
} | go | func (nk *nick) delChannel(ch *channel) {
if _, ok := nk.chans[ch]; ok {
delete(nk.chans, ch)
delete(nk.lookup, ch.name)
} else {
logging.Warn("Nick.delChannel(): %s not on %s.", nk.nick, ch.name)
}
} | [
"func",
"(",
"nk",
"*",
"nick",
")",
"delChannel",
"(",
"ch",
"*",
"channel",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"nk",
".",
"chans",
"[",
"ch",
"]",
";",
"ok",
"{",
"delete",
"(",
"nk",
".",
"chans",
",",
"ch",
")",
"\n",
"delete",
"(",
"nk",
".",
"lookup",
",",
"ch",
".",
"name",
")",
"\n",
"}",
"else",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"nk",
".",
"nick",
",",
"ch",
".",
"name",
")",
"\n",
"}",
"\n",
"}"
] | // Disassociates a Channel from a Nick. | [
"Disassociates",
"a",
"Channel",
"from",
"a",
"Nick",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/nick.go#L98-L105 |
11,757 | fluffle/goirc | state/nick.go | parseModes | func (nk *nick) parseModes(modes string) {
var modeop bool // true => add mode, false => remove mode
for i := 0; i < len(modes); i++ {
switch m := modes[i]; m {
case '+':
modeop = true
case '-':
modeop = false
case 'B':
nk.modes.Bot = modeop
case 'i':
nk.modes.Invisible = modeop
case 'o':
nk.modes.Oper = modeop
case 'w':
nk.modes.WallOps = modeop
case 'x':
nk.modes.HiddenHost = modeop
case 'z':
nk.modes.SSL = modeop
default:
logging.Info("Nick.ParseModes(): unknown mode char %c", m)
}
}
} | go | func (nk *nick) parseModes(modes string) {
var modeop bool // true => add mode, false => remove mode
for i := 0; i < len(modes); i++ {
switch m := modes[i]; m {
case '+':
modeop = true
case '-':
modeop = false
case 'B':
nk.modes.Bot = modeop
case 'i':
nk.modes.Invisible = modeop
case 'o':
nk.modes.Oper = modeop
case 'w':
nk.modes.WallOps = modeop
case 'x':
nk.modes.HiddenHost = modeop
case 'z':
nk.modes.SSL = modeop
default:
logging.Info("Nick.ParseModes(): unknown mode char %c", m)
}
}
} | [
"func",
"(",
"nk",
"*",
"nick",
")",
"parseModes",
"(",
"modes",
"string",
")",
"{",
"var",
"modeop",
"bool",
"// true => add mode, false => remove mode",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"modes",
")",
";",
"i",
"++",
"{",
"switch",
"m",
":=",
"modes",
"[",
"i",
"]",
";",
"m",
"{",
"case",
"'+'",
":",
"modeop",
"=",
"true",
"\n",
"case",
"'-'",
":",
"modeop",
"=",
"false",
"\n",
"case",
"'B'",
":",
"nk",
".",
"modes",
".",
"Bot",
"=",
"modeop",
"\n",
"case",
"'i'",
":",
"nk",
".",
"modes",
".",
"Invisible",
"=",
"modeop",
"\n",
"case",
"'o'",
":",
"nk",
".",
"modes",
".",
"Oper",
"=",
"modeop",
"\n",
"case",
"'w'",
":",
"nk",
".",
"modes",
".",
"WallOps",
"=",
"modeop",
"\n",
"case",
"'x'",
":",
"nk",
".",
"modes",
".",
"HiddenHost",
"=",
"modeop",
"\n",
"case",
"'z'",
":",
"nk",
".",
"modes",
".",
"SSL",
"=",
"modeop",
"\n",
"default",
":",
"logging",
".",
"Info",
"(",
"\"",
"\"",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Parse mode strings for a Nick. | [
"Parse",
"mode",
"strings",
"for",
"a",
"Nick",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/nick.go#L108-L132 |
11,758 | fluffle/goirc | state/nick.go | IsOn | func (nk *Nick) IsOn(ch string) (*ChanPrivs, bool) {
cp, ok := nk.Channels[ch]
return cp, ok
} | go | func (nk *Nick) IsOn(ch string) (*ChanPrivs, bool) {
cp, ok := nk.Channels[ch]
return cp, ok
} | [
"func",
"(",
"nk",
"*",
"Nick",
")",
"IsOn",
"(",
"ch",
"string",
")",
"(",
"*",
"ChanPrivs",
",",
"bool",
")",
"{",
"cp",
",",
"ok",
":=",
"nk",
".",
"Channels",
"[",
"ch",
"]",
"\n",
"return",
"cp",
",",
"ok",
"\n",
"}"
] | // Returns true if the Nick is associated with the Channel. | [
"Returns",
"true",
"if",
"the",
"Nick",
"is",
"associated",
"with",
"the",
"Channel",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/nick.go#L135-L138 |
11,759 | fluffle/goirc | state/nick.go | Equals | func (nk *Nick) Equals(other *Nick) bool {
return reflect.DeepEqual(nk, other)
} | go | func (nk *Nick) Equals(other *Nick) bool {
return reflect.DeepEqual(nk, other)
} | [
"func",
"(",
"nk",
"*",
"Nick",
")",
"Equals",
"(",
"other",
"*",
"Nick",
")",
"bool",
"{",
"return",
"reflect",
".",
"DeepEqual",
"(",
"nk",
",",
"other",
")",
"\n",
"}"
] | // Tests Nick equality. | [
"Tests",
"Nick",
"equality",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/nick.go#L141-L143 |
11,760 | fluffle/goirc | state/nick.go | Copy | func (nm *NickMode) Copy() *NickMode {
if nm == nil {
return nil
}
n := *nm
return &n
} | go | func (nm *NickMode) Copy() *NickMode {
if nm == nil {
return nil
}
n := *nm
return &n
} | [
"func",
"(",
"nm",
"*",
"NickMode",
")",
"Copy",
"(",
")",
"*",
"NickMode",
"{",
"if",
"nm",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"n",
":=",
"*",
"nm",
"\n",
"return",
"&",
"n",
"\n",
"}"
] | // Duplicates a NickMode struct. | [
"Duplicates",
"a",
"NickMode",
"struct",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/nick.go#L146-L152 |
11,761 | fluffle/goirc | state/nick.go | Equals | func (nm *NickMode) Equals(other *NickMode) bool {
return reflect.DeepEqual(nm, other)
} | go | func (nm *NickMode) Equals(other *NickMode) bool {
return reflect.DeepEqual(nm, other)
} | [
"func",
"(",
"nm",
"*",
"NickMode",
")",
"Equals",
"(",
"other",
"*",
"NickMode",
")",
"bool",
"{",
"return",
"reflect",
".",
"DeepEqual",
"(",
"nm",
",",
"other",
")",
"\n",
"}"
] | // Tests NickMode equality. | [
"Tests",
"NickMode",
"equality",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/nick.go#L155-L157 |
11,762 | fluffle/goirc | client/line.go | Copy | func (l *Line) Copy() *Line {
nl := *l
nl.Args = make([]string, len(l.Args))
copy(nl.Args, l.Args)
if l.Tags != nil {
nl.Tags = make(map[string]string)
for k, v := range l.Tags {
nl.Tags[k] = v
}
}
return &nl
} | go | func (l *Line) Copy() *Line {
nl := *l
nl.Args = make([]string, len(l.Args))
copy(nl.Args, l.Args)
if l.Tags != nil {
nl.Tags = make(map[string]string)
for k, v := range l.Tags {
nl.Tags[k] = v
}
}
return &nl
} | [
"func",
"(",
"l",
"*",
"Line",
")",
"Copy",
"(",
")",
"*",
"Line",
"{",
"nl",
":=",
"*",
"l",
"\n",
"nl",
".",
"Args",
"=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"l",
".",
"Args",
")",
")",
"\n",
"copy",
"(",
"nl",
".",
"Args",
",",
"l",
".",
"Args",
")",
"\n",
"if",
"l",
".",
"Tags",
"!=",
"nil",
"{",
"nl",
".",
"Tags",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"l",
".",
"Tags",
"{",
"nl",
".",
"Tags",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"nl",
"\n",
"}"
] | // Copy returns a deep copy of the Line. | [
"Copy",
"returns",
"a",
"deep",
"copy",
"of",
"the",
"Line",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/line.go#L28-L39 |
11,763 | fluffle/goirc | client/line.go | Target | func (line *Line) Target() string {
// TODO(fluffle): Add 005 CHANTYPES parsing for this?
switch line.Cmd {
case PRIVMSG, NOTICE, ACTION:
if !line.Public() {
return line.Nick
}
case CTCP, CTCPREPLY:
if !line.Public() {
return line.Nick
}
return line.Args[1]
}
if len(line.Args) > 0 {
return line.Args[0]
}
return ""
} | go | func (line *Line) Target() string {
// TODO(fluffle): Add 005 CHANTYPES parsing for this?
switch line.Cmd {
case PRIVMSG, NOTICE, ACTION:
if !line.Public() {
return line.Nick
}
case CTCP, CTCPREPLY:
if !line.Public() {
return line.Nick
}
return line.Args[1]
}
if len(line.Args) > 0 {
return line.Args[0]
}
return ""
} | [
"func",
"(",
"line",
"*",
"Line",
")",
"Target",
"(",
")",
"string",
"{",
"// TODO(fluffle): Add 005 CHANTYPES parsing for this?",
"switch",
"line",
".",
"Cmd",
"{",
"case",
"PRIVMSG",
",",
"NOTICE",
",",
"ACTION",
":",
"if",
"!",
"line",
".",
"Public",
"(",
")",
"{",
"return",
"line",
".",
"Nick",
"\n",
"}",
"\n",
"case",
"CTCP",
",",
"CTCPREPLY",
":",
"if",
"!",
"line",
".",
"Public",
"(",
")",
"{",
"return",
"line",
".",
"Nick",
"\n",
"}",
"\n",
"return",
"line",
".",
"Args",
"[",
"1",
"]",
"\n",
"}",
"\n",
"if",
"len",
"(",
"line",
".",
"Args",
")",
">",
"0",
"{",
"return",
"line",
".",
"Args",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // Target returns the contextual target of the line, usually the first Arg
// for the IRC verb. If the line was broadcast from a channel, the target
// will be that channel. If the line was sent directly by a user, the target
// will be that user. | [
"Target",
"returns",
"the",
"contextual",
"target",
"of",
"the",
"line",
"usually",
"the",
"first",
"Arg",
"for",
"the",
"IRC",
"verb",
".",
"If",
"the",
"line",
"was",
"broadcast",
"from",
"a",
"channel",
"the",
"target",
"will",
"be",
"that",
"channel",
".",
"If",
"the",
"line",
"was",
"sent",
"directly",
"by",
"a",
"user",
"the",
"target",
"will",
"be",
"that",
"user",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/line.go#L54-L71 |
11,764 | fluffle/goirc | state/tracker.go | NewTracker | func NewTracker(mynick string) *stateTracker {
st := &stateTracker{
chans: make(map[string]*channel),
nicks: make(map[string]*nick),
}
st.me = newNick(mynick)
st.nicks[mynick] = st.me
return st
} | go | func NewTracker(mynick string) *stateTracker {
st := &stateTracker{
chans: make(map[string]*channel),
nicks: make(map[string]*nick),
}
st.me = newNick(mynick)
st.nicks[mynick] = st.me
return st
} | [
"func",
"NewTracker",
"(",
"mynick",
"string",
")",
"*",
"stateTracker",
"{",
"st",
":=",
"&",
"stateTracker",
"{",
"chans",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"channel",
")",
",",
"nicks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"nick",
")",
",",
"}",
"\n",
"st",
".",
"me",
"=",
"newNick",
"(",
"mynick",
")",
"\n",
"st",
".",
"nicks",
"[",
"mynick",
"]",
"=",
"st",
".",
"me",
"\n",
"return",
"st",
"\n",
"}"
] | // ... and a constructor to make it ... | [
"...",
"and",
"a",
"constructor",
"to",
"make",
"it",
"..."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L52-L60 |
11,765 | fluffle/goirc | state/tracker.go | Wipe | func (st *stateTracker) Wipe() {
st.mu.Lock()
defer st.mu.Unlock()
// Deleting all the channels implicitly deletes every nick but me.
for _, ch := range st.chans {
st.delChannel(ch)
}
} | go | func (st *stateTracker) Wipe() {
st.mu.Lock()
defer st.mu.Unlock()
// Deleting all the channels implicitly deletes every nick but me.
for _, ch := range st.chans {
st.delChannel(ch)
}
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"Wipe",
"(",
")",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"// Deleting all the channels implicitly deletes every nick but me.",
"for",
"_",
",",
"ch",
":=",
"range",
"st",
".",
"chans",
"{",
"st",
".",
"delChannel",
"(",
"ch",
")",
"\n",
"}",
"\n",
"}"
] | // ... and a method to wipe the state clean. | [
"...",
"and",
"a",
"method",
"to",
"wipe",
"the",
"state",
"clean",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L63-L70 |
11,766 | fluffle/goirc | state/tracker.go | GetNick | func (st *stateTracker) GetNick(n string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
if nk, ok := st.nicks[n]; ok {
return nk.Nick()
}
return nil
} | go | func (st *stateTracker) GetNick(n string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
if nk, ok := st.nicks[n]; ok {
return nk.Nick()
}
return nil
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"GetNick",
"(",
"n",
"string",
")",
"*",
"Nick",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"nk",
",",
"ok",
":=",
"st",
".",
"nicks",
"[",
"n",
"]",
";",
"ok",
"{",
"return",
"nk",
".",
"Nick",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Returns a nick for the nick n, if we're tracking it. | [
"Returns",
"a",
"nick",
"for",
"the",
"nick",
"n",
"if",
"we",
"re",
"tracking",
"it",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L94-L101 |
11,767 | fluffle/goirc | state/tracker.go | ReNick | func (st *stateTracker) ReNick(old, neu string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
nk, ok := st.nicks[old]
if !ok {
logging.Warn("Tracker.ReNick(): %s not tracked.", old)
return nil
}
if _, ok := st.nicks[neu]; ok {
logging.Warn("Tracker.ReNick(): %s already exists.", neu)
return nil
}
nk.nick = neu
delete(st.nicks, old)
st.nicks[neu] = nk
for ch, _ := range nk.chans {
// We also need to update the lookup maps of all the channels
// the nick is on, to keep things in sync.
delete(ch.lookup, old)
ch.lookup[neu] = nk
}
return nk.Nick()
} | go | func (st *stateTracker) ReNick(old, neu string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
nk, ok := st.nicks[old]
if !ok {
logging.Warn("Tracker.ReNick(): %s not tracked.", old)
return nil
}
if _, ok := st.nicks[neu]; ok {
logging.Warn("Tracker.ReNick(): %s already exists.", neu)
return nil
}
nk.nick = neu
delete(st.nicks, old)
st.nicks[neu] = nk
for ch, _ := range nk.chans {
// We also need to update the lookup maps of all the channels
// the nick is on, to keep things in sync.
delete(ch.lookup, old)
ch.lookup[neu] = nk
}
return nk.Nick()
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"ReNick",
"(",
"old",
",",
"neu",
"string",
")",
"*",
"Nick",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"nk",
",",
"ok",
":=",
"st",
".",
"nicks",
"[",
"old",
"]",
"\n",
"if",
"!",
"ok",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"old",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"st",
".",
"nicks",
"[",
"neu",
"]",
";",
"ok",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"neu",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"nk",
".",
"nick",
"=",
"neu",
"\n",
"delete",
"(",
"st",
".",
"nicks",
",",
"old",
")",
"\n",
"st",
".",
"nicks",
"[",
"neu",
"]",
"=",
"nk",
"\n",
"for",
"ch",
",",
"_",
":=",
"range",
"nk",
".",
"chans",
"{",
"// We also need to update the lookup maps of all the channels",
"// the nick is on, to keep things in sync.",
"delete",
"(",
"ch",
".",
"lookup",
",",
"old",
")",
"\n",
"ch",
".",
"lookup",
"[",
"neu",
"]",
"=",
"nk",
"\n",
"}",
"\n",
"return",
"nk",
".",
"Nick",
"(",
")",
"\n",
"}"
] | // Signals to the tracker that a nick should be tracked
// under a "neu" nick rather than the old one. | [
"Signals",
"to",
"the",
"tracker",
"that",
"a",
"nick",
"should",
"be",
"tracked",
"under",
"a",
"neu",
"nick",
"rather",
"than",
"the",
"old",
"one",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L105-L128 |
11,768 | fluffle/goirc | state/tracker.go | DelNick | func (st *stateTracker) DelNick(n string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
if nk, ok := st.nicks[n]; ok {
if nk == st.me {
logging.Warn("Tracker.DelNick(): won't delete myself.")
return nil
}
st.delNick(nk)
return nk.Nick()
}
logging.Warn("Tracker.DelNick(): %s not tracked.", n)
return nil
} | go | func (st *stateTracker) DelNick(n string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
if nk, ok := st.nicks[n]; ok {
if nk == st.me {
logging.Warn("Tracker.DelNick(): won't delete myself.")
return nil
}
st.delNick(nk)
return nk.Nick()
}
logging.Warn("Tracker.DelNick(): %s not tracked.", n)
return nil
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"DelNick",
"(",
"n",
"string",
")",
"*",
"Nick",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"nk",
",",
"ok",
":=",
"st",
".",
"nicks",
"[",
"n",
"]",
";",
"ok",
"{",
"if",
"nk",
"==",
"st",
".",
"me",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"st",
".",
"delNick",
"(",
"nk",
")",
"\n",
"return",
"nk",
".",
"Nick",
"(",
")",
"\n",
"}",
"\n",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"n",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Removes a nick from being tracked. | [
"Removes",
"a",
"nick",
"from",
"being",
"tracked",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L131-L144 |
11,769 | fluffle/goirc | state/tracker.go | NickInfo | func (st *stateTracker) NickInfo(n, ident, host, name string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
nk, ok := st.nicks[n]
if !ok {
return nil
}
nk.ident = ident
nk.host = host
nk.name = name
return nk.Nick()
} | go | func (st *stateTracker) NickInfo(n, ident, host, name string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
nk, ok := st.nicks[n]
if !ok {
return nil
}
nk.ident = ident
nk.host = host
nk.name = name
return nk.Nick()
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"NickInfo",
"(",
"n",
",",
"ident",
",",
"host",
",",
"name",
"string",
")",
"*",
"Nick",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"nk",
",",
"ok",
":=",
"st",
".",
"nicks",
"[",
"n",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"nk",
".",
"ident",
"=",
"ident",
"\n",
"nk",
".",
"host",
"=",
"host",
"\n",
"nk",
".",
"name",
"=",
"name",
"\n",
"return",
"nk",
".",
"Nick",
"(",
")",
"\n",
"}"
] | // Sets ident, host and "real" name for the nick. | [
"Sets",
"ident",
"host",
"and",
"real",
"name",
"for",
"the",
"nick",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L167-L178 |
11,770 | fluffle/goirc | state/tracker.go | NickModes | func (st *stateTracker) NickModes(n, modes string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
nk, ok := st.nicks[n]
if !ok {
return nil
}
nk.parseModes(modes)
return nk.Nick()
} | go | func (st *stateTracker) NickModes(n, modes string) *Nick {
st.mu.Lock()
defer st.mu.Unlock()
nk, ok := st.nicks[n]
if !ok {
return nil
}
nk.parseModes(modes)
return nk.Nick()
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"NickModes",
"(",
"n",
",",
"modes",
"string",
")",
"*",
"Nick",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"nk",
",",
"ok",
":=",
"st",
".",
"nicks",
"[",
"n",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"nk",
".",
"parseModes",
"(",
"modes",
")",
"\n",
"return",
"nk",
".",
"Nick",
"(",
")",
"\n",
"}"
] | // Sets user modes for the nick. | [
"Sets",
"user",
"modes",
"for",
"the",
"nick",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L181-L190 |
11,771 | fluffle/goirc | state/tracker.go | NewChannel | func (st *stateTracker) NewChannel(c string) *Channel {
if c == "" {
logging.Warn("Tracker.NewChannel(): Not tracking empty channel.")
return nil
}
st.mu.Lock()
defer st.mu.Unlock()
if _, ok := st.chans[c]; ok {
logging.Warn("Tracker.NewChannel(): %s already tracked.", c)
return nil
}
st.chans[c] = newChannel(c)
return st.chans[c].Channel()
} | go | func (st *stateTracker) NewChannel(c string) *Channel {
if c == "" {
logging.Warn("Tracker.NewChannel(): Not tracking empty channel.")
return nil
}
st.mu.Lock()
defer st.mu.Unlock()
if _, ok := st.chans[c]; ok {
logging.Warn("Tracker.NewChannel(): %s already tracked.", c)
return nil
}
st.chans[c] = newChannel(c)
return st.chans[c].Channel()
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"NewChannel",
"(",
"c",
"string",
")",
"*",
"Channel",
"{",
"if",
"c",
"==",
"\"",
"\"",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"st",
".",
"chans",
"[",
"c",
"]",
";",
"ok",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"c",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"st",
".",
"chans",
"[",
"c",
"]",
"=",
"newChannel",
"(",
"c",
")",
"\n",
"return",
"st",
".",
"chans",
"[",
"c",
"]",
".",
"Channel",
"(",
")",
"\n",
"}"
] | // Creates a new Channel, initialises it, and stores it so it
// can be properly tracked for state management purposes. | [
"Creates",
"a",
"new",
"Channel",
"initialises",
"it",
"and",
"stores",
"it",
"so",
"it",
"can",
"be",
"properly",
"tracked",
"for",
"state",
"management",
"purposes",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L194-L207 |
11,772 | fluffle/goirc | state/tracker.go | DelChannel | func (st *stateTracker) DelChannel(c string) *Channel {
st.mu.Lock()
defer st.mu.Unlock()
if ch, ok := st.chans[c]; ok {
st.delChannel(ch)
return ch.Channel()
}
logging.Warn("Tracker.DelChannel(): %s not tracked.", c)
return nil
} | go | func (st *stateTracker) DelChannel(c string) *Channel {
st.mu.Lock()
defer st.mu.Unlock()
if ch, ok := st.chans[c]; ok {
st.delChannel(ch)
return ch.Channel()
}
logging.Warn("Tracker.DelChannel(): %s not tracked.", c)
return nil
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"DelChannel",
"(",
"c",
"string",
")",
"*",
"Channel",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"ch",
",",
"ok",
":=",
"st",
".",
"chans",
"[",
"c",
"]",
";",
"ok",
"{",
"st",
".",
"delChannel",
"(",
"ch",
")",
"\n",
"return",
"ch",
".",
"Channel",
"(",
")",
"\n",
"}",
"\n",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"c",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Removes a Channel from being tracked. | [
"Removes",
"a",
"Channel",
"from",
"being",
"tracked",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L220-L229 |
11,773 | fluffle/goirc | state/tracker.go | Topic | func (st *stateTracker) Topic(c, topic string) *Channel {
st.mu.Lock()
defer st.mu.Unlock()
ch, ok := st.chans[c]
if !ok {
return nil
}
ch.topic = topic
return ch.Channel()
} | go | func (st *stateTracker) Topic(c, topic string) *Channel {
st.mu.Lock()
defer st.mu.Unlock()
ch, ok := st.chans[c]
if !ok {
return nil
}
ch.topic = topic
return ch.Channel()
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"Topic",
"(",
"c",
",",
"topic",
"string",
")",
"*",
"Channel",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"ch",
",",
"ok",
":=",
"st",
".",
"chans",
"[",
"c",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"ch",
".",
"topic",
"=",
"topic",
"\n",
"return",
"ch",
".",
"Channel",
"(",
")",
"\n",
"}"
] | // Sets the topic of a channel. | [
"Sets",
"the",
"topic",
"of",
"a",
"channel",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L245-L254 |
11,774 | fluffle/goirc | state/tracker.go | ChannelModes | func (st *stateTracker) ChannelModes(c, modes string, args ...string) *Channel {
st.mu.Lock()
defer st.mu.Unlock()
ch, ok := st.chans[c]
if !ok {
return nil
}
ch.parseModes(modes, args...)
return ch.Channel()
} | go | func (st *stateTracker) ChannelModes(c, modes string, args ...string) *Channel {
st.mu.Lock()
defer st.mu.Unlock()
ch, ok := st.chans[c]
if !ok {
return nil
}
ch.parseModes(modes, args...)
return ch.Channel()
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"ChannelModes",
"(",
"c",
",",
"modes",
"string",
",",
"args",
"...",
"string",
")",
"*",
"Channel",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"ch",
",",
"ok",
":=",
"st",
".",
"chans",
"[",
"c",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"ch",
".",
"parseModes",
"(",
"modes",
",",
"args",
"...",
")",
"\n",
"return",
"ch",
".",
"Channel",
"(",
")",
"\n",
"}"
] | // Sets modes for a channel, including privileges like +o. | [
"Sets",
"modes",
"for",
"a",
"channel",
"including",
"privileges",
"like",
"+",
"o",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L257-L266 |
11,775 | fluffle/goirc | state/tracker.go | IsOn | func (st *stateTracker) IsOn(c, n string) (*ChanPrivs, bool) {
st.mu.Lock()
defer st.mu.Unlock()
nk, nok := st.nicks[n]
ch, cok := st.chans[c]
if nok && cok {
return nk.isOn(ch)
}
return nil, false
} | go | func (st *stateTracker) IsOn(c, n string) (*ChanPrivs, bool) {
st.mu.Lock()
defer st.mu.Unlock()
nk, nok := st.nicks[n]
ch, cok := st.chans[c]
if nok && cok {
return nk.isOn(ch)
}
return nil, false
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"IsOn",
"(",
"c",
",",
"n",
"string",
")",
"(",
"*",
"ChanPrivs",
",",
"bool",
")",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"nk",
",",
"nok",
":=",
"st",
".",
"nicks",
"[",
"n",
"]",
"\n",
"ch",
",",
"cok",
":=",
"st",
".",
"chans",
"[",
"c",
"]",
"\n",
"if",
"nok",
"&&",
"cok",
"{",
"return",
"nk",
".",
"isOn",
"(",
"ch",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}"
] | // Returns true if both the channel c and the nick n are tracked
// and the nick is associated with the channel. | [
"Returns",
"true",
"if",
"both",
"the",
"channel",
"c",
"and",
"the",
"nick",
"n",
"are",
"tracked",
"and",
"the",
"nick",
"is",
"associated",
"with",
"the",
"channel",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L278-L287 |
11,776 | fluffle/goirc | state/tracker.go | Associate | func (st *stateTracker) Associate(c, n string) *ChanPrivs {
st.mu.Lock()
defer st.mu.Unlock()
nk, nok := st.nicks[n]
ch, cok := st.chans[c]
if !cok {
// As we can implicitly delete both nicks and channels from being
// tracked by dissociating one from the other, we should verify that
// we're not being passed an old Nick or Channel.
logging.Error("Tracker.Associate(): channel %s not found in "+
"internal state.", c)
return nil
} else if !nok {
logging.Error("Tracker.Associate(): nick %s not found in "+
"internal state.", n)
return nil
} else if _, ok := nk.isOn(ch); ok {
logging.Warn("Tracker.Associate(): %s already on %s.",
nk, ch)
return nil
}
cp := new(ChanPrivs)
ch.addNick(nk, cp)
nk.addChannel(ch, cp)
return cp.Copy()
} | go | func (st *stateTracker) Associate(c, n string) *ChanPrivs {
st.mu.Lock()
defer st.mu.Unlock()
nk, nok := st.nicks[n]
ch, cok := st.chans[c]
if !cok {
// As we can implicitly delete both nicks and channels from being
// tracked by dissociating one from the other, we should verify that
// we're not being passed an old Nick or Channel.
logging.Error("Tracker.Associate(): channel %s not found in "+
"internal state.", c)
return nil
} else if !nok {
logging.Error("Tracker.Associate(): nick %s not found in "+
"internal state.", n)
return nil
} else if _, ok := nk.isOn(ch); ok {
logging.Warn("Tracker.Associate(): %s already on %s.",
nk, ch)
return nil
}
cp := new(ChanPrivs)
ch.addNick(nk, cp)
nk.addChannel(ch, cp)
return cp.Copy()
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"Associate",
"(",
"c",
",",
"n",
"string",
")",
"*",
"ChanPrivs",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"nk",
",",
"nok",
":=",
"st",
".",
"nicks",
"[",
"n",
"]",
"\n",
"ch",
",",
"cok",
":=",
"st",
".",
"chans",
"[",
"c",
"]",
"\n\n",
"if",
"!",
"cok",
"{",
"// As we can implicitly delete both nicks and channels from being",
"// tracked by dissociating one from the other, we should verify that",
"// we're not being passed an old Nick or Channel.",
"logging",
".",
"Error",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"c",
")",
"\n",
"return",
"nil",
"\n",
"}",
"else",
"if",
"!",
"nok",
"{",
"logging",
".",
"Error",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"n",
")",
"\n",
"return",
"nil",
"\n",
"}",
"else",
"if",
"_",
",",
"ok",
":=",
"nk",
".",
"isOn",
"(",
"ch",
")",
";",
"ok",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"nk",
",",
"ch",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"cp",
":=",
"new",
"(",
"ChanPrivs",
")",
"\n",
"ch",
".",
"addNick",
"(",
"nk",
",",
"cp",
")",
"\n",
"nk",
".",
"addChannel",
"(",
"ch",
",",
"cp",
")",
"\n",
"return",
"cp",
".",
"Copy",
"(",
")",
"\n",
"}"
] | // Associates an already known nick with an already known channel. | [
"Associates",
"an",
"already",
"known",
"nick",
"with",
"an",
"already",
"known",
"channel",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L290-L316 |
11,777 | fluffle/goirc | state/tracker.go | Dissociate | func (st *stateTracker) Dissociate(c, n string) {
st.mu.Lock()
defer st.mu.Unlock()
nk, nok := st.nicks[n]
ch, cok := st.chans[c]
if !cok {
// As we can implicitly delete both nicks and channels from being
// tracked by dissociating one from the other, we should verify that
// we're not being passed an old Nick or Channel.
logging.Error("Tracker.Dissociate(): channel %s not found in "+
"internal state.", c)
} else if !nok {
logging.Error("Tracker.Dissociate(): nick %s not found in "+
"internal state.", n)
} else if _, ok := nk.isOn(ch); !ok {
logging.Warn("Tracker.Dissociate(): %s not on %s.",
nk.nick, ch.name)
} else if nk == st.me {
// I'm leaving the channel for some reason, so it won't be tracked.
st.delChannel(ch)
} else {
// Remove the nick from the channel and the channel from the nick.
ch.delNick(nk)
nk.delChannel(ch)
if len(nk.chans) == 0 {
// We're no longer in any channels with this nick.
st.delNick(nk)
}
}
} | go | func (st *stateTracker) Dissociate(c, n string) {
st.mu.Lock()
defer st.mu.Unlock()
nk, nok := st.nicks[n]
ch, cok := st.chans[c]
if !cok {
// As we can implicitly delete both nicks and channels from being
// tracked by dissociating one from the other, we should verify that
// we're not being passed an old Nick or Channel.
logging.Error("Tracker.Dissociate(): channel %s not found in "+
"internal state.", c)
} else if !nok {
logging.Error("Tracker.Dissociate(): nick %s not found in "+
"internal state.", n)
} else if _, ok := nk.isOn(ch); !ok {
logging.Warn("Tracker.Dissociate(): %s not on %s.",
nk.nick, ch.name)
} else if nk == st.me {
// I'm leaving the channel for some reason, so it won't be tracked.
st.delChannel(ch)
} else {
// Remove the nick from the channel and the channel from the nick.
ch.delNick(nk)
nk.delChannel(ch)
if len(nk.chans) == 0 {
// We're no longer in any channels with this nick.
st.delNick(nk)
}
}
} | [
"func",
"(",
"st",
"*",
"stateTracker",
")",
"Dissociate",
"(",
"c",
",",
"n",
"string",
")",
"{",
"st",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"st",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"nk",
",",
"nok",
":=",
"st",
".",
"nicks",
"[",
"n",
"]",
"\n",
"ch",
",",
"cok",
":=",
"st",
".",
"chans",
"[",
"c",
"]",
"\n\n",
"if",
"!",
"cok",
"{",
"// As we can implicitly delete both nicks and channels from being",
"// tracked by dissociating one from the other, we should verify that",
"// we're not being passed an old Nick or Channel.",
"logging",
".",
"Error",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"c",
")",
"\n",
"}",
"else",
"if",
"!",
"nok",
"{",
"logging",
".",
"Error",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"n",
")",
"\n",
"}",
"else",
"if",
"_",
",",
"ok",
":=",
"nk",
".",
"isOn",
"(",
"ch",
")",
";",
"!",
"ok",
"{",
"logging",
".",
"Warn",
"(",
"\"",
"\"",
",",
"nk",
".",
"nick",
",",
"ch",
".",
"name",
")",
"\n",
"}",
"else",
"if",
"nk",
"==",
"st",
".",
"me",
"{",
"// I'm leaving the channel for some reason, so it won't be tracked.",
"st",
".",
"delChannel",
"(",
"ch",
")",
"\n",
"}",
"else",
"{",
"// Remove the nick from the channel and the channel from the nick.",
"ch",
".",
"delNick",
"(",
"nk",
")",
"\n",
"nk",
".",
"delChannel",
"(",
"ch",
")",
"\n",
"if",
"len",
"(",
"nk",
".",
"chans",
")",
"==",
"0",
"{",
"// We're no longer in any channels with this nick.",
"st",
".",
"delNick",
"(",
"nk",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Dissociates an already known nick from an already known channel.
// Does some tidying up to stop tracking nicks we're no longer on
// any common channels with, and channels we're no longer on. | [
"Dissociates",
"an",
"already",
"known",
"nick",
"from",
"an",
"already",
"known",
"channel",
".",
"Does",
"some",
"tidying",
"up",
"to",
"stop",
"tracking",
"nicks",
"we",
"re",
"no",
"longer",
"on",
"any",
"common",
"channels",
"with",
"and",
"channels",
"we",
"re",
"no",
"longer",
"on",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/state/tracker.go#L321-L351 |
11,778 | fluffle/goirc | client/dispatch.go | add | func (hs *hSet) add(ev string, h Handler) Remover {
hs.Lock()
defer hs.Unlock()
ev = strings.ToLower(ev)
l, ok := hs.set[ev]
if !ok {
l = &hList{}
}
hn := &hNode{
set: hs,
event: ev,
handler: h,
}
if !ok {
l.start = hn
} else {
hn.prev = l.end
l.end.next = hn
}
l.end = hn
hs.set[ev] = l
return hn
} | go | func (hs *hSet) add(ev string, h Handler) Remover {
hs.Lock()
defer hs.Unlock()
ev = strings.ToLower(ev)
l, ok := hs.set[ev]
if !ok {
l = &hList{}
}
hn := &hNode{
set: hs,
event: ev,
handler: h,
}
if !ok {
l.start = hn
} else {
hn.prev = l.end
l.end.next = hn
}
l.end = hn
hs.set[ev] = l
return hn
} | [
"func",
"(",
"hs",
"*",
"hSet",
")",
"add",
"(",
"ev",
"string",
",",
"h",
"Handler",
")",
"Remover",
"{",
"hs",
".",
"Lock",
"(",
")",
"\n",
"defer",
"hs",
".",
"Unlock",
"(",
")",
"\n",
"ev",
"=",
"strings",
".",
"ToLower",
"(",
"ev",
")",
"\n",
"l",
",",
"ok",
":=",
"hs",
".",
"set",
"[",
"ev",
"]",
"\n",
"if",
"!",
"ok",
"{",
"l",
"=",
"&",
"hList",
"{",
"}",
"\n",
"}",
"\n",
"hn",
":=",
"&",
"hNode",
"{",
"set",
":",
"hs",
",",
"event",
":",
"ev",
",",
"handler",
":",
"h",
",",
"}",
"\n",
"if",
"!",
"ok",
"{",
"l",
".",
"start",
"=",
"hn",
"\n",
"}",
"else",
"{",
"hn",
".",
"prev",
"=",
"l",
".",
"end",
"\n",
"l",
".",
"end",
".",
"next",
"=",
"hn",
"\n",
"}",
"\n",
"l",
".",
"end",
"=",
"hn",
"\n",
"hs",
".",
"set",
"[",
"ev",
"]",
"=",
"l",
"\n",
"return",
"hn",
"\n",
"}"
] | // When a new Handler is added for an event, it is wrapped in a hNode and
// returned as a Remover so the caller can remove it at a later time. | [
"When",
"a",
"new",
"Handler",
"is",
"added",
"for",
"an",
"event",
"it",
"is",
"wrapped",
"in",
"a",
"hNode",
"and",
"returned",
"as",
"a",
"Remover",
"so",
"the",
"caller",
"can",
"remove",
"it",
"at",
"a",
"later",
"time",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/dispatch.go#L82-L104 |
11,779 | fluffle/goirc | client/dispatch.go | Handle | func (conn *Conn) Handle(name string, h Handler) Remover {
return conn.fgHandlers.add(name, h)
} | go | func (conn *Conn) Handle(name string, h Handler) Remover {
return conn.fgHandlers.add(name, h)
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"Handle",
"(",
"name",
"string",
",",
"h",
"Handler",
")",
"Remover",
"{",
"return",
"conn",
".",
"fgHandlers",
".",
"add",
"(",
"name",
",",
"h",
")",
"\n",
"}"
] | // Handle adds the provided handler to the foreground set for the named event.
// It will return a Remover that allows that handler to be removed again. | [
"Handle",
"adds",
"the",
"provided",
"handler",
"to",
"the",
"foreground",
"set",
"for",
"the",
"named",
"event",
".",
"It",
"will",
"return",
"a",
"Remover",
"that",
"allows",
"that",
"handler",
"to",
"be",
"removed",
"again",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/dispatch.go#L162-L164 |
11,780 | fluffle/goirc | client/dispatch.go | HandleBG | func (conn *Conn) HandleBG(name string, h Handler) Remover {
return conn.bgHandlers.add(name, h)
} | go | func (conn *Conn) HandleBG(name string, h Handler) Remover {
return conn.bgHandlers.add(name, h)
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"HandleBG",
"(",
"name",
"string",
",",
"h",
"Handler",
")",
"Remover",
"{",
"return",
"conn",
".",
"bgHandlers",
".",
"add",
"(",
"name",
",",
"h",
")",
"\n",
"}"
] | // HandleBG adds the provided handler to the background set for the named
// event. It may go away in the future.
// It will return a Remover that allows that handler to be removed again. | [
"HandleBG",
"adds",
"the",
"provided",
"handler",
"to",
"the",
"background",
"set",
"for",
"the",
"named",
"event",
".",
"It",
"may",
"go",
"away",
"in",
"the",
"future",
".",
"It",
"will",
"return",
"a",
"Remover",
"that",
"allows",
"that",
"handler",
"to",
"be",
"removed",
"again",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/dispatch.go#L169-L171 |
11,781 | fluffle/goirc | client/dispatch.go | HandleFunc | func (conn *Conn) HandleFunc(name string, hf HandlerFunc) Remover {
return conn.Handle(name, hf)
} | go | func (conn *Conn) HandleFunc(name string, hf HandlerFunc) Remover {
return conn.Handle(name, hf)
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"HandleFunc",
"(",
"name",
"string",
",",
"hf",
"HandlerFunc",
")",
"Remover",
"{",
"return",
"conn",
".",
"Handle",
"(",
"name",
",",
"hf",
")",
"\n",
"}"
] | // HandleFunc adds the provided function as a handler in the foreground set
// for the named event.
// It will return a Remover that allows that handler to be removed again. | [
"HandleFunc",
"adds",
"the",
"provided",
"function",
"as",
"a",
"handler",
"in",
"the",
"foreground",
"set",
"for",
"the",
"named",
"event",
".",
"It",
"will",
"return",
"a",
"Remover",
"that",
"allows",
"that",
"handler",
"to",
"be",
"removed",
"again",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/dispatch.go#L180-L182 |
11,782 | fluffle/goirc | client/handlers.go | h_REGISTER | func (conn *Conn) h_REGISTER(line *Line) {
if conn.cfg.Pass != "" {
conn.Pass(conn.cfg.Pass)
}
conn.Nick(conn.cfg.Me.Nick)
conn.User(conn.cfg.Me.Ident, conn.cfg.Me.Name)
} | go | func (conn *Conn) h_REGISTER(line *Line) {
if conn.cfg.Pass != "" {
conn.Pass(conn.cfg.Pass)
}
conn.Nick(conn.cfg.Me.Nick)
conn.User(conn.cfg.Me.Ident, conn.cfg.Me.Name)
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_REGISTER",
"(",
"line",
"*",
"Line",
")",
"{",
"if",
"conn",
".",
"cfg",
".",
"Pass",
"!=",
"\"",
"\"",
"{",
"conn",
".",
"Pass",
"(",
"conn",
".",
"cfg",
".",
"Pass",
")",
"\n",
"}",
"\n",
"conn",
".",
"Nick",
"(",
"conn",
".",
"cfg",
".",
"Me",
".",
"Nick",
")",
"\n",
"conn",
".",
"User",
"(",
"conn",
".",
"cfg",
".",
"Me",
".",
"Ident",
",",
"conn",
".",
"cfg",
".",
"Me",
".",
"Name",
")",
"\n",
"}"
] | // Handler for initial registration with server once tcp connection is made. | [
"Handler",
"for",
"initial",
"registration",
"with",
"server",
"once",
"tcp",
"connection",
"is",
"made",
"."
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/handlers.go#L35-L41 |
11,783 | fluffle/goirc | client/handlers.go | h_001 | func (conn *Conn) h_001(line *Line) {
// we're connected!
conn.dispatch(&Line{Cmd: CONNECTED, Time: time.Now()})
// and we're being given our hostname (from the server's perspective)
t := line.Args[len(line.Args)-1]
if idx := strings.LastIndex(t, " "); idx != -1 {
t = t[idx+1:]
if idx = strings.Index(t, "@"); idx != -1 {
if conn.st != nil {
me := conn.Me()
conn.st.NickInfo(me.Nick, me.Ident, t[idx+1:], me.Name)
} else {
conn.cfg.Me.Host = t[idx+1:]
}
}
}
} | go | func (conn *Conn) h_001(line *Line) {
// we're connected!
conn.dispatch(&Line{Cmd: CONNECTED, Time: time.Now()})
// and we're being given our hostname (from the server's perspective)
t := line.Args[len(line.Args)-1]
if idx := strings.LastIndex(t, " "); idx != -1 {
t = t[idx+1:]
if idx = strings.Index(t, "@"); idx != -1 {
if conn.st != nil {
me := conn.Me()
conn.st.NickInfo(me.Nick, me.Ident, t[idx+1:], me.Name)
} else {
conn.cfg.Me.Host = t[idx+1:]
}
}
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_001",
"(",
"line",
"*",
"Line",
")",
"{",
"// we're connected!",
"conn",
".",
"dispatch",
"(",
"&",
"Line",
"{",
"Cmd",
":",
"CONNECTED",
",",
"Time",
":",
"time",
".",
"Now",
"(",
")",
"}",
")",
"\n",
"// and we're being given our hostname (from the server's perspective)",
"t",
":=",
"line",
".",
"Args",
"[",
"len",
"(",
"line",
".",
"Args",
")",
"-",
"1",
"]",
"\n",
"if",
"idx",
":=",
"strings",
".",
"LastIndex",
"(",
"t",
",",
"\"",
"\"",
")",
";",
"idx",
"!=",
"-",
"1",
"{",
"t",
"=",
"t",
"[",
"idx",
"+",
"1",
":",
"]",
"\n",
"if",
"idx",
"=",
"strings",
".",
"Index",
"(",
"t",
",",
"\"",
"\"",
")",
";",
"idx",
"!=",
"-",
"1",
"{",
"if",
"conn",
".",
"st",
"!=",
"nil",
"{",
"me",
":=",
"conn",
".",
"Me",
"(",
")",
"\n",
"conn",
".",
"st",
".",
"NickInfo",
"(",
"me",
".",
"Nick",
",",
"me",
".",
"Ident",
",",
"t",
"[",
"idx",
"+",
"1",
":",
"]",
",",
"me",
".",
"Name",
")",
"\n",
"}",
"else",
"{",
"conn",
".",
"cfg",
".",
"Me",
".",
"Host",
"=",
"t",
"[",
"idx",
"+",
"1",
":",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Handler to trigger a CONNECTED event on receipt of numeric 001 | [
"Handler",
"to",
"trigger",
"a",
"CONNECTED",
"event",
"on",
"receipt",
"of",
"numeric",
"001"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/handlers.go#L44-L60 |
11,784 | fluffle/goirc | client/handlers.go | h_CTCP | func (conn *Conn) h_CTCP(line *Line) {
if line.Args[0] == VERSION {
conn.CtcpReply(line.Nick, VERSION, conn.cfg.Version)
} else if line.Args[0] == PING && line.argslen(2) {
conn.CtcpReply(line.Nick, PING, line.Args[2])
}
} | go | func (conn *Conn) h_CTCP(line *Line) {
if line.Args[0] == VERSION {
conn.CtcpReply(line.Nick, VERSION, conn.cfg.Version)
} else if line.Args[0] == PING && line.argslen(2) {
conn.CtcpReply(line.Nick, PING, line.Args[2])
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_CTCP",
"(",
"line",
"*",
"Line",
")",
"{",
"if",
"line",
".",
"Args",
"[",
"0",
"]",
"==",
"VERSION",
"{",
"conn",
".",
"CtcpReply",
"(",
"line",
".",
"Nick",
",",
"VERSION",
",",
"conn",
".",
"cfg",
".",
"Version",
")",
"\n",
"}",
"else",
"if",
"line",
".",
"Args",
"[",
"0",
"]",
"==",
"PING",
"&&",
"line",
".",
"argslen",
"(",
"2",
")",
"{",
"conn",
".",
"CtcpReply",
"(",
"line",
".",
"Nick",
",",
"PING",
",",
"line",
".",
"Args",
"[",
"2",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // Handle VERSION requests and CTCP PING | [
"Handle",
"VERSION",
"requests",
"and",
"CTCP",
"PING"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/handlers.go#L92-L98 |
11,785 | fluffle/goirc | client/handlers.go | h_NICK | func (conn *Conn) h_NICK(line *Line) {
if conn.st == nil && line.Nick == conn.cfg.Me.Nick {
conn.cfg.Me.Nick = line.Args[0]
}
} | go | func (conn *Conn) h_NICK(line *Line) {
if conn.st == nil && line.Nick == conn.cfg.Me.Nick {
conn.cfg.Me.Nick = line.Args[0]
}
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"h_NICK",
"(",
"line",
"*",
"Line",
")",
"{",
"if",
"conn",
".",
"st",
"==",
"nil",
"&&",
"line",
".",
"Nick",
"==",
"conn",
".",
"cfg",
".",
"Me",
".",
"Nick",
"{",
"conn",
".",
"cfg",
".",
"Me",
".",
"Nick",
"=",
"line",
".",
"Args",
"[",
"0",
"]",
"\n",
"}",
"\n",
"}"
] | // Handle updating our own NICK if we're not using the state tracker | [
"Handle",
"updating",
"our",
"own",
"NICK",
"if",
"we",
"re",
"not",
"using",
"the",
"state",
"tracker"
] | 08c1bcf17445781669bcecc47159c627962e18f1 | https://github.com/fluffle/goirc/blob/08c1bcf17445781669bcecc47159c627962e18f1/client/handlers.go#L101-L105 |
11,786 | howeyc/crc16 | hash.go | tableSum | func tableSum(t *Table) uint16 {
var a [1024]byte
b := a[:0]
if t != nil {
for _, x := range t.entries {
b = appendUint16(b, x)
}
}
return ChecksumIBM(b)
} | go | func tableSum(t *Table) uint16 {
var a [1024]byte
b := a[:0]
if t != nil {
for _, x := range t.entries {
b = appendUint16(b, x)
}
}
return ChecksumIBM(b)
} | [
"func",
"tableSum",
"(",
"t",
"*",
"Table",
")",
"uint16",
"{",
"var",
"a",
"[",
"1024",
"]",
"byte",
"\n",
"b",
":=",
"a",
"[",
":",
"0",
"]",
"\n",
"if",
"t",
"!=",
"nil",
"{",
"for",
"_",
",",
"x",
":=",
"range",
"t",
".",
"entries",
"{",
"b",
"=",
"appendUint16",
"(",
"b",
",",
"x",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ChecksumIBM",
"(",
"b",
")",
"\n",
"}"
] | // tableSum returns the IBM checksum of table t. | [
"tableSum",
"returns",
"the",
"IBM",
"checksum",
"of",
"table",
"t",
"."
] | 2b2a61e366a66d3efb279e46176e7291001e0354 | https://github.com/howeyc/crc16/blob/2b2a61e366a66d3efb279e46176e7291001e0354/hash.go#L107-L116 |
11,787 | howeyc/crc16 | crc16.go | MakeTableNoXOR | func MakeTableNoXOR(poly uint16) *Table {
tab := makeTable(poly)
tab.noXOR = true
return tab
} | go | func MakeTableNoXOR(poly uint16) *Table {
tab := makeTable(poly)
tab.noXOR = true
return tab
} | [
"func",
"MakeTableNoXOR",
"(",
"poly",
"uint16",
")",
"*",
"Table",
"{",
"tab",
":=",
"makeTable",
"(",
"poly",
")",
"\n",
"tab",
".",
"noXOR",
"=",
"true",
"\n",
"return",
"tab",
"\n",
"}"
] | // MakeTableNoXOR returns the Table constructed from the specified polynomial.
// Updates happen without XOR in and XOR out. | [
"MakeTableNoXOR",
"returns",
"the",
"Table",
"constructed",
"from",
"the",
"specified",
"polynomial",
".",
"Updates",
"happen",
"without",
"XOR",
"in",
"and",
"XOR",
"out",
"."
] | 2b2a61e366a66d3efb279e46176e7291001e0354 | https://github.com/howeyc/crc16/blob/2b2a61e366a66d3efb279e46176e7291001e0354/crc16.go#L58-L62 |
11,788 | howeyc/crc16 | crc16.go | makeBitsReversedTable | func makeBitsReversedTable(poly uint16) *Table {
t := &Table{
reversed: true,
}
width := uint16(16)
for i := uint16(0); i < 256; i++ {
crc := i << (width - 8)
for j := 0; j < 8; j++ {
if crc&(1<<(width-1)) != 0 {
crc = (crc << 1) ^ poly
} else {
crc <<= 1
}
}
t.entries[i] = crc
}
return t
} | go | func makeBitsReversedTable(poly uint16) *Table {
t := &Table{
reversed: true,
}
width := uint16(16)
for i := uint16(0); i < 256; i++ {
crc := i << (width - 8)
for j := 0; j < 8; j++ {
if crc&(1<<(width-1)) != 0 {
crc = (crc << 1) ^ poly
} else {
crc <<= 1
}
}
t.entries[i] = crc
}
return t
} | [
"func",
"makeBitsReversedTable",
"(",
"poly",
"uint16",
")",
"*",
"Table",
"{",
"t",
":=",
"&",
"Table",
"{",
"reversed",
":",
"true",
",",
"}",
"\n",
"width",
":=",
"uint16",
"(",
"16",
")",
"\n",
"for",
"i",
":=",
"uint16",
"(",
"0",
")",
";",
"i",
"<",
"256",
";",
"i",
"++",
"{",
"crc",
":=",
"i",
"<<",
"(",
"width",
"-",
"8",
")",
"\n",
"for",
"j",
":=",
"0",
";",
"j",
"<",
"8",
";",
"j",
"++",
"{",
"if",
"crc",
"&",
"(",
"1",
"<<",
"(",
"width",
"-",
"1",
")",
")",
"!=",
"0",
"{",
"crc",
"=",
"(",
"crc",
"<<",
"1",
")",
"^",
"poly",
"\n",
"}",
"else",
"{",
"crc",
"<<=",
"1",
"\n",
"}",
"\n",
"}",
"\n",
"t",
".",
"entries",
"[",
"i",
"]",
"=",
"crc",
"\n",
"}",
"\n",
"return",
"t",
"\n",
"}"
] | // makeTable returns the Table constructed from the specified polynomial. | [
"makeTable",
"returns",
"the",
"Table",
"constructed",
"from",
"the",
"specified",
"polynomial",
"."
] | 2b2a61e366a66d3efb279e46176e7291001e0354 | https://github.com/howeyc/crc16/blob/2b2a61e366a66d3efb279e46176e7291001e0354/crc16.go#L65-L82 |
11,789 | gopherjs/websocket | websocketjs/websocketjs.go | New | func New(url string) (ws *WebSocket, err error) {
defer func() {
e := recover()
if e == nil {
return
}
if jsErr, ok := e.(*js.Error); ok && jsErr != nil {
ws = nil
err = jsErr
} else {
panic(e)
}
}()
object := js.Global.Get("WebSocket").New(url)
ws = &WebSocket{
Object: object,
}
return
} | go | func New(url string) (ws *WebSocket, err error) {
defer func() {
e := recover()
if e == nil {
return
}
if jsErr, ok := e.(*js.Error); ok && jsErr != nil {
ws = nil
err = jsErr
} else {
panic(e)
}
}()
object := js.Global.Get("WebSocket").New(url)
ws = &WebSocket{
Object: object,
}
return
} | [
"func",
"New",
"(",
"url",
"string",
")",
"(",
"ws",
"*",
"WebSocket",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"e",
":=",
"recover",
"(",
")",
"\n",
"if",
"e",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"jsErr",
",",
"ok",
":=",
"e",
".",
"(",
"*",
"js",
".",
"Error",
")",
";",
"ok",
"&&",
"jsErr",
"!=",
"nil",
"{",
"ws",
"=",
"nil",
"\n",
"err",
"=",
"jsErr",
"\n",
"}",
"else",
"{",
"panic",
"(",
"e",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"object",
":=",
"js",
".",
"Global",
".",
"Get",
"(",
"\"",
"\"",
")",
".",
"New",
"(",
"url",
")",
"\n\n",
"ws",
"=",
"&",
"WebSocket",
"{",
"Object",
":",
"object",
",",
"}",
"\n\n",
"return",
"\n",
"}"
] | // New creates a new low-level WebSocket. It immediately returns the new
// WebSocket. | [
"New",
"creates",
"a",
"new",
"low",
"-",
"level",
"WebSocket",
".",
"It",
"immediately",
"returns",
"the",
"new",
"WebSocket",
"."
] | 87ee47603f137e7f8419765b3621b3c36e715a08 | https://github.com/gopherjs/websocket/blob/87ee47603f137e7f8419765b3621b3c36e715a08/websocketjs/websocketjs.go#L70-L91 |
11,790 | gopherjs/websocket | conn.go | initialize | func (c *conn) initialize() {
// We need this so that received binary data is in ArrayBufferView format so
// that it can easily be read.
c.BinaryType = "arraybuffer"
c.AddEventListener("message", false, c.onMessage)
c.AddEventListener("close", false, c.onClose)
} | go | func (c *conn) initialize() {
// We need this so that received binary data is in ArrayBufferView format so
// that it can easily be read.
c.BinaryType = "arraybuffer"
c.AddEventListener("message", false, c.onMessage)
c.AddEventListener("close", false, c.onClose)
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"initialize",
"(",
")",
"{",
"// We need this so that received binary data is in ArrayBufferView format so",
"// that it can easily be read.",
"c",
".",
"BinaryType",
"=",
"\"",
"\"",
"\n\n",
"c",
".",
"AddEventListener",
"(",
"\"",
"\"",
",",
"false",
",",
"c",
".",
"onMessage",
")",
"\n",
"c",
".",
"AddEventListener",
"(",
"\"",
"\"",
",",
"false",
",",
"c",
".",
"onClose",
")",
"\n",
"}"
] | // initialize adds all of the event handlers necessary for a conn to function.
// It should never be called more than once and is already called if Dial was
// used to create the conn. | [
"initialize",
"adds",
"all",
"of",
"the",
"event",
"handlers",
"necessary",
"for",
"a",
"conn",
"to",
"function",
".",
"It",
"should",
"never",
"be",
"called",
"more",
"than",
"once",
"and",
"is",
"already",
"called",
"if",
"Dial",
"was",
"used",
"to",
"create",
"the",
"conn",
"."
] | 87ee47603f137e7f8419765b3621b3c36e715a08 | https://github.com/gopherjs/websocket/blob/87ee47603f137e7f8419765b3621b3c36e715a08/conn.go#L141-L148 |
11,791 | gopherjs/websocket | conn.go | handleFrame | func (c *conn) handleFrame(message *messageEvent, ok bool) (*messageEvent, error) {
if !ok { // The channel has been closed
return nil, io.EOF
} else if message == nil {
// See onClose for the explanation about sending a nil item.
close(c.ch)
return nil, io.EOF
}
return message, nil
} | go | func (c *conn) handleFrame(message *messageEvent, ok bool) (*messageEvent, error) {
if !ok { // The channel has been closed
return nil, io.EOF
} else if message == nil {
// See onClose for the explanation about sending a nil item.
close(c.ch)
return nil, io.EOF
}
return message, nil
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"handleFrame",
"(",
"message",
"*",
"messageEvent",
",",
"ok",
"bool",
")",
"(",
"*",
"messageEvent",
",",
"error",
")",
"{",
"if",
"!",
"ok",
"{",
"// The channel has been closed",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"}",
"else",
"if",
"message",
"==",
"nil",
"{",
"// See onClose for the explanation about sending a nil item.",
"close",
"(",
"c",
".",
"ch",
")",
"\n",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n\n",
"return",
"message",
",",
"nil",
"\n",
"}"
] | // handleFrame handles a single frame received from the channel. This is a
// convenience funciton to dedupe code for the multiple deadline cases. | [
"handleFrame",
"handles",
"a",
"single",
"frame",
"received",
"from",
"the",
"channel",
".",
"This",
"is",
"a",
"convenience",
"funciton",
"to",
"dedupe",
"code",
"for",
"the",
"multiple",
"deadline",
"cases",
"."
] | 87ee47603f137e7f8419765b3621b3c36e715a08 | https://github.com/gopherjs/websocket/blob/87ee47603f137e7f8419765b3621b3c36e715a08/conn.go#L152-L162 |
11,792 | gopherjs/websocket | conn.go | receiveFrame | func (c *conn) receiveFrame(observeDeadline bool) (*messageEvent, error) {
var deadlineChan <-chan time.Time // Receiving on a nil channel always blocks indefinitely
if observeDeadline && !c.readDeadline.IsZero() {
now := time.Now()
if now.After(c.readDeadline) {
select {
case item, ok := <-c.ch:
return c.handleFrame(item, ok)
default:
return nil, errDeadlineReached
}
}
timer := time.NewTimer(c.readDeadline.Sub(now))
defer timer.Stop()
deadlineChan = timer.C
}
select {
case item, ok := <-c.ch:
return c.handleFrame(item, ok)
case <-deadlineChan:
return nil, errDeadlineReached
}
} | go | func (c *conn) receiveFrame(observeDeadline bool) (*messageEvent, error) {
var deadlineChan <-chan time.Time // Receiving on a nil channel always blocks indefinitely
if observeDeadline && !c.readDeadline.IsZero() {
now := time.Now()
if now.After(c.readDeadline) {
select {
case item, ok := <-c.ch:
return c.handleFrame(item, ok)
default:
return nil, errDeadlineReached
}
}
timer := time.NewTimer(c.readDeadline.Sub(now))
defer timer.Stop()
deadlineChan = timer.C
}
select {
case item, ok := <-c.ch:
return c.handleFrame(item, ok)
case <-deadlineChan:
return nil, errDeadlineReached
}
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"receiveFrame",
"(",
"observeDeadline",
"bool",
")",
"(",
"*",
"messageEvent",
",",
"error",
")",
"{",
"var",
"deadlineChan",
"<-",
"chan",
"time",
".",
"Time",
"// Receiving on a nil channel always blocks indefinitely",
"\n\n",
"if",
"observeDeadline",
"&&",
"!",
"c",
".",
"readDeadline",
".",
"IsZero",
"(",
")",
"{",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"if",
"now",
".",
"After",
"(",
"c",
".",
"readDeadline",
")",
"{",
"select",
"{",
"case",
"item",
",",
"ok",
":=",
"<-",
"c",
".",
"ch",
":",
"return",
"c",
".",
"handleFrame",
"(",
"item",
",",
"ok",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"errDeadlineReached",
"\n",
"}",
"\n",
"}",
"\n\n",
"timer",
":=",
"time",
".",
"NewTimer",
"(",
"c",
".",
"readDeadline",
".",
"Sub",
"(",
"now",
")",
")",
"\n",
"defer",
"timer",
".",
"Stop",
"(",
")",
"\n\n",
"deadlineChan",
"=",
"timer",
".",
"C",
"\n",
"}",
"\n\n",
"select",
"{",
"case",
"item",
",",
"ok",
":=",
"<-",
"c",
".",
"ch",
":",
"return",
"c",
".",
"handleFrame",
"(",
"item",
",",
"ok",
")",
"\n",
"case",
"<-",
"deadlineChan",
":",
"return",
"nil",
",",
"errDeadlineReached",
"\n",
"}",
"\n",
"}"
] | // receiveFrame receives one full frame from the WebSocket. It blocks until the
// frame is received. | [
"receiveFrame",
"receives",
"one",
"full",
"frame",
"from",
"the",
"WebSocket",
".",
"It",
"blocks",
"until",
"the",
"frame",
"is",
"received",
"."
] | 87ee47603f137e7f8419765b3621b3c36e715a08 | https://github.com/gopherjs/websocket/blob/87ee47603f137e7f8419765b3621b3c36e715a08/conn.go#L166-L192 |
11,793 | gopherjs/websocket | conn.go | Write | func (c *conn) Write(b []byte) (n int, err error) {
// []byte is converted to an Uint8Array by GopherJS, which fullfils the
// ArrayBufferView definition.
err = c.Send(b)
if err != nil {
return 0, err
}
return len(b), nil
} | go | func (c *conn) Write(b []byte) (n int, err error) {
// []byte is converted to an Uint8Array by GopherJS, which fullfils the
// ArrayBufferView definition.
err = c.Send(b)
if err != nil {
return 0, err
}
return len(b), nil
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"// []byte is converted to an Uint8Array by GopherJS, which fullfils the",
"// ArrayBufferView definition.",
"err",
"=",
"c",
".",
"Send",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"len",
"(",
"b",
")",
",",
"nil",
"\n",
"}"
] | // Write writes the contents of b to the WebSocket using a binary opcode. | [
"Write",
"writes",
"the",
"contents",
"of",
"b",
"to",
"the",
"WebSocket",
"using",
"a",
"binary",
"opcode",
"."
] | 87ee47603f137e7f8419765b3621b3c36e715a08 | https://github.com/gopherjs/websocket/blob/87ee47603f137e7f8419765b3621b3c36e715a08/conn.go#L237-L245 |
11,794 | gopherjs/websocket | conn.go | RemoteAddr | func (c *conn) RemoteAddr() net.Addr {
wsURL, err := url.Parse(c.URL)
if err != nil {
// TODO(nightexcessive): Should we be panicking for this?
panic(err)
}
return &addr{wsURL}
} | go | func (c *conn) RemoteAddr() net.Addr {
wsURL, err := url.Parse(c.URL)
if err != nil {
// TODO(nightexcessive): Should we be panicking for this?
panic(err)
}
return &addr{wsURL}
} | [
"func",
"(",
"c",
"*",
"conn",
")",
"RemoteAddr",
"(",
")",
"net",
".",
"Addr",
"{",
"wsURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"c",
".",
"URL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// TODO(nightexcessive): Should we be panicking for this?",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"addr",
"{",
"wsURL",
"}",
"\n",
"}"
] | // RemoteAddr returns the remote network address, based on
// websocket.WebSocket.URL. | [
"RemoteAddr",
"returns",
"the",
"remote",
"network",
"address",
"based",
"on",
"websocket",
".",
"WebSocket",
".",
"URL",
"."
] | 87ee47603f137e7f8419765b3621b3c36e715a08 | https://github.com/gopherjs/websocket/blob/87ee47603f137e7f8419765b3621b3c36e715a08/conn.go#L260-L267 |
11,795 | xxtea/xxtea-go | xxtea/xxtea.go | Encrypt | func Encrypt(data []byte, key []byte) []byte {
if data == nil || len(data) == 0 {
return data
}
return toBytes(encrypt(toUint32s(data, true), toUint32s(key, false)), false)
} | go | func Encrypt(data []byte, key []byte) []byte {
if data == nil || len(data) == 0 {
return data
}
return toBytes(encrypt(toUint32s(data, true), toUint32s(key, false)), false)
} | [
"func",
"Encrypt",
"(",
"data",
"[",
"]",
"byte",
",",
"key",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"data",
"==",
"nil",
"||",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"data",
"\n",
"}",
"\n",
"return",
"toBytes",
"(",
"encrypt",
"(",
"toUint32s",
"(",
"data",
",",
"true",
")",
",",
"toUint32s",
"(",
"key",
",",
"false",
")",
")",
",",
"false",
")",
"\n",
"}"
] | // Encrypt the data with key.
// data is the bytes to be encrypted.
// key is the encrypt key. It is the same as the decrypt key. | [
"Encrypt",
"the",
"data",
"with",
"key",
".",
"data",
"is",
"the",
"bytes",
"to",
"be",
"encrypted",
".",
"key",
"is",
"the",
"encrypt",
"key",
".",
"It",
"is",
"the",
"same",
"as",
"the",
"decrypt",
"key",
"."
] | 35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242 | https://github.com/xxtea/xxtea-go/blob/35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242/xxtea/xxtea.go#L120-L125 |
11,796 | xxtea/xxtea-go | xxtea/xxtea.go | Decrypt | func Decrypt(data []byte, key []byte) []byte {
if data == nil || len(data) == 0 {
return data
}
return toBytes(decrypt(toUint32s(data, false), toUint32s(key, false)), true)
} | go | func Decrypt(data []byte, key []byte) []byte {
if data == nil || len(data) == 0 {
return data
}
return toBytes(decrypt(toUint32s(data, false), toUint32s(key, false)), true)
} | [
"func",
"Decrypt",
"(",
"data",
"[",
"]",
"byte",
",",
"key",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"data",
"==",
"nil",
"||",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"data",
"\n",
"}",
"\n",
"return",
"toBytes",
"(",
"decrypt",
"(",
"toUint32s",
"(",
"data",
",",
"false",
")",
",",
"toUint32s",
"(",
"key",
",",
"false",
")",
")",
",",
"true",
")",
"\n",
"}"
] | // Decrypt the data with key.
// data is the bytes to be decrypted.
// key is the decrypted key. It is the same as the encrypt key. | [
"Decrypt",
"the",
"data",
"with",
"key",
".",
"data",
"is",
"the",
"bytes",
"to",
"be",
"decrypted",
".",
"key",
"is",
"the",
"decrypted",
"key",
".",
"It",
"is",
"the",
"same",
"as",
"the",
"encrypt",
"key",
"."
] | 35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242 | https://github.com/xxtea/xxtea-go/blob/35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242/xxtea/xxtea.go#L130-L135 |
11,797 | xxtea/xxtea-go | xxtea/xxtea.go | EncryptString | func EncryptString(str, key string) string {
s := []byte(str)
k := []byte(key)
b64 := base64.StdEncoding
return b64.EncodeToString(Encrypt(s, k))
} | go | func EncryptString(str, key string) string {
s := []byte(str)
k := []byte(key)
b64 := base64.StdEncoding
return b64.EncodeToString(Encrypt(s, k))
} | [
"func",
"EncryptString",
"(",
"str",
",",
"key",
"string",
")",
"string",
"{",
"s",
":=",
"[",
"]",
"byte",
"(",
"str",
")",
"\n",
"k",
":=",
"[",
"]",
"byte",
"(",
"key",
")",
"\n",
"b64",
":=",
"base64",
".",
"StdEncoding",
"\n",
"return",
"b64",
".",
"EncodeToString",
"(",
"Encrypt",
"(",
"s",
",",
"k",
")",
")",
"\n",
"}"
] | // Encrypt the data with key.
// data is the string to be encrypted.
// key is the string of encrypt key. | [
"Encrypt",
"the",
"data",
"with",
"key",
".",
"data",
"is",
"the",
"string",
"to",
"be",
"encrypted",
".",
"key",
"is",
"the",
"string",
"of",
"encrypt",
"key",
"."
] | 35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242 | https://github.com/xxtea/xxtea-go/blob/35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242/xxtea/xxtea.go#L140-L145 |
11,798 | xxtea/xxtea-go | xxtea/xxtea.go | DecryptString | func DecryptString(str, key string) (string, error) {
k := []byte(key)
b64 := base64.StdEncoding
decodeStr, err := b64.DecodeString(str)
if err != nil {
return "", err
}
result := Decrypt([]byte(decodeStr), k)
return string(result), nil
} | go | func DecryptString(str, key string) (string, error) {
k := []byte(key)
b64 := base64.StdEncoding
decodeStr, err := b64.DecodeString(str)
if err != nil {
return "", err
}
result := Decrypt([]byte(decodeStr), k)
return string(result), nil
} | [
"func",
"DecryptString",
"(",
"str",
",",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"k",
":=",
"[",
"]",
"byte",
"(",
"key",
")",
"\n",
"b64",
":=",
"base64",
".",
"StdEncoding",
"\n",
"decodeStr",
",",
"err",
":=",
"b64",
".",
"DecodeString",
"(",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"result",
":=",
"Decrypt",
"(",
"[",
"]",
"byte",
"(",
"decodeStr",
")",
",",
"k",
")",
"\n",
"return",
"string",
"(",
"result",
")",
",",
"nil",
"\n",
"}"
] | // Decrypt the data with key.
// data is the string to be decrypted.
// key is the decrypted key. It is the same as the encrypt key. | [
"Decrypt",
"the",
"data",
"with",
"key",
".",
"data",
"is",
"the",
"string",
"to",
"be",
"decrypted",
".",
"key",
"is",
"the",
"decrypted",
"key",
".",
"It",
"is",
"the",
"same",
"as",
"the",
"encrypt",
"key",
"."
] | 35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242 | https://github.com/xxtea/xxtea-go/blob/35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242/xxtea/xxtea.go#L150-L159 |
11,799 | xxtea/xxtea-go | xxtea/xxtea.go | DecryptURLToStdString | func DecryptURLToStdString(str, key string) (string, error) {
return DecryptString(decryptBase64ToStdFormat(str), key)
} | go | func DecryptURLToStdString(str, key string) (string, error) {
return DecryptString(decryptBase64ToStdFormat(str), key)
} | [
"func",
"DecryptURLToStdString",
"(",
"str",
",",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"DecryptString",
"(",
"decryptBase64ToStdFormat",
"(",
"str",
")",
",",
"key",
")",
"\n",
"}"
] | // Decrypt the URL string with key and convert the URL string to the origin string | [
"Decrypt",
"the",
"URL",
"string",
"with",
"key",
"and",
"convert",
"the",
"URL",
"string",
"to",
"the",
"origin",
"string"
] | 35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242 | https://github.com/xxtea/xxtea-go/blob/35c4b17eecf6c3c2350f8cecaf1b3f9f7fafc242/xxtea/xxtea.go#L167-L169 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.