Obtains the PropertyEditorRegistry instance.
@return The PropertyEditorRegistry
422275
public PropertyEditorRegistry getPropertyEditorRegistry() {
        final HttpServletRequest servletRequest = getCurrentRequest();
        PropertyEditorRegistry registry = (PropertyEditorRegistry) servletRequest.getAttribute(GrailsApplicationAttributes.PROPERTY_REGISTRY);
        if (registry == null) {
            registry = new PropertyEditorRegistrySupport();
            PropertyEditorRegistryUtils.registerCustomEditors(this, registry, RequestContextUtils.getLocale(servletRequest));
            servletRequest.setAttribute(GrailsApplicationAttributes.PROPERTY_REGISTRY, registry);
        }
        return registry;
    }
942435
public String getComponentId() {
    if (Annotation_Type.featOkTst && ((Annotation_Type)jcasType).casFeat_componentId == null)
      jcasType.jcas.throwFeatMissing("componentId", "de.julielab.jules.types.Annotation");
    return jcasType.ll_cas.ll_getStringValue(addr, ((Annotation_Type)jcasType).casFeatCode_componentId);}
826729
public static synchronized NameResolverRegistry getDefaultRegistry() {
    if (instance == null) {
      List<NameResolverProvider> providerList = ServiceProviders.loadAll(
          NameResolverProvider.class,
          getHardCodedClasses(),
          NameResolverProvider.class.getClassLoader(),
          new NameResolverPriorityAccessor());
      if (providerList.isEmpty()) {
        logger.warning("No NameResolverProviders found via ServiceLoader, including for DNS. This "
            + "is probably due to a broken build. If using ProGuard, check your configuration");
      }
      instance = new NameResolverRegistry();
      for (NameResolverProvider provider : providerList) {
        logger.fine("Service loader found " + provider);
        if (provider.isAvailable()) {
          instance.addProvider(provider);
        }
      }
      instance.refreshProviders();
    }
    return instance;
  }
1168818
public static CmsEntity getEntity() {

        if ((INSTANCE == null) || (INSTANCE.m_entityObserver == null)) {
            CmsDebugLog.getInstance().printLine("handling external registration");
            if (isObserverExported()) {
                return CmsEntityBackend.createFromNativeWrapper(nativeGetEntity());
            } else {
                throw new RuntimeException("Editor is not initialized yet.");
            }
        } else {
            return INSTANCE.getCurrentEntity();
        }
    }
12567
private static ActionRegistry getRegistry(boolean global) {
        if (global) {
            return instance;
        }
        
        Page page = ExecutionContext.getPage();
        ActionRegistry registry = (ActionRegistry) page.getAttribute(ATTR_LOCAL_REGISTRY);
        
        if (registry == null) {
            page.setAttribute(ATTR_LOCAL_REGISTRY, registry = new ActionRegistry());
        }
        
        return registry;
    }
930146
public synchronized InputRegister[] getRegisters() {
        InputRegister[] dest = new InputRegister[registers.length];
        System.arraycopy(registers, 0, dest, 0, dest.length);
        return dest;
    }
547959
public com.google.appengine.v1.ScriptHandlerOrBuilder getScriptOrBuilder() {
    if (handlerTypeCase_ == 3) {
       return (com.google.appengine.v1.ScriptHandler) handlerType_;
    }
    return com.google.appengine.v1.ScriptHandler.getDefaultInstance();
  }
580697
public static PropertiesLoader getPropertiesLoader() {
		synchronized (PropertiesLoader.class) {
			final ClassLoader classLoader = ConfigurableClassLoader.INSTANCE.getClassLoader();
			PropertiesLoader loader = clMap.get(classLoader);
			if (loader == null) {
				try {
					loader = new PropertiesLoader(MASTER_PLUGIN_FILE, EXTRA_PLUGIN_FILE);
					clMap.put(classLoader, loader);
				} catch (final IOException ex) {
					throw new RuntimeException(ex);
				}
			}
			return loader;
		}
	}
448877
public Record getUserRegistration()
    {
        Record recUserRegistration = (Record)m_systemRecordOwner.getRecord(UserRegistrationModel.USER_REGISTRATION_FILE);
        if (recUserRegistration == null)
            recUserRegistration = Record.makeRecordFromClassName(UserRegistrationModel.THICK_CLASS, m_systemRecordOwner);
        return recUserRegistration;
    }
813219
public static synchronized LoadBalancerRegistry getDefaultRegistry() {
    if (instance == null) {
      List<LoadBalancerProvider> providerList = ServiceProviders.loadAll(
          LoadBalancerProvider.class,
          HARDCODED_CLASSES,
          LoadBalancerProvider.class.getClassLoader(),
          new LoadBalancerPriorityAccessor());
      instance = new LoadBalancerRegistry();
      for (LoadBalancerProvider provider : providerList) {
        logger.fine("Service loader found " + provider);
        if (provider.isAvailable()) {
          instance.addProvider(provider);
        }
      }
      instance.refreshProviderMap();
    }
    return instance;
  }
560600
public ManagedBinding getManagedBinding() {
        final SocketBindingManager.NamedManagedBindingRegistry registry = this.socketBindings.getNamedRegistry();
        return registry.getManagedBinding(name);
    }
1121275
public static ComposedValueConverter getInstance() {

    if (instance == null) {
      synchronized (DefaultComposedValueConverter.class) {
        if (instance == null) {
          DefaultComposedValueConverter impl = new DefaultComposedValueConverter();
          impl.initialize();
          instance = impl;
        }
      }
    }
    return instance;
  }
747662
public static void register(Class<?> typeClass, Class<? extends PropertyEditor> editorClass)
    {
        synchronized (editors)
        {
            editors.put(typeClass, editorClass);
        }
    }
1145191
public Type getPropertyType(String propertyName) {
    Type type = (Type) propertyTypes.get(propertyName);
    if (null == type) {
      Class<?> propertyType = PropertyUtils.getPropertyType(componentClass, propertyName);
      if (null != propertyType) { return new IdentifierType(propertyType); }
    }
    return type;
  }
313890
public String getAsText() {

        Object value = getValue();
        if (value == null) {
            return "";
        }

        String propertyName = null; // used in error handling below
        try {
            StringBuffer label = new StringBuffer();

            for (int i = 0; i < properties.length; i++) {
                propertyName = properties[i];
                Class<?> propertyType = PropertyUtils.getPropertyType(value, propertyName);
                Object propertyValue = PropertyUtils.getNestedProperty(value, propertyName);
                PropertyEditor editor = registry.findCustomEditor(propertyType, registryPropertyNamePrefix + propertyName);
                if (editor == null) {
                    label.append(propertyValue);
                } else {
                    editor.setValue(propertyValue);
                    label.append(editor.getAsText());
                    editor.setValue(null);
                }
                
                if (i < (properties.length - 1)) {
                    label.append(separator);
                }
            }
            
            return label.toString();
            
        } catch (Exception e) {
            throw new IllegalArgumentException("Couldn't access " + propertyName + 
                    " of " + value.getClass().getName() + " : " +
                    e.getMessage(), e);
        }

    }
974082
public function getRegistrar()
    {
        if (isset($this->registrar)) {
            return $this->registrar;
        }

        return $this->registrar = new ResourceRegistrar($this);
    }
734504
public Map<String, Object> getProperties()
    {
        Record recUserRegistration = this.getUserRegistration();
        return ((PropertiesField)recUserRegistration.getField(UserRegistrationModel.PROPERTIES)).getProperties();
    }