Returns a generator function over all the existing indexes

        @returns A generator function over all rhe Index objects
198474
def getIndices(self):
        """"""
        for indexName in self.neograph.nodes.indexes.keys():
            indexObject = self.neograph.nodes.indexes.get(indexName)
            yield Index(indexName, "vertex", "manual", indexObject)
        for indexName in self.neograph.relationships.indexes.keys():
            indexObject = self.neograph.relationships.indexes.get(indexName)
            yield Index(indexName, "edge", "manual", indexObject)
285517
def _operator_generator(index, conj):
        
        pterm = PauliTerm('I', 0, 1.0)
        Zstring = PauliTerm('I', 0, 1.0)
        for j in range(index):
            Zstring = Zstring*PauliTerm('Z', j, 1.0)

        pterm1 = Zstring*PauliTerm('X', index, 0.5)
        scalar = 0.5 * conj * 1.0j
        pterm2 = Zstring*PauliTerm('Y', index, scalar)
        pterm = pterm * (pterm1 + pterm2)

        pterm = pterm.simplify()
        return pterm
737050
def generate(fn):
    ''''''
    if isinstance(fn, str):
        return lambda f: generate(f).desc(fn)

    @wraps(fn)
    @Parser
    def generated(text, index):
        iterator, value = fn(), None
        try:
            while True:
                parser = iterator.send(value)
                res = parser(text, index)
                if not res.status:  # this parser failed.
                    return res
                value, index = res.value, res.index  # iterate
        except StopIteration as stop:
            endval = stop.value
            if isinstance(endval, Parser):
                return endval(text, index)
            else:
                return Value.success(index, endval)
    return generated.desc(fn.__name__)
431428
function arrayFunction(item, index) {
      return function(data, cb) {
        if (iterator.length === 2) {
          iterator(item, cb);
        } else if (iterator.length === 3) {
          iterator(item, index, cb);
        } else {
          iterator(item, index, data, cb);
        }
      };
    }
1038195
function keysIndexes(children, startIndex, endIndex) {
  var i, keys = Object.create(null), key;
  for (i = startIndex; i <= endIndex; ++i) {
    if (children[i]) {
      key = children[i].key;
      if (key !== undefined) {
        keys[key] = i;
      }
    }
  }
  return keys;
}
485333
public ArrayList<String> getGenerators() {
        ArrayList<String> genList = new ArrayList<String>();
        for (ArrayList<HashMap<String, String>> genGroup : genGroups) {
            if (!genGroup.isEmpty()) {
                HashMap<String, String> genRule = genGroup.get(genGroup.size() - 1);
                if (!genRule.isEmpty()) {
                    genList.add(genRule.get("cmd") + "," + genRule.get("variable") + "," + genRule.get("args"));
                }
            }
        }

        return genList;
    }
1163587
private ImmutableList<Function> getAtomsForGenerators(Collection<TreeWitnessGenerator> gens, Term r0)  {
		return TreeWitnessGenerator.getMaximalBasicConcepts(gens, reasoner).stream()
				.map(con -> {
					log.debug("  BASIC CONCEPT: {}", con);
					if (con instanceof OClass) {
						return atomFactory.getMutableTripleBodyAtom(r0, ((OClass) con).getIRI());
					}
					else if (con instanceof ObjectSomeValuesFrom) {
						ObjectPropertyExpression ope = ((ObjectSomeValuesFrom)con).getProperty();
						return (!ope.isInverse())
								? atomFactory.getMutableTripleBodyAtom(r0, ope.getIRI(), getFreshVariable())
								: atomFactory.getMutableTripleBodyAtom(getFreshVariable(), ope.getIRI(), r0);
					}
					else {
						DataPropertyExpression dpe = ((DataSomeValuesFrom)con).getProperty();
						return atomFactory.getMutableTripleBodyAtom(r0, dpe.getIRI(), getFreshVariable());
					}
				})
				.collect(ImmutableCollectors.toList());
	}
563175
def itertuples(self, index=True, name='Raccoon'):
        
        fields = [self._index_name] if index else list()
        fields.extend(self._columns)
        row_tuple = namedtuple(name, fields)
        for i in range(len(self._index)):
            row = {self._index_name: self._index[i]} if index else dict()
            for c, col in enumerate(self._columns):
                row[col] = self._data[c][i]
            yield row_tuple(**row)
784047
function getIndexes(done, results) {
  var client = results.client;
  var ns = mongodbNS(results.namespace);
  client
    .db(ns.database)
    .collection(ns.collection)
    .indexes(function(err, indexes) {
      if (err) {
        done(err);
      }
      // add ns field to each index
      _.each(indexes, function(idx) {
        idx.ns = ns.ns;
      });
      done(null, indexes);
    });
}
998354
def generate_index(credentials, instance_config, instance_name,
                   script_dir, genome_file, output_dir, annotation_file=None,
                   splice_overhang=100,
                   num_threads=8, chromosome_bin_bits=18,
                   genome_memory_limit=31000000000,
                   self_destruct=True,
                   **kwargs):
    """"""

    template = _TEMPLATE_ENV.get_template(
        os.path.join('generate_index.sh'))
    startup_script = template.render(
        script_dir=script_dir,
        genome_file=genome_file,
        annotation_file=annotation_file,
        splice_overhang=splice_overhang,
        output_dir=output_dir,
        num_threads=num_threads,
        chromosome_bin_bits=chromosome_bin_bits,
        genome_memory_limit=genome_memory_limit,
        self_destruct=self_destruct)

    op_name = instance_config.create_instance(
        credentials, instance_name, startup_script=startup_script, **kwargs)

    return op_name
69158
function()
  {
    this.indices = {};

    for (var i = 0, l = this.keys.length; i < l; i++)
    {
      this.indices[ this.keys[ i ] ] = i;
    }

    return this;
  }
579414
function generate(base, tuple, index) {
    var name = dims[index],
        v = vals[index++],
        k, key;

    for (k in v) {
      tuple[name] = v[k];
      key = base ? base + '|' + k : k;
      if (index < n) generate(key, tuple, index);
      else if (!curr[key]) aggr.cell(key, tuple);
    }
  }
215658
private int[] getIndexes() {
    int[] res = new int[this.indexes.size()];
    int i = 0;
    for (Integer idx : this.indexes) {
      res[i] = idx;
      i++;
    }
    return res;
  }
302672
def generateIndex(self, refresh=0, refresh_index=0):
        """"""
        open(self.index_file, "wt").write(self.renderIndex(refresh=refresh, refresh_index=refresh_index))
1353247
function starx(obj) {
    if (!isGenerator(obj) && !isIterator(obj)) throw new TypeError('obj must be a generator or iterator')

    return function executor(done) {
      var self = this,
          done = once(done || noop),
          iterator = isGenerator(obj) ? obj.call(self) : obj

      process.nextTick(next)
      function next(err, value) {    
        var res, _next = once(next)

        domain.create()
          // iterator throws, we're done
          .on('error', done)
          .run(function() {
            res = err ? iterator.throw(err) : iterator.next(value)
          })
      
        domain.create()
          // yieldable throws, iterator is certainly not yet exhausted, so run next
          .on('error', _next)
          .run(function() {
            wrap.call(self, res.value).call(self, function cb() {
              (res.done ? done : _next).apply(null, arguments)
            })
          })
      }
    }
  }
1092243
def get_generation(self, *tables, **kwargs):
        """"""
        db = kwargs.get('db', 'default')
        if len(tables) > 1:
            return self.get_multi_generation(tables, db)
        return self.get_single_generation(tables[0], db)
151467
public List<TableGenerator<OrmDescriptor>> getAllTableGenerator()
   {
      List<TableGenerator<OrmDescriptor>> list = new ArrayList<TableGenerator<OrmDescriptor>>();
      List<Node> nodeList = model.get("table-generator");
      for(Node node: nodeList)
      {
         TableGenerator<OrmDescriptor>  type = new TableGeneratorImpl<OrmDescriptor>(this, "table-generator", model, node);
         list.add(type);
      }
      return list;
   }