<p>adapt.</p>

@param append a {@link Append} object.
@return a {@link ReadModifyWriteRow} object.
356392
public ReadModifyWriteRow adapt(Append append) {
    ReadModifyWriteRow readModifyWriteRow = ReadModifyWriteRow
        .create(bigtableTableName.getTableId(), ByteString.copyFrom(append.getRow()));
    Adapters.APPEND_ADAPTER.adapt(append, readModifyWriteRow);
    return readModifyWriteRow;
  }
140839
public static <T> Set<T> append(Set<T> readonly, T obj)
    {
        Set<T> writable = readonly != null ? new HashSet<>(readonly) : new HashSet<>();

        writable.add(obj);

        return writable;
    }
430531
Append append(String format, Object... args) {
    return append(String.format(format, args));
  }
598945
public static String[] appendToAll(String append, String[] appendTo) {
        if (append == null) {
            throw new IllegalArgumentException("Method argument append must not be null.");
        }
        if (appendTo == null) {
            throw new IllegalArgumentException("Method argument to must not be null.");
        }

        String[] result = new String[appendTo.length];
        for (int i = 0; i  < appendTo.length; ++i) {
            result[i] = appendTo[i] == null ? null : appendTo[i] + append;
        }

        return result;
    }
64892
protected void append(String v) {
        try {
            writer.write(v);
        } catch (Exception e) {
            throw MwsUtl.wrap(e);
        }
    }
508280
private JSONWriter append(String s) throws JSONException {

        if (s == null) {
            throw new JSONException("Null pointer");
        }
        if ((m_mode == 'o') || (m_mode == 'a')) {
            try {
                if (m_comma && (m_mode == 'a')) {
                    m_writer.write(',');
                }
                m_writer.write(s);
            } catch (IOException e) {
                throw new JSONException(e);
            }
            if (m_mode == 'o') {
                m_mode = 'k';
            }
            m_comma = true;
            return this;
        }
        throw new JSONException("Value out of sequence.");
    }
905552
public static Writer append(Writer writer, String string) {
        try {
            writer.append(string);
            writer.flush();
            return writer;
        } catch (IOException e) {
            return JMExceptionManager.handleExceptionAndReturn(log, e,
                    "append", () -> writer, string);
        }
    }
391847
private static Writer getWriter(final File aFile) throws FileNotFoundException {
        try {
            return new OutputStreamWriter(new FileOutputStream(aFile), StandardCharsets.UTF_8.name());
        } catch (final java.io.UnsupportedEncodingException details) {
            throw new UnsupportedEncodingException(details, StandardCharsets.UTF_8.name());
        }
    }
291294
public ExtendedOutputStreamWriter append(double d) throws IOException {
        super.append(String.format(Locale.ROOT, doubleFormat, d));
        return this;
    }
727273
@Override
    public Writer append(CharSequence csq, int start, int end) throws IOException {
        encodedAppender.append(encoder, null, csq, 0, end - start);
        return this;
    }
1360470
public final <A extends Appendable> A appendTo(A appendable, Object[] parts) throws IOException {
    return appendTo(appendable, Arrays.asList(parts));
  }
229627
private int writeExtensions(
      TypeElement type,
      ExtensionContext context,
      ImmutableList<AutoValueExtension> applicableExtensions) {
    int writtenSoFar = 0;
    for (AutoValueExtension extension : applicableExtensions) {
      String parentFqName = generatedSubclassName(type, writtenSoFar + 1);
      String parentSimpleName = TypeSimplifier.simpleNameOf(parentFqName);
      String classFqName = generatedSubclassName(type, writtenSoFar);
      String classSimpleName = TypeSimplifier.simpleNameOf(classFqName);
      boolean isFinal = (writtenSoFar == 0);
      String source = extension.generateClass(context, classSimpleName, parentSimpleName, isFinal);
      if (source != null) {
        source = Reformatter.fixup(source);
        writeSourceFile(classFqName, source, type);
        writtenSoFar++;
      }
    }
    return writtenSoFar;
  }
635123
public void appendTo(Appendable app) throws IOException {
        app.append("{properties=[");
        int length = mProperties.length;
        for (int i=0; i<length; i++) {
            if (i > 0) {
                app.append(", ");
            }
            app.append(mDirections[i].toCharacter());
            app.append(mProperties[i].getName());
        }
        app.append(']');
        app.append(", unique=");
        app.append(String.valueOf(isUnique()));
        app.append('}');
    }
315485
@Override
	public Appendable append(CharSequence csq, int start, int end) {
		final int otherLen = end - start;
		grow(this.len + otherLen);
		for (int pos = start; pos < end; pos++) {
			this.value[this.len + pos] = csq.charAt(pos);
		}
		this.len += otherLen;
		return this;
	}
1186961
public RowMutation adapt(Put put) {
    RowMutation rowMutation = newRowMutationModel(put.getRow());
    adapt(put, rowMutation);
    return rowMutation;
  }
678626
OutputStream append(String src, int buffersize, Progressable progress
      ) throws IOException {
    checkOpen();
    clearFileStatusCache();

    FileStatus stat = null;
    LocatedBlock lastBlock = null;
    boolean success = false;
    
    try {
      stat = getFileInfo(src);
      if (namenodeProtocolProxy != null
            && namenodeProtocolProxy.isMethodSupported(
                "appendAndFetchOldGS", String.class, String.class)) {
        LocatedBlockWithOldGS loc = namenode.appendAndFetchOldGS(src, 
            clientName);
        lastBlock = loc;
        if (loc != null) {
          updateNamespaceIdIfNeeded(loc.getNamespaceID());
          updateDataTransferProtocolVersionIfNeeded(loc.getDataProtocolVersion());
          getNewNameNodeIfNeeded(loc.getMethodFingerPrint());
        }
      } else if (namenodeProtocolProxy != null 
               && dataTransferVersion >= DataTransferProtocol.APPEND_BLOCK_VERSION) {
        // fail the request if the data transfer version support the new append 
        // protocol, but the namenode method is not supported.
        // This should not happen unless there is a bug.
        throw new IOException ("DataTransferVersion " + dataTransferVersion +
              "requires the method appendAndFetchOldGS is supported in Namenode");
      } else if (namenodeProtocolProxy != null
          && namenodeProtocolProxy.isMethodSupported(
              "appendAndFetchMetaInfo", String.class, String.class)) {
        LocatedBlockWithMetaInfo loc = namenode.appendAndFetchMetaInfo(src,
            clientName);
        lastBlock = loc;
        if (loc != null) {
          updateNamespaceIdIfNeeded(loc.getNamespaceID());
          updateDataTransferProtocolVersionIfNeeded(loc.getDataProtocolVersion());
          getNewNameNodeIfNeeded(loc.getMethodFingerPrint());
        }
      } else {
        lastBlock = namenode.append(src, clientName);
      }

      OutputStream result = new DFSOutputStream(this, src, buffersize, progress,
          lastBlock, stat, conf.getInt("io.bytes.per.checksum", 512), namespaceId);
      leasechecker.put(src, result);
      success = true;

      return result;
    } catch(RemoteException re) {
      throw re.unwrapRemoteException(FileNotFoundException.class,
                                     AccessControlException.class,
                                     NSQuotaExceededException.class,
                                     DSQuotaExceededException.class);
    } finally {
      if (!success) {
        try {
          namenode.abandonFile(src, clientName);
        } catch (RemoteException e) {
          if (e.unwrapRemoteException() instanceof LeaseExpiredException) {
            LOG.debug(String.format(
              "client %s attempting to abandon file %s which it does not own",
              clientName, src), 
              e
            );
          } else {
            throw e;
          }
        }
      }
    }
  }
1093930
public MarkdownDocStream append(CharSequence p, int start, int end) {
    for(int pos = start; pos < end; ++pos) {
      final char c = p.charAt(pos);
      if(c == '\r') {
        continue;
      }
      append(c); // Uses \n magic.
    }
    return this;
  }