A list of collections we will write to

 @return [Array<String>] A list of the collection names we will write to
548579
def write_collections
      edge_collections.flat_map do |target_state|
        [target_state.edge_collection_name] +
          (target_state.from_vertices + target_state.to_vertices).map(&:collection)
      end.uniq.compact
    end
1225307
def read_items(client, items)
      return [] if !items
      items.map do |item_class,items_of_class|
        items_of_class = [items_of_class] if !items_of_class.is_a?(Array)
        items_of_class.map do |item|
          Item.new(client, item_class, item)
        end
      end.flatten
    end
1341448
def get_collections(self):
        
        collections = self.request.matchdict['collections'].split('/')[0]
        collections = [coll.strip() for coll in collections.split(',')]
        return set(collections)
1160478
def [](name)
      key = name.to_s
      if attributes.key?(key)
        attributes[key]
      elsif index = underscored_column_names.index(key)
        attributes[@columns[index].name]
      end
    end
330583
def branches(self) -> Set[str]:
        
        if self._branches is None:
            self._branches = self._get_branches()

        return self._branches
663579
def marks(*names)
      return self if names.empty?
      names = names.flatten.collect { |n| n.to_s }
      self.select do |mark| 
        names.member? mark.name.to_s
      end
    end
1081330
def collection_names(self, include_system_collections=True):
        
        with self.__client._socket_for_reads(
                ReadPreference.PRIMARY) as (sock_info, slave_okay):

            wire_version = sock_info.max_wire_version
            results = self._list_collections(sock_info, slave_okay)

        # Iterating the cursor to completion may require a socket for getmore.
        # Ensure we do that outside the "with" block so we don't require more
        # than one socket at a time.
        names = [result["name"] for result in results]
        if wire_version <= 2:
            # MongoDB 2.4 and older return index namespaces and collection
            # namespaces prefixed with the database name.
            names = [n[len(self.__name) + 1:] for n in names
                     if n.startswith(self.__name + ".") and "$" not in n]

        if not include_system_collections:
            names = [name for name in names if not name.startswith("system.")]
        return names
846116
public Collection<String> getNames() {
		Collection<String> names = new HashSet<String>();
		for (InitParam initParam : initParams) {
			names.add(initParam.getName());
		}
		return names;
	}
431793
def tag_list=(names)
      self.tags = names.split(",").map do |n|
        SimpleTags::Tag.where(name: n.strip).first_or_create!
      end
    end
421519
def tables(options = {})
      batches = Enumerator.new do |y|
        resp = @client.list_tables(options)
        resp.each_page do |page|
          batch = []
          page.data.table_names.each do |t|
            batch << Table.new(
              name: t,
              client: @client
            )
          end
          y.yield(batch)
        end
      end
      Table::Collection.new(batches)
    end
602875
def collections(page = 1, per_page = 10)
      params = {
        page:     page,
        per_page: per_page
      }

      list = JSON.parse(connection.get("/users/#{username}/collections", params).body)
      list.map do |collection|
        Unsplash::Collection.new collection.to_hash
      end
    end
467113
def as_list(self):
        
        self._sanitise()
        l = []
        for name in self.names:
            l.append(getattr(self, name))
        return l
1151697
protected List<String> getPages() {

        if (m_pages == null) {
            m_pages = Arrays.asList(getPageArray());
        }
        return m_pages;
    }
596207
def get_all_collections()
      response = self.get('collections').body
      parsed = JSON.parse(response)
      all_collections = []
      parsed.each do |item_hash|
        all_collections.push OmekaClient::OmekaCollection.new(self, item_hash)
      end
      return all_collections
    end
25507
@VisibleForTesting
  List<Name> names(Iterable<String> names) {
    List<Name> result = new ArrayList<>();
    for (String name : names) {
      result.add(name(name));
    }
    return result;
  }
257529
def list(type)
      resource_class = parse_type(type)
      client_setup
      all = resource_class.get_all(@client)
      if options['attribute']
        data = select_attributes_from_multiple(options['attribute'], all)
        output data, -2 # Shift left by 2 so things look right
      else # List names only by default
        names = []
        all.each { |r| names.push(r['name']) }
        output names
      end
    end
753382
def get_note_names(self):
        
        res = []
        for n in self.notes:
            if n.name not in res:
                res.append(n.name)
        return res