----- interface APIBuilder -----
165541
@Override
	public ResultTransformer createMapping(final App app, final String sourceType, final String targetType, final Map<String, String> propertyMappings, final Map<String, String> transforms) throws FrameworkException {

		try (final Tx tx = app.tx()) {

			final VirtualType type = app.create(VirtualType.class,
				new NodeAttribute<>(StructrApp.key(VirtualType.class, "sourceType"), sourceType),
				new NodeAttribute<>(StructrApp.key(VirtualType.class, "name"),       targetType)
			);

			int i = 0;

			for (final Entry<String, String> entry : propertyMappings.entrySet()) {

				final String sourceProperty = entry.getKey();
				final String targetProperty = entry.getValue();

				app.create(VirtualProperty.class,
					new NodeAttribute<>(StructrApp.key(VirtualProperty.class, "virtualType"),   type),
					new NodeAttribute<>(StructrApp.key(VirtualProperty.class, "sourceName"),    sourceProperty),
					new NodeAttribute<>(StructrApp.key(VirtualProperty.class, "targetName"),    targetProperty),
					new NodeAttribute<>(StructrApp.key(VirtualProperty.class, "position"),      i++),
					new NodeAttribute<>(StructrApp.key(VirtualProperty.class, "inputFunction"), transforms.get(sourceProperty))
				);
			}

			tx.success();

			return type;
		}
	}
355588
@Nonnull
	public static <T, R> LObjIntLongFunctionBuilder<T, R> objIntLongFunction(Consumer<LObjIntLongFunction<T, R>> consumer) {
		return new LObjIntLongFunctionBuilder(consumer);
	}
903898
@Nonnull
	public static <T> LOiToIntFunction<T> oiToIntFunctionFrom(Consumer<LOiToIntFunctionBuilder<T>> buildingFunction) {
		LOiToIntFunctionBuilder builder = new LOiToIntFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
453507
static void addToObject(final JsonObjectBuilder builder, final String key, final String type, final Function<String, javax.json.JsonValue> defaultBehavior) {
        if (STRING.equals(type)) {
            builder.add(key, "string");
            return;
        }

        if (BOOLEAN.equals(type) || PRIMITIVE_BOOLEAN.equals(type)) {
            builder.add(key, false);
            return;
        }

        // TODO
//        if (INTEGER_TYPES.contains(type)) {
//            builder.add(key, 0);
//            return;
//        }
//
//        if (DOUBLE_TYPES.contains(type)) {
//            builder.add(key, 0.0);
//            return;
//        }
//
//        // plain-old date and JSR-310
//        if (type.isAssignableTo(DATE) || type.isAssignableTo(TEMPORAL_ACCESSOR)) {
//            builder.add(key, "date");
//            return;
//        }
//
//        if (type.isAssignableTo(MAP)) {
//            builder.add(key, Json.createObjectBuilder().build());
//            return;
//        }

        // fall-back
        builder.add(key, defaultBehavior.apply(type));
    }
378430
@Nonnull
	public static <T, R> LObjIntSrtFunctionBuilder<T, R> objIntSrtFunction(Consumer<LObjIntSrtFunction<T, R>> consumer) {
		return new LObjIntSrtFunctionBuilder(consumer);
	}
982776
@CheckReturnValue
  public <NewReqT, NewRespT> Builder<NewReqT, NewRespT> toBuilder(
      Marshaller<NewReqT> requestMarshaller, Marshaller<NewRespT> responseMarshaller) {
    return MethodDescriptor.<NewReqT, NewRespT>newBuilder()
        .setRequestMarshaller(requestMarshaller)
        .setResponseMarshaller(responseMarshaller)
        .setType(type)
        .setFullMethodName(fullMethodName)
        .setIdempotent(idempotent)
        .setSafe(safe)
        .setSampledToLocalTracing(sampledToLocalTracing)
        .setSchemaDescriptor(schemaDescriptor);
  }
78115
@Override
  public <T> ServiceRef.ServiceBuilder service(Class<T> serviceClass)
  {
    Objects.requireNonNull(serviceClass);

    validator().serviceClass(serviceClass);

    Key<?> key = Key.of(serviceClass, ServiceImpl.class);

    ServiceBuilderWebImpl service
      = new ServiceBuilderWebImpl(this, key, serviceClass);

    _includes.add(service);

    return service;
  }
190648
MethodBuilder getMethoddBuilder(Element element) {
        MethodBuilder methodBuilder = new MethodBuilder(messager, element);
        methodBuilder.setBindingManager(this);
        return methodBuilder;
    }
830557
public static <T> SerializerBinderBuilder<T> builderOf(Binder binder, final Class<T> type) {
        return new SerializerBinderBuilderImpl<T> (binder, new TypeReference<T>() {
            @Override
            public Type getType() {
                return type;
            }
        });
    }
803988
@Nonnull
	public static <T, R> LObjFltFunctionBuilder<T, R> objFltFunction(Consumer<LObjFltFunction<T, R>> consumer) {
		return new LObjFltFunctionBuilder(consumer);
	}
258177
@Nonnull
	public static <T1, T2, R> LBiObjBoolFunction<T1, T2, R> biObjBoolFunctionFrom(Consumer<LBiObjBoolFunctionBuilder<T1, T2, R>> buildingFunction) {
		LBiObjBoolFunctionBuilder builder = new LBiObjBoolFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
1064674
@Nonnull
	public static <T1, T2, R> LBiObjIntFunctionBuilder<T1, T2, R> biObjIntFunction() {
		return new LBiObjIntFunctionBuilder();
	}
364520
function parameterBuilder(paramName) {
    // 
    return function (key) {
        // console.log("Declaration");
        // console.log({ key:key});
        // 
        return function (target, propertyKey, parameterIndex) {
            // console.log("Instance");
            // console.log({ key:key, propertyKey: propertyKey,parameterIndex: parameterIndex });
            target.methods = target.methods || {};
            var a = target.methods[propertyKey];
            if (!a) {
                a = [];
                target.methods[propertyKey] = a;
            }
            a[parameterIndex] = new WebAtoms.Rest.ServiceParameter(paramName, key);
        };
    };
}
1266251
private static void generateOptionsFromBuilderApi(Class<?> apiNode, Set<Class<?>> processedApiNodes, List<CliDeclaredOptionSpec> cliOptionsFoundSoFar) {
		if (processedApiNodes.contains(apiNode)) {
			return;
		}
		
		processedApiNodes.add(apiNode);
		
		for (Method m : ClassUtils.collectMethods(apiNode, apiNode, of(MethodModifier.PUBLIC))) {
			if (methodIsCliCompatible(m)) {
				final String optionName = determineCliOptionName(apiNode, m);
				LOGGER.debug("option {} found for {}.{}({})", optionName, apiNode.getSimpleName(), m.getName(), m.getParameterTypes());
				
				// assertion check
				for (CliDeclaredOptionSpec knownOption : cliOptionsFoundSoFar) {
					if (knownOption.getName().equals(optionName)) {
						String msg = "@CliOptionNameOverride needed one of the following two methods:\n\t%s\n\t%s\n\t----------";
						throw new AssertionError(format(msg, knownOption.getSourceMethod(), m));
					}
				}
				
				cliOptionsFoundSoFar.add(new CliDeclaredOptionSpec(
						optionName,
						TherapiJavadocHelper.determineCliOptionDescriptions(m),
						getArgumentsForCliOption(m),
						apiNode.getAnnotation(Cli.BuilderApiNode.class).builderApiType(),
						m));
				Class<?> potentialNestedApiNode = m.getReturnType();
				if (potentialNestedApiNode.isAnnotationPresent(Cli.BuilderApiNode.class)) {
					generateOptionsFromBuilderApiChain(potentialNestedApiNode, processedApiNodes, cliOptionsFoundSoFar);
				}
			} else {
				LOGGER.debug("Method not CLI compatible: {}.{}({})", apiNode.getSimpleName(), m.getName(), Arrays.toString(m.getParameterTypes()));
			}
		}
	}
1261363
static String getInterfaceSignature(String[] interfaces, String apiName) {
        StringBuilder signature = new StringBuilder("<T::L" + XsdSupportingStructure.elementType + "<TT;TZ;>;Z::" + XsdSupportingStructure.elementTypeDesc + ">" + JAVA_OBJECT_DESC);

        if (interfaces != null){
            for (String anInterface : interfaces) {
                signature.append("L")
                        .append(getFullClassTypeName(anInterface, apiName))
                        .append("<TT;TZ;>;");
            }
        }

        return signature.toString();
    }
266888
@SuppressWarnings("unchecked")
    public <T> ProcessorBuilder<T> resolve(final Class<T> type) {
        
        ProcessorBuilder<?> builder = builderMap.get(type);
        if(builder == null && Enum.class.isAssignableFrom(type)) {
            // 列挙型の場合は、具象化されたクラスタイプである必要があるため、別途取得する
            builder = builderMap.get(Enum.class);
        }
        
        return (ProcessorBuilder<T>) builder;
    }
1186207
public <T> JsonBuilder registerTypeAdapter(Class<T> clazz, TypeAdapter<T> typeAdapter) {
        typeAdapters.registerTypeAdapter(clazz, typeAdapter);
        return this;
    }