Interface MutableConfigurationPropertyModel

    • Method Detail

      • getModelSnapshot

        ConfigurationPropertyModel getModelSnapshot()
        Returns a serializable, non-mutable version of the model appropriate for sending to the designer or remote gateways.
      • addProperties

        void addProperties​(java.util.Collection<Property<?>> properties)
        Registers properties that are always editable.
      • addProperties

        default void addProperties​(Property<?>... properties)
      • removeProperties

        void removeProperties​(java.util.Collection<Property<?>> properties)
        Unregisters tag properties. Only affects properties registered by registerProperties.
      • removeProperties

        default void removeProperties​(Property<?>... properties)
      • addClassifiedProperties

        void addClassifiedProperties​(java.lang.String classification,
                                     Property<?> keyProp,
                                     java.util.Collection<Property<?>> properties)
        Registers a set of properties that would be available for a given value of a certain classification. This is typically used for properties registered by extension points. The type id is the "class", and then as profiles are added and removed, they are registered/unregistered with registerClassifiedValue.
      • addClassifiedValue

        <T> void addClassifiedValue​(java.lang.String classification,
                                    Property<T> keyProp,
                                    T value)
        Links a particular value to a given classification. This value will become one of the allowed values for the property, and then the properties registered for the classification will become available when the value is selected.
      • removeClassifiedProperties

        void removeClassifiedProperties​(java.lang.String classification,
                                        Property<?> keyProp)
      • removeClassifiedValue

        <T> void removeClassifiedValue​(java.lang.String classification,
                                       Property<T> keyProp,
                                       T value)
      • addResourceValue

        <T> void addResourceValue​(java.lang.String id,
                                  T... value)
        Resource values are a type of value that multiple properties can share. The are registered here, and then separately a property must be set to use a resource value type with setResourceValueSource(id). An example of this would be Tag Groups- multiple properties use them. This function adds available values to anything that was already registered.
      • setResourceValues

        <T> void setResourceValues​(java.lang.String id,
                                   java.util.Collection<T> values)
        Resource values are a type of value that multiple properties can share. The are registered here, and then separately a property must be set to use a resource value type with setResourceValueSource(id). An example of this would be Tag Groups- multiple properties use them. This function sets the available values, replacing anything that was previously registered.
      • addDependantProperties

        default <T> void addDependantProperties​(Property<T> prop,
                                                T value,
                                                Property<?>... properties)
        Registers properties that are only available if the specified property is equal to the given value.
      • addDependantProperties

        default <T> void addDependantProperties​(Property<T> prop,
                                                T value,
                                                java.util.Collection<Property<?>> properties)
        Registers properties that are only available if the specified property is equal to the given value.
      • addDependantProperties

        <T> void addDependantProperties​(Property<T> prop,
                                        java.util.Collection<T> values,
                                        java.util.Collection<Property<?>> properties)
        Same as single-value registerDependentProperties, but when multiple values are valid. Slightly more efficient than registering each value independently.
      • removeDependantProperties

        <T> void removeDependantProperties​(Property<T> prop,
                                           T value)
        Removes all dependant properties for the given value.
      • setAllowedValues

        <T> void setAllowedValues​(Property<T> property,
                                  java.util.List<T> values)
        Registers a set of allowed values for the given property. If values are already defined, they will be replaced. If the property is a string type, the empty string option will automatically be added. This function is primarily used by string options that want to allow selection from a list of profiles, or objects. Often these properties allow "" but don't provide it as a value from their model. If you really want to not allow the empty option, you can call setAllowedValues(p, null), and then call registerAllowedValues(...) with the values you want.
      • setResourceValueSource

        <T> void setResourceValueSource​(Property<T> property,
                                        java.lang.String id)
        Sets a "resource type" as the value source. These are values that are registered through add/setResourceValue.
      • registerAllowedValues

        <T> void registerAllowedValues​(Property<T> property,
                                       java.util.List<T> values)
        Registers a set of allowed values for the given property. If values are already defined, these will be added to them.
      • setAllowCustomValue

        void setAllowCustomValue​(Property<?> property,
                                 boolean value)
        Marks whether or not a property that has allowed values is also customizable.
      • markImmutable

        void markImmutable​(Property<?> property)
        This effectively excludes a property from ever being "applicable". However, it's still used to evaluate dependencies. Therefore, it's used when we want sets of properties to be dependent on a value that should not be changed through any sort of editing UI.