/** like "database..table". */
  protected String getTableNameWithDBAndSchema(
      final String dbName, final String schema, String tableName) {
    if (tableName == null || EMPTY.equals(tableName.trim())) {
      tableName = QueryUtil.DEFAULT_TABLE_NAME;
    }

    final StringBuffer tableNameWithDBAndSchema = new StringBuffer();

    //
    if (dbName != null && !EMPTY.equals(dbName)) {
      /*
       * should not add quote always.
       */
      setForceAddQuote(false);
      tableNameWithDBAndSchema.append(checkContextAndAddQuote(dbName));
      revertAddQuoteSetting();
      tableNameWithDBAndSchema.append(getSQLFieldConnector());

      // schema is special empty "."
      tableNameWithDBAndSchema.append(getSQLFieldConnector());
    }
    //
    // setForceAddQuote(true); //FIXME, if add quote always, should be opened
    tableNameWithDBAndSchema.append(checkContextAndAddQuote(tableName));
    // revertAddQuoteSetting();

    return tableNameWithDBAndSchema.toString();
  }
  @Override
  public void validate() {

    if (stillBirthRegistration.getDateOfEvent() != null
        && stillBirthRegistration.getDateOfEvent().after(DateUtils.today()))
      addActionError(getMessage("dateOfEvent.today.validate"));

    if (stillBirthRegistration.getRegistrationDate() != null
        && stillBirthRegistration.getDateOfEvent() != null
        && stillBirthRegistration
            .getDateOfEvent()
            .after(stillBirthRegistration.getRegistrationDate()))
      addActionError(getMessage("dateOfEvent.registration.validate"));

    if (placeTypeTemp != null
        && !EMPTY.equals(placeTypeTemp)
        && BndConstants.HOSPTIAL.equalsIgnoreCase(placeTypeTemp)
        && stillBirthRegistration.getEstablishment() == null)
      addActionError(getMessage("hospitalname.required"));
    // For Offline mode validating registration number....
    if (OFFLINE.equals(mode)
        && stillBirthRegistration.getRegistrationNo() != null
        && !EMPTY.equals(stillBirthRegistration.getRegistrationNo().trim()))
      if (stillBirthRegistration.getRegistrationUnit() != null
          && birthRegistrationService.checkUniqueRegistrationNumber(
              stillBirthRegistration.getRegistrationUnit().getId(),
              stillBirthRegistration.getId(),
              stillBirthRegistration.getRegistrationNo(),
              BndConstants.REGISTRATIONDATE.equalsIgnoreCase(numberGenKey)
                  ? stillBirthRegistration.getRegistrationDate()
                  : stillBirthRegistration.getDateOfEvent(),
              BndConstants.STILLBIRTHNUM)) addActionError(getMessage("registration.number.exists"));
      else if (BndUtils.isNum(stillBirthRegistration.getRegistrationNo().trim())) {
        final int eventYear =
            BndConstants.REGISTRATIONDATE.equalsIgnoreCase(numberGenKey)
                ? BndDateUtils.getCurrentYear(stillBirthRegistration.getRegistrationDate())
                : BndDateUtils.getCurrentYear(stillBirthRegistration.getDateOfEvent());
        final RegKeys regNumRange =
            regKeyService.getRegKeyByRegUnitAndDate(
                stillBirthRegistration.getRegistrationUnit(),
                eventYear,
                numberGenerationService.buildObjectType(
                    stillBirthRegistration, eventYear, BndConstants.STILLBIRTHNUM));
        if (regNumRange != null) {
          final Integer regNumber = Integer.valueOf(stillBirthRegistration.getRegistrationNo());
          if (regNumber >= regNumRange.getMinValue())
            addActionError(
                getMessage("regNumber.minvalue.validate")
                    .concat(" ")
                    .concat(regNumRange.getMinValue().toString()));
        }
      }
  }
  private void configure(String broadcasterLifeCyclePolicy) {

    int maxIdleTime = 5 * 60 * 1000;
    String idleTime =
        config.getInitParameter(ApplicationConfig.BROADCASTER_LIFECYCLE_POLICY_IDLETIME);
    if (idleTime != null) {
      maxIdleTime = Integer.parseInt(idleTime);
    }

    if (EMPTY.name().equalsIgnoreCase(broadcasterLifeCyclePolicy)) {
      policy = new BroadcasterLifeCyclePolicy.Builder().policy(EMPTY).build();
    } else if (EMPTY_DESTROY.name().equalsIgnoreCase(broadcasterLifeCyclePolicy)) {
      policy = new BroadcasterLifeCyclePolicy.Builder().policy(EMPTY_DESTROY).build();
    } else if (IDLE.name().equalsIgnoreCase(broadcasterLifeCyclePolicy)) {
      policy =
          new BroadcasterLifeCyclePolicy.Builder().policy(IDLE).idleTimeInMS(maxIdleTime).build();
    } else if (IDLE_DESTROY.name().equalsIgnoreCase(broadcasterLifeCyclePolicy)) {
      policy =
          new BroadcasterLifeCyclePolicy.Builder()
              .policy(IDLE_DESTROY)
              .idleTimeInMS(maxIdleTime)
              .build();
    } else if (IDLE_RESUME.name().equalsIgnoreCase(broadcasterLifeCyclePolicy)) {
      policy =
          new BroadcasterLifeCyclePolicy.Builder()
              .policy(IDLE_RESUME)
              .idleTimeInMS(maxIdleTime)
              .build();
    } else if (NEVER.name().equalsIgnoreCase(broadcasterLifeCyclePolicy)) {
      policy = new BroadcasterLifeCyclePolicy.Builder().policy(NEVER).build();
    } else {
      logger.warn("Unsupported BroadcasterLifeCyclePolicy policy {}", broadcasterLifeCyclePolicy);
    }
  }
示例#4
0
 @Override
 protected void load(MappedByteBuffer mmap) throws IOException {
   String name = Util.readUTFString(mmap);
   this.name = EMPTY.equals(name) ? null : name;
   int len = mmap.getInt();
   this.nodes = new Node[len];
   MapInfo mapInfo = State.getInstance().getMapInfo();
   for (int i = 0; i < len; i++) {
     this.nodes[i] = mapInfo.getNode(mmap.getInt());
   }
   this.wayInfo = WayInfo.loadFromInput(mmap);
 }
示例#5
0
 @Override
 protected void load(DataInput input) throws IOException {
   String name = input.readUTF();
   this.name = EMPTY.equals(name) ? null : name;
   int len = input.readInt();
   this.nodes = new Node[len];
   MapInfo mapInfo = State.getInstance().getMapInfo();
   for (int i = 0; i < len; i++) {
     this.nodes[i] = mapInfo.getNode(input.readInt());
   }
   this.wayInfo = WayInfo.loadFromInput(input);
 }
  public void testUseAsDefaultsForComposition() {
    assertEquals(EMPTY.user("c"), test("a", "b", "c"));
    assertEquals(EMPTY.user("c"), test("a", null, "c"));
    assertEquals(EMPTY.user("c"), test(null, "b", "c"));

    assertEquals(EMPTY.user("b"), test("a", "b", null));
    assertEquals(EMPTY.user("a"), test("a", null, null));
    assertEquals(EMPTY.user("b"), test(null, "b", null));
  }
示例#7
0
 @Test
 public void noSwapForEmptyMark() {
   assertEquals(EMPTY, EMPTY.swapMark());
 }
示例#8
0
 @Test
 public void convertsEmptyMarkToString() {
   assertEquals("", EMPTY.getString());
 }
  // algorithm: treat sentence snippets as miniature documents
  // we can intersect these with the postings lists via BreakIterator.preceding(offset),s
  // score each sentence as norm(sentenceStartOffset) * sum(weight * tf(freq))
  private Passage[] highlightDoc(
      String field,
      BytesRef terms[],
      int contentLength,
      BreakIterator bi,
      int doc,
      TermsEnum termsEnum,
      DocsAndPositionsEnum[] postings,
      int n)
      throws IOException {
    PassageScorer scorer = getScorer(field);
    if (scorer == null) {
      throw new NullPointerException("PassageScorer cannot be null");
    }
    PriorityQueue<OffsetsEnum> pq = new PriorityQueue<>();
    float weights[] = new float[terms.length];
    // initialize postings
    for (int i = 0; i < terms.length; i++) {
      DocsAndPositionsEnum de = postings[i];
      int pDoc;
      if (de == EMPTY) {
        continue;
      } else if (de == null) {
        postings[i] = EMPTY; // initially
        if (!termsEnum.seekExact(terms[i])) {
          continue; // term not found
        }
        de =
            postings[i] = termsEnum.docsAndPositions(null, null, DocsAndPositionsEnum.FLAG_OFFSETS);
        if (de == null) {
          // no positions available
          throw new IllegalArgumentException(
              "field '" + field + "' was indexed without offsets, cannot highlight");
        }
        pDoc = de.advance(doc);
      } else {
        pDoc = de.docID();
        if (pDoc < doc) {
          pDoc = de.advance(doc);
        }
      }

      if (doc == pDoc) {
        weights[i] = scorer.weight(contentLength, de.freq());
        de.nextPosition();
        pq.add(new OffsetsEnum(de, i));
      }
    }

    pq.add(new OffsetsEnum(EMPTY, Integer.MAX_VALUE)); // a sentinel for termination

    PriorityQueue<Passage> passageQueue =
        new PriorityQueue<>(
            n,
            new Comparator<Passage>() {
              @Override
              public int compare(Passage left, Passage right) {
                if (left.score < right.score) {
                  return -1;
                } else if (left.score > right.score) {
                  return 1;
                } else {
                  return left.startOffset - right.startOffset;
                }
              }
            });
    Passage current = new Passage();

    OffsetsEnum off;
    while ((off = pq.poll()) != null) {
      final DocsAndPositionsEnum dp = off.dp;
      int start = dp.startOffset();
      if (start == -1) {
        throw new IllegalArgumentException(
            "field '" + field + "' was indexed without offsets, cannot highlight");
      }
      int end = dp.endOffset();
      // LUCENE-5166: this hit would span the content limit... however more valid
      // hits may exist (they are sorted by start). so we pretend like we never
      // saw this term, it won't cause a passage to be added to passageQueue or anything.
      assert EMPTY.startOffset() == Integer.MAX_VALUE;
      if (start < contentLength && end > contentLength) {
        continue;
      }
      if (start >= current.endOffset) {
        if (current.startOffset >= 0) {
          // finalize current
          current.score *= scorer.norm(current.startOffset);
          // new sentence: first add 'current' to queue
          if (passageQueue.size() == n && current.score < passageQueue.peek().score) {
            current.reset(); // can't compete, just reset it
          } else {
            passageQueue.offer(current);
            if (passageQueue.size() > n) {
              current = passageQueue.poll();
              current.reset();
            } else {
              current = new Passage();
            }
          }
        }
        // if we exceed limit, we are done
        if (start >= contentLength) {
          Passage passages[] = new Passage[passageQueue.size()];
          passageQueue.toArray(passages);
          for (Passage p : passages) {
            p.sort();
          }
          // sort in ascending order
          Arrays.sort(
              passages,
              new Comparator<Passage>() {
                @Override
                public int compare(Passage left, Passage right) {
                  return left.startOffset - right.startOffset;
                }
              });
          return passages;
        }
        // advance breakiterator
        assert BreakIterator.DONE < 0;
        current.startOffset = Math.max(bi.preceding(start + 1), 0);
        current.endOffset = Math.min(bi.next(), contentLength);
      }
      int tf = 0;
      while (true) {
        tf++;
        BytesRef term = terms[off.id];
        if (term == null) {
          // multitermquery match, pull from payload
          term = off.dp.getPayload();
          assert term != null;
        }
        current.addMatch(start, end, term);
        if (off.pos == dp.freq()) {
          break; // removed from pq
        } else {
          off.pos++;
          dp.nextPosition();
          start = dp.startOffset();
          end = dp.endOffset();
        }
        if (start >= current.endOffset || end > contentLength) {
          pq.offer(off);
          break;
        }
      }
      current.score += weights[off.id] * scorer.tf(tf, current.endOffset - current.startOffset);
    }

    // Dead code but compiler disagrees:
    assert false;
    return null;
  }
 public FileAttributes test(String defaultDefaultUser, String defaultUser, String user) {
   return EMPTY
       .user(defaultDefaultUser)
       .useAsDefaultsFor(EMPTY.user(defaultUser))
       .useAsDefaultsFor(EMPTY.user(user));
 }
  public void testEquals() {
    assertEquals(EMPTY, EMPTY);

    assertFalse(EMPTY.user("trygve").equals(EMPTY));
  }