Writes the message with an additional target origin.
330964
public void writeMessage( Writer writer, String targetOrigin ) throws IOException
	{
		writeMessage( writer, messageFormatter, targetOrigin );
	}
637900
def set_origin(self, origin=None):
        """"""
        if origin:
            self._origin = origin.encode()
        else:
            self._origin = None
371340
public static void appendLocusTadAndGeneIDToMessage(Feature feature, ValidationMessage<Origin> message) {
        if (SequenceEntryUtils.isQualifierAvailable(Qualifier.LOCUS_TAG_QUALIFIER_NAME, feature)) {
            Qualifier locusTag = SequenceEntryUtils.getQualifier(Qualifier.LOCUS_TAG_QUALIFIER_NAME, feature);
            if (locusTag.isValue()) {
                message.appendCuratorMessage("locus tag = " + locusTag.getValue());
            }
        }

        if (SequenceEntryUtils.isQualifierAvailable(Qualifier.GENE_QUALIFIER_NAME, feature)) {
            Qualifier geneName = SequenceEntryUtils.getQualifier(Qualifier.GENE_QUALIFIER_NAME, feature);
            if (geneName.isValue()) {
                message.appendCuratorMessage("gene = " + geneName.getValue());
            }
        }
    }
940366
public static void writeToMemory(byte[] src, Object target, long targetOffset) {
    Platform.copyMemory(src, Platform.BYTE_ARRAY_OFFSET, target, targetOffset, src.length);
  }
155791
def set_origin(self, offset):
        """"""
        offset = np.array(offset)
        for node in self.worldbody.findall("./*[@pos]"):
            cur_pos = string_to_array(node.get("pos"))
            new_pos = cur_pos + offset
            node.set("pos", array_to_string(new_pos))
108645
public function write($source, string $target): void
    {
        $source->move(\dirname($target), basename($target));
    }
740300
def put(self, message, indent=0):
        '''
        
        '''
        color = self._colors_conf.get(indent + indent % 2, self._colors_conf.get(0, self._default_color))

        for chunk in [' ' * indent, self._colors[color], message, self._colors['ENDC']]:
            self._device.write(str(chunk))
        self._device.write(os.linesep)
        self._device.flush()
1227384
@Override
    public void writeContent(XMLExtendedStreamWriter writer, Resource value) throws XMLStreamException {

        if(value != null && this != value) {
            throw new IllegalStateException("Wrong target resource.");
        }

        writer.writeStartElement(ModuleConfigImpl.RESOURCE_ROOT);
        writer.writeAttribute(ModuleConfigImpl.PATH, path);
        writer.writeEndElement();
    }
58660
def send(self, message):
        
        message.update(self._globalFields)
        errors = []
        for dest in self._destinations:
            try:
                dest(message)
            except:
                errors.append(sys.exc_info())
        if errors:
            raise _DestinationsSendError(errors)
934223
function(localeCode, data) {
        var localeMessages = messages[localeCode];
        var originData, newData;

        if (!localeMessages && !data) {
            throw new Error('You should set messages to map the locale code.');
        }

        newData = flattenMessageMap(data);

        if (localeMessages) {
            originData = flattenMessageMap(localeMessages);
            messageMap = _.extend(originData, newData);
        } else {
            messageMap = newData;
        }
    }
84899
public void writeTo(Writer target, boolean flushTarget, boolean emptyAfter) throws IOException {
        if (target instanceof GrailsWrappedWriter) {
            GrailsWrappedWriter wrappedWriter = ((GrailsWrappedWriter)target);
            if (wrappedWriter.isAllowUnwrappingOut()) {
                target = wrappedWriter.unwrap();
            }
        }
        if (target == writer) {
            throw new IllegalArgumentException("Cannot write buffer to itself.");
        }
        if (!emptyAfter && target instanceof StreamCharBufferWriter) {
            ((StreamCharBufferWriter)target).write(this, null);
            return;
        } else if (writeToEncodedAppender(this, target, writer.getEncodedAppender(), true)) {
            if (emptyAfter) {
                emptyAfterReading();
            }
            if (flushTarget) {
                target.flush();
            }
            return;
        }
        writeToImpl(target, flushTarget, emptyAfter);
    }
844324
function(file, targetPath) {
		rigger(
			file,
			{ output: targetPath},
			function(error, content) {
				if (error) {
					console.log(error);
					return;
				}
				fs.writeFile(targetPath, content, 'utf8');
			}
		);
	}
804350
public static <T> void writeTo(XMLStreamWriter writer, T message, Schema<T> schema)
            throws IOException, XMLStreamException, XmlOutputException
    {
        writer.writeStartElement(schema.messageName());

        schema.writeTo(new XmlOutput(writer, schema), message);

        writer.writeEndElement();
    }
971674
public static <Message extends PMessage<Message, Field>, Field extends PField>
    int writeMessage(BigEndianBinaryWriter writer, Message message)
            throws IOException {
        if (message instanceof BinaryWriter) {
            return ((BinaryWriter) message).writeBinary(writer);
        }

        int len = 0;
        if (message instanceof PUnion) {
            if (((PUnion) message).unionFieldIsSet()) {
                PField field = ((PUnion) message).unionField();
                len += writeFieldSpec(writer, forType(field.getDescriptor().getType()), field.getId());
                len += writeFieldValue(writer,
                                       message.get(field.getId()),
                                       field.getDescriptor());
            }
        } else {
            for (PField field : message.descriptor().getFields()) {
                if (message.has(field.getId())) {
                    len += writeFieldSpec(writer, forType(field.getDescriptor().getType()), field.getId());
                    len += writeFieldValue(writer,
                                           message.get(field.getId()),
                                           field.getDescriptor());
                }
            }
        }
        len += writer.writeUInt8(BinaryType.STOP);
        return len;
    }
1004101
def writemessage(self, text):
        """"""
        # Need to grab the input queue lock to ensure the entered data doesn't change
        # before we're done rebuilding it.
        # Note that writemessage will eventually call writecooked
        self.IQUEUELOCK.acquire()
        TelnetHandlerBase.writemessage(self, text)
        self.IQUEUELOCK.release()
580751
public static OriginIdElement addOriginId(Message message) {
        OriginIdElement originId = new OriginIdElement();
        message.addExtension(originId);
        // TODO: Find solution to have both the originIds stanzaId and a nice to look at incremental stanzaID.
        // message.setStanzaId(originId.getId());
        return originId;
    }
949210
public Writer writeTo(Writer target) throws IOException {
        writeTo(target, false, false);
        return target;
    }