Set the Magnetic variation (in degrees) of a point.

@param contentBuffer Contains the information to put in the table
511745
public final void setMagvar(StringBuilder contentBuffer) {
        ptValues[GpxMetadata.PTMAGVAR] = Double.parseDouble(contentBuffer.toString());
    }
1341434
public void setContents(Contents contents) {
		this.contents = contents;
		if (contents != null) {
			this.tableName = contents.getId();
		} else {
			this.tableName = null;
		}
	}
767841
public void setContentType(String contentType) throws InvalidArgumentException {
    if (Strings.isNullOrEmpty(contentType)) {
      throw new InvalidArgumentException("empty content type");
    }

    this.contentType = contentType;
  }
9743
public final void setSat(StringBuilder contentBuffer) {
        ptValues[GpxMetadata.PTSAT] = Integer.parseInt(contentBuffer.toString());
    }
826472
public void setContent(IContent content)
	{
		this.content = content;
		content.setParent(this);
		content.setPosition(Position.of(15, 2));
	}
1112212
public void setContentTargeting(com.google.api.ads.admanager.axis.v201902.ContentTargeting contentTargeting) {
        this.contentTargeting = contentTargeting;
    }
983411
function ( content ) {
		// fast-fail in case of illegal data
		if ( content === null || content === undefined ) {

			throw 'Provided content is not a valid ArrayBuffer or String. Unable to continue parsing';

		}
		if ( this.logging.enabled ) console.time( 'OBJLoader2 parse: ' + this.modelName );
		this.meshBuilder.init();

		var parser = new THREE.OBJLoader2.Parser();
		parser.setLogging( this.logging.enabled, this.logging.debug );
		parser.setMaterialPerSmoothingGroup( this.materialPerSmoothingGroup );
		parser.setUseOAsMesh( this.useOAsMesh );
		parser.setUseIndices( this.useIndices );
		parser.setDisregardNormals( this.disregardNormals );
		// sync code works directly on the material references
		parser.setMaterials( this.meshBuilder.getMaterials() );

		var scope = this;
		var onMeshLoaded = function ( payload ) {
			var meshes = scope.meshBuilder.processPayload( payload );
			var mesh;
			for ( var i in meshes ) {
				mesh = meshes[ i ];
				scope.loaderRootNode.add( mesh );
			}
		};
		parser.setCallbackOnAssetAvailable( onMeshLoaded );
		var onProgressScoped = function ( text, numericalValue ) {
			scope.onProgress( 'progressParse', text, numericalValue );
		};
		parser.setCallbackOnProgress( onProgressScoped );
		var onErrorScoped = function ( message ) {
			scope._onError( message );
		};
		parser.setCallbackOnError( onErrorScoped );

		if ( content instanceof ArrayBuffer || content instanceof Uint8Array ) {

			if ( this.logging.enabled ) console.info( 'Parsing arrayBuffer...' );
			parser.parse( content );

		} else if ( typeof( content ) === 'string' || content instanceof String ) {

			if ( this.logging.enabled ) console.info( 'Parsing text...' );
			parser.parseText( content );

		} else {

			this._onError( 'Provided content was neither of type String nor Uint8Array! Aborting...' );

		}
		if ( this.logging.enabled ) console.timeEnd( 'OBJLoader2 parse: ' + this.modelName );

		return this.loaderRootNode;
	}
259989
public void setContentHandler(ContentHandler handler)
  {

    if (handler == null)
    {
      throw new NullPointerException(XSLMessages.createMessage(XSLTErrorResources.ER_NULL_CONTENT_HANDLER, null)); //"Null content handler");
    }
    else
    {
      m_outputContentHandler = handler;

      if (null == m_serializationHandler)
      {
        ToXMLSAXHandler h = new ToXMLSAXHandler();
        h.setContentHandler(handler);
        h.setTransformer(this);
        
        m_serializationHandler = h;
      }
      else
        m_serializationHandler.setContentHandler(handler);
    }
  }
819665
public void setAppContent(Component appContent) {

        m_appArea.removeAllComponents();
        if (appContent != null) {
            m_appArea.addComponent(appContent);
        }
    }
1076296
@Override
    public void setContent(InputStream data) throws IOException {
        try {
            ImageIcon image =
                    new ImageIcon(JAI
                            .create("stream",
                                    new MemoryCacheSeekableStream(data))
                            .getAsBufferedImage());
            if (m_pane == null) {
                m_label = new JLabel(image);
                m_pane = new JScrollPane(m_label);
            } else {
                m_label.setIcon(image);
            }
        } catch (Exception e) {
            throw new IOException(e.getMessage());
        }
    }
464636
public void serializeParameter(String name, Map< ? , ? > map, boolean type, ContentHandler contentHandler)
    {
        Attributes attributes;

        if (type) {
            AttributesImpl attributesImpl = new AttributesImpl();
            attributesImpl.addAttribute(null, null, "type", null, "stringmap");
            attributes = attributesImpl;
        } else {
            attributes = EMPTY_ATTRIBUTES;
        }

        startElement(name, attributes, contentHandler);
        for (Map.Entry< ? , ? > entry : map.entrySet()) {
            if (entry.getValue() != null && entry.getKey() != null) {
                serializeParameter(entry.getKey().toString(), entry.getValue().toString(), null, contentHandler);
            }
        }
        endElement(name, contentHandler);
    }
944465
public void setContent(Component newContent) {
        Component oldContent = getContent();
        if (hasContent()) {
            remove(oldContent);
        }
        add(newContent, BorderLayout.CENTER);
        firePropertyChange("content", oldContent, newContent);
    }
1045141
public void setContentRect(int width, int height, int paddingLeft, int paddingTop, int paddingRight,
                               int paddingBottom) {
        chartWidth = width;
        chartHeight = height;
        maxContentRect.set(paddingLeft, paddingTop, width - paddingRight, height - paddingBottom);
        contentRectMinusAxesMargins.set(maxContentRect);
        contentRectMinusAllMargins.set(maxContentRect);
    }
926858
public void setContentType(String contentType) {
        if (contentType == null) {
            _properties.remove(AMQP_PROP_CONTENT_TYPE);
            return;
        }
        
        _properties.put(AMQP_PROP_CONTENT_TYPE, contentType);
    }
612463
private synchronized void set( Artifact artifact, Content content )
    {
        Map<String, Map<String, Map<Artifact, Content>>> artifactMap = contents.get( artifact.getGroupId() );
        if ( artifactMap == null )
        {
            artifactMap = new HashMap<String, Map<String, Map<Artifact, Content>>>();
            contents.put( artifact.getGroupId(), artifactMap );
        }
        Map<String, Map<Artifact, Content>> versionMap = artifactMap.get( artifact.getArtifactId() );
        if ( versionMap == null )
        {
            versionMap = new HashMap<String, Map<Artifact, Content>>();
            artifactMap.put( artifact.getArtifactId(), versionMap );
        }
        Map<Artifact, Content> filesMap = versionMap.get( artifact.getVersion() );
        if ( filesMap == null )
        {
            filesMap = new HashMap<Artifact, Content>();
            versionMap.put( artifact.getVersion(), filesMap );
        }
        filesMap.put( artifact, content );
    }
907044
public void setContent(String data) {

        if (data == null) {
            data = "";
        }

        encodeInfo = "";

        switch (inputDataType) {
            case GS1:
                content = Gs1.verify(data, FNC1_STRING);
                readable = data.replace('[', '(').replace(']', ')');
                break;
            case HIBC:
                content = hibcProcess(data);
                break;
            default:
                content = data;
                break;
        }

        if (content.isEmpty() && !emptyContentAllowed) {
            throw new OkapiException("No input data");
        }

        encode();
        plotSymbol();
        mergeVerticalBlocks();
    }
1007900
public final void setHdop(StringBuilder contentBuffer) {
        ptValues[GpxMetadata.PTHDOP] = Double.parseDouble(contentBuffer.toString());
    }