private synchronized PolicyResult constructResultWrapper(final ResultType resultType) {
   return new PolicyResult(
       resultType,
       validationsPerformed.get(),
       lastTotalCharsValidated.get(),
       streamer.getStreamingMode());
 }
    @Override
    synchronized PolicyResult validate() {
      streamer.stream(); // todo: better get a read-lock on streamer

      ResultType resultType = ResultType.VALID;
      if (!streamer.getMemoryBuffer().isEmpty()) {
        validationsPerformed.incrementAndGet();
        for (Iterator<Character> iter = streamer.getMemoryBuffer().iterator(); iter.hasNext(); ) {
          char c = iter.next();
          lastTotalCharsValidated.incrementAndGet();
          try {
            switch (c) {
              case Braces.START_PAREN:
              case Braces.START_BRACE:
              case Braces.START_SQBRACE:
                stack.add(c);
                break;
              case Braces.END_PAREN:
                if (stack.pop() != Braces.START_PAREN) {
                  return constructResultWrapper(ResultType.INVALID);
                }
                break;
              case Braces.END_BRACE:
                if (stack.pop() != Braces.START_BRACE) {
                  return constructResultWrapper(ResultType.INVALID);
                }
                break;
              case Braces.END_SQBRACE:
                if (stack.pop() != Braces.START_SQBRACE) {
                  return constructResultWrapper(ResultType.INVALID);
                }
                break;
            }
          } catch (EmptyStackException emptyStack) {
            return constructResultWrapper(ResultType.INVALID);
          }
        }

        if (!stack.isEmpty()) {
          resultType = ResultType.INVALID;
        }
      }

      return constructResultWrapper(resultType);
    }
 public void stopNow() {
   streamer.stop();
 }
 public Result validateNow() {
   return streamer.validate();
 }