Returns description of the given symbol.

@param symbol for this symbol the corresponding description will be
returned
@return description of the given symbol
425047
public static String getDescription(String symbol)
    {
        CharInfo info = (CharInfo) fSymbolMap.get(symbol);
        return (info != null) ? info.fDescription : null;
    }
1189828
def symbol(self):
        """"""
        if self._symbol is None:
            self._symbol = self._symbol_extract(cache.RE_CURSOR)
            
        return self._symbol
754651
@Nullable
  @CheckForNull
  public String getDescription(String languageCode) {
    String i18nDescription = getString(getI18nAttributeName(DESCRIPTION, languageCode));
    return i18nDescription != null ? i18nDescription : getDescription();
  }
584519
public static String getChemicalSeries(String symbol) {
        Elements e = Elements.ofString(symbol);
        for (Series s : Series.values())
            if (s.contains(e)) return s.name();
        return null;
    }
17077
def description(self):
        """"""
        result = ""
        if isinstance(self._element, ValueElement):
            if self._element.kind is not None:
                result = "{}({}) | {}".format(self._element.dtype, self._element.kind,
                                          self._element.summary)
            else:
                result = "{} | {}".format(self._element.dtype,
                                          self._element.summary)
        elif isinstance(self._element, Executable):
            result = "({})".format(self._element.parameters_as_string())
        elif isinstance(self._element, str):
            result = "Intrinsic Fortran Symbol"
        elif isinstance(self._element, TypeExecutable):
            result = self._type_description()

        #Clean off any line breaks from the XML and excessive whitespace.
        cleaned = re.sub("\s+", " ", result.replace("\n", " "))
        return cleaned
1286827
public static int getElementCount(IMolecularFormula formula, String symbol) {
        return getElementCount(formula, formula.getBuilder().newInstance(IElement.class, symbol));
    }
943682
@Override
  public int get(String symbol) {
    int id = symbolToId.getOrDefault(symbol, -1);
    if (id < 0) {
      throw new IllegalArgumentException("No symbol exists for key " + symbol);
    }
    return id;
  }
621791
public String getRequiredSymbol(String key) {
        String result = null;
        Object symbol = getSymbol(key);
        if (symbol == null) {
            throw new FitFailureException("No Symbol defined with key: " + key);
        } else {
            result = symbol.toString();
        }
        return result;
    }
10668
def read_symbol
      logger.debug "  read symbol"
      skip_whitespace
      r = ""
      while !empty? && (c = text[position]) =~ /[-a-zA-Z_0-9]/
        r << c
        increase
      end
      s = STRING_TO_TOKEN[r]
      s = r.to_sym unless s
      s = true if s == :true
      s = false if s == :false
      logger.debug "  resulting symbol: #{s}"
      s
    end
1162126
public function render(Symbol $symbol)
    {
        $jsonBuilder = $this->getJsonBuilder()
            ->setValue('[path]', $this->symbolPathRenderer->render($symbol->getPath()), false);

        if ($symbol->hasAnchor()) {
            $jsonBuilder->setValue('[anchor]', $symbol->getAnchor()->getVariable(), false);
        }

        if ($symbol->hasLabelOrigin()) {
            $jsonBuilder->setValue('[labelOrigin]', $symbol->getLabelOrigin()->getVariable(), false);
        }

        $jsonBuilder->setValues($symbol->getOptions());

        return $this->getFormatter()->renderObjectAssignment($symbol, $jsonBuilder->build());
    }
338606
@Override
    public String getDescription()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getDescription");

        String desc = _definition.getDescription();

        // Assume that a null description means inherit.
        if (null == desc)
        {
            desc = getTarget().getDescription();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getDescription", desc);

        return desc;
    }
459141
public static TimeZone getStockTimeZone(String symbol) {
        // First check if it's a known stock index
        if(INDEX_TIMEZONES.containsKey(symbol)) {
            return INDEX_TIMEZONES.get(symbol);
        }
        
        if(!symbol.contains(".")) {
            return ExchangeTimeZone.get("");
        }
        String[] split = symbol.split("\\.");
        return ExchangeTimeZone.get(split[split.length - 1]);
    }
53398
def descriptor_for_symbol(self, symbol):
        
        if isinstance(symbol, basestring):
            symbol = sympy.Symbol(symbol)

        try:
            return self._descriptions_dict[symbol]
        except KeyError:
            raise KeyError("Symbol {0!r} not found in left-hand-side of the equations".format(symbol))
1363345
@Override
    public String getSymbol() {
        if (atomicNumber == null)
            return null;
        if (atomicNumber == 0)
            return "R";
        return Elements.ofNumber(atomicNumber).symbol();
    }
998501
def _get_formated_symbol(self, symbol):
        
        # pylint: disable=no-self-use

        old_symbols = [
            '\\',
            '.',
            '+',
            '*',
            '?',
            '^',
            '$',
            '[',
            ']',
            '{',
            '}',
            '(',
            ')',
            '|',
            '/',
            ',',
            '!',
            '=',
            ':',
            '-'
        ]
        replace_dict = {
            '\\': '\\\\',
            '.': r'\.',
            '+': r'\+',
            '*': r'\*',
            '?': r'\?',
            '^': r'\^',
            '$': r'\$',
            '[': r'\[',
            ']': r'\]',
            '{': r'\{',
            '}': r'\}',
            '(': r'\(',
            ')': r'\)',
            '|': r'\|',
            '/': r'\/',
            ',': r'\,',
            '!': r'\!',
            '=': r'\=',
            ':': r'\:',
            '-': r'\-'
        }
        for old in old_symbols:
            symbol = symbol.replace(old, replace_dict[old])
        return symbol
575590
public boolean containsSymbolTerm(Token.Symbol symbol) {

        for(Term<FormattedNumber> term : terms) {
            if(!(term instanceof NumberTerm.SymbolTerm)) {
                continue;
            }

            final NumberTerm.SymbolTerm symbolTerm = (NumberTerm.SymbolTerm) term;
            if(symbolTerm.getToken().equals(symbol)) {
                return true;
            }
        }

        return false;

    }
719615
@SuppressWarnings("unchecked")
    public Declaration getDeclaration(final String identifier) {
        if ( this.dirty || (this.declarations == null) ) {
            this.declarations = this.getExtendedLhs( this, null ).getOuterDeclarations();
            this.dirty = false;
        }
        return this.declarations.get( identifier );
    }