How to use

SClass

in

org.bimserver.shared.meta

private void genProtocolBuffersToServiceInterface(PrintWriter out, String sourceName, String targetName, SClass sType, SMethod method) {
  for (SField field : sType.getAllFields()) {
    if (sType.getInstanceClass().isAssignableFrom(List.class)) {
    } else if (sType.isDate()) {
      out.println("\t\t\t\t" + targetName + ".set" + field.getName() + "(new Date(" + sourceName + "." + method.getName() + "()));");
    } else if (sType.isClass()) {
      out.println("\t\t\t\t" + targetName + ".set" + field.getName() + "(Class.forName(" + sourceName + "." + method.getName() + "()));");
    } else if (sType.isDataHandler()) {
      out.println("\t\t\t\t" + targetName + ".setFile(new DataHandler(new ByteArrayDataSource(" + sourceName + ".getFile().toByteArray(), \"\")));");
    } else if (sType.isEnum()) {
      out.println("\t\t\t\t" + targetName + ".set" + field.getName() + "(" + method.getReturnType().getName().replace("$", ".") + ".values()[" + sourceName + "."
          + method.getName() + "().ordinal()]);");
    } else {
      out.println("\t\t\t\t" + targetName + ".set" + field.getName() + "(" + sourceName + "." + method.getName() + "());");
    }
  }
}

public void addType(SClass type) {
  types.put(type.getSimpleName(), type);
  types.put(type.getName(), type);
  addRelatedTypes(type.getInstanceClass());
}

public String returnTypeToJavaCode() {
  StringBuilder sb = new StringBuilder();
  if (getGenericReturnType() != null) {
    sb.append(getReturnType().toJavaCode());
    sb.append("<");
    sb.append(getGenericReturnType().toJavaCode());
    sb.append(">");
  } else {
    sb.append(getReturnType().toJavaCode());
  }
  return sb.toString();
}

private void addSuperClass(SClass sType) {
  superClass = sType;
  for (SField field : superClass.getAllFields()) {
    allFields.put(field.getName(), field);
  }
  sType.addSubClass(this);
}

public ObjectNode toJson(ObjectMapper OBJECT_MAPPER) {
  ObjectNode result = OBJECT_MAPPER.createObjectNode();
  result.put("name", getName());
  result.put("simpleName", getSimpleName());
  result.put("simpleType", getSimpleType().name());
  ArrayNode fieldsJson = OBJECT_MAPPER.createArrayNode();
  for (SField field : ownFields.values()) {
    fieldsJson.add(field.toJson(OBJECT_MAPPER));
  }
  result.set("fields", fieldsJson);
  return result;
}

    SBase newObject = sClass.newInstance();
    for (SField field : newObject.getSClass().getAllFields()) {
      if (jsonObject.has(field.getName())) {
        newObject.sSet(field, fromJson(field.getType(), field.getGenericType(), jsonObject.get(field.getName())));
  if (definedType.isList()) {
    List<Object> list = new ArrayList<Object>();
    for (int i = 0; i < array.size(); i++) {
  } else if (definedType.isSet()) {
    Set<Object> set = new HashSet<Object>();
    for (int i = 0; i < array.size(); i++) {
} else if (definedType.isByteArray()) {
  if (object instanceof ValueNode) {
    ValueNode jsonPrimitive = (ValueNode) object;
    return Base64.decodeBase64(jsonPrimitive.asText().getBytes(Charsets.UTF_8));
} else if (definedType.isDataHandler()) {
  if (object instanceof ValueNode) {
    ValueNode jsonPrimitive = (ValueNode) object;
} else if (definedType.isInteger()) {
  if (object instanceof ValueNode) {
    return ((ValueNode) object).asInt();
} else if (definedType.isLong()) {
  if (object instanceof ValueNode) {
    return ((ValueNode) object).asLong();

private void genServiceInterfaceToProtocolBuffers(PrintWriter out, String sourceName, String targetName, SClass parameterType) {
  for (SField field : parameterType.getAllFields()) {
    SClass fieldType = field.getType();
    SClass fieldClass = fieldType;
    if (fieldClass.isList()) {
      out.println("\t\t\tfor (" + fieldType.getName() + " o : " + sourceName + "." + field.getName() + "()) {");
      out.println("\t\t\t\t" + targetName + ".add" + field.getName() + "(o);");
      out.println("\t\t\t}");
    } else if (fieldClass.isDate()) {
      out.println("\t\t\t" + targetName + ".set" + field.getName() + "(" + sourceName + "." + field.getName() + "().getTime());");
    } else if (fieldType.getInstanceClass() == byte[].class) {
      out.println("\t\t\t" + targetName + ".set" + field.getName() + "(ByteString.copyFrom(" + sourceName + "." + field.getName() + "()));");
    } else if (fieldClass.isEnum()) {
      out.println("\t\t\t" + targetName + ".set" + field.getName() + "(" + fieldType.getInstanceClass().getSimpleName() + ".values()[" + sourceName + "."
          + field.getName() + "().ordinal()]);");
    } else {
      out.println("\t\t\t" + targetName + ".set" + field.getName() + "(" + sourceName + "." + field.getName() + "());");
    }
  }
}

  out.print("\tpublic void " + sMethod.getName() + "(");
} else {
  fullResultType = sMethod.getReturnType().getName();
  if (sMethod.isAggregateReturnType()) {
    fullResultType = sMethod.getReturnType().getName() + "<" + sMethod.getGenericReturnType().getName() + ">";
    out.print(parameter.getType().getName() + "<" + parameter.getGenericType().getName() + "> " + parameter.getName() + (parameter.isLast() ? "" : ", "));
  } else {
    out.print(parameter.getType().getName() + " " + parameter.getName() + (parameter.isLast() ? "" : ", "));
  if (parameter.isAggregate()) {
    out.println("\t\t\tfor (" + parameter.getGenericType() + " val : " + parameter.getName() + ") {");
    if (parameter.getType().isPrimitive() || parameter.getType().getInstanceClass() == String.class) {
      out.println("\t\t\t\t" + parameter.getGenericType().getInstanceClass().getSimpleName() + " v = val;");
    } else {
      out.println("\t\t\t\tProtocolBuffersService." + parameter.getGenericType().getInstanceClass().getSimpleName() + " v = null;");
  } else if (parameter.getType().getInstanceClass().isAssignableFrom(DataHandler.class)) {
    out.println("\t\t\tByteString bs = ByteString.copyFrom(BinUtils.readInputStream(" + parameter.getName() + ".getInputStream()));");
    out.println("\t\t\trequestBuilder.set" + StringUtils.firstUpperCase(parameter.getName()) + "(bs);");
  } else if (parameter.getType().getInstanceClass().isPrimitive()) {
    out.println("\t\t\trequestBuilder.set" + StringUtils.firstUpperCase(parameter.getName()) + "(" + parameter.getName() + ");");
  } else if (parameter.getType().getInstanceClass().isEnum()) {
    out.println("\t\t\trequestBuilder.set" + StringUtils.firstUpperCase(parameter.getName()) + "(ProtocolBuffersService."
        + parameter.getType().getInstanceClass().getSimpleName() + ".values()[" + parameter.getName() + ".ordinal()]);");
  } else if (parameter.getType().getInstanceClass().isPrimitive() || parameter.getType().getInstanceClass() == String.class) {
    out.println("\t\t\trequestBuilder.set" + StringUtils.firstUpperCase(parameter.getName()) + "(" + parameter.getName() + ");");
  } else {
    out.println("\t\t\tProtocolBuffersService." + parameter.getType().getInstanceClass().getSimpleName() + ".Builder newVal = "

@SuppressWarnings({ "unchecked", "rawtypes" })
public Message convertSObjectToProtocolBuffersObject(SBase object, SClass definedType) throws ConvertException {
  Builder builder = null;
  MessageDescriptorContainer messageDescriptor = protocolBuffersMetaData.getMessageDescriptor(definedType.getSimpleName());
  if (messageDescriptor == null) {
    throw new ConvertException("No message descriptor found with name " + definedType.getSimpleName());
  while (superClass.getSuperClass() != null && superClass.getSuperClass().getInstanceClass() != Object.class) {
    superClass = superClass.getSuperClass();
    builder.setField(messageDescriptor.getField("__actual_type"), sClass.getSimpleName());
    builder.setField(messageDescriptor.getField("__" + sClass.getSimpleName()), convertSObjectToProtocolBuffersObject(object, sClass));
  for (SField field : definedType.getAllFields()) {
    try {
      Object value = object.sGet(field);

  return "VoidResponse";
Class<?> clazz = sType.getInstanceClass();
if (generatedClasses.containsKey(clazz)) {
  return generatedClasses.get(clazz);
} else if (clazz.isEnum()) {
  return createEnum(sb, clazz);
} else if (sType.isString()) {
  return "string";
} else {
  messageBuilder.append("message " + clazz.getSimpleName() + " {\n");
  int counter = 1;
  if (!sType.getSubClasses().isEmpty()) {
    messageBuilder.append("\trequired string __actual_type = " + (counter++) + ";\n");
    for (SClass subClass : sType.getSubClasses()) {
      messageBuilder.append('\t');
      messageBuilder.append("optional ");
      messageBuilder.append(createMessage(sb, subClass) + " __" + subClass.getInstanceClass().getSimpleName() + " = " + (counter++) + ";\n");
  for (SField field : sType.getAllFields()) {
    messageBuilder.append('\t');
    if (field.isAggregate()) {

public void addType(final Class<?> type) {
  if (!types.containsKey(type.getSimpleName())) {
    // TODO reflective constructor use can be slow
    SClass sClass = new SClass(this, type, new SConstructor(){
      @Override
      public Object newInstance() {
        try {
          return type.getConstructors()[0].newInstance();
        } catch (InstantiationException e) {
          e.printStackTrace();
        } catch (IllegalAccessException e) {
          e.printStackTrace();
        } catch (IllegalArgumentException e) {
          e.printStackTrace();
        } catch (InvocationTargetException e) {
          e.printStackTrace();
        } catch (SecurityException e) {
          e.printStackTrace();
        }
        return null;
      }});
    types.put(sClass.getSimpleName(), sClass);
    types.put(sClass.getName(), sClass);
    addRelatedTypes(type);
  }
}

for (SMethod sMethod : sService.getMethods()) {
  methodBuilder.append(" else if ($2.equals(\"" + sMethod.getName() + "\")) {");
  if (!sMethod.getReturnType().isVoid()) {
    methodBuilder.append("return ");
  int i=0;
  for (SParameter sParameter : sMethod.getParameters()) {
    methodBuilder.append("(" + sParameter.getType().toJavaCode() + ")$4[" + i + "].getValue()");
    if (i < sMethod.getParameters().size() - 1) {
      methodBuilder.append(", ");

Descriptor descriptor = message.getDescriptorForType();
if (newInstance == null) {
  newInstance = sClass.newInstance();
    sClass = sClass.getServicesMap().getSType((String)message.getField(fieldDescriptor));
    newInstance = sClass.newInstance();
  } else if (fieldDescriptor.getName().startsWith("__")) {
    if (fieldDescriptor.getName().substring(2).equals(sClass.getSimpleName())) {
      subTypeMessage = (Message) message.getField(fieldDescriptor);
    SField field = newInstance.getSClass().getField(fieldDescriptor.getName());
    if (field == null) {
      throw new ConvertException("No field on " + sClass.getName() + " with name " + fieldDescriptor.getName());
        throw new ConvertException("Field " + sClass.getName() + "." + fieldDescriptor.getName() + " should have list value");
      SField sField = sClass.getField(fieldDescriptor.getName());
      newInstance.sSet(sField, convertFieldValue(sField, val));

public SServiceType createSServiceType(SClass sClass, boolean recurse) throws UserException, ServerException {
  if (sClass == null) {
    return null;
  }
  SServiceType sServiceType = new SServiceType();
  sServiceType.setName(sClass.getName());
  sServiceType.setSimpleName(sClass.getSimpleName());
  sServiceType.setSimpleType(SServiceSimpleType.valueOf(sClass.getSimpleType().name()));
  for (SField field : sClass.getOwnFields()) {
    SServiceField sServiceField = new SServiceField();
    sServiceField.setName(field.getName());
    if (recurse) {
      sServiceField.setType(createSServiceType(field.getType(), recurse));
      sServiceField.setGenericType(createSServiceType(field.getGenericType(), recurse));
    }
    sServiceField.setDoc(field.getDoc());
    sServiceType.getFields().add(sServiceField);
  }
  return sServiceType;
}

SBase base = (SBase) object;
ObjectNode jsonObject = OBJECT_MAPPER.createObjectNode();
jsonObject.put("__type", base.getSClass().getSimpleName());
for (SField field : base.getSClass().getAllFields()) {
  jsonObject.set(field.getName(), toJson(base.sGet(field)));

public boolean isAggregate() {
  return type.getInstanceClass().isAssignableFrom(List.class) || type.getInstanceClass().isAssignableFrom(Set.class);
}

  @Override
  public int compareTo(SClass arg0) {
    return name.compareTo(arg0.getName());
  }
}

public void init() {
  try {
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SUserType"), null));
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SSIPrefix"), null));
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SObjectState"), null));
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SProject"), new SConstructor(){
      public Object newInstance() {
        return new org.bimserver.interfaces.objects.SProject();
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SUser"), new SConstructor(){
      public Object newInstance() {
        return new org.bimserver.interfaces.objects.SUser();
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SRevision"), new SConstructor(){
      public Object newInstance() {
        return new org.bimserver.interfaces.objects.SRevision();
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SConcreteRevision"), new SConstructor(){
      public Object newInstance() {
        return new org.bimserver.interfaces.objects.SConcreteRevision();
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SGeoTag"), new SConstructor(){
      public Object newInstance() {
        return new org.bimserver.interfaces.objects.SGeoTag();
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SCheckout"), new SConstructor(){
      public Object newInstance() {
        return new org.bimserver.interfaces.objects.SCheckout();
    getServicesMap().addType(new SClass(getServicesMap(), Class.forName("org.bimserver.interfaces.objects.SServerSettings"), new SConstructor(){

  stringBuffer.append(method.getGenericReturnType() != null ? (method.getReturnType().toJavaCode() + "<" + method.getGenericReturnType().toJavaCode() + ">") : method.getReturnType().toJavaCode());
  stringBuffer.append(TEXT_8);
  stringBuffer.append(method.getName());
  stringBuffer.append(parameter.getGenericType() != null ? (parameter.getType().toJavaCode() + "<" + parameter.getGenericType() + ">") : parameter.getType().toJavaCode());
  stringBuffer.append(TEXT_8);
  stringBuffer.append(parameter.getName());
if (!method.getReturnType().isVoid()) {

public List<String> getEnumLiterals(String enumName) throws UserException {
  List<String> result = new ArrayList<String>();
  SClass type = getBimServer().getServicesMap().getType(enumName);
  for (Object enumConstant : type.getInstanceClass().getEnumConstants()) {
    result.add(enumConstant.toString());
  }
  return result;
}