private void doAddOp(int i, Fragment fragment, String s, int j) {
   fragment.mFragmentManager = mManager;
   if (s != null) {
     if (fragment.mTag != null && !s.equals(fragment.mTag))
       throw new IllegalStateException(
           (new StringBuilder())
               .append("Can't change tag of fragment ")
               .append(fragment)
               .append(": was ")
               .append(fragment.mTag)
               .append(" now ")
               .append(s)
               .toString());
     fragment.mTag = s;
   }
   if (i != 0) {
     if (fragment.mFragmentId != 0 && fragment.mFragmentId != i)
       throw new IllegalStateException(
           (new StringBuilder())
               .append("Can't change container ID of fragment ")
               .append(fragment)
               .append(": was ")
               .append(fragment.mFragmentId)
               .append(" now ")
               .append(i)
               .toString());
     fragment.mFragmentId = i;
     fragment.mContainerId = i;
   }
   Op op = new Op();
   op.cmd = j;
   op.fragment = fragment;
   addOp(op);
 }
 public FragmentTransaction remove(Fragment fragment) {
   Op op = new Op();
   op.cmd = 3;
   op.fragment = fragment;
   addOp(op);
   return this;
 }
 public FragmentTransaction show(Fragment fragment) {
   Op op = new Op();
   op.cmd = 5;
   op.fragment = fragment;
   addOp(op);
   return this;
 }
 public FragmentTransaction detach(Fragment fragment) {
   Op op = new Op();
   op.cmd = 6;
   op.fragment = fragment;
   addOp(op);
   return this;
 }
Ejemplo n.º 5
0
 /**
  * @param operator
  * @param parent
  * @return
  * @throws JSONException
  * @throws JsonParseException
  * @throws JsonMappingException
  * @throws IOException
  * @throws Exception assumption: each operator only has one parent but may have many children
  */
 Op extractOp(JSONObject operator)
     throws JSONException, JsonParseException, JsonMappingException, IOException, Exception {
   String[] names = JSONObject.getNames(operator);
   if (names.length != 1) {
     throw new Exception("Expect only one operator in " + operator.toString());
   } else {
     String opName = names[0];
     JSONObject attrObj = (JSONObject) operator.get(opName);
     Map<String, String> attrs = new TreeMap<>();
     List<Op> children = new ArrayList<>();
     String id = null;
     String outputVertexName = null;
     for (String attrName : JSONObject.getNames(attrObj)) {
       if (attrName.equals("children")) {
         Object childrenObj = attrObj.get(attrName);
         if (childrenObj instanceof JSONObject) {
           if (((JSONObject) childrenObj).length() != 0) {
             children.add(extractOp((JSONObject) childrenObj));
           }
         } else if (childrenObj instanceof JSONArray) {
           if (((JSONArray) childrenObj).length() != 0) {
             JSONArray array = ((JSONArray) childrenObj);
             for (int index = 0; index < array.length(); index++) {
               children.add(extractOp(array.getJSONObject(index)));
             }
           }
         } else {
           throw new Exception(
               "Unsupported operator "
                   + this.name
                   + "'s children operator is neither a jsonobject nor a jsonarray");
         }
       } else {
         if (attrName.equals("OperatorId:")) {
           id = attrObj.get(attrName).toString();
         } else if (attrName.equals("outputname:")) {
           outputVertexName = attrObj.get(attrName).toString();
         } else {
           if (!attrObj.get(attrName).toString().isEmpty()) {
             attrs.put(attrName, attrObj.get(attrName).toString());
           }
         }
       }
     }
     Op op = new Op(opName, id, outputVertexName, children, attrs, operator, this, parser);
     if (!children.isEmpty()) {
       for (Op child : children) {
         child.parent = op;
       }
     } else {
       this.rootOps.add(op);
     }
     return op;
   }
 }
Ejemplo n.º 6
0
  /** Tests {@link OpService#op(String, Object...)}. */
  @Test
  public void testOpByName() {
    final DoubleType value = new DoubleType(123.456);

    final Op op = ops.op("test.infinity", value);
    assertSame(InfinityOp.class, op.getClass());

    assertFalse(Double.isInfinite(value.get()));
    op.run();
    assertTrue(Double.isInfinite(value.get()));
  }
Ejemplo n.º 7
0
 public Address(int type, int size, int address) {
   this.type = type;
   this.size = size;
   this.address = address;
   if (Op.matches(type, Op.MEM | Op.REG | Op.FPUREG)) {
     dynamic = true;
   }
 }
Ejemplo n.º 8
0
 /** Tests op lookups by class. */
 @Test
 public void testMatchingByClass() {
   Op op = ops.op("test.arrr!", (Object) null);
   assertSame(FirstMate.class, op.getClass());
   op = ops.op("test.arrr!", (EyePatch) null);
   assertSame(FirstMate.class, op.getClass());
   op = ops.op("test.arrr!", (Booty) null);
   assertSame(FirstMate.class, op.getClass());
   op = ops.op("test.arrr!", EyePatch.class);
   assertSame(FirstMate.class, op.getClass());
   op = ops.op("test.arrr!", Booty.class);
   assertSame(Captain.class, op.getClass());
 }
 void addOp(Op op) {
   if (mHead == null) {
     mTail = op;
     mHead = op;
   } else {
     op.prev = mTail;
     mTail.next = op;
     mTail = op;
   }
   op.enterAnim = mEnterAnim;
   op.exitAnim = mExitAnim;
   op.popEnterAnim = mPopEnterAnim;
   op.popExitAnim = mPopExitAnim;
   mNumOp = 1 + mNumOp;
 }
Ejemplo n.º 10
0
 public Schema schema() {
   return subOp.schema().subset(keys);
 }
Ejemplo n.º 11
0
 public void print(Printer printer, int indentFlag, String type, Vertex callingVertex)
     throws JSONException, Exception {
   // print vertexname
   if (parser.printSet.contains(this) && !hasMultiReduceOp) {
     if (type != null) {
       printer.println(
           TezJsonParser.prefixString(indentFlag, "<-")
               + " Please refer to the previous "
               + this.name
               + " ["
               + type
               + "]");
     } else {
       printer.println(
           TezJsonParser.prefixString(indentFlag, "<-")
               + " Please refer to the previous "
               + this.name);
     }
     return;
   }
   parser.printSet.add(this);
   if (type != null) {
     printer.println(
         TezJsonParser.prefixString(indentFlag, "<-")
             + this.name
             + " ["
             + type
             + "]"
             + this.executionMode);
   } else if (this.name != null) {
     printer.println(TezJsonParser.prefixString(indentFlag) + this.name + this.executionMode);
   }
   // print operators
   if (hasMultiReduceOp && !(callingVertex.vertexType == VertexType.UNION)) {
     // find the right op
     Op choose = null;
     for (Op op : this.rootOps) {
       if (op.outputVertexName.equals(callingVertex.name)) {
         choose = op;
       }
     }
     if (choose != null) {
       choose.print(printer, indentFlag, false);
     } else {
       throw new Exception(
           "Can not find the right reduce output operator for vertex " + this.name);
     }
   } else {
     for (Op op : this.rootOps) {
       // dummy vertex is treated as a branch of a join operator
       if (this.dummy) {
         op.print(printer, indentFlag, true);
       } else {
         op.print(printer, indentFlag, false);
       }
     }
   }
   if (vertexType == VertexType.UNION) {
     // print dependent vertexs
     indentFlag++;
     for (int index = 0; index < this.parentConnections.size(); index++) {
       Connection connection = this.parentConnections.get(index);
       connection.from.print(printer, indentFlag, connection.type, this);
     }
   }
 }
 @Override
 public Node forAssignment(Assignment that) {
   // System.out.println("PreDesugar entry");
   // Here there are three sorts of rewrite to consider:
   // (a) If this is a compound assignment, rewrite to use ordinary assignment.
   // (b) If the lhs is a tuple, rewrite into a set of individual assignments.
   // (c) If the lhs is a subscript expression, rewrite to a method call.
   List<Lhs> lhs = that.getLhs();
   Option<FunctionalRef> assignOp = that.getAssignOp();
   Expr rhs = that.getRhs();
   List<CompoundAssignmentInfo> assignmentInfos = that.getAssignmentInfos();
   if (!Shell.getAssignmentPreDesugaring()) {
     // System.out.println("Did not PreDesugar");
     return super.forAssignment(that);
   } else if (assignOp.isSome() || lhs.size() > 1) {
     // System.out.println("Compound/tuple PreDesugar");
     // Compound and/or tuple assignment
     // The basic idea is to transform `(a, b.field, c[sub1,sub2]) := e` into
     // `do (ta, tb, tc, tsub1, tsub2, (t1, t2, t3)) = (a, b, c, sub1, sub2, e)
     //     a := t1; tb.field := t2; tc[tsub1, tsub2] := t3 end`
     // (TODO) Unfortunately, currently we don't handle nested binding tuples.
     // For now, we'll just transform it into
     // `do (ta, tb, tc, tsub1, tsub2) = (a, b, c, sub1, sub2)
     //     (t1, t2, t3) = e
     //     a := t1; tb.field := t2; tc[tsub1, tsub2] := t3 end`
     // which merely loses a bit of potential parallelism.
     // We omit the first tuple binding if the tuple is empty.
     // If it is a compound assignment `(a, b.field, c[sub1,sub2]) OP= e`, it becomes
     // `do (ta, tb, tc, tsub1, tsub2) = (a, b, c, sub1, sub2)
     //     (t1, t2, t3) = (ta, tb, tc[tsub1, tsub2]) OP e
     //     a := t1; tb.field := t2; tc[tsub1, tsub2] := t3 end`
     List<LValue> exprLValues = Useful.list();
     List<LValue> otherLValues = Useful.list();
     List<Expr> otherExprs = Useful.list();
     List<Expr> assignments = Useful.list();
     boolean isCompound = assignOp.isSome();
     List<Expr> accesses = Useful.list();
     Span thatSpan = NodeUtil.getSpan(that);
     for (Lhs lh : lhs) {
       Span lhSpan = NodeUtil.getSpan((Expr) lh);
       Id tempId = DesugarerUtil.gensymId(lhSpan, "e");
       VarRef tempVar = ExprFactory.makeVarRef(lhSpan, tempId);
       exprLValues = Useful.snoc(exprLValues, NodeFactory.makeLValue(lhSpan, tempId));
       if (lh instanceof SubscriptExpr) {
         SubscriptExpr lhsub = (SubscriptExpr) lh;
         Expr obj = lhsub.getObj();
         Span objSpan = NodeUtil.getSpan(obj);
         List<Expr> subs = lhsub.getSubs();
         Id baseTempId = DesugarerUtil.gensymId(objSpan, "b");
         VarRef baseTempVar = ExprFactory.makeVarRef(objSpan, baseTempId);
         otherLValues = Useful.snoc(otherLValues, NodeFactory.makeLValue(objSpan, baseTempId));
         otherExprs = Useful.snoc(otherExprs, obj);
         List<Expr> subTempVars = Useful.list();
         for (Expr sub : lhsub.getSubs()) {
           Span subSpan = NodeUtil.getSpan(sub);
           Id subTempId = DesugarerUtil.gensymId(subSpan, "s");
           subTempVars = Useful.snoc(subTempVars, ExprFactory.makeVarRef(subSpan, subTempId));
           otherLValues = Useful.snoc(otherLValues, NodeFactory.makeLValue(subSpan, subTempId));
         }
         otherExprs = Useful.concat(otherExprs, subs);
         SubscriptExpr newLhs =
             ExprFactory.makeSubscriptExpr(
                 NodeUtil.getSpan(lhsub),
                 baseTempVar,
                 subTempVars,
                 lhsub.getOp(),
                 lhsub.getStaticArgs());
         if (isCompound) accesses = Useful.snoc(accesses, newLhs);
         assignments =
             Useful.snoc(assignments, ExprFactory.makeAssignment(thatSpan, newLhs, tempVar));
       } else if (lh instanceof FieldRef) {
         FieldRef lhref = (FieldRef) lh;
         Expr obj = lhref.getObj();
         Span objSpan = NodeUtil.getSpan(obj);
         Id objTempId = DesugarerUtil.gensymId(objSpan, "o");
         VarRef objTempVar = ExprFactory.makeVarRef(objSpan, objTempId);
         otherLValues = Useful.snoc(otherLValues, NodeFactory.makeLValue(objSpan, objTempId));
         otherExprs = Useful.snoc(otherExprs, obj);
         FieldRef newLhs =
             ExprFactory.makeFieldRef(NodeUtil.getSpan(lhref), objTempVar, lhref.getField());
         if (isCompound) accesses = Useful.snoc(accesses, newLhs);
         assignments =
             Useful.snoc(assignments, ExprFactory.makeAssignment(thatSpan, newLhs, tempVar));
       } else if (lh instanceof VarRef) {
         VarRef lhvar = (VarRef) lh;
         Span varSpan = NodeUtil.getSpan(lhvar);
         Id varTempId = DesugarerUtil.gensymId(varSpan, "v");
         VarRef varTempVar = ExprFactory.makeVarRef(varSpan, varTempId);
         otherLValues = Useful.snoc(otherLValues, NodeFactory.makeLValue(varSpan, varTempId));
         otherExprs = Useful.snoc(otherExprs, lhvar);
         if (isCompound) accesses = Useful.snoc(accesses, varTempVar);
         assignments =
             Useful.snoc(assignments, ExprFactory.makeAssignment(thatSpan, lhvar, tempVar));
       } else {
         bug(that, "Malformed assignment LHS");
       }
     }
     Expr result = ExprFactory.makeBlock(thatSpan, assignments);
     if (otherExprs.size() > 0) {
       Expr otherRhs = ExprFactory.makeMaybeTupleExpr(thatSpan, otherExprs);
       result = ExprFactory.makeLocalVarDecl(thatSpan, otherLValues, otherRhs, result);
     }
     Expr newRhs =
         isCompound
             ? ExprFactory.makeOpExpr(
                 NodeUtil.spanTwo(assignOp.unwrap(), rhs),
                 assignOp.unwrap(),
                 ExprFactory.makeMaybeTupleExpr(thatSpan, accesses),
                 rhs)
             : rhs;
     result = ExprFactory.makeLocalVarDecl(thatSpan, exprLValues, newRhs, result);
     return (Expr) recur(result);
   } else if (lhs.get(0) instanceof SubscriptExpr) {
     // System.out.println("PreDesugar single subscript expr");
     // Subscripted assignment
     SubscriptExpr lhExpr = (SubscriptExpr) lhs.get(0);
     Expr obj = lhExpr.getObj();
     List<Expr> subs = lhExpr.getSubs();
     Option<Op> op = lhExpr.getOp();
     List<StaticArg> staticArgs = lhExpr.getStaticArgs();
     if (!op.isSome()) bug(lhExpr, "Subscript operator expected");
     Op knownOp = op.unwrap();
     Expr result =
         ExprFactory.makeMethodInvocation(
             that,
             obj,
             NodeFactory.makeOp(knownOp, knownOp.getText() + ":="),
             staticArgs,
             ExprFactory.makeTupleExpr(NodeUtil.spanTwo(knownOp, rhs), Useful.cons(rhs, subs)));
     return (Expr) recur(result);
   } else {
     // System.out.println("PreDesugar single expr of class " + lhs.get(0).getClass().getName());
     return super.forAssignment(that);
   }
 }
Ejemplo n.º 13
0
 @Override
 public String toString() {
   return "FilterDto op: " + operator.toString() + ", values: " + values;
 }
Ejemplo n.º 14
0
 public String toString() {
   String t2 = second.isType(VALUE) ? "'" + second + "'" : second.toString();
   return "(" + getFirst() + getType().toSymbol() + t2 + ')';
 }
  public void run() {
    label0:
    {
      if (FragmentManagerImpl.DEBUG)
        Log.v("FragmentManager", (new StringBuilder()).append("Run: ").append(this).toString());
      if (mAddToBackStack && mIndex < 0)
        throw new IllegalStateException("addToBackStack() called after commit()");
      bumpBackStackNesting(1);
      Op op = mHead;
      label1:
      do {
        if (op == null) break label0;
        switch (op.cmd) {
          default:
            break label1;

          case 7: // '\007'
            Fragment fragment7 = op.fragment;
            fragment7.mNextAnim = op.enterAnim;
            mManager.attachFragment(fragment7, mTransition, mTransitionStyle);
            break;

          case 6: // '\006'
            Fragment fragment6 = op.fragment;
            fragment6.mNextAnim = op.exitAnim;
            mManager.detachFragment(fragment6, mTransition, mTransitionStyle);
            break;

          case 5: // '\005'
            Fragment fragment5 = op.fragment;
            fragment5.mNextAnim = op.enterAnim;
            mManager.showFragment(fragment5, mTransition, mTransitionStyle);
            break;

          case 4: // '\004'
            Fragment fragment4 = op.fragment;
            fragment4.mNextAnim = op.exitAnim;
            mManager.hideFragment(fragment4, mTransition, mTransitionStyle);
            break;

          case 3: // '\003'
            Fragment fragment3 = op.fragment;
            fragment3.mNextAnim = op.exitAnim;
            mManager.removeFragment(fragment3, mTransition, mTransitionStyle);
            break;

          case 2: // '\002'
            Fragment fragment1 = op.fragment;
            if (mManager.mAdded != null) {
              for (int i = 0; i < mManager.mAdded.size(); i++) {
                Fragment fragment2 = (Fragment) mManager.mAdded.get(i);
                if (FragmentManagerImpl.DEBUG)
                  Log.v(
                      "FragmentManager",
                      (new StringBuilder())
                          .append("OP_REPLACE: adding=")
                          .append(fragment1)
                          .append(" old=")
                          .append(fragment2)
                          .toString());
                if (fragment1 != null && fragment2.mContainerId != fragment1.mContainerId) continue;
                if (fragment2 == fragment1) {
                  fragment1 = null;
                  op.fragment = null;
                  continue;
                }
                if (op.removed == null) op.removed = new ArrayList();
                op.removed.add(fragment2);
                fragment2.mNextAnim = op.exitAnim;
                if (mAddToBackStack) {
                  fragment2.mBackStackNesting = 1 + fragment2.mBackStackNesting;
                  if (FragmentManagerImpl.DEBUG)
                    Log.v(
                        "FragmentManager",
                        (new StringBuilder())
                            .append("Bump nesting of ")
                            .append(fragment2)
                            .append(" to ")
                            .append(fragment2.mBackStackNesting)
                            .toString());
                }
                mManager.removeFragment(fragment2, mTransition, mTransitionStyle);
              }
            }
            if (fragment1 != null) {
              fragment1.mNextAnim = op.enterAnim;
              mManager.addFragment(fragment1, false);
            }
            break;

          case 1: // '\001'
            Fragment fragment = op.fragment;
            fragment.mNextAnim = op.enterAnim;
            mManager.addFragment(fragment, false);
            break;
        }
        op = op.next;
      } while (true);
      throw new IllegalArgumentException(
          (new StringBuilder()).append("Unknown cmd: ").append(op.cmd).toString());
    }
    mManager.moveToState(mManager.mCurState, mTransition, mTransitionStyle, true);
    if (mAddToBackStack) mManager.addBackStackState(this);
  }
Ejemplo n.º 16
0
 public int cost(CostModel model) {
   return subOp.cost(model);
 }
Ejemplo n.º 17
0
  /**
   * Override the preAppend for checkAndPut and checkAndDelete, as we need the ability to a) set the
   * TimeRange for the Get being done and b) return something back to the client to indicate
   * success/failure
   */
  @SuppressWarnings("deprecation")
  @Override
  public Result preAppend(
      final ObserverContext<RegionCoprocessorEnvironment> e, final Append append)
      throws IOException {
    byte[] opBuf = append.getAttribute(OPERATION_ATTRIB);
    if (opBuf == null) {
      return null;
    }
    Op op = Op.values()[opBuf[0]];

    long clientTimestamp = HConstants.LATEST_TIMESTAMP;
    byte[] clientTimestampBuf = append.getAttribute(MAX_TIMERANGE_ATTRIB);
    if (clientTimestampBuf != null) {
      clientTimestamp = Bytes.toLong(clientTimestampBuf);
    }
    boolean hadClientTimestamp = (clientTimestamp != HConstants.LATEST_TIMESTAMP);
    if (hadClientTimestamp) {
      // Prevent race condition of creating two sequences at the same timestamp
      // by looking for a sequence at or after the timestamp at which it'll be
      // created.
      if (op == Op.CREATE_SEQUENCE) {
        clientTimestamp++;
      }
    } else {
      clientTimestamp = EnvironmentEdgeManager.currentTimeMillis();
      clientTimestampBuf = Bytes.toBytes(clientTimestamp);
    }

    RegionCoprocessorEnvironment env = e.getEnvironment();
    // We need to set this to prevent region.append from being called
    e.bypass();
    e.complete();
    HRegion region = env.getRegion();
    byte[] row = append.getRow();
    region.startRegionOperation();
    try {
      Integer lid = region.getLock(null, row, true);
      try {
        KeyValue keyValue = append.getFamilyMap().values().iterator().next().iterator().next();
        byte[] family = keyValue.getFamily();
        byte[] qualifier = keyValue.getQualifier();

        Get get = new Get(row);
        get.setTimeRange(MetaDataProtocol.MIN_TABLE_TIMESTAMP, clientTimestamp);
        get.addColumn(family, qualifier);
        Result result = region.get(get);
        if (result.isEmpty()) {
          if (op == Op.DROP_SEQUENCE || op == Op.RESET_SEQUENCE) {
            return getErrorResult(
                row, clientTimestamp, SQLExceptionCode.SEQUENCE_UNDEFINED.getErrorCode());
          }
        } else {
          if (op == Op.CREATE_SEQUENCE) {
            return getErrorResult(
                row, clientTimestamp, SQLExceptionCode.SEQUENCE_ALREADY_EXIST.getErrorCode());
          }
        }
        Mutation m = null;
        switch (op) {
          case RESET_SEQUENCE:
            KeyValue currentValueKV = result.raw()[0];
            long expectedValue =
                PDataType.LONG
                    .getCodec()
                    .decodeLong(append.getAttribute(CURRENT_VALUE_ATTRIB), 0, null);
            long value =
                PDataType.LONG
                    .getCodec()
                    .decodeLong(currentValueKV.getBuffer(), currentValueKV.getValueOffset(), null);
            // Timestamp should match exactly, or we may have the wrong sequence
            if (expectedValue != value || currentValueKV.getTimestamp() != clientTimestamp) {
              return new Result(
                  Collections.singletonList(
                      KeyValueUtil.newKeyValue(
                          row,
                          PhoenixDatabaseMetaData.SEQUENCE_FAMILY_BYTES,
                          QueryConstants.EMPTY_COLUMN_BYTES,
                          currentValueKV.getTimestamp(),
                          ByteUtil.EMPTY_BYTE_ARRAY)));
            }
            m = new Put(row, currentValueKV.getTimestamp());
            m.getFamilyMap().putAll(append.getFamilyMap());
            break;
          case DROP_SEQUENCE:
            m = new Delete(row, clientTimestamp, null);
            break;
          case CREATE_SEQUENCE:
            m = new Put(row, clientTimestamp);
            m.getFamilyMap().putAll(append.getFamilyMap());
            break;
        }
        if (!hadClientTimestamp) {
          for (List<KeyValue> kvs : m.getFamilyMap().values()) {
            for (KeyValue kv : kvs) {
              kv.updateLatestStamp(clientTimestampBuf);
            }
          }
        }
        @SuppressWarnings("unchecked")
        Pair<Mutation, Integer>[] mutations = new Pair[1];
        mutations[0] = new Pair<Mutation, Integer>(m, lid);
        region.batchMutate(mutations);
        long serverTimestamp = MetaDataUtil.getClientTimeStamp(m);
        // Return result with single KeyValue. The only piece of information
        // the client cares about is the timestamp, which is the timestamp of
        // when the mutation was actually performed (useful in the case of .
        return new Result(
            Collections.singletonList(
                KeyValueUtil.newKeyValue(
                    row,
                    PhoenixDatabaseMetaData.SEQUENCE_FAMILY_BYTES,
                    QueryConstants.EMPTY_COLUMN_BYTES,
                    serverTimestamp,
                    SUCCESS_VALUE)));
      } finally {
        region.releaseRowLock(lid);
      }
    } catch (Throwable t) {
      ServerUtil.throwIOException("Increment of sequence " + Bytes.toStringBinary(row), t);
      return null; // Impossible
    } finally {
      region.closeRegionOperation();
    }
  }
Ejemplo n.º 18
0
 public static void main(String[] args) {
   Scanner user_input = new Scanner(System.in);
   try {
     String text;
     Op operator;
     Calc<?> calD;
     Expr expr;
     boolean parseExpression = true;
     calD = new CalcDouble<Double>(Double.class);
     expr = new Expr(calD);
     System.out.println("Operatorer: " + Op.toString(calD.operators));
     System.out.println("i: heltall d: desimal f: flyttall parse trace h: help s: slutt");
     do {
       System.out.print(": ");
       text = user_input.nextLine();
       calD.saveStack();
       // Check if the text is a valid operator for the type of
       // arguments
       operator = Op.operator(text, calD.operators);
       if (operator != null) {
         calD.op(operator);
       } else {
         // If the operator exists, but is invalid for the type write
         // that
         operator = Op.operator(text);
         if (operator != null)
           System.out.println(
               "Operator "
                   + operator.abbrev()
                   + " ugyldig for "
                   + calD.type.getSimpleName()
                   + ".");
         else {
           switch (text.toLowerCase()) {
             case "s":
               break;
             case "i":
               calD.clear();
               calD = new CalcBigInteger<BigInteger>(BigInteger.class);
               expr.setCalc(calD);
               System.out.println("Operatorer: " + Op.toString(calD.operators));
               break;
             case "d":
               calD.clear();
               calD = new CalcBigDecimal<BigDecimal>(BigDecimal.class);
               expr.setCalc(calD);
               System.out.println("Operatorer: " + Op.toString(calD.operators));
               break;
             case "f":
               calD.clear();
               calD = new CalcDouble<Double>(Double.class);
               expr.setCalc(calD);
               System.out.println("Operatorer: " + Op.toString(calD.operators));
               break;
             case "":
             case "help":
             case "h":
               System.out.println("Operatorer: " + Op.toString(calD.operators));
               System.out.println(
                   "i: heltall d: desimal f: flyttall parse trace h: help s: slutt");
               break;
             case "parse":
               parseExpression = !parseExpression;
               if (parseExpression) System.out.println("Parsing på.");
               else System.out.println("Parsing av.");
               break;
             case "trace":
               expr.setTrace();
               break;
             default:
               if (parseExpression) {
                 if (expr.parse(text)) expr.calculate();
               } else {
                 calD.enter(text);
               }
           }
         }
       }
     } while (!text.equals("s"));
   } catch (Exception e) {
     System.out.println("Alvorlig feil: " + e.getMessage());
   } finally {
     user_input.close();
   }
   System.out.println("Avsluttet kalkulator");
 }
Ejemplo n.º 19
0
 /**
  * Add a list of {@link Op}s to the {@link OpsBuilder}.
  *
  * @param ops the {@link Op}s
  * @return the {@link OpsBuilder}
  */
 public DocBuilder withOps(List<Op> ops) {
   for (Op op : ops) {
     op.add(this); // These operations call the operations below to build the doc.
   }
   return this;
 }