Encapsulates the work that will be done for case 6 of __embed_frond,
    since it gets used in more than one place.
431925
def __do_case_6_work(d_w, d_u, case_1, case_2, case_3, dfs_data):
    """"""
    # --We should only ever see u-cases 1 and 3
    if case_2:
        # --We should never get here
        return False

    comp_d_w = abs(d_w)

    # --Add the frond to the right side
    __insert_frond_RF(d_w, d_u, dfs_data)

    # --Add uw to Rm
    m = dfs_data['FG']['m']
    Rm = R(m, dfs_data)
    if comp_d_w < Rm['x']:
        Rm['x'] = d_w
    if d_u > Rm['y']:
        Rm['y'] = d_u

    # --Case 3 requires a bit of extra work
    if case_3:
        Rm['x'] = d_w
        u_m1 = u(m-1, dfs_data)
        while comp_d_w < u_m1:
            merge_Fm(dfs_data)
            m = dfs_data['FG']['m']
            u_m1 = u(m-1, dfs_data)
    #else:
        #print "Case 6 work, u-case 1"

    return True
551204
void recomposeIncludes(Stylesheet including)
  {

    int n = including.getIncludeCount();

    if (n > 0)
    {
      if (null == m_includesComposed)
        m_includesComposed = new Vector();

      for (int i = 0; i < n; i++)
      {
        Stylesheet included = including.getInclude(i);
        m_includesComposed.addElement(included);
        recomposeIncludes(included);
      }
    }
  }
967240
private void associateClones(Node n, Node snapshot) {
    // TODO(johnlenz): determine if MODULE_BODY is useful here.
    if (n.isRoot() || NodeUtil.isChangeScopeRoot(n)) {
      clonesByCurrent.put(n, snapshot);
    }

    Node child = n.getFirstChild();
    Node snapshotChild = snapshot.getFirstChild();
    while (child != null) {
      associateClones(child, snapshotChild);
      child = child.getNext();
      snapshotChild = snapshotChild.getNext();
    }
  }
1219499
function embed (resource, e) {
    e && [].concat(e)
      .forEach(function (externalResource) {
        if (db.get(externalResource).value) {
          var query = {}
          var singularResource = pluralize.singular(name)
          query[singularResource + 'Id'] = resource.id
          resource[externalResource] = db.get(externalResource).filter(query).value()
        }
      })
  }
180135
function Job (client, jobID, module) {
  this.client = client
  this.jobID = jobID
  this.module = module
}
165264
protected function performEnrichment()
    {
        if ( ! count($this->info->export->columns)) {
            $this->fillDataForEmpty();
        } else {
            $this->enrichCustomData();
        }

        // Separate strategies may have their own column setups.
        // If not, the defaults should be copied for them.
        foreach ($this->info->export->strategies as $key => $strategyData) {

            if ( ! count($strategyData->columns)) {
                $this->info->export->strategies[ $key ]->columns = $this->info->export->columns;
            } else {
                $this->enrichCustomData($key);
            }
        }
    }
891977
function includeFiles(config, backRef)
{
  backRef = backRef || [];

  Object.keys(config).forEach(function(key)
  {
    var value, oneOffContext;

    if (typeof config[key] == 'string')
    {
      // create temp context
      oneOffContext = merge.call(cloneFunction, this, { files: [config[key]] });

      // try to load data from file
      value = this.load(oneOffContext);

      // keep the entry if something's been resolved
      // empty or unchanged value signal otherwise
      if (isEmpty(value))
      {
        delete config[key];
      }
      else
      {
        config[key] = value;
      }
    }
    else if (isObject(config[key]))
    {
      includeFiles.call(this, config[key], backRef.concat(key));
    }
    // Unsupported entry type
    else
    {
      throw new Error('Illegal key type for custom-include-files at ' + backRef.concat(key).join('.') + ': ' + Object.prototype.toString.call(config[key]));
    }
  }.bind(this));

  return config;
}
927105
def __do_case_5_work(d_w, d_u, case_1, case_2, case_3, dfs_data):
    """"""
    # --We should only ever see u-cases 1 and 2
    if case_3:
        # --We should never get here
        return False

    comp_d_w = abs(d_w)

    #if case_1:
    # --Add the frond to the left side
    __insert_frond_LF(d_w, d_u, dfs_data)

    # --Add uw to Lm
    m = dfs_data['FG']['m']
    Lm = L(m, dfs_data)
    if comp_d_w < Lm['u']:
        Lm['u'] = d_w
    if d_u > Lm['v']:
        Lm['v'] = d_u

    # --Case 2 requires a bit of extra work
    if case_2:
        Lm['u'] = d_w
        x_m1 = fn_x(m-1, dfs_data)
        while comp_d_w < x_m1:
            merge_Fm(dfs_data)
            m = dfs_data['FG']['m']
            x_m1 = fn_x(m-1, dfs_data)
    #else:
        #print "Case 5 work, u-case 1"

    return True
1043795
function(module) {
        for (var i = 0; i < module.include.length; i++) {
          var curInclude = module.include[i];
          if (curInclude.substr(0, 2) == '^!') {
            module.include[i] = curInclude.substr(2);
            attachBuildIds.push(curInclude.substr(2));
          }
        }
      }
635258
def extern_project_multi(self, context_handle, val, field_str_ptr, field_str_len):
    """"""
    c = self._ffi.from_handle(context_handle)
    obj = c.from_value(val[0])
    field_name = self.to_py_str(field_str_ptr, field_str_len)

    return c.vals_buf(tuple(c.to_value(p) for p in getattr(obj, field_name)))
156936
def write_main_jobwrappers(self):
        '''
        
        '''
        main_section = ''

        # toil cannot technically start with multiple jobs, so an empty
        # 'initialize_jobs' function is always called first to get around this
        main_section = main_section + '\n        job0 = Job.wrapJobFn(initialize_jobs)\n'

        # declare each job in main as a wrapped toil function in order of priority
        for wf in self.workflows_dictionary:
            for assignment in self.workflows_dictionary[wf]:
                if assignment.startswith('call'):
                    main_section += '        job0 = job0.encapsulate()\n'
                    main_section += self.write_main_jobwrappers_call(self.workflows_dictionary[wf][assignment])
                if assignment.startswith('scatter'):
                    main_section += '        job0 = job0.encapsulate()\n'
                    main_section += self.write_main_jobwrappers_scatter(self.workflows_dictionary[wf][assignment],
                                                                        assignment)
                if assignment.startswith('if'):
                    main_section += '        if {}:\n'.format(self.workflows_dictionary[wf][assignment]['expression'])
                    main_section += self.write_main_jobwrappers_if(self.workflows_dictionary[wf][assignment]['body'])

        main_section += '\n        fileStore.start(job0)\n'

        return main_section
1016927
function (cb) {
            var self = this;

            Y.prepare([DEFAULT_THEME, themeDir], self.getProjectMeta(), function (err, opts) {
                opts.meta.title = self.data.project.name;
                opts.meta.projectRoot = './';
                opts.meta.projectAssets = './assets';
                opts.meta.projectLogo = self._resolveUrl(self.data.project.logo, opts);
                opts = self.populateClasses(opts);
                opts = self.populateModules(opts);

                var view = new Y.DocView(opts.meta);
                self.render('{{>index}}', view, opts.layouts.main, opts.partials, function (err, html) {
                    self.files++;
                    cb(html, view);
                });
            });
        }
85135
def included(base = nil, &block)
      if base.nil?
        if instance_variable_defined?(:@_included_block)
          if @_included_block.source_location != block.source_location
            raise MultipleIncludedBlocks
          end
        else
          @_included_block = block
        end
      else
        super
      end
    end
466636
def _make_embedded_from(self, doc):
        ''''''
        ld = utils.CurieDict(self._core.default_curie, {})
        for rel, doc in doc.get('_embedded', {}).items():
            if isinstance(doc, list):
                ld[rel] = [self._recursively_embed(d) for d in doc]
            else:
                ld[rel] = self._recursively_embed(doc)
        return ld
1018970
def _include_file(context, uri, calling_uri, **kwargs):
    """"""

    template = _lookup_template(context, uri, calling_uri)
    (callable_, ctx) = _populate_self_namespace(
                                context._clean_inheritance_tokens(),
                                template)
    callable_(ctx, **_kwargs_for_include(callable_, context._data, **kwargs))
26137
private static void collectIncludedModulesRecursively(Loader plugin, ModuleAdapter<?> adapter,
      Map<Class<?>, ModuleAdapter<?>> result) {
    for (Class<?> include : adapter.includes) {
      if (!result.containsKey(include)) {
        ModuleAdapter<?> includedModuleAdapter = plugin.getModuleAdapter(include);
        result.put(include, includedModuleAdapter);
        collectIncludedModulesRecursively(plugin, includedModuleAdapter, result);
      }
    }
  }
641917
@Override
    public Tuple6<Maybe<A>, Maybe<B>, Maybe<C>, Maybe<D>, Maybe<E>, Maybe<F>> project() {
        return into6(HList::tuple, CoProduct6.super.project());
    }