Пример #1
0
  /**
   * Checks whether a type is an array. The canBeConstant flag allows or disallows it to be an array
   * of constant values.
   *
   * @param t Type
   * @param canBeConstant Can the array be constant?
   * @return Is it an array
   */
  public static boolean isArray(Type t, boolean canBeConstant) {
    if (!canBeConstant) {
      return t.equals(Type.ArrayChar) || t.equals(Type.ArrayInt);
    }

    return isArray(t, false) || t.equals(Type.ConstArrayChar) || t.equals(Type.ConstArrayInt);
  }
Пример #2
0
 /**
  * Returns a string version of the commodity type.
  *
  * <p>This method is actually unnecessary; if you just try to use Commodity.Type.WALNUT as a
  * string, you get the string "WALNUT" -- this is a property of Enums.
  *
  * @param t the commodity type you would like to turn into a string
  * @return the string version of the commodity type
  */
 public static String toString(Type t) {
   if (t.equals(Type.WALNUT)) return "Walnut";
   else if (t.equals(Type.PECAN)) return "Pecan";
   else if (t.equals(Type.ALMOND)) return "Almond";
   else if (t.equals(Type.CASHEW)) return "Cashew";
   else return "";
 }
Пример #3
0
 /**
  * Converts a non-const value to a const-value
  *
  * @param t Non-const value X
  * @return const X or None if it cannot be done
  */
 public static Type toConst(Type t) {
   if (t.equals(Type.Char)) return Type.ConstChar;
   else if (t.equals(Type.Int)) return Type.ConstInt;
   else if (t.equals(Type.ArrayChar)) return Type.ConstArrayChar;
   else if (t.equals(Type.ArrayInt)) return Type.ConstArrayInt;
   return Type.None;
 }
Пример #4
0
 /**
  * Removes an item.
  *
  * @param item The item to remove.
  * @param preferredSlot The preferred slot.
  * @param allowZero If a zero amount item should be allowed.
  * @return The number of items removed.
  */
 public int remove(Item item, int preferredSlot, boolean allowZero) {
   int removed = 0;
   if ((item.getDefinition().isStackable() || type.equals(Type.ALWAYS_STACK))
       && !type.equals(Type.NEVER_STACK)) {
     int slot = getSlotById(item.getId());
     Item stack = get(slot);
     if (stack.getCount() > item.getCount()) {
       removed = item.getCount();
       set(slot, new Item(stack.getId(), stack.getCount() - item.getCount()));
     } else {
       removed = stack.getCount();
       set(slot, allowZero ? new Item(stack.getId(), 0) : null);
     }
   } else {
     for (int i = 0; i < item.getCount(); i++) {
       int slot = getSlotById(item.getId());
       if (i == 0 && preferredSlot != -1) {
         Item inSlot = get(preferredSlot);
         if (inSlot.getId() == item.getId()) {
           slot = preferredSlot;
         }
       }
       if (slot != -1) {
         removed++;
         set(slot, null);
       } else {
         break;
       }
     }
   }
   return removed;
 }
Пример #5
0
  /**
   * Checks whether a type is const.
   *
   * @param t Type
   * @param isArray Is it an array or not
   * @return It does the checking
   */
  public static boolean isConst(Type t, boolean isArray) {
    if (isArray) {
      return t.equals(Type.ConstArrayChar) || t.equals(Type.ConstArrayInt);
    }

    return t.equals(Type.ConstChar) || t.equals(Type.ConstInt);
  }
Пример #6
0
 /** Symbolically executes the corresponding Java Virtual Machine instruction. */
 public void visitINVOKESPECIAL(INVOKESPECIAL o) {
   if (o.getMethodName(cpg).equals(Constants.CONSTRUCTOR_NAME)) {
     UninitializedObjectType t =
         (UninitializedObjectType) stack().peek(o.getArgumentTypes(cpg).length);
     if (t == Frame._this) {
       Frame._this = null;
     }
     stack().initializeObject(t);
     locals().initializeObject(t);
   }
   stack().pop(); // objectref
   for (int i = 0; i < o.getArgumentTypes(cpg).length; i++) {
     stack().pop();
   }
   // We are sure the invoked method will xRETURN eventually
   // We simulate xRETURNs functionality here because we
   // don't really "jump into" and simulate the invoked
   // method.
   if (o.getReturnType(cpg) != Type.VOID) {
     Type t = o.getReturnType(cpg);
     if (t.equals(Type.BOOLEAN)
         || t.equals(Type.CHAR)
         || t.equals(Type.BYTE)
         || t.equals(Type.SHORT)) {
       t = Type.INT;
     }
     stack().push(t);
   }
 }
Пример #7
0
 /** Symbolically executes the corresponding Java Virtual Machine instruction. */
 public void visitGETSTATIC(GETSTATIC o) {
   Type t = o.getFieldType(cpg);
   if (t.equals(Type.BOOLEAN)
       || t.equals(Type.CHAR)
       || t.equals(Type.BYTE)
       || t.equals(Type.SHORT)) {
     t = Type.INT;
   }
   stack().push(t);
 }
Пример #8
0
 /**
  * Attempts to add a specific slot.
  *
  * @param item The item.
  * @param slot The desired slot.
  * @return <code>true</code> if the item was added, <code>false</code> if not.
  */
 public boolean add(Item item, int slot) {
   if (item == null) return false;
   int newSlot = (slot > -1) ? slot : freeSlot();
   if ((item.getDefinition().isStackable() || type.equals(Type.ALWAYS_STACK))
       && !type.equals(Type.NEVER_STACK)) {
     if (getCount(item.getId()) > 0) {
       newSlot = getSlotById(item.getId());
     }
   }
   if (newSlot == -1) {
     // the free slot is -1
     return false;
   }
   if (get(newSlot) != null) {
     newSlot = freeSlot();
   }
   if ((item.getDefinition().isStackable() || type.equals(Type.ALWAYS_STACK))
       && !type.equals(Type.NEVER_STACK)) {
     for (int i = 0; i < items.length; i++) {
       if (items[i] != null && items[i].getId() == item.getId()) {
         int totalCount = item.getCount() + items[i].getCount();
         if (totalCount >= Constants.MAX_ITEMS || totalCount < 1) {
           return false;
         }
         set(i, new Item(items[i].getId(), items[i].getCount() + item.getCount()));
         return true;
       }
     }
     if (newSlot == -1) {
       return false;
     } else {
       set(slot > -1 ? newSlot : freeSlot(), item);
       return true;
     }
   } else {
     int slots = freeSlots();
     if (slots >= item.getCount()) {
       boolean b = firingEvents;
       firingEvents = false;
       try {
         for (int i = 0; i < item.getCount(); i++) {
           set(slot > -1 ? newSlot : freeSlot(), new Item(item.getId()));
         }
         if (b) {
           fireItemsChanged();
         }
         return true;
       } finally {
         firingEvents = b;
       }
     } else {
       return false;
     }
   }
 }
Пример #9
0
  private static Class<?> getClosureInterface(Type type) {
    if (!type.isReference()) {
      if (type.equals(Type.VOID)) {
        return VoidClosure.class;
      } else if (type.equals(Type.BOOLEAN)) {
        return BooleanClosure.class;
      } else if (type.equals(Type.INT)) {
        return IntegerClosure.class;
      } else if (type.equals(Type.LONG)) {
        return LongClosure.class;
      } else if (type.equals(Type.FLOAT)) {
        return FloatClosure.class;
      } else if (type.equals(Type.DOUBLE)) {
        return DoubleClosure.class;
      } else if (type.equals(Type.BYTE)) {
        return ByteClosure.class;
      } else if (type.equals(Type.CHAR)) {
        return CharacterClosure.class;
      } else if (type.equals(Type.SHORT)) {
        return ShortClosure.class;
      }

      throw new RuntimeException("Non-exhaustive matching!");
    } else {
      return ObjectClosure.class;
    }
  }
Пример #10
0
 /** Symbolically executes the corresponding Java Virtual Machine instruction. */
 public void visitGETFIELD(GETFIELD o) {
   stack().pop();
   Type t = o.getFieldType(cpg);
   if (t.equals(Type.BOOLEAN)
       || t.equals(Type.CHAR)
       || t.equals(Type.BYTE)
       || t.equals(Type.SHORT)) {
     t = Type.INT;
   }
   stack().push(t);
 }
Пример #11
0
  @Override
  public boolean equals(final Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    if (!super.equals(o)) return false;

    final TypeApp typeApp = (TypeApp) o;

    if (!base.equals(typeApp.base)) return false;
    if (!arg.equals(typeApp.arg)) return false;

    return true;
  }
Пример #12
0
  /**
   * Lists all possible casts from a type, explicit or just implicit, depending on the flag.
   *
   * @param type Type
   * @param explicit Does it include explicit casts?
   * @return List of possible casts
   */
  private static List<Type> canCastFrom(Type type, boolean explicit) {
    if (casts == null) {
      initCasts();
    }

    List<Type> cast = new ArrayList<Type>(casts.get(type));

    if ((type.equals(Type.Int) || type.equals(Type.ConstInt)) && explicit) {
      cast.add(Type.Char);
      cast.add(Type.ConstChar);
    }

    return cast;
  }
Пример #13
0
  @Override
  public boolean equals(Object obj) {
    if (!(obj instanceof SabresDescriptor)) {
      return false;
    }
    if (obj == this) {
      return true;
    }

    SabresDescriptor other = (SabresDescriptor) obj;

    return type.equals(other.type)
        && !(ofType != null && !(ofType.equals(other.ofType)))
        && !(name != null && !(name.equals(other.name)));
  }
Пример #14
0
 /** Calculate the type of this expression, using the given context and type environment. */
 public Type typeOf(Context ctxt, TypeEnv locals) throws Failure {
   Type et = exp.typeOf(ctxt, locals);
   if (!et.equals(Type.INT)) {
     ctxt.report(new Failure("CastInt"));
   }
   return Type.DOUBLE;
 }
Пример #15
0
  private MemoryLockToken getLock(String resource, Type type, long wait)
      throws InterruptedException {
    ReentrantReadWriteLock lockEntry;
    synchronized (locks) {
      if (locks.containsKey(resource)) {
        lockEntry = locks.get(resource);
      } else {
        lockEntry = new ReentrantReadWriteLock(true);
        locks.put(resource, lockEntry);
      }
    }

    Lock lock = (type.equals(Type.READ)) ? lockEntry.readLock() : lockEntry.writeLock();

    if (wait == -1) {
      lock.lock();
    } else {
      if (wait > 0) {
        if (!lock.tryLock(wait, TimeUnit.MILLISECONDS)) {
          return null;
        }
      } else {
        if (!lock.tryLock()) {
          return null;
        }
      }
    }
    synchronized (locks) {
      if (!locks.containsKey(resource)) {
        locks.put(resource, lockEntry);
      }
    }
    return new MemoryLockToken(lockEntry, lock, resource);
  }
Пример #16
0
 /**
  * Attempts to add an item into the next free slot.
  *
  * @param item The item.
  * @return <code>true</code> if the item was added, <code>false</code> if not.
  */
 public boolean add(Item item) {
   if (item.getDefinition().isStackable() || type.equals(Type.ALWAYS_STACK)) {
     for (int i = 0; i < items.length; i++) {
       if (items[i] != null && items[i].getId() == item.getId()) {
         int totalCount = item.getCount() + items[i].getCount();
         if (totalCount >= Integer.MAX_VALUE || totalCount < 1) {
           return false;
         }
         set(i, new Item(items[i].getId(), items[i].getCount() + item.getCount()));
         return true;
       }
     }
     int slot = freeSlot();
     if (slot == -1) {
       return false;
     } else {
       set(slot, item);
       return true;
     }
   } else {
     int slots = freeSlots();
     if (slots >= item.getCount()) {
       for (int i = 0; i < item.getCount(); i++) {
         set(freeSlot(), new Item(item.getId()));
       }
       return true;
     } else {
       return false;
     }
   }
 }
Пример #17
0
  @Override
  public String toString() {
    if (type.equals(Type.Pointer)) {
      return String.format("%s to %s", type.toString(), name);
    }

    if (type.equals(Type.List)) {
      if (ofType.equals(Type.Pointer)) {
        return String.format("List of %s to %s", ofType.toString(), name);
      }

      return String.format("List of %s", ofType.toString());
    }

    return type.toString();
  }
Пример #18
0
 private static int checkParameterizedType(
     String subroutineName,
     ParameterizedType expectedType,
     ArgumentsList arguments,
     List<LispObject> args,
     int argsCounter,
     int i) {
   Type rawType = expectedType.getRawType();
   Type expectedTypeArguments = expectedType.getActualTypeArguments()[0];
   try {
     if (((Class) rawType).isInstance(args.get(argsCounter))) {
       Type actualTypeArguments =
           ((ParameterizedType) (Type) args.get(argsCounter).getClass())
               .getActualTypeArguments()[0];
       if (!expectedTypeArguments.equals(actualTypeArguments)) {
         throw new WrongTypeArgumentException(
             ((Class) rawType).getSimpleName()
                 + "<"
                 + ((Class) expectedTypeArguments).getSimpleName()
                 + ">",
             args.get(argsCounter));
       }
       arguments.setValue(i, args.get(argsCounter));
       return argsCounter + 1;
     } else {
       if (arguments.isOptional(i)) return -1;
       throw new WrongTypeArgumentException(expectedType.toString(), args.get(argsCounter));
     }
   } catch (IndexOutOfBoundsException e) {
     if (arguments.isOptional(i)) return -1;
     throw new WrongNumberOfArgumentsException(subroutineName, i);
   }
 }
Пример #19
0
  /**
   * Handles a DataStoreEvent with the specified type. If the current event type is not equal to the
   * specified type, the events accumulated up to now will be fired first.
   *
   * <p>The new event will be aggregated and fired on demand if {@link #accumulateDataStoreEvents}
   * is set, otherwise all registered <code>DataStoreListener</code> will be notified immediately
   * that the content of the database has been changed.
   *
   * @param objects the objects that have been changed, i.e. inserted, deleted or updated
   */
  private void fireObjectsChanged(DBIDs objects, Type type) {
    // flush first
    if (currentDataStoreEventType != null && !currentDataStoreEventType.equals(type)) {
      flushDataStoreEvents();
    }
    if (accumulateDataStoreEvents) {
      if (this.dataStoreObjects == null) {
        this.dataStoreObjects = DBIDUtil.newHashSet();
      }
      this.dataStoreObjects.addDBIDs(objects);
      currentDataStoreEventType = type;
      return;
    }
    // Execute immediately:
    DataStoreEvent e;
    switch (type) {
      case INSERT:
        e = DataStoreEvent.insertionEvent(objects);
        break;
      case REMOVE:
        e = DataStoreEvent.removalEvent(objects);
        break;
      case UPDATE:
        e = DataStoreEvent.updateEvent(objects);
        break;
      default:
        return;
    }

    for (int i = dataListenerList.size(); --i >= 0; ) {
      dataListenerList.get(i).contentChanged(e);
    }
  }
Пример #20
0
 @Override
 public boolean equals(Object obj) {
   if (this == obj) {
     return true;
   }
   if (obj == null) {
     return false;
   }
   if (getClass() != obj.getClass()) {
     return false;
   }
   AliasRef other = (AliasRef) obj;
   if (name == null) {
     if (other.name != null) {
       return false;
     }
   } else if (!name.equals(other.name)) {
     return false;
   }
   if (type == null) {
     if (other.type != null) {
       return false;
     }
   } else if (!type.equals(other.type)) {
     return false;
   }
   return true;
 }
Пример #21
0
 @Override
 public String toString() {
   if (type.equals(Type.STRING)) {
     return strings.toString();
   } else {
     return "" + num;
   }
 }
Пример #22
0
 /** Symbolically executes the corresponding Java Virtual Machine instruction. */
 public void visitATHROW(ATHROW o) {
   Type t = stack().pop();
   stack().clear();
   if (t.equals(Type.NULL)) {
     stack().push(Type.getType("Ljava/lang/NullPointerException;"));
   } else {
     stack().push(t);
   }
 }
Пример #23
0
  public boolean equals(Object o) {
    if (!(o instanceof MultiType)) return false;

    MultiType multi = (MultiType) o;
    if (resolved != null) return resolved.equals(multi.resolved);
    else if (multi.resolved != null) return false;

    return interfaces.keySet().equals(multi.interfaces.keySet());
  }
 /**
  * Return true if this type does not correspond to a single token class. This occurs if the type
  * is not instantiable, or it represents either an abstract base class or an interface.
  *
  * @param type The type to be checked
  * @return True if this type does not correspond to a single token class.
  */
 public boolean isCompatible(Type type) {
   if (type.equals(BaseType.UNKNOWN)) {
     return true;
   }
   if (!(type instanceof ObjectType)) {
     return false;
   }
   return _isLessThanOrEqualTo((ObjectType) type, this);
 }
Пример #25
0
 /**
  * Returns the public api representation of a folder.
  *
  * <p>Note: properties are modelled after the OpenCMIS node properties
  */
 public Folder getFolder(NodeRef nodeRef) {
   Type type = getType(nodeRef);
   if (type.equals(Type.FOLDER)) {
     Properties properties = getCMISProperties(nodeRef);
     Folder folder = new Folder(nodeRef, properties);
     return folder;
   } else {
     throw new InvalidArgumentException("Node is not a folder");
   }
 }
Пример #26
0
 /**
  * Checks if there is room in the inventory for an item.
  *
  * @param item The item.
  * @return <code>true</code> if so, <code>false</code> if not.
  */
 public boolean hasRoomFor(Item item) {
   if ((item.getDefinition().isStackable() || type.equals(Type.ALWAYS_STACK))
       && !type.equals(Type.NEVER_STACK)) {
     for (int i = 0; i < items.length; i++) {
       if (items[i] != null && items[i].getId() == item.getId()) {
         int totalCount = item.getCount() + items[i].getCount();
         if (totalCount >= Constants.MAX_ITEMS || totalCount < 1) {
           return false;
         }
         return true;
       }
     }
     int slot = freeSlot();
     return slot != -1;
   } else {
     int slots = freeSlots();
     return slots >= item.getCount();
   }
 }
Пример #27
0
 /**
  * Returns the public api representation of a document.
  *
  * <p>Note: properties are modelled after the OpenCMIS node properties
  */
 public Document getDocument(NodeRef nodeRef) {
   Type type = getType(nodeRef);
   if (type.equals(Type.DOCUMENT)) {
     Properties properties = getCMISProperties(nodeRef);
     Document doc = new Document(nodeRef, properties);
     return doc;
   } else {
     throw new InvalidArgumentException("Node is not a file");
   }
 }
  @Override
  public PersonFavourite addFavourite(String userName, NodeRef nodeRef) {
    PersonFavourite personFavourite = null;

    Type type = getType(nodeRef);
    if (type == null) {
      throw new IllegalArgumentException("Cannot favourite this node");
    } else if (type.equals(Type.FILE)) {
      personFavourite = addFavouriteDocumentOrFolder(userName, Type.FILE, nodeRef);
    } else if (type.equals(Type.FOLDER)) {
      personFavourite = addFavouriteDocumentOrFolder(userName, Type.FOLDER, nodeRef);
    } else if (type.equals(Type.SITE)) {
      personFavourite = addFavouriteSite(userName, nodeRef);
    } else {
      throw new IllegalArgumentException("Cannot favourite this node");
    }

    return personFavourite;
  }
  @Override
  public boolean removeFavourite(String userName, NodeRef nodeRef) {
    boolean exists = false;

    Type type = getType(nodeRef);
    if (type == null) {
      throw new IllegalArgumentException("Cannot un-favourite this node");
    } else if (type.equals(Type.FILE)) {
      exists = removeFavouriteNode(userName, type, nodeRef);
    } else if (type.equals(Type.FOLDER)) {
      exists = removeFavouriteNode(userName, type, nodeRef);
    } else if (type.equals(Type.SITE)) {
      exists = removeFavouriteSite(userName, nodeRef);
    } else {
      throw new IllegalArgumentException("Cannot un-favourite this node");
    }

    return exists;
  }
  @Override
  public boolean isFavourite(String userName, NodeRef nodeRef) {
    boolean isFavourite = false;

    Type type = getType(nodeRef);
    if (type == null) {
      throw new IllegalArgumentException("Unsupported node type");
    } else if (type.equals(Type.FILE)) {
      isFavourite = isFavouriteNode(userName, type, nodeRef);
    } else if (type.equals(Type.FOLDER)) {
      isFavourite = isFavouriteNode(userName, type, nodeRef);
    } else if (type.equals(Type.SITE)) {
      isFavourite = isFavouriteSite(userName, nodeRef);
    } else {
      throw new IllegalArgumentException("Unsupported node type");
    }

    return isFavourite;
  }