Export Rules

1
2
3
4
# Get rules by batch
rules = index.browse_rules
# With a block
index.browse_rules { |rule| puts rule }

1
2
3
4
5
index.browseRules({
  batch: batch => console.log(batch),
}).then(() => {
  // done
});

1
2
3
# Print all rules in an index.
for rule in index.browse_rules():
    print(rule)

1
2
3
4
5
index.browseRules { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
var rulesIterator = index.BrowseRules();

foreach (var rule in rulesIterator)
{
    Console.WriteLine(rule);
}

1
2
3
List<Rule> rules = new ArrayList();
RulesIterable sourceRules = index.browseRules();
sourceRules.forEach(rules::add);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
it, err := index.BrowseRules()
// error handling

for {
	rule, err := it.Next()
	if err != nil {
		if err == io.EOF {
			break
		}
		// error handling
	}

	fmt.Printf("%#v\n", *rule)
}

1
2
val helper = AlgoliaSyncHelper(client)
helper.exportRules("myIndex").map(println)

1
2
3
index.browseRules().forEach {
    println(it)
}