will retrieve icons from the glyphs map for a certain glyphName

@param glyphName the glyph name
@return SVGGlyph node
336039
public static SVGGlyph getIcoMoonGlyph(String glyphName) throws Exception{
        SVGGlyphBuilder builder = glyphsMap.get(glyphName);
        if(builder == null) throw new Exception("Glyph '" + glyphName + "' not found!");
        SVGGlyph glyph = builder.build();
        // we need to apply transformation to correct the icon since
        // its being inverted after importing from icomoon
        glyph.getTransforms().add(new Scale(1, -1));
        Translate height = new Translate();
        height.yProperty().bind(Bindings.createDoubleBinding(() -> -glyph.getHeight(), glyph.heightProperty()));
        glyph.getTransforms().add(height);
        return glyph;
    }
1369295
function (graphicName)  {
        if (!this.defs) {
            // create svg defs tag
            this.defs = this.createDefs();
        }
        var id = this.container.id + "-" + graphicName;
        
        // check if symbol already exists in the defs
        var existing = document.getElementById(id);
        if (existing != null) {
            return existing;
        }
        
        var symbol = OpenLayers.Renderer.symbol[graphicName];
        if (!symbol) {
            throw new Error(graphicName + ' is not a valid symbol name');
        }

        var symbolNode = this.nodeFactory(id, "symbol");
        var node = this.nodeFactory(null, "polygon");
        symbolNode.appendChild(node);
        var symbolExtent = new OpenLayers.Bounds(
                                    Number.MAX_VALUE, Number.MAX_VALUE, 0, 0);

        var points = [];
        var x,y;
        for (var i=0; i<symbol.length; i=i+2) {
            x = symbol[i];
            y = symbol[i+1];
            symbolExtent.left = Math.min(symbolExtent.left, x);
            symbolExtent.bottom = Math.min(symbolExtent.bottom, y);
            symbolExtent.right = Math.max(symbolExtent.right, x);
            symbolExtent.top = Math.max(symbolExtent.top, y);
            points.push(x, ",", y);
        }
        
        node.setAttributeNS(null, "points", points.join(" "));
        
        var width = symbolExtent.getWidth();
        var height = symbolExtent.getHeight();
        // create a viewBox three times as large as the symbol itself,
        // to allow for strokeWidth being displayed correctly at the corners.
        var viewBox = [symbolExtent.left - width,
                        symbolExtent.bottom - height, width * 3, height * 3];
        symbolNode.setAttributeNS(null, "viewBox", viewBox.join(" "));
        this.symbolMetrics[id] = [
            Math.max(width, height),
            symbolExtent.getCenterLonLat().lon,
            symbolExtent.getCenterLonLat().lat
        ];
        
        this.defs.appendChild(symbolNode);
        return symbolNode;
    }
854596
public String getTextValueForPatternName(final String name) {
        Node n = this.getSingle(name);
        String text = n == null ? null : n.getText();
        return text;
    }
773701
def get_glyph(glyph_name, data=None):
    

    # Read data on first use.
    if data is None:
        global GLYPHDATA
        if GLYPHDATA is None:
            GLYPHDATA = GlyphData.from_files(
                os.path.join(
                    os.path.dirname(glyphsLib.__file__), "data", "GlyphData.xml"
                ),
                os.path.join(
                    os.path.dirname(glyphsLib.__file__),
                    "data",
                    "GlyphData_Ideographs.xml",
                ),
            )
        data = GLYPHDATA

    # Look up data by full glyph name first.
    attributes = _lookup_attributes(glyph_name, data)

    production_name = attributes.get("production")
    if production_name is None:
        production_name = _construct_production_name(glyph_name, data=data)

    unicode_value = attributes.get("unicode")

    category = attributes.get("category")
    sub_category = attributes.get("subCategory")
    if category is None:
        category, sub_category = _construct_category(glyph_name, data)

    # TODO: Determine script in ligatures.
    script = attributes.get("script")
    description = attributes.get("description")

    return Glyph(
        glyph_name,
        production_name,
        unicode_value,
        category,
        sub_category,
        script,
        description,
    )
697261
public static Typeface getTypeface(Context ctx, String fontName){
        Typeface existing = mLoadedTypefaces.get(fontName);
        if(existing == null){
            existing = Typeface.createFromAsset(ctx.getAssets(), fontName);
            mLoadedTypefaces.put(fontName, existing);
        }
        return existing;
    }
553894
private List<Glyph> getGlyphsOfPEs(Set<PhysicalEntity> pes, String context) {
		List<Glyph> gs = new ArrayList<Glyph>();

		for (PhysicalEntity pe : pes)
			if (glyphMap.containsKey(convertID(pe.getUri())))
				gs.add(getGlyphToLink(pe, context));

		return gs;
	}
800158
public static TextStyleContainer findIcons(Spanned spannable, HashMap<String, ITypeface> fonts) {
        LinkedList<StyleContainer> styleContainers = new LinkedList<>();
        LinkedList<StyleContainer> existingSpans = new LinkedList<>();

        // remember the previous style spans
        for (ParcelableSpan span : spannable.getSpans(0, spannable.length(), ParcelableSpan.class)) {
            existingSpans.add(new StyleContainer(spannable.getSpanStart(span), spannable.getSpanEnd(span), span, spannable.getSpanFlags(span)));
        }
        for (CharacterStyle span : spannable.getSpans(0, spannable.length(), CharacterStyle.class)) {
            existingSpans.add(new StyleContainer(spannable.getSpanStart(span), spannable.getSpanEnd(span), span, spannable.getSpanFlags(span)));
        }

        //the new string built with the replaced icons
        SpannableStringBuilder spannedString = new SpannableStringBuilder();
        SpannableStringBuilder tempIconString = new SpannableStringBuilder();

        int removedChars = 0;
        for (int i = 0; i < spannable.length(); i++) {
            Character c = spannable.charAt(i);
            if (c == ICON_START) {
                //if something started with { but was no icon replacement
                spannedString.append(tempIconString);
                //start to remember the tempIconString again
                tempIconString = new SpannableStringBuilder();
                tempIconString.append(c);
            } else if (c == ICON_END) {
                tempIconString.append(c);
                //make sure there was a { before and enough chars for the font key
                if (tempIconString.length() > 5) {
                    StyleContainer styleContainer = placeFontIcon(spannedString, tempIconString, fonts);
                    if (styleContainer != null) {
                        styleContainers.add(styleContainer);

                        //adjust existing spans to new position
                        for (StyleContainer existingStyleContainer : existingSpans) {
                            if (existingStyleContainer.startIndex > i - removedChars) {
                                existingStyleContainer.startIndex = existingStyleContainer.startIndex - tempIconString.length() + 1;
                            }
                            if (existingStyleContainer.endIndex > i - removedChars) {
                                existingStyleContainer.endIndex = existingStyleContainer.endIndex - tempIconString.length() + 1;
                            }
                        }
                        removedChars += tempIconString.length() - 1;
                    }
                } else {
                    spannedString.append(tempIconString);
                }
                tempIconString = new SpannableStringBuilder();
            } else {
                if (tempIconString.length() == 0) {
                    spannedString.append(c);
                } else {
                    tempIconString.append(c);
                }
            }
        }

        //make sure to add the last characters which create no complete icon
        spannedString.append(tempIconString);

        //add the existing spans
        styleContainers.addAll(existingSpans);

        return new TextStyleContainer(spannedString, styleContainers);
    }
70346
public static FontData getBold(String familyName) {
		FontData data = (FontData) bold.get(familyName);
		
		return data;
	}
1256403
public static FontData getBoldItalic(String familyName) {
		FontData data = (FontData) bolditalic.get(familyName);
		
		return data;
	}
659949
function ttfobject2icon(ttf, options) {

    var glyfList = [];

    // glyf 信息
    var filtered = ttf.glyf.filter(function (g) {
        return g.name !== '.notdef'
            && g.name !== '.null'
            && g.name !== 'nonmarkingreturn'
            && g.unicode && g.unicode.length;
    });

    filtered.forEach(function (g) {
        glyfList.push({
            code: '&#x' + g.unicode[0].toString(16) + ';',
            codeName: listUnicode(g.unicode),
            name: g.name
        });
    });

    return {
        fontFamily: ttf.name.fontFamily || config.name.fontFamily,
        iconPrefix: options.iconPrefix || 'icon',
        glyfList: glyfList
    };

}
504921
public static function getGlyphicon($glyph) {
		$result=new HtmlGlyphicon("");
		if (is_int($glyph)) {
			$glyphs=CssGlyphicon::getConstants();
			if ($glyph<sizeof($glyphs)) {
				$glyph=array_values($glyphs)[$glyph];
			}
		}
		$result->setGlyphicon($glyph);
		return $result;
	}
512608
public GroupEntity getGroup(String groupName) {
		return restClient.get("groups/" + groupName, GroupEntity.class, new HashMap<String, String>());
	}
1018129
@Override
    public Shape getShape(final Object o) throws NotAvailableException {
        if (o instanceof GlyphIcons) {
            return GLYPH_ICON_SHAPE_PROVIDER.getShape((GlyphIcons) o);
        }

        if (o instanceof Shape) {
            return SVG_PATH_SHAPE_PROVIDER.getShape((SVGPath) o);
        }

        throw new NotAvailableException(ContextType.USE_ID_AS_CONTEXT, "ShapeProvider", new InvalidStateException("Shape description " + o + " is not supported!"));
    }
736143
public static void loadGlyphsFont(URL url) throws IOException {
        try {
            DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

            docBuilder.setEntityResolver((publicId, systemId) -> {
                // disable dtd entites at runtime
                return new InputSource(new StringReader(""));
            });

            File svgFontFile = new File(url.toURI());
            Document doc = docBuilder.parse(svgFontFile);
            doc.getDocumentElement().normalize();

            NodeList glyphsList = doc.getElementsByTagName("glyph");
            for (int i = 0; i < glyphsList.getLength(); i++) {
                Node glyph = glyphsList.item(i);
                Node glyphName = glyph.getAttributes().getNamedItem("glyph-name");
                if (glyphName == null) {
                    continue;
                }

                String glyphId = glyphName.getNodeValue();
                SVGGlyphBuilder glyphPane = new SVGGlyphBuilder(i,
                    glyphId,
                    glyph.getAttributes()
                        .getNamedItem("d")
                        .getNodeValue());
                glyphsMap.put(svgFontFile.getName() + "." + glyphId, glyphPane);
            }
        } catch (ParserConfigurationException | SAXException | URISyntaxException e) {
            e.printStackTrace();
        }
    }
820360
public static FontData getItalic(String familyName) {
		FontData data = (FontData) italic.get(familyName);
		
		return data;
	}
1202351
public static FontData getPlain(String familyName) {
		FontData data = (FontData) plain.get(familyName);
		
		return data;
	}
544381
public CallTreeNode getChild(String name) {
		return (children == null) ? null : children.get(name);
	}