def _readSingleInstanceElement(self, instanceElement, makeGlyphs=True, makeKerning=True, makeInfo=True):
        """ Read a single instance element.
            If we have glyph specifications, only make those.
            Otherwise make all available glyphs.
        """
        # get the data from the instanceElement itself
        filename = instanceElement.attrib.get('filename')

        instancePath = os.path.join(os.path.dirname(self.path), filename)
        self.reportProgress("generate", 'start', instancePath)
        if self.verbose and self.logger:
            self.logger.info("\tGenerating instance %s", os.path.basename(instancePath))
        filenameTokenForResults = os.path.basename(filename)

        instanceObject = self._instanceWriterClass(instancePath,
            ufoVersion=self.ufoVersion,
            roundGeometry=self.roundGeometry,
            axes = self.axes,
            verbose=self.verbose,
            logger=self.logger
            )
        self.results[filenameTokenForResults] = instancePath

        # set the masters
        instanceObject.setSources(self.sources)
        self.unicodeMap = instanceObject.makeUnicodeMapFromSources()
        instanceObject.setMuted(self.muted)
        familyname = instanceElement.attrib.get('familyname')
        if familyname is not None:
            instanceObject.setFamilyName(familyname)
        stylename = instanceElement.attrib.get('stylename')
        if stylename is not None:
            instanceObject.setStyleName(stylename)
        postScriptFontName = instanceElement.attrib.get('postscriptfontname')
        if postScriptFontName is not None:
            instanceObject.setPostScriptFontName(postScriptFontName)
        styleMapFamilyName = instanceElement.attrib.get('stylemapfamilyname')
        if styleMapFamilyName is not None:
            instanceObject.setStyleMapFamilyName(styleMapFamilyName)
        styleMapStyleName = instanceElement.attrib.get('stylemapstylename')
        if styleMapStyleName is not None:
            instanceObject.setStyleMapStyleName(styleMapStyleName)

        # location
        instanceLocation = self.locationFromElement(instanceElement)

        if instanceLocation is not None:
            instanceObject.setLocation(instanceLocation)

        if makeGlyphs:

            # step 1: generate all glyphs we have mutators for.
            names = instanceObject.getAvailableGlyphnames()
            for n in names:
                unicodes = self.unicodeMap.get(n, None)
                try:
                    instanceObject.addGlyph(n, unicodes)
                except AssertionError:
                    if self.verbose and self.logger:
                        self.logger.info("Problem making glyph %s, skipping.", n)
            # step 2: generate all the glyphs that have special definitions.
            for glyphElement in instanceElement.findall('.glyphs/glyph'):
                self.readGlyphElement(glyphElement, instanceObject)

        # read the kerning
        if makeKerning:
            for kerningElement in instanceElement.findall('.kerning'):
                self.readKerningElement(kerningElement, instanceObject)
                break

        # read the fontinfo
        if makeInfo:
            for infoElement in instanceElement.findall('.info'):
                self.readInfoElement(infoElement, instanceObject)

        # copy the features
        if self.featuresSource is not None:
            instanceObject.copyFeatures(self.featuresSource)

        # copy the groups
        if self.groupsSource is not None:
            if self.groupsSource in self.sources:
                groupSourceObject, loc = self.sources[self.groupsSource]
                # copy the groups from the designated source to the new instance
                # note: setGroups will filter the group members
                # only glyphs present in the font will be added to the group.
                # Depending on the ufoversion we might or might not expect the kerningGroupConversionRenameMaps attribute.
                if hasattr(groupSourceObject, "kerningGroupConversionRenameMaps"):
                    renameMap = groupSourceObject.kerningGroupConversionRenameMaps
                else:
                    renameMap = {}
                instanceObject.setGroups(groupSourceObject.groups, kerningGroupConversionRenameMaps=renameMap)

        # lib items
        if self.libSource is not None:
            if self.libSource in self.sources:
                libSourceObject, loc = self.sources[self.libSource]
                instanceObject.setLib(libSourceObject.lib)

        # save the instance. Done.
        success, report = instanceObject.save()
        if not success and self.logger:
            # report problems other than validation errors and failed glyphs
            self.logger.info("%s:\nErrors generating: %s", filename, report)

        # report failed glyphs
        failed = instanceObject.getFailed()
        if failed:
            failed.sort()
            msg = "%s:\nErrors calculating %s glyphs: \n%s"%(filename, len(failed),"\t"+"\n\t".join(failed))
            self.reportProgress('error', 'glyphs', msg)
            if self.verbose and self.logger:
                self.logger.info(msg)

        # report missing unicodes
        missing = instanceObject.getMissingUnicodes()
        if missing:
            missing.sort()
            msg = "%s:\nPossibly missing unicodes for %s glyphs: \n%s"%(filename, len(missing),"\t"+"\n\t".join(missing))
            self.reportProgress('error', 'unicodes', msg)

        # store
        self.instances[postScriptFontName] = instanceObject
        self.reportProgress("generate", 'stop', filenameTokenForResults)
Read a single instance element.
            If we have glyph specifications, only make those.
            Otherwise make all available glyphs.