Changes the rotation value inside a rule.

@param rule the {@link Rule}.
@param newRotation the new rotation value in degrees.
543548
public static void changeRotation( Rule rule, int newRotation ) {
        PointSymbolizer pointSymbolizer = StyleUtilities.pointSymbolizerFromRule(rule);
        Graphic graphic = SLD.graphic(pointSymbolizer);
        graphic.setRotation(ff.literal(newRotation));
        // Mark oldMark = SLDs.mark(pointSymbolizer);
        // oldMark.setSize(ff.literal(newRotation));
    }
1162690
@InternalFunction(operator="=", precedence=1,isAssign=true)
    public void assign(RuleContext ruleContext, Object value, RuleProxyField target)
    {
        s_log.debug("{}assign: {} {}",new Object[]{m_indenter,target,value});
        assign(target,value,ruleContext,true);
    }
62047
public void bind(Object newValue)
    {
    	if (getValue() == null)
    	{
    		setValue(newValue);
    	}	
    	else
    	{
    		setValue2(newValue);
    		setBound(true); 		
    	}
    }
1087006
public void setCustomRules(java.util.Collection<CustomRule> customRules) {
        if (customRules == null) {
            this.customRules = null;
            return;
        }

        this.customRules = new java.util.ArrayList<CustomRule>(customRules);
    }
1319750
public void setConeInnerAngle (float angle)
    {
        if (_coneInnerAngle != angle) {
            AL10.alSourcef(_id, AL10.AL_CONE_INNER_ANGLE, _coneInnerAngle = angle);
        }
    }
72973
public void setRules(java.util.Collection<Rule> rules) {
        if (rules == null) {
            this.rules = null;
            return;
        }

        this.rules = new java.util.ArrayList<Rule>(rules);
    }
310545
public synchronized void addRule(final RuleImpl rule) throws InvalidPatternException {
        final List<TerminalNode> terminals = this.ruleBuilder.addRule( rule,
                                                                       this.kBase );

        BaseNode[] nodes = terminals.toArray( new BaseNode[terminals.size()] );
        this.rules.put( rule.getFullyQualifiedName(), nodes );
        if (rule.isQuery()) {
            this.queries.put( rule.getName(), nodes );
        }
    }
149066
public static PolygonSymbolizer polygonSymbolizerFromRule( Rule rule ) {
        List<Symbolizer> symbolizers = rule.symbolizers();
        PolygonSymbolizer polygonSymbolizer = null;
        for( Symbolizer symbolizer : symbolizers ) {
            if (symbolizer instanceof PolygonSymbolizer) {
                polygonSymbolizer = (PolygonSymbolizer) symbolizer;
                break;
            }
        }
        if (polygonSymbolizer == null) {
            throw new IllegalArgumentException();
        }
        return polygonSymbolizer;
    }
76059
public static LineSymbolizer lineSymbolizerFromRule( Rule rule ) {
        List<Symbolizer> symbolizers = rule.symbolizers();
        LineSymbolizer lineSymbolizer = null;
        for( Symbolizer symbolizer : symbolizers ) {
            if (symbolizer instanceof LineSymbolizer) {
                lineSymbolizer = (LineSymbolizer) symbolizer;
                break;
            }
        }
        if (lineSymbolizer == null) {
            throw new IllegalArgumentException();
        }
        return lineSymbolizer;
    }
95352
public void setTextRotationAlignment(@Property.TEXT_ROTATION_ALIGNMENT String value) {
    PropertyValue propertyValue = textRotationAlignment(value);
    constantPropertyUsageMap.put(PROPERTY_TEXT_ROTATION_ALIGNMENT, propertyValue);
    layer.setProperties(propertyValue);
  }
645061
public function setRule(Rule $rule)
    {
        $expectedType = $this->getRuleType();
        
        if (Reflection::isInstanceOf($rule, $expectedType) === true) {
            $this->rule = $rule;
        } else {
            $procClass = get_class($this);
            $givenType = get_class($rule);
            $msg = "The ${procClass} Rule Processor only processes ${expectedType} Rule objects, ${givenType} given.";
            throw new InvalidArgumentException($msg);
        }
    }
618610
public void setBuiltInCreativeRotationType(com.google.api.ads.admanager.axis.v201805.CreativeRotationType builtInCreativeRotationType) {
        this.builtInCreativeRotationType = builtInCreativeRotationType;
    }
968755
public static void changeMarkSize( Rule rule, int newSize ) {
        PointSymbolizer pointSymbolizer = StyleUtilities.pointSymbolizerFromRule(rule);
        Graphic graphic = SLD.graphic(pointSymbolizer);
        graphic.setSize(ff.literal(newSize));
        // Mark oldMark = SLDs.mark(pointSymbolizer);
        // oldMark.setSize(ff.literal(newSize));
        // Graphic graphic = SLDs.graphic(pointSymbolizer);
    }
1303089
public void rotate(double angle) {
        double s = Math.sin(angle);
        double c = Math.cos(angle);

        double temp1 = m00;
        double temp2 = m01;
        m00 =  c * temp1 + s * temp2;
        m01 = -s * temp1 + c * temp2;
        temp1 = m10;
        temp2 = m11;
        m10 =  c * temp1 + s * temp2;
        m11 = -s * temp1 + c * temp2;
    }
1246914
def set_rotation(rotation)
      if rotation == 270
        rotation = 255
      elsif rotation >= -90 || rotation <= 90
        rotation = -rotation + 90 if rotation < 0
      else
        raise "Rotation #{rotation} outside range: -90 <= angle <= 90"
        rotation = 0
      end

      @rotation = rotation
    end
1318371
public static function setPluralRule($rule, $locale)
    {
        // temporary set a locale for brazilian
        if ("pt_BR" == $locale) {
            $locale = "xbr";
        }
        
        if (strlen($locale) > 3) {
            $locale = substr($locale, 0, -strlen(strrchr($locale, '_')));
        }

        if (!is_callable($rule)) {
            throw new LogicException('The given rule can not be called');
        }

        self::$position_rules[$locale] = $rule;
    }
320627
public void rotate(double x, double y) {
        if (!(projection instanceof Projection3D)) {
            throw new UnsupportedOperationException("Only 3D graphics supports rotation.");
        }

        ((Projection3D) projection).rotate(x, y);
    }