@Override
  public int hashCode() {
    int hash = type.name().hashCode();
    if (ofType != null) {
      hash += ofType.name().hashCode();
    }

    if (name != null) {
      hash += name.hashCode();
    }

    return hash;
  }
 private int getIndexOfType(String msg, Type t) {
   if (msg == null) {
     return 0;
   }
   String typeString = "%" + t.name().toLowerCase();
   return StringUtils.indexOf(msg, typeString);
 }
    @Override
    public Uri generateJsonUri() {

      Uri.Builder builder = new Uri.Builder();
      builder.scheme(Constants.Reddit.getScheme()).authority(Constants.Reddit.getDomain());

      builder.appendEncodedPath("user");
      builder.appendPath(user);
      builder.appendEncodedPath(type.name().toLowerCase());

      if (before != null) {
        builder.appendQueryParameter("before", before);
      }

      if (after != null) {
        builder.appendQueryParameter("after", after);
      }

      if (limit != null) {
        builder.appendQueryParameter("limit", String.valueOf(limit));
      }

      builder.appendEncodedPath(".json");

      return builder.build();
    }
Example #4
0
 public JSONObject toJSON() throws JSONException {
   final JSONObject root = new JSONObject();
   root.put("type", type.name());
   root.put("name", LengthUtils.safeString(name, "auto"));
   root.put("timestamp", SDF.format(timestamp));
   return root;
 }
 // @see org.jgroups.protocols.Executing#sendToCoordinator(org.jgroups.protocols.Executing.Type,
 // long, org.jgroups.Address)
 @Override
 protected void sendToCoordinator(Type type, final long requestId, final Address value) {
   if (is_coord) {
     if (log.isTraceEnabled())
       log.trace(
           "[redirect] <--> ["
               + local_addr
               + "] "
               + type.name()
               + " ["
               + value
               + (requestId != -1 ? " request id: " + requestId : "")
               + "]");
     switch (type) {
       case RUN_REQUEST:
         handleTaskRequest(requestId, value);
         break;
       case CONSUMER_READY:
         handleConsumerReadyRequest(requestId, value);
         break;
       case CONSUMER_UNREADY:
         handleConsumerUnreadyRequest(requestId, value);
         break;
     }
     ;
   } else sendRequest(coord, type, requestId, value);
 }
 private void throwIfSwipeToDeleteEnabled() {
   if (!swipeToDelete) {
     return;
   }
   throw new IllegalStateException(
       "SwipeToDelete not supported with this layout type: " + type.name());
 }
Example #7
0
 protected static String calcLabel(ValueDescriptor descriptor) {
   final ValueDescriptorImpl valueDescriptor = (ValueDescriptorImpl) descriptor;
   final Value value = valueDescriptor.getValue();
   if (value instanceof ObjectReference) {
     if (value instanceof StringReference) {
       return ((StringReference) value).value();
     } else if (value instanceof ClassObjectReference) {
       ReferenceType type = ((ClassObjectReference) value).reflectedType();
       return (type != null) ? type.name() : "{...}";
     } else {
       final ObjectReference objRef = (ObjectReference) value;
       final Type type = objRef.type();
       if (type instanceof ClassType && ((ClassType) type).isEnum()) {
         final String name = getEnumConstantName(objRef, (ClassType) type);
         if (name != null) {
           return name;
         } else {
           return type.name();
         }
       } else {
         return "";
       }
     }
   } else if (value == null) {
     //noinspection HardCodedStringLiteral
     return "null";
   } else {
     return DebuggerBundle.message("label.undefined");
   }
 }
Example #8
0
    public String evaluate(Program pgm, Variables vars, Instruction inst) throws Exception {
      Object[] objs = Bit.getObjects(pgm, vars, inst, 1);
      String type = objs[0].toString();
      String msg = "";
      for (int i = 1; i < objs.length; i++) {
        msg += objs[i].toString();
      }
      Type t = null;
      try {
        t = Type.valueOf(type);
      } catch (Exception e) {
        Bit.error(inst, "Invalid type, first parameter must be the type");
      }
      if (t == null) Bit.error(inst, "First parameter must be the type");

      String i;
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      System.out.print(msg);
      i = br.readLine();
      while (!t.isValidValue(i)) {
        System.out.println("The value must be a valid " + t.name());
        System.out.print(msg);
        i = br.readLine();
      }

      Reference ref = new Reference();
      ref.type = t;
      ref.value = t.getObject(i, null);
      return pgm.getReferences().newReference(ref);
    }
Example #9
0
 /**
  * Creates a new Event.
  *
  * @param entityKey key of the entity bound to the event
  * @param type type of the event
  * @param comment comment
  */
 public Event(final Key entityKey, final Type type, final String comment) {
   this.entityKey = entityKey;
   this.type = type.ordinal();
   this.name = type.name();
   this.comment = comment;
   setV(1);
 }
 private Combo createTypeCombo() {
   final Combo c = new Combo(this, SWT.NONE);
   for (final Type type : Type.values()) {
     c.add(type.name());
   }
   c.select(0);
   return c;
 }
Example #11
0
 /** @return - human readable representation of the address */
 @Override
 public String toString() {
   try {
     return toSatoshiStyle(this);
   } catch (ValidationException e) {
     return network.name() + ":" + type.name() + ":" + ByteUtils.toHex(bytes);
   }
 }
 public static Type fromString(final String value) {
   Type result = null;
   for (Type type : values()) {
     if (value.equals(type.name())) {
       result = type;
     }
   }
   return result;
 }
Example #13
0
 public String toString() {
   return type.name()
       + " ["
       + lock_name
       + ", owner="
       + owner
       + (is_trylock ? ", trylock " : " ")
       + (timeout > 0 ? "(timeout=" + timeout + ")" : "" + "]");
 }
Example #14
0
 public Text(String id, String name, Type type, Date date, String notes, String language) {
   this.id = id;
   this.name = name;
   this.state = State.Created.name();
   this.type = type == null ? null : type.name();
   this.date = date;
   this.notes = notes;
   this.language = language;
 }
    private static Type _getType(String name) {
      name = StringUtil.toUpperCase(name);

      for (Type type : values()) {
        if (name.equals(type.name())) {
          return type;
        }
      }

      return Type.STRING;
    }
Example #16
0
  /** Given a Fantom type, get its stack type: 'A', 'I', 'J', etc */
  public static int toJavaStackType(Type t) {
    if (!t.isNullable()) {
      if (t == Sys.VoidType) return 'V';
      if (t == Sys.BoolType) return 'I';
      if (t == Sys.IntType) return 'J';
      if (t == Sys.FloatType) return 'D';
      if (t.isJava() && t.podName().equals("[java]")) {
        // FFI primitives
        if (t.name().equals("byte")) return 'I';
        if (t.name().equals("char")) return 'I';
        if (t.name().equals("short")) return 'I';
        if (t.name().equals("int")) return 'I';
        if (t.name().equals("float")) return 'F';

        // fail-safe
        if (t.name().equals("long")) return 'L';
        if (t.name().equals("boolean")) return 'F';
        if (t.name().equals("double")) return 'D';
      }
    }
    return 'A';
  }
Example #17
0
  private void buildTables(Index index) {
    pool = new StrongInternPool<String>();
    classTable = new TreeMap<DotName, Integer>();

    // Build the pool for all strings
    for (ClassInfo clazz : index.getKnownClasses()) {
      addClassName(clazz.name());
      if (clazz.superName() != null) addClassName(clazz.superName());

      for (DotName intf : clazz.interfaces()) addClassName(intf);

      for (Entry<DotName, List<AnnotationTarget>> entry : clazz.annotations().entrySet()) {
        addClassName(entry.getKey());

        for (AnnotationTarget target : entry.getValue()) {
          if (target instanceof FieldInfo) {
            FieldInfo field = (FieldInfo) target;
            intern(field.name());
            addClassName(field.type().name());

          } else if (target instanceof MethodInfo) {
            MethodInfo method = (MethodInfo) target;
            intern(method.name());
            for (Type type : method.args()) addClassName(type.name());

            addClassName(method.returnType().name());
          } else if (target instanceof MethodParameterInfo) {
            MethodParameterInfo param = (MethodParameterInfo) target;
            intern(param.method().name());
            for (Type type : param.method().args()) addClassName(type.name());

            addClassName(param.method().returnType().name());
          }
        }
      }
    }

    poolIndex = pool.index();
  }
 private Object read(
     DataInput objBuffer,
     Type propertyType,
     boolean array,
     UnrealPackageReadOnly.ExportEntry arrayInner,
     String structName,
     UnrealPackageReadOnly up,
     String objClass,
     String pname)
     throws IOException {
   System.out.println("\t" + objClass + "->" + pname + " [" + propertyType.name() + "]");
   return read(objBuffer, propertyType, array, arrayInner, structName, up);
 }
Example #19
0
 @Override
 public String toString() {
   return type.name()
       + "["
       + start
       + ","
       + end
       + "] "
       + value()
           .replaceAll("\r", "\\\\r")
           .replaceAll("\n", "\\\\n")
           .replaceAll(" ", "\\\\s")
           .replaceAll("\t", "\\\\t");
 }
 @Override
 public String toString() {
   if (type == Type.HARDWARE_INTERRUPT) {
     return "HW interrupt "
         + TxInterruptController.hardwareInterruptDescription[interruptNumber].symbolicName
         + " (#"
         + interruptNumber
         + "d = 0x"
         + Format.asHex(interruptNumber, 2)
         + ")";
   } else {
     return type.name();
   }
 }
Example #21
0
  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder();

    for (Type type : Type.values()) {
      if (scores[type.ordinal()] > 0) {
        if (builder.length() > 0) {
          builder.append(", ");
        }
        builder.append(String.format("%s: %f", type.name(), scores[type.ordinal()]));
      }
    }

    return builder.toString();
  }
Example #22
0
 @JsIgnore
 public Property(
     Type type,
     Object value,
     boolean reflectToAttribute,
     boolean readOnly,
     boolean notify,
     String computed,
     String observer) {
   setType(getGlobalObject(type.name()));
   setValue(value);
   setReflectToAttribute(reflectToAttribute);
   setReadOnly(readOnly);
   setNotify(notify);
   setComputed(computed);
   setObserver(observer);
 }
Example #23
0
 protected GridFSInputFile create(Type type, boolean createEmptyFile) {
   Assert.notNull(type, "Type must not be null");
   GridFSInputFile file = this.fs.createFile(getFilename(getPath()));
   JailedResourcePath parent = this.path.getParent();
   if (parent != null) {
     file.put(PARENT, parent.getUnjailedPath().toString());
   }
   file.put(RESOURCE_TYPE, type.name());
   if (createEmptyFile) {
     try {
       file.getOutputStream().close();
     } catch (IOException e) {
       throw new ResourceException(e);
     }
   }
   return file;
 }
  private static Map<String, Type> parseTestXmlWithMap(final String xPathExpr, final String xml)
      throws ParserConfigurationException, XPathExpressionException, IOException, SAXException {
    final Document document =
        DocumentBuilderFactory.newInstance()
            .newDocumentBuilder()
            .parse(new ByteArrayInputStream(xml.getBytes()));
    final XPath xPath = XPathFactory.newInstance().newXPath();
    final NodeList list =
        (NodeList) xPath.compile(xPathExpr).evaluate(document, XPathConstants.NODESET);
    final Map<String, Type> map = new HashMap<>();

    final ParserOptions options =
        ParserOptions.builder().stopOnError(true).suppressOutput(true).warningsFatal(true).build();
    document.setUserData(XmlSchemaParser.ERROR_HANDLER_KEY, new ErrorHandler(options), null);

    for (int i = 0, size = list.getLength(); i < size; i++) {
      final Type t = new SetType(list.item(i));
      map.put(t.name(), t);
    }

    return map;
  }
Example #25
0
  public QProfileChangeDto toDto() {
    QProfileChangeDto dto = new QProfileChangeDto();
    dto.setChangeType(type.name());
    dto.setProfileKey(getKey().qProfile());
    Map<String, String> data = new HashMap<>();
    data.put("key", getKey().toString());
    data.put("ruleKey", getKey().ruleKey().toString());

    parameters
        .entrySet()
        .stream()
        .filter(param -> !param.getKey().isEmpty())
        .forEach(param -> data.put("param_" + param.getKey(), param.getValue()));

    if (StringUtils.isNotEmpty(severity)) {
      data.put("severity", severity);
    }
    if (inheritance != null) {
      data.put("inheritance", inheritance.name());
    }
    dto.setData(data);
    return dto;
  }
Example #26
0
 public static String getFileName(final Type type, final Date timestamp) {
   return type.name() + "." + SDF.format(timestamp) + ".jso";
 }
 private Label createFieldTypeLabel(final Type type) {
   final Label l = new Label(this, SWT.NONE);
   l.setText(type.name());
   return l;
 }
Example #28
0
 public String name() {
   return type.name();
 }
Example #29
0
  @Override
  public String toString() {
    // Simple button - no items
    if (items.isEmpty()) {
      StringBuilder sb = new StringBuilder(renderComment()).append("<button type=\"");
      sb.append(type.name().toLowerCase());
      sb.append("\" class=\"btn");
      buttonClasses(sb);

      String classMerge = merge("class");
      if (classMerge.length() > 0) {
        sb.append(" ");
        sb.append(classMerge);
      }

      sb.append("\"");
      if (disabled) {
        sb.append(" disabled=\"disabled\"");
      }
      sb.append(attributes("class", "type", "disabled"));
      sb.append(">");
      for (Object c : content) {
        sb.append(c);
      }
      sb.append("</button>");

      if (isInputGroupButton) {
        return "<span class=\"input-group-btn\">" + sb + "</span>";
      }

      return sb.append(genLoadRemoteContentScript()).toString();
    }

    // Dropdown button
    StringBuilder sb = new StringBuilder("<div class=\"");
    if (isInputGroupButton) {
      sb.append("input-group-btn");
    } else {
      sb.append("btn-group");
    }
    if (dropup) {
      sb.append(" dropup");
    }
    sb.append("\">");
    sb.append("<button type=\"");
    sb.append(type.name().toLowerCase());
    sb.append("\" class=\"btn");
    buttonClasses(sb);
    if (!split) {
      sb.append(" dropdown-toggle");
    }

    String classMerge = merge("class");
    if (classMerge.length() > 0) {
      sb.append(" ");
      sb.append(classMerge);
    }

    sb.append("\"");
    if (disabled) {
      sb.append(" disabled=\"disabled\"");
    }

    if (!split) {
      sb.append("data-toggle=\"dropdown\"");
    }

    sb.append(attributes("class", "type", "disabled", "data-toggle"));
    sb.append(">");
    for (Object c : content) {
      sb.append(c);
    }
    if (!split) {
      sb.append(" <span class=\"caret\"></span>");
    }
    sb.append("</button>");

    if (split) {
      sb.append("<button type=\"button\" class=\"btn");
      buttonClasses(sb);
      sb.append(" dropdown-toggle\" data-toggle=\"dropdown\">");

      sb.append("<span class=\"caret\"></span>");
      sb.append("<span class=\"sr-only\">Toggle Dropdown</span>");
      sb.append("</button>");
    }

    sb.append("<ul class=\"dropdown-menu\" role=\"menu\"");
    if (forEachExpresion != null && forEachExpresion.toString().trim().length() > 0) {
      sb.append(" data-bind=\"foreach: " + forEachExpresion + "\"");
    }
    sb.append(">");
    for (DropdownItem item : items) {
      if (item instanceof Item) {
        sb.append("<li>");
        sb.append(((Item) item).content);
        sb.append("</li>");
      } else if (item instanceof Divider) {
        sb.append("<li class=\"divider\"></li>");
      } else {
        sb.append("<li class=\"dropdown-header\">");
        sb.append(((Header) item).content);
        sb.append("</li>");
      }
    }
    sb.append("</ul>");
    sb.append("</div>");

    return sb.toString();
  }
Example #30
0
 /** Given a Fantom type, get the Java type signature: fan/sys/Duration */
 public static String toJavaTypeSig(Type t) {
   return toJavaTypeSig(t.podName(), t.name(), t.isNullable());
 }