Retrieves all replication documents from the replication database.

        :returns: List containing replication Document objects
502458
def list_replications(self):
        
        docs = self.database.all_docs(include_docs=True)['rows']
        documents = []
        for doc in docs:
            if doc['id'].startswith('_design/'):
                continue
            document = Document(self.database, doc['id'])
            document.update(doc['doc'])
            documents.append(document)
        return documents
836833
def all_documents(index=INDEX_NAME):
    
    query = {
        'query': {
            'match_all': {}
        }
    }
    for result in raw_query(query, index=index):
        yield result
1229585
public java.util.List<ReplicationGroup> getReplicationGroups() {
        if (replicationGroups == null) {
            replicationGroups = new com.amazonaws.internal.SdkInternalList<ReplicationGroup>();
        }
        return replicationGroups;
    }
376845
def all(self):
        
        url = "{url_base}/resource/{pid}/files/".format(url_base=self.hs.url_base,
                                                                 pid=self.pid)
        r = self.hs._request('GET', url)
        return r
194061
def _concrete_instance_list(self, instance_docs):
        
        if not instance_docs:
            return []

        return list(
            filter(None, [self._concrete_instance(instance_doc=doc) for doc in instance_docs])
        )
820119
def protocol_list(self):
        
        result = []
        for group in self.groups:
            result.extend(group.protocols)
        return result
1288400
def _get_rows(self):
        
        html = requests.get(self.url.build()).text
        if re.search('did not match any documents', html):
            return []
        pq = PyQuery(html)
        rows = pq("table.data").find("tr")
        return map(rows.eq, range(rows.size()))[1:]
764578
public List<JSONObject> getResourceData()
    {
        List<JSONObject> resources = new ArrayList<JSONObject>();
    
        try
        {
            if (data != null && data.has(documentsParam))
            {
                List<JSONObject> results = getDocuments();
                
                for(JSONObject json : results)
                {
                    if (json.has(documentParam))
                    {
                        JSONObject result = json.getJSONObject(documentParam);
                        results.add(result);
                    }
                }
            }
            else if (data != null && data.has(getRecordParam))
            {
                List<JSONObject> results = getRecords();
                
                for(JSONObject json : results)
                {
                    if (json.has(resourceDataParam))
                    {
                        JSONObject result = json.getJSONObject(resourceDataParam);
                        results.add(result);
                    }
                }
            }
        }
        catch (JSONException e)
        {
            //This is already handled by the enclosing "has" checks
        }
        
        return resources;
    }
522249
def get_documents_in_database(self, with_id=True):
        
        documents = []
        for coll in self.get_collection_names():
            documents += self.get_documents_in_collection(
                coll,
                with_id=with_id
            )

        return documents
315453
def list_all_elements(self):
        
        res = []

        # We are a host/service
        if self.operand in ['host', 'service']:
            return [self.sons[0]]

        for son in self.sons:
            res.extend(son.list_all_elements())

        # and returns a list of unique uuids
        return list(set(res))
819278
def documents(self):
        

        document_list = []
        document_uri_list = self.api.document.get(collection=self.name)['documents']
        for document_uri in document_uri_list:
            splitted_uri = document_uri.split('/')
            document_key = splitted_uri[-1]
            document_id = "%s/%s" % (self.name, document_key)

            doc = Document(
                id=document_id,
                key=document_key,
                collection=self,
                api=self.api
            )

            document_list.append(doc)

        return document_list
447427
def get_collections(self):
        
        collections = []
        for result in self._get_collections():
            collections.append(result['collection'])

        return collections
1159805
def replicate(self, doc_id, source, target, continuous=False):
        
        if doc_id in self["_replicator"]:
            return
        data = {
            "_id": doc_id,
            "source": source,
            "target": target,
            "continuous": continuous
        }
        self["_replicator"][doc_id] = data
497987
def get_all_keys(self):
        
        all_keys = []
        for keys in self._index.values():
            all_keys.extend(keys)
        return all_keys
58610
def authorization_documents(self):
        
        if self._authorization_documents is None:
            self._authorization_documents = AuthorizationDocumentList(self)
        return self._authorization_documents
697902
def all(self):
        
        datasets = []
        for dataset in self.index.searcher().documents():
            res = DatasetSearchResult()
            res.vid = dataset['vid']
            res.b_score = 1
            datasets.append(res)
        return datasets
788729
def items(self):
        
        all_items = [(k.decode('utf-8'),v.decode('utf-8')) for k,v in self.rdb.hgetall(self.session_hash).items()]
        return all_items