Returns a canonical instance.

@throws IllegalArgumentException if property is null
481452
@SuppressWarnings("unchecked")
    public static <S extends Storable> OrderedProperty<S> get(ChainedProperty<S> property,
                                                              Direction direction) {
        return (OrderedProperty<S>) cCanonical.put(new OrderedProperty<S>(property, direction));
    }
196972
public String getCanonical() {
    if (BioVerb_Type.featOkTst && ((BioVerb_Type)jcasType).casFeat_canonical == null)
      jcasType.jcas.throwFeatMissing("canonical", "ch.epfl.bbp.uima.types.BioVerb");
    return jcasType.ll_cas.ll_getStringValue(addr, ((BioVerb_Type)jcasType).casFeatCode_canonical);}
201819
public static function singleton()
    {
        $returnValue = null;

        

		if (core_kernel_persistence_smoothsql_Property::$instance == null){
			core_kernel_persistence_smoothsql_Property::$instance = new core_kernel_persistence_smoothsql_Property();
		}
		$returnValue = core_kernel_persistence_smoothsql_Property::$instance;

        

        return $returnValue;
    }
119847
@Override
  public Pair getCanonicalForm(Pair value) throws UcumException  {
		assert value != null : paramError("getCanonicalForm", "value", "must not be null");
		assert checkStringParam(value.getCode()) : paramError("getCanonicalForm", "value.code", "must not be null or empty");
		
		Term term = new ExpressionParser(model).parse(value.getCode());
		Canonical c = new Converter(model, handlers).convert(term);
		if (value.getValue() == null)
			return new Pair(null, new ExpressionComposer().compose(c, false));
		else
			return new Pair(value.getValue().multiply(c.getValue()), new ExpressionComposer().compose(c, false));
	}
1323144
public Object convert(String property, Object value)
    {
        if (value == null)
        {
            return defaultMap.get(property);
        }
        Class<?> type = getType(property);
        if (type == null)
        {
            throw new IllegalArgumentException(property+" unknown");
        }
        return ConvertUtil.convertTo(value, type);
    }
320589
public HierarchicalProperty getProperty(String name) throws RepositoryException
   {

      for (HierarchicalProperty p : properties)
      {
         if (p.getStringName().equals(name))
            return p;
      }
      return null;

      // if ("jcr:primaryType".equals(name) || "jcr:mixinTypes".equals(name) ||
      // "jcr:data".equals(name)
      // || "jcr:uuid".equals(name))
      // return null;
      //
      // String value;
      // try {
      // value = node.getProperty(name).getString();
      // } catch (PathNotFoundException e) {
      // return null;
      // }
      // String ns = ((ExtendedSession) node.getSession()).getLocationFactory()
      // .parseJCRName(name)
      // .getNamespace();
      // return new HierarchicalProperty(name, value, ns);

   }
118756
@SuppressWarnings("unchecked")
    public static <S extends Storable> ChainedProperty<S> get(StorableProperty<S> prime) {
        return (ChainedProperty<S>) cCanonical.put(new ChainedProperty<S>(prime, null, null));
    }
1187056
@SuppressWarnings("unchecked")
    static <S extends Storable> PropertyFilter<S> getCanonical(PropertyFilter<S> filter,
                                                               int bindID)
    {
        if (filter.mBindID == bindID) {
            return filter;
        }
        return (PropertyFilter<S>) cCanonical
            .put(new PropertyFilter<S>(filter.getChainedProperty(),
                                       filter.getOperator(), bindID, filter.mConstant));
    }
278379
@Override
	public synchronized T get() {
		@Nullable T checkedObject = this.object;

		if (checkedObject == null) {
			this.object = checkedObject = Objects.requireNonNull(this.initializer.get());
		}
		return checkedObject;
	}
910949
@NullableDecl
  private Throwable rootCause() {
    for (Step step : steps) {
      if (!step.isCheckCall() && step.subject.actual() instanceof Throwable) {
        return (Throwable) step.subject.actual();
      }
    }
    return null;
  }
555239
private static Object getPluginImplementationViaProperty(Class<?> pluginClass) {
		String className = pluginClass.getCanonicalName();
		if (className == null) {
			throw new IllegalArgumentException("Class " + pluginClass + " does not have a canonical name!");
		}
		// Check system properties for plugin class.
		// This will only happen during system startup thus it's okay to use the synchronized
		// System.getProperties as it will never get called in normal operations.
		String implementingClass = System.getProperty(PROPERTY_PREFIX + className);
		if (implementingClass != null) {
			try {
				Class<?> cls = Class.forName(implementingClass);
				// narrow the scope (cast) to the type we're expecting
				cls = cls.asSubclass(pluginClass);
				return cls.newInstance();
			} catch (ClassCastException e) {
				throw new RuntimeException(className + " implementation is not an instance of " + className + ": " + implementingClass);
			} catch (ClassNotFoundException e) {
				throw new RuntimeException(className + " implementation class not found: " + implementingClass, e);
			} catch (InstantiationException e) {
				throw new RuntimeException(className + " implementation not able to be instantiated: " + implementingClass, e);
			} catch (IllegalAccessException e) {
				throw new RuntimeException(className + " implementation not able to be accessed: " + implementingClass, e);
			}
		} else {
			return null;
		}
	}
494038
public function getScalarEiProperty(): ?ScalarEiProperty {
		return new CommonScalarEiProperty($this, null, function ($value) {
			ArgUtils::valScalar($value, true);
			if ($value === null) return null;
			return (int) $value;
		});
	}
262334
@Override
    public Object get(String propName) {
        if (propName.equals(PROP_PRINCIPAL_NAME)) {
            return getPrincipalName();
        }
        if (propName.equals(PROP_PASSWORD)) {
            return getPassword();
        }
        if (propName.equals(PROP_REALM)) {
            return getRealm();
        }
        if (propName.equals(PROP_CERTIFICATE)) {
            return getCertificate();
        }
        return super.get(propName);
    }
1067538
public static Object handleGetProperty(Object o, String prop) throws JspCoreException {
        if (o == null) {
            throw new JspCoreException("jsp.error.beans.nullbean");
        }
        Object value = null;
        try {
            Method method = getReadMethod(o.getClass(), prop);
            value = method.invoke(o, null);
        }
        catch (Exception ex) {
            throw new JspCoreException(ex);
        }
        return value;
    }
290015
public function build(): SetEffectivePropertyValueForNodeRequest
	{
		$instance = new SetEffectivePropertyValueForNodeRequest();
		if ($this->nodeId === null) {
			throw new BuilderException('Property [nodeId] is required.');
		}
		$instance->nodeId = $this->nodeId;
		if ($this->propertyName === null) {
			throw new BuilderException('Property [propertyName] is required.');
		}
		$instance->propertyName = $this->propertyName;
		if ($this->value === null) {
			throw new BuilderException('Property [value] is required.');
		}
		$instance->value = $this->value;
		return $instance;
	}
1017764
public static JustificationBuilder getInstance() {

    if (instance == null) {
      synchronized (JustificationBuilderImpl.class) {
        if (instance == null) {
          instance = new JustificationBuilderImpl();
        }
      }
    }
    return instance;
  }
1186404
public HierarchicalProperty getProperty(String name) throws RepositoryException
   {
      if ("jcr:primaryType".equals(name) || "jcr:mixinTypes".equals(name))
         return null;

      if (content == null)
         return null;

      if (content.getProperty(name) != null)
      {
         return content.getProperty(name);
      }

      try
      {

         String value;
         Property p = node.getProperty(name);
         if (p.getDefinition().isMultiple())
         {
            if (p.getValues().length == 0)
               value = "";
            else
               value = p.getValues()[0].getString();
         }
         else
         {
            value = p.getString();
         }

         //String value = node.getProperty(name).getString();

         String ns = ((ExtendedSession)node.getSession()).getLocationFactory().parseJCRName(name).getNamespace();
         return new HierarchicalProperty(name, value, ns);
      }
      catch (PathNotFoundException e)
      {
         return null;
      }

   }