PHP preload_course_contexts函数代码示例

//.........这里部分代码省略.........
            $context = context::instance_by_id($contextid);
            $this->assertSame(get_context_instance_by_id($contextid), $context);
            $this->assertSame(get_context_instance($record->contextlevel, $record->instanceid), $context);
            $this->assertSame(get_parent_contexts($context), $context->get_parent_context_ids());
            if ($context->id == SYSCONTEXTID) {
                $this->assertSame(get_parent_contextid($context), false);
            } else {
                $this->assertSame(get_parent_contextid($context), $context->get_parent_context()->id);
            }
        }

        $CFG->debug = 0;
        $children = get_child_contexts($systemcontext);
        $CFG->debug = DEBUG_DEVELOPER;
        $this->assertEquals(count($children), $DB->count_records('context')-1);
        unset($children);

        $DB->delete_records('context', array('contextlevel'=>CONTEXT_BLOCK));
        create_contexts();
        $this->assertFalse($DB->record_exists('context', array('contextlevel'=>CONTEXT_BLOCK)));

        $DB->set_field('context', 'depth', 0, array('contextlevel'=>CONTEXT_BLOCK));
        build_context_path();
        $this->assertFalse($DB->record_exists('context', array('depth'=>0)));

        $lastcourse = $DB->get_field_sql("SELECT MAX(id) FROM {course}");
        $DB->delete_records('course', array('id'=>$lastcourse));
        $lastcategory = $DB->get_field_sql("SELECT MAX(id) FROM {course_categories}");
        $DB->delete_records('course_categories', array('id'=>$lastcategory));
        $lastuser = $DB->get_field_sql("SELECT MAX(id) FROM {user} WHERE deleted=0");
        $DB->delete_records('user', array('id'=>$lastuser));
        $DB->delete_records('block_instances', array('parentcontextid'=>$frontpagepagecontext->id));
        $DB->delete_records('course_modules', array('id'=>$frontpagepagecontext->instanceid));
        cleanup_contexts();
        $count = 1; //system
        $count += $DB->count_records('user', array('deleted'=>0));
        $count += $DB->count_records('course_categories');
        $count += $DB->count_records('course');
        $count += $DB->count_records('course_modules');
        $count += $DB->count_records('block_instances');
        $this->assertEquals($DB->count_records('context'), $count);

        context_helper::reset_caches();
        preload_course_contexts($SITE->id);
        $this->assertEquals(context_inspection::test_context_cache_size(), 1);

        context_helper::reset_caches();
        list($select, $join) = context_instance_preload_sql('c.id', CONTEXT_COURSECAT, 'ctx');
        $sql = "SELECT c.id $select FROM {course_categories} c $join";
        $records = $DB->get_records_sql($sql);
        foreach ($records as $record) {
            context_instance_preload($record);
            $record = (array)$record;
            $this->assertEquals(1, count($record)); // only id left
        }
        $this->assertEquals(count($records), context_inspection::test_context_cache_size());

        accesslib_clear_all_caches(true);
        $DB->delete_records('cache_flags', array());
        mark_context_dirty($systemcontext->path);
        $dirty = get_cache_flags('accesslib/dirtycontexts', time()-2);
        $this->assertTrue(isset($dirty[$systemcontext->path]));

        accesslib_clear_all_caches(false);
        $DB->delete_records('cache_flags', array());
        $course = $DB->get_record('course', array('id'=>$testcourses[2]));
        $context = get_context_instance(CONTEXT_COURSE, $course->id);
        $oldpath = $context->path;
        $miscid = $DB->get_field_sql("SELECT MIN(id) FROM {course_categories}");
        $categorycontext = context_coursecat::instance($miscid);
        $course->category = $miscid;
        $DB->update_record('course', $course);
        context_moved($context, $categorycontext);
        $context = get_context_instance(CONTEXT_COURSE, $course->id);
        $this->assertEquals($context->get_parent_context(), $categorycontext);

        $this->assertTrue($DB->record_exists('context', array('contextlevel'=>CONTEXT_COURSE, 'instanceid'=>$testcourses[2])));
        delete_context(CONTEXT_COURSE, $testcourses[2]);
        $this->assertFalse($DB->record_exists('context', array('contextlevel'=>CONTEXT_COURSE, 'instanceid'=>$testcourses[2])));

        $name = get_contextlevel_name(CONTEXT_COURSE);
        $this->assertFalse(empty($name));

        $context = get_context_instance(CONTEXT_COURSE, $testcourses[2]);
        $name = print_context_name($context);
        $this->assertFalse(empty($name));

        $url = get_context_url($coursecontext);
        $this->assertFalse($url instanceof modole_url);

        $page = $DB->get_record('page', array('id'=>$testpages[7]));
        $context = get_context_instance(CONTEXT_MODULE, $page->id);
        $coursecontext = get_course_context($context);
        $this->assertEquals($coursecontext->contextlevel, CONTEXT_COURSE);
        $this->assertEquals(get_courseid_from_context($context), $page->course);

        $caps = fetch_context_capabilities($systemcontext);
        $this->assertTrue(is_array($caps));
        unset($caps);
    }

            $params = array('id' => $id);
        } else {
            print_error('unspecifycourseid', 'error');
        }
    }
}
$course = $DB->get_record('course', $params, '*', MUST_EXIST);
$urlparams = array('id' => $course->id);
if ($section) {
    $urlparams['section'] = $section;
}
$PAGE->set_url('/course/view.php', $urlparams);
// Defined here to avoid notices on errors etc
// Prevent caching of this page to stop confusion when changing page after making AJAX changes
$PAGE->set_cacheable(false);
preload_course_contexts($course->id);
$context = context_course::instance($course->id, MUST_EXIST);
// Remove any switched roles before checking login
if ($switchrole == 0 && confirm_sesskey()) {
    role_switch($switchrole, $context);
}
require_login($course);
// Switchrole - sanity check in cost-order...
$reset_user_allowed_editing = false;
if ($switchrole > 0 && confirm_sesskey() && has_capability('moodle/role:switchroles', $context)) {
    // is this role assignable in this context?
    // inquiring minds want to know...
    $aroles = get_switchable_roles($context);
    if (is_array($aroles) && isset($aroles[$switchrole])) {
        role_switch($switchrole, $context);
        // Double check that this role is allowed here

 /**
  * Constructs based on course.
  * Note: This constructor should not usually be called directly.
  * Use get_fast_modinfo($course) instead as this maintains a cache.
  * @param object $course Moodle course object, which may include modinfo
  * @param int $userid User ID
  */
 public function __construct($course, $userid)
 {
     global $CFG, $DB;
     // Set initial values
     $this->courseid = $course->id;
     $this->userid = $userid;
     $this->sections = array();
     $this->cms = array();
     $this->instances = array();
     $this->groups = null;
     $this->course = $course;
     // Check modinfo field is set. If not, build and load it.
     if (empty($course->modinfo)) {
         rebuild_course_cache($course->id);
         $course->modinfo = $DB->get_field('course', 'modinfo', array('id' => $course->id));
     }
     // Load modinfo field into memory as PHP object and check it's valid
     $info = unserialize($course->modinfo);
     if (!is_array($info)) {
         // hmm, something is wrong - lets try to fix it
         rebuild_course_cache($course->id);
         $course->modinfo = $DB->get_field('course', 'modinfo', array('id' => $course->id));
         $info = unserialize($course->modinfo);
         if (!is_array($info)) {
             // If it still fails, abort
             debugging('Problem with "modinfo" data for this course');
             return;
         }
     }
     // If we haven't already preloaded contexts for the course, do it now
     preload_course_contexts($course->id);
     // Loop through each piece of module data, constructing it
     $modexists = array();
     foreach ($info as $mod) {
         if (empty($mod->name)) {
             // something is wrong here
             continue;
         }
         // Skip modules which don't exist
         if (empty($modexists[$mod->mod])) {
             if (!file_exists("{$CFG->dirroot}/mod/{$mod->mod}/lib.php")) {
                 continue;
             }
             $modexists[$mod->mod] = true;
         }
         // Construct info for this module
         $cm = new cm_info($this, $course, $mod, $info);
         // Store module in instances and cms array
         if (!isset($this->instances[$cm->modname])) {
             $this->instances[$cm->modname] = array();
         }
         $this->instances[$cm->modname][$cm->instance] = $cm;
         $this->cms[$cm->id] = $cm;
         // Reconstruct sections. This works because modules are stored in order
         if (!isset($this->sections[$cm->sectionnum])) {
             $this->sections[$cm->sectionnum] = array();
         }
         $this->sections[$cm->sectionnum][] = $cm->id;
     }
     // We need at least 'dynamic' data from each course-module (this is basically the remaining
     // data which was always present in previous version of get_fast_modinfo, so it's required
     // for BC). Creating it in a second pass is necessary because obtain_dynamic_data sometimes
     // needs to be able to refer to a 'complete' (with basic data) modinfo.
     foreach ($this->cms as $cm) {
         $cm->obtain_dynamic_data();
     }
 }

/**
 * Returns reference to full info about modules in course (including visibility).
 * Cached and as fast as possible (0 or 1 db query).
 * @param $course object or 'reset' string to reset caches, modinfo may be updated in db
 * @return mixed courseinfo object or nothing if resetting
 */
function &get_fast_modinfo(&$course, $userid = 0)
{
    global $CFG, $USER;
    static $cache = array();
    if ($course === 'reset') {
        $cache = array();
        $nothing = null;
        return $nothing;
        // we must return some reference
    }
    if (empty($userid)) {
        $userid = $USER->id;
    }
    if (array_key_exists($course->id, $cache) and $cache[$course->id]->userid == $userid) {
        return $cache[$course->id];
    }
    if (empty($course->modinfo)) {
        // no modinfo yet - load it
        rebuild_course_cache($course->id);
        $course->modinfo = get_field('course', 'modinfo', 'id', $course->id);
    }
    $modinfo = new object();
    $modinfo->courseid = $course->id;
    $modinfo->userid = $userid;
    $modinfo->sections = array();
    $modinfo->cms = array();
    $modinfo->instances = array();
    $modinfo->groups = null;
    // loaded only when really needed - the only one db query
    $info = unserialize($course->modinfo);
    if (!is_array($info)) {
        // hmm, something is wrong - lets try to fix it
        rebuild_course_cache($course->id);
        $course->modinfo = get_field('course', 'modinfo', 'id', $course->id);
        $info = unserialize($course->modinfo);
        if (!is_array($info)) {
            return $modinfo;
        }
    }
    if ($info) {
        // detect if upgrade required
        $first = reset($info);
        if (!isset($first->id)) {
            rebuild_course_cache($course->id);
            $course->modinfo = get_field('course', 'modinfo', 'id', $course->id);
            $info = unserialize($course->modinfo);
            if (!is_array($info)) {
                return $modinfo;
            }
        }
    }
    $modlurals = array();
    // If we haven't already preloaded contexts for the course, do it now
    preload_course_contexts($course->id);
    foreach ($info as $mod) {
        if (empty($mod->name)) {
            // something is wrong here
            continue;
        }
        // reconstruct minimalistic $cm
        $cm = new object();
        $cm->id = $mod->cm;
        $cm->instance = $mod->id;
        $cm->course = $course->id;
        $cm->modname = $mod->mod;
        $cm->name = urldecode($mod->name);
        $cm->visible = $mod->visible;
        $cm->sectionnum = $mod->section;
        $cm->groupmode = $mod->groupmode;
        $cm->groupingid = $mod->groupingid;
        $cm->groupmembersonly = $mod->groupmembersonly;
        $cm->extra = isset($mod->extra) ? urldecode($mod->extra) : '';
        $cm->icon = isset($mod->icon) ? $mod->icon : '';
        $cm->uservisible = true;
        // preload long names plurals and also check module is installed properly
        if (!isset($modlurals[$cm->modname])) {
            if (!file_exists("{$CFG->dirroot}/mod/{$cm->modname}/lib.php")) {
                continue;
            }
            $modlurals[$cm->modname] = get_string('modulenameplural', $cm->modname);
        }
        $cm->modplural = $modlurals[$cm->modname];
        $modcontext = get_context_instance(CONTEXT_MODULE, $cm->id);
        if (!$cm->visible and !has_capability('moodle/course:viewhiddenactivities', $modcontext, $userid)) {
            $cm->uservisible = false;
        } else {
            if (!empty($CFG->enablegroupings) and !empty($cm->groupmembersonly) and !has_capability('moodle/site:accessallgroups', $modcontext, $userid)) {
                if (is_null($modinfo->groups)) {
                    $modinfo->groups = groups_get_user_groups($course->id, $userid);
                }
                if (empty($modinfo->groups[$cm->groupingid])) {
                    $cm->uservisible = false;
                }
            }
//.........这里部分代码省略.........

/**
 * Returns reference to full info about modules in course (including visibility).
 * Cached and as fast as possible (0 or 1 db query).
 *
 * @global object
 * @global object
 * @global object
 * @uses CONTEXT_MODULE
 * @uses MAX_MODINFO_CACHE_SIZE
 * @param mixed $course object or 'reset' string to reset caches, modinfo may be updated in db
 * @param int $userid Defaults to current user id
 * @return mixed courseinfo object or nothing if resetting
 */
function &get_fast_modinfo(&$course, $userid = 0)
{
    global $CFG, $USER, $DB;
    require_once $CFG->dirroot . '/course/lib.php';
    if (!empty($CFG->enableavailability)) {
        require_once $CFG->libdir . '/conditionlib.php';
    }
    static $cache = array();
    if ($course === 'reset') {
        $cache = array();
        $nothing = null;
        return $nothing;
        // we must return some reference
    }
    if (empty($userid)) {
        $userid = $USER->id;
    }
    if (array_key_exists($course->id, $cache) and $cache[$course->id]->userid == $userid) {
        return $cache[$course->id];
    }
    if (empty($course->modinfo)) {
        // no modinfo yet - load it
        rebuild_course_cache($course->id);
        $course->modinfo = $DB->get_field('course', 'modinfo', array('id' => $course->id));
    }
    $modinfo = new object();
    $modinfo->courseid = $course->id;
    $modinfo->userid = $userid;
    $modinfo->sections = array();
    $modinfo->cms = array();
    $modinfo->instances = array();
    $modinfo->groups = null;
    // loaded only when really needed - the only one db query
    $info = unserialize($course->modinfo);
    if (!is_array($info)) {
        // hmm, something is wrong - lets try to fix it
        rebuild_course_cache($course->id);
        $course->modinfo = $DB->get_field('course', 'modinfo', array('id' => $course->id));
        $info = unserialize($course->modinfo);
        if (!is_array($info)) {
            return $modinfo;
        }
    }
    if ($info) {
        // detect if upgrade required
        $first = reset($info);
        if (!isset($first->id)) {
            rebuild_course_cache($course->id);
            $course->modinfo = $DB->get_field('course', 'modinfo', array('id' => $course->id));
            $info = unserialize($course->modinfo);
            if (!is_array($info)) {
                return $modinfo;
            }
        }
    }
    $modlurals = array();
    // If we haven't already preloaded contexts for the course, do it now
    preload_course_contexts($course->id);
    foreach ($info as $mod) {
        if (empty($mod->name)) {
            // something is wrong here
            continue;
        }
        // reconstruct minimalistic $cm
        $cm = new object();
        $cm->id = $mod->cm;
        $cm->instance = $mod->id;
        $cm->course = $course->id;
        $cm->modname = $mod->mod;
        $cm->name = urldecode($mod->name);
        $cm->visible = $mod->visible;
        $cm->sectionnum = $mod->section;
        $cm->groupmode = $mod->groupmode;
        $cm->groupingid = $mod->groupingid;
        $cm->groupmembersonly = $mod->groupmembersonly;
        $cm->indent = $mod->indent;
        $cm->completion = $mod->completion;
        $cm->extra = isset($mod->extra) ? urldecode($mod->extra) : '';
        $cm->icon = isset($mod->icon) ? $mod->icon : '';
        $cm->uservisible = true;
        if (!empty($CFG->enableavailability)) {
            // We must have completion information from modinfo. If it's not
            // there, cache needs rebuilding
            if (!isset($mod->availablefrom)) {
                debugging('enableavailability option was changed; rebuilding ' . 'cache for course ' . $course->id);
                rebuild_course_cache($course->id, true);
                // Re-enter this routine to do it all properly
//.........这里部分代码省略.........

//.........这里部分代码省略.........
     $prevsize = context_inspection::test_context_cache_size();
     for ($i = 0; $i < 100; $i++) {
         context_user::instance($testusers[$i]);
         $this->assertEqual(context_inspection::test_context_cache_size(), $prevsize);
     }
     context_user::instance($testusers[102]);
     $this->assertEqual(context_inspection::test_context_cache_size(), $prevsize + 1);
     unset($testusers);
     // =================================================================
     // ======= basic test of legacy functions ==========================
     // =================================================================
     // note: watch out, the fake site might be pretty borked already
     $this->assertIdentical(get_system_context(), context_system::instance());
     foreach ($DB->get_records('context') as $contextid => $record) {
         $context = context::instance_by_id($contextid);
         $this->assertIdentical(get_context_instance_by_id($contextid), $context);
         $this->assertIdentical(get_context_instance($record->contextlevel, $record->instanceid), $context);
         $this->assertIdentical(get_parent_contexts($context), $context->get_parent_context_ids());
         if ($context->id == SYSCONTEXTID) {
             $this->assertIdentical(get_parent_contextid($context), false);
         } else {
             $this->assertIdentical(get_parent_contextid($context), $context->get_parent_context()->id);
         }
     }
     $children = get_child_contexts($systemcontext);
     $this->assertEqual(count($children), $DB->count_records('context') - 1);
     unset($children);
     $DB->delete_records('context', array('contextlevel' => CONTEXT_BLOCK));
     create_contexts();
     $this->assertFalse($DB->record_exists('context', array('contextlevel' => CONTEXT_BLOCK)));
     $DB->set_field('context', 'depth', 0, array('contextlevel' => CONTEXT_BLOCK));
     build_context_path();
     $this->assertFalse($DB->record_exists('context', array('depth' => 0)));
     $lastcourse = $DB->get_field_sql("SELECT MAX(id) FROM {course}");
     $DB->delete_records('course', array('id' => $lastcourse));
     $lastcategory = $DB->get_field_sql("SELECT MAX(id) FROM {course_categories}");
     $DB->delete_records('course_categories', array('id' => $lastcategory));
     $lastuser = $DB->get_field_sql("SELECT MAX(id) FROM {user} WHERE deleted=0");
     $DB->delete_records('user', array('id' => $lastuser));
     $DB->delete_records('block_instances', array('parentcontextid' => $frontpagepagecontext->id));
     $DB->delete_records('course_modules', array('id' => $frontpagepagecontext->instanceid));
     cleanup_contexts();
     $count = 1;
     //system
     $count += $DB->count_records('user', array('deleted' => 0));
     $count += $DB->count_records('course_categories');
     $count += $DB->count_records('course');
     $count += $DB->count_records('course_modules');
     $count += $DB->count_records('block_instances');
     $this->assertEqual($DB->count_records('context'), $count);
     context_helper::reset_caches();
     preload_course_contexts($SITE->id);
     $this->assertEqual(context_inspection::test_context_cache_size(), 1);
     context_helper::reset_caches();
     list($select, $join) = context_instance_preload_sql('c.id', CONTEXT_COURSECAT, 'ctx');
     $sql = "SELECT c.id {$select} FROM {course_categories} c {$join}";
     $records = $DB->get_records_sql($sql);
     foreach ($records as $record) {
         context_instance_preload($record);
         $record = (array) $record;
         $this->assertEqual(1, count($record));
         // only id left
     }
     $this->assertEqual(count($records), context_inspection::test_context_cache_size());
     accesslib_clear_all_caches(true);
     $DB->delete_records('cache_flags', array());
     mark_context_dirty($systemcontext->path);
     $dirty = get_cache_flags('accesslib/dirtycontexts', time() - 2);
     $this->assertTrue(isset($dirty[$systemcontext->path]));
     accesslib_clear_all_caches(false);
     $DB->delete_records('cache_flags', array());
     $course = $DB->get_record('course', array('id' => $testcourses[2]));
     $context = get_context_instance(CONTEXT_COURSE, $course->id);
     $oldpath = $context->path;
     $miscid = $DB->get_field_sql("SELECT MIN(id) FROM {course_categories}");
     $categorycontext = context_coursecat::instance($miscid);
     $course->category = $miscid;
     $DB->update_record('course', $course);
     context_moved($context, $categorycontext);
     $context = get_context_instance(CONTEXT_COURSE, $course->id);
     $this->assertIdentical($context->get_parent_context(), $categorycontext);
     $this->assertTrue($DB->record_exists('context', array('contextlevel' => CONTEXT_COURSE, 'instanceid' => $testcourses[2])));
     delete_context(CONTEXT_COURSE, $testcourses[2]);
     $this->assertFalse($DB->record_exists('context', array('contextlevel' => CONTEXT_COURSE, 'instanceid' => $testcourses[2])));
     $name = get_contextlevel_name(CONTEXT_COURSE);
     $this->assertFalse(empty($name));
     $context = get_context_instance(CONTEXT_COURSE, $testcourses[2]);
     $name = print_context_name($context);
     $this->assertFalse(empty($name));
     $url = get_context_url($coursecontext);
     $this->assertFalse($url instanceof modole_url);
     $page = $DB->get_record('page', array('id' => $testpages[7]));
     $context = get_context_instance(CONTEXT_MODULE, $page->id);
     $coursecontext = get_course_context($context);
     $this->assertEqual($coursecontext->contextlevel, CONTEXT_COURSE);
     $this->assertEqual(get_courseid_from_context($context), $page->course);
     $caps = fetch_context_capabilities($systemcontext);
     $this->assertTrue(is_array($caps));
     unset($caps);
 }

 /**
  * Constructs based on course.
  * Note: This constructor should not usually be called directly.
  * Use get_fast_modinfo($course) instead as this maintains a cache.
  * @param object $course Moodle course object, which may include modinfo
  * @param int $userid User ID
  */
 public function __construct($course, $userid)
 {
     global $CFG, $DB, $COURSE, $SITE;
     if (!isset($course->modinfo) || !isset($course->sectioncache)) {
         $course = get_course($course->id, false);
     }
     // Check modinfo field is set. If not, build and load it.
     if (empty($course->modinfo) || empty($course->sectioncache)) {
         rebuild_course_cache($course->id);
         $course = $DB->get_record('course', array('id' => $course->id), '*', MUST_EXIST);
     }
     // Set initial values
     $this->courseid = $course->id;
     $this->userid = $userid;
     $this->sections = array();
     $this->cms = array();
     $this->instances = array();
     $this->groups = null;
     $this->course = $course;
     // Load modinfo field into memory as PHP object and check it's valid
     $info = unserialize($course->modinfo);
     if (!is_array($info)) {
         // hmm, something is wrong - lets try to fix it
         rebuild_course_cache($course->id);
         $course->modinfo = $DB->get_field('course', 'modinfo', array('id' => $course->id));
         $info = unserialize($course->modinfo);
         if (!is_array($info)) {
             // If it still fails, abort
             debugging('Problem with "modinfo" data for this course');
             return;
         }
     }
     // Load sectioncache field into memory as PHP object and check it's valid
     $sectioncache = unserialize($course->sectioncache);
     if (!is_array($sectioncache)) {
         // hmm, something is wrong - let's fix it
         rebuild_course_cache($course->id);
         $course->sectioncache = $DB->get_field('course', 'sectioncache', array('id' => $course->id));
         $sectioncache = unserialize($course->sectioncache);
         if (!is_array($sectioncache)) {
             // If it still fails, abort
             debugging('Problem with "sectioncache" data for this course');
             return;
         }
     }
     // If we haven't already preloaded contexts for the course, do it now.
     // Modules are also cached here as long as it's the first time this course has been preloaded.
     preload_course_contexts($course->id);
     // Quick integrity check: as a result of race conditions modinfo may not be regenerated after the change.
     // It is especially dangerous if modinfo contains the deleted course module, as it results in fatal error.
     // We can check it very cheap by validating the existence of module context.
     if ($course->id == $COURSE->id || $course->id == $SITE->id) {
         // Only verify current course (or frontpage) as pages with many courses may not have module contexts cached.
         // (Uncached modules will result in a very slow verification).
         foreach ($info as $mod) {
             if (!context_module::instance($mod->cm, IGNORE_MISSING)) {
                 debugging('Course cache integrity check failed: course module with id ' . $mod->cm . ' does not have context. Rebuilding cache for course ' . $course->id);
                 rebuild_course_cache($course->id);
                 $this->course = $DB->get_record('course', array('id' => $course->id), '*', MUST_EXIST);
                 $info = unserialize($this->course->modinfo);
                 $sectioncache = unserialize($this->course->sectioncache);
                 break;
             }
         }
     }
     // Loop through each piece of module data, constructing it
     $modexists = array();
     foreach ($info as $mod) {
         if (empty($mod->name)) {
             // something is wrong here
             continue;
         }
         // Skip modules which don't exist
         if (empty($modexists[$mod->mod])) {
             if (!file_exists("{$CFG->dirroot}/mod/{$mod->mod}/lib.php")) {
                 continue;
             }
             $modexists[$mod->mod] = true;
         }
         // Construct info for this module
         $cm = new cm_info($this, $course, $mod, $info);
         // Store module in instances and cms array
         if (!isset($this->instances[$cm->modname])) {
             $this->instances[$cm->modname] = array();
         }
         $this->instances[$cm->modname][$cm->instance] = $cm;
         $this->cms[$cm->id] = $cm;
         // Reconstruct sections. This works because modules are stored in order
         if (!isset($this->sections[$cm->sectionnum])) {
             $this->sections[$cm->sectionnum] = array();
         }
         $this->sections[$cm->sectionnum][] = $cm->id;
     }
//.........这里部分代码省略.........