// Sort performs a topological sort of the graph // https://en.wikipedia.org/wiki/Topological_sorting // // If the graph can be topologically sorted the result will // contain the sorted nodes. // // If the graph cannot be sorted in case of circular dependencies, // then the result will contain the remaining nodes from the graph, // which are the ones causing the circular dependency. func (g *Graph) Sort() ([]*Node, error) { var sorted []*Node // Iteratively find and remove nodes from the graph which have no edges. // If at some point there are still nodes in the graph and we cannot find // nodes without edges, that means we have a circular dependency for len(g.Nodes) > 0 { // Contains the ready nodes, which have no edges to other nodes //ready := make([]*Node, 0) ready := mapset.NewSet() // Find the nodes with no edges for _, node := range g.Nodes { if len(node.Edges) == 0 { ready.Add(node) } } // If there aren't any ready nodes, then we have a cicular dependency if ready.Cardinality() == 0 { // The remaining nodes in the graph are the ones causing the // circular dependency. var remaining []*Node for _, n := range g.Nodes { remaining = append(remaining, n) } return remaining, ErrCircularDependency } // Remove the ready nodes and add them to the sorted result for item := range ready.Iter() { node := item.(*Node) delete(g.Nodes, node.Name) sorted = append(sorted, node) } // Remove ready nodes from the remaining node edges as well for _, node := range g.Nodes { // Add the remaining nodes in a set currentEdgeSet := mapset.NewSet() for _, edge := range node.Edges { currentEdgeSet.Add(edge) } newEdgeSet := currentEdgeSet.Difference(ready) node.Edges = make([]*Node, 0) for edge := range newEdgeSet.Iter() { node.Edges = append(node.Edges, edge.(*Node)) } } } return sorted, nil }
func hosts(entries discovery.Entries) mapset.Set { hosts := mapset.NewSet() for _, entry := range entries { hosts.Add(entry.Host) } return hosts }
func makeSet(ss []string) mapset.Set { set := mapset.NewSet() for _, s := range ss { set.Add(s) } return set }
// Create a new watcher. func NewWatcher() *watcher { w := &watcher{ InterfaceAdded: make(chan string), InterfaceRemoved: make(chan string), oldNames: set.NewSet(), } go w.watch() return w }
func main() { requiredClasses := set.NewSet() requiredClasses.Add("Cooking") requiredClasses.Add("English") requiredClasses.Add("Math") requiredClasses.Add("Biology") scienceClasses := set.NewSet() scienceClasses.Add("Biology") scienceClasses.Add("Chemistry") electiveClasses := set.NewSet() electiveClasses.Add("Welding") electiveClasses.Add("Music") electiveClasses.Add("Automotive") bonusClasses := set.NewSet() bonusClasses.Add("Go Programming") bonusClasses.Add("Python Programming") allClasses := requiredClasses.Union(scienceClasses). Union(electiveClasses).Union(bonusClasses) fmt.Println(scienceClasses.Contains("Cooking")) //Returns: false // what are all the classes I can take that are not science classes? fmt.Println(allClasses.Difference(scienceClasses)) //Returns: Set{Music, Automotive, Go Programming, Python Programming, Cooking, English, Math, Welding} // Which of the science classes are also required classes? fmt.Println(scienceClasses.Intersect(requiredClasses)) //Returns: Set{Biology} // How many bonus classes are offered for this winter schedule? fmt.Println(bonusClasses.Cardinality()) //Returns: 2 // Check exist fmt.Println(allClasses.Contains("Welding", "Automotive", "English")) //Returns: true }
func (suite *StatsTestSuite) Test_Regex() { // We'll make a new client with actual regexps. pageViewRegexes := make([]map[string]string, 0) httpsRequestRegexes := []map[string]string{make(map[string]string), make(map[string]string)} httpsRequestRegexes[0]["regex"] = `^[a-z0-9\.]*\.(example\.com)$` httpsRequestRegexes[0]["replace"] = "$1" httpsRequestRegexes[1]["regex"] = `^.*example\.org$` httpsRequestRegexes[1]["replace"] = "replacement" regexps, _ := MakeRegexps(pageViewRegexes, httpsRequestRegexes) suite.httpClient = &http.Client{ Transport: &http.Transport{ Dial: makeStatsDialer(_SERVER_ID, regexps), }, } // Using both HTTP and HTTPS will help us to exercise both methods of hostname parsing for _, scheme := range []string{"http", "https"} { // No subdomain, so won't match regex url := fmt.Sprintf("%s://example.com/index.html", scheme) resp, err := suite.httpClient.Get(url) suite.Nil(err) resp.Body.Close() // Will match the first regex url = fmt.Sprintf("%s://www.example.com/index.html", scheme) resp, err = suite.httpClient.Get(url) suite.Nil(err) resp.Body.Close() // Will match the second regex url = fmt.Sprintf("%s://example.org/index.html", scheme) resp, err = suite.httpClient.Get(url) suite.Nil(err) resp.Body.Close() payload := GetForServer(_SERVER_ID) suite.NotNil(payload, "should get stats because we made HTTP reqs; %s", scheme) expectedHostnames := mapset.NewSet() expectedHostnames.Add("(OTHER)") expectedHostnames.Add("example.com") expectedHostnames.Add("replacement") hostnames := make([]interface{}, 0) for hostname := range payload.hostnameToStats { hostnames = append(hostnames, hostname) } actualHostnames := mapset.NewSetFromSlice(hostnames) suite.Equal(expectedHostnames, actualHostnames, "post-regex hostnames should be processed as expecteds; %s", scheme) } }
func readConfig() { config = make([]Entry, 0) configMap = make(map[string]Entry) file, _ := os.Open("conf.json") decoder := json.NewDecoder(file) err := decoder.Decode(&config) if err != nil { fmt.Println("error:", err) } for id, entry := range config { configMap[entry.Name] = config[id] } toRun = set.NewSet() }
func main() { readConfig() watcher, err := fsnotify.NewWatcher() if err != nil { log.Fatal(err) } defer watcher.Close() done := make(chan bool) go func() { run := false delay := 1000 * time.Millisecond timer := time.NewTimer(delay) updated := set.NewSet() for { select { case <-timer.C: if run { run = false filesUpdated(updated) updated.Clear() } case event := <-watcher.Events: timer.Reset(delay) //if event.Op&fsnotify.Write == fsnotify.Write { run = true updated.Add(event.Name) //} case err := <-watcher.Errors: log.Println("error:", err) } } }() wd, err := os.Getwd() if err == nil { fmt.Println("Monitoring", wd) err = watcher.Add(wd) } if err != nil { log.Fatal(err) } <-done }
// Refresh the list of interfaces. func (w *watcher) refresh() error { newNames := set.NewSet() ifis, err := net.Interfaces() if err != nil { return err } for _, ifi := range ifis { if ifi.Flags&net.FlagUp != 0 && ifi.Flags&(net.FlagBroadcast|net.FlagMulticast) != 0 { newNames.Add(ifi.Name) } } for name := range newNames.Difference(w.oldNames).Iter() { w.InterfaceAdded <- name.(string) } for name := range w.oldNames.Difference(newNames).Iter() { w.InterfaceRemoved <- name.(string) } w.oldNames = newNames return nil }
// NewHostDiscovery function creates a host discovery object func NewHostDiscovery(watcher discovery.Watcher) HostDiscovery { return &hostDiscovery{watcher: watcher, nodes: mapset.NewSet(), stopChan: make(chan struct{})} }
// NewHostDiscovery function creates a host discovery object func NewHostDiscovery() HostDiscovery { return &hostDiscovery{nodes: mapset.NewSet(), stopChan: make(chan struct{})} }
func (om *ohmModel) Set(key string) ohmSet { return ohmSet(set.NewSet()) }