Actual CString object of which an instance represents a variable of which the property is defined with CStringDeclaration
186485
function CString(value, written, cond) {
  this.value   = value   || '';
  this.written = written || false;
  this.cond    = cond    || false;
}
568177
@Override
  public String asString(Object object)
  {
    // at this point object is guaranteed to be enumeration
    Enum<?> e = (Enum<?>)object;
    if(object instanceof OrdinalEnum) {
      return Integer.toString(e.ordinal());
    }
    return e.name();
  }
1347173
def get_id_from_cstring(name):
        """"""
        for key in list(LogTocElement.types.keys()):
            if (LogTocElement.types[key][0] == name):
                return key
        raise KeyError('Type [%s] not found in LogTocElement.types!' % name)
812589
def object
      if instance_variable_defined?(:@object)
        @object
      else
        rdf_node = Redland.librdf_statement_get_object(rdf_statement)
        @object = rdf_node.null? ? nil : Node.new(rdf_node)
      end
    end
508647
private static String readAnnotationProperty(String ref, TypeDef source, Property property) {
        return convertReference(ref, source, ((ClassRef)property.getTypeRef()).getDefinition());
    }
368137
function jsonStringifyIfObject (value) {
  if (!(value instanceof Object)) {
    return value;
  }
  return JSON.stringify(value, options.jsonStringifyReplacer,
    options.jsonStringifySpaces);
}
481484
def datatype
      if instance_variable_defined?(:@datatype)
        @datatype
      else
        @datatype = if literal?
                      rdf_uri = Redland.librdf_node_get_literal_value_datatype_uri(rdf_node)
                      rdf_uri.null? ? XmlSchema.datatype_of("") : URI.parse(Redland.librdf_uri_to_string(rdf_uri))
                    else
                      nil
                    end
      end
    end
203361
public Variable getDeclaredVariable(String name, boolean publicOnly) {
        //private Set mPrivateVars;

        Variable var = mDeclared.get(name);
        if (var != null) {
            // If its okay to be private or its public then...
            if (!publicOnly || mPrivateVars == null ||
                !mPrivateVars.contains(var)) {
                return var;
            }
        }
        
        if (mParent != null) {
            return mParent.getDeclaredVariable(name);
        }
        
        return null;
    }
53682
function isString(value) {
    return typeof value == 'string' ||
      value && typeof value == 'object' && toString.call(value) == stringClass || false;
  }
80091
private Class<?> getPropertyType(PersistentClass pc, String propertyString) {
    String[] properties = split(propertyString, '.');
    Property p = pc.getProperty(properties[0]);
    Component cp = ((Component) p.getValue());
    int i = 1;
    for (; i < properties.length; i++) {
      p = cp.getProperty(properties[i]);
      cp = ((Component) p.getValue());
    }
    return cp.getComponentClass();
  }
1240895
public String getVariableAsString(String name) {
        TraceState ts = traceState.get();

        if (ts != null) {
            Object variable = ts.getVariables().get(name);
            if (log.isLoggable(Level.FINEST)) {
                log.finest("Get variable '" + name + "' = " + variable);
            }
            return variable == null ? null : variable.toString();
        }

        if (log.isLoggable(Level.FINEST)) {
            log.finest("Get variable '" + name + "' requested, but no trace state");
        }
        return null;
    }
326330
protected void parseBindVariable() {
        String expr = tokenizer.getToken();
        peek().addChild(new BindVariableNode(expr, beanDescFactory));
    }
1209023
private Object parseObjectString(Class<?> objectType, final String objectString) {
        Object res;
        if (ResourceParams.class.isAssignableFrom(objectType)) {
            // Setup the default object
            if (this.object instanceof List<?>) {
                ResourceParams rp = (ResourceParams) ((List<?>) this.object).get(0);
                try {
                    rp = (ResourceParams) rp.clone();
                    rp.parse(objectString.split(PARAMETER_SEPARATOR_REGEX));
                    rp.getKey();
                } catch (final CloneNotSupportedException e) {
                }
                res = rp;
            } else {
                ((ResourceParams) this.object).parse(objectString.split(PARAMETER_SEPARATOR_REGEX));
                // return the new value
                res = this.object;
            }
        } else if (Class.class.isAssignableFrom(objectType)) {
            res = parseClassParameter(objectString);
        } else if (Enum.class.isAssignableFrom(objectType)) {
            res = parseEnumParameter((Enum<?>) this.object, objectString);
        } else if (File.class.isAssignableFrom(objectType)) {
            res = parseFileParameter(objectString);
        } else if (List.class.isAssignableFrom(objectType)) {
            res = parseListParameter(objectString);
        } else {
            res = parsePrimitive(objectType, objectString);
        }
        return res;
    }
906178
function parseConstLetDeclaration(kind) {
        var declarations;

        expectKeyword(kind);

        declarations = parseVariableDeclarationList(kind);

        consumeSemicolon();

        return {
            type: Syntax.VariableDeclaration,
            declarations: declarations,
            kind: kind
        };
    }
299145
def view_properties field=@form.get_current_field
    alert "Nil field" unless field
    return unless field
    text = ["Instance Variables"]
    text << "------------------"
    #iv = field.instance_variables.map do |v| v.to_s; end
    field.instance_variables.each do |v|
      val = field.instance_variable_get(v)
      klass = val.class
      if val.is_a? Array 
        val = val.size
      elsif val.is_a? Hash
        val = val.keys
      end
      case val
      when String, Integer, TrueClass, FalseClass, NilClass, Array, Hash, Symbol
        ;
      else
        val = "Not shown"
      end
      text << "%20s  %10s  %s" % [v, klass, val]
    end
    text << " "
    text << "Public Methods"
    text << "--------------"
    pm = field.public_methods(false).map do |v| v.to_s; end
    text +=  pm
    text << " "
    text << "Inherited Methods"
    text << "-----------------"
    pm = field.public_methods(true) - field.public_methods(false)
    pm = pm.map do |v| v.to_s; end
    text +=  pm

    #$log.debug "  view_properties #{s.size} , #{s} "
    textdialog text, :title => "Properties"
  end
626908
def type_str(c)
      ret = c.type.to_s
      ret << ", primary" if c.primary
      ret << ", default=#{truncate_default(c.default)}" if c.default
      ret << ", not null" unless c.null
      ret << ", limit=#{c.limit}" if c.limit && (c.limit != 255 && c.type != :string)
      ret
    end
849798
def p_encaps_var_object_property(p):
    ''
    p[0] = ast.ObjectProperty(ast.Variable(p[1], lineno=p.lineno(1)), p[3],
                              lineno=p.lineno(2))