inline const cpp_impl *unwrap(const wrapper *w) {                            \
    return reinterpret_cast<const cpp_impl *>(w);                              \
  }                                                                            \
                                                                               \
  inline wrapper *wrap(cpp_impl *i) { return reinterpret_cast<wrapper *>(i); } \

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.dcerpc;


/**
 * Unicode string type wrapper
 * 
 */
public class UnicodeString extends rpc.unicode_string {

    boolean zterm;


    /**
     * 
     * @param zterm
     *            whether the string should be zero terminated
     */

    checkNotNull(future);
    try {
      return getUninterruptibly(future);
    } catch (ExecutionException wrapper) {
      if (wrapper.getCause() instanceof Error) {
        throw new ExecutionError((Error) wrapper.getCause());
      }
      /*
       * It's an Exception. (Or it's a non-Error, non-Exception Throwable. From my survey of such

    WrapperException(Throwable t) {
      super(t);
    }
  }

  private static void rethrow(ExecutionException e) throws ExecutionException {
    Throwable wrapper = e.getCause();
    if (wrapper instanceof WrapperException) {
      Throwable cause = wrapper.getCause();
      if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      } else if (cause instanceof Error) {
        throw (Error) cause;

#include "tensorflow/core/framework/function.h"
#include "tensorflow/core/platform/refcount.h"
namespace tensorflow {
namespace tracing {
namespace graph {
using tensorflow::AbstractFunction;
// Thin wrapper around a FunctionDef.
class GraphFunction : public AbstractFunction {
 public:
  explicit GraphFunction(FunctionDef fdef);
  ~GraphFunction() override;

  // GraphFunction maybe stay alive for the duration of the returned

    }

    @Override
    public Map<C, Map<R, V>> columnMap() {
      Function<Map<R, V>, Map<R, V>> wrapper = unmodifiableWrapper();
      return Collections.unmodifiableMap(Maps.transformValues(super.columnMap(), wrapper));
    }

    @Override
    @CheckForNull
    public V put(
        @ParametricNullness R rowKey,
        @ParametricNullness C columnKey,

				var t T
				return &t
			},
		},
		emptySz: sz,
	}
}

func (p *JSONPool[T]) new() *T {
	var zero T
	t := p.pool.Get().(*T)
	*t = zero
	return t
}

// JSON is a wrapper around a T object that can be serialized.
// There is an internal value
type JSON[T any] struct {
	p   *JSONPool[T]
	val *T
}

// NewJSON returns a new JSONPool.
// No initial value is set.

import org.codehaus.plexus.interpolation.PrefixedValueSourceWrapper;
import org.codehaus.plexus.interpolation.QueryEnabledValueSource;

/**
 * Wraps an arbitrary object with an {@link ObjectBasedValueSource} instance, then
 * wraps that source with a {@link PrefixedValueSourceWrapper} instance, to which
 * this class delegates all of its calls.
 *

  }

  /**
   * Returns the object that originated this event (not the object that originated the
   * wrapped event). This is generally an {@link EventBus}.
   *
   * @return the source of this event.
   */
  public Object getSource() {
    return source;
  }

  /**
   * Returns the wrapped, 'dead' event, which the system was unable to deliver to any registered
   * subscriber.
   *

/**
 * <p>
 * Under normal conditions it is not necessary to use
 * this class to use jCIFS properly. Name resolusion is
 * handled internally to the <code>jcifs.smb</code> package.
 * <p>
 * This class is a wrapper for both {@link jcifs.netbios.NbtAddress}
 * and {@link java.net.InetAddress}. The name resolution mechanisms
 * used will systematically query all available configured resolution