示例#1
0
 @Override
 public PageReference readFirstReference() throws SirixIOException {
   final PageReference uberPageReference = new PageReference();
   // Read primary beacon.
   final long lastIndex = mChronicle.size() - 1;
   uberPageReference.setKey(lastIndex);
   final UberPage page = (UberPage) read(lastIndex, null);
   uberPageReference.setPage(page);
   return uberPageReference;
 }
 public static void main(String[] args) throws Exception {
   String name = TMP + "/chronicle";
   Chronicle chronicle = new IndexedChronicle(name);
   DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
   List<String> underlying = new ArrayList<String>();
   int maxMessageSize = 128;
   ListWrapper<String> list =
       new ListWrapper<String>(dataStore, "testlist", String.class, underlying, maxMessageSize);
   dataStore.start();
   for (int i = 0; i < 1000000; i++) {
     list.add(0, "hello" + i);
     list.add(1, "world" + i);
     list.remove(0);
     list.remove(1); // does nothing until second loop and leaves one elements
   }
   System.out.println("list.size(): " + list.size());
   System.out.println("list: " + list);
   chronicle.close();
 }
 public InProcessChronicleSource(Chronicle chronicle, int port) throws IOException {
   this.chronicle = chronicle;
   server = ServerSocketChannel.open();
   server.socket().setReuseAddress(true);
   server.socket().bind(new InetSocketAddress(port));
   name = chronicle.name() + "@" + port;
   logger = Logger.getLogger(getClass().getName() + "." + name);
   service = Executors.newCachedThreadPool(new NamedThreadFactory(name));
   service.execute(new Acceptor());
 }
 @Override
 public void close() {
   closed = true;
   chronicle.close();
   try {
     server.close();
   } catch (IOException e) {
     logger.warning("Error closing server port " + e);
   }
 }
示例#5
0
 public ChronicleReader(final Chronicle chronicle, final ByteHandler handler)
     throws SirixIOException {
   mChronicle = checkNotNull(chronicle);
   mByteHandler = checkNotNull(handler);
   mExcerpt = mChronicle.createExcerpt();
 }
 @Override
 public <E> EnumeratedMarshaller<E> getMarshaller(Class<E> eClass) {
   return chronicle.getMarshaller(eClass);
 }
 @Override
 public <E> void setEnumeratedMarshaller(EnumeratedMarshaller<E> marshaller) {
   chronicle.setEnumeratedMarshaller(marshaller);
 }
 @Override
 public ByteOrder byteOrder() {
   return chronicle.byteOrder();
 }
 @Override
 public long sizeInBytes() {
   return chronicle.sizeInBytes();
 }
 @Override
 public long size() {
   return chronicle.size();
 }
 @Override
 public String name() {
   return chronicle.name();
 }
示例#12
0
  @Test
  public void testMethods() throws IOException {
    String name = TMP + "/set-methods";
    ChronicleTools.deleteOnExit(name);
    {
      MapListener stringsListener = createMock("strings", MapListener.class);
      stringsListener.eventStart(1, "strings");
      stringsListener.add("Hello", "hi");
      stringsListener.eventEnd(true);

      stringsListener.eventStart(3, "strings");
      stringsListener.add("World", "all");
      stringsListener.eventEnd(true);

      MapListener intListener = createMock("ints", MapListener.class);
      for (int i = 0; i < 3; i++) {
        intListener.eventStart(i * 2, "ints");
        intListener.add(i, i + 1000);
        intListener.eventEnd(true);
      }

      replay(stringsListener);
      replay(intListener);
      Chronicle chronicle = new IndexedChronicle(name);
      DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
      MapWrapper<String, String> strings =
          new MapWrapper<String, String>(
              dataStore,
              "strings",
              String.class,
              String.class,
              new LinkedHashMap<String, String>(),
              16);
      strings.addListener(stringsListener);
      MapWrapper<Integer, Integer> ints =
          new MapWrapper<Integer, Integer>(
              dataStore,
              "ints",
              Integer.class,
              Integer.class,
              new LinkedHashMap<Integer, Integer>(),
              16);
      ints.addListener(intListener);

      dataStore.start();

      ints.put(0, 1000);
      strings.put("Hello", "hi");
      ints.put(1, 1001);
      strings.put("World", "all");
      ints.put(2, 1002);

      verify(stringsListener);
      verify(intListener);

      assertEquals("{Hello=hi, World=all}", strings.toString());
      assertEquals("{0=1000, 1=1001, 2=1002}", ints.toString());

      chronicle.close();
    }
    {
      MapListener stringsListener = createMock("strings", MapListener.class);
      stringsListener.eventStart(5, "strings");
      stringsListener.add("!", "end");
      stringsListener.eventEnd(true);

      MapListener intListener = createMock("ints", MapListener.class);

      intListener.eventStart(6, "ints");
      intListener.add(3, 1003);
      intListener.eventEnd(true);

      replay(stringsListener);
      replay(intListener);

      Chronicle chronicle = new IndexedChronicle(name);
      DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
      MapWrapper<String, String> strings =
          new MapWrapper<String, String>(
              dataStore,
              "strings",
              String.class,
              String.class,
              new LinkedHashMap<String, String>(),
              16);
      strings.addListener(stringsListener);
      MapWrapper<Integer, Integer> ints =
          new MapWrapper<Integer, Integer>(
              dataStore,
              "ints",
              Integer.class,
              Integer.class,
              new LinkedHashMap<Integer, Integer>(),
              16);
      ints.addListener(intListener);

      // assume we have  all the events written so far
      dataStore.start(chronicle.size());

      strings.put("!", "end");
      ints.put(3, 1003);

      verify(stringsListener);
      verify(intListener);

      assertEquals("{Hello=hi, World=all, !=end}", strings.toString());
      assertEquals("{0=1000, 1=1001, 2=1002, 3=1003}", ints.toString());
      chronicle.close();
    }
  }
示例#13
0
  @Test
  public void testMapPerformance() throws IOException {
    String name = TMP + "/map-perf";
    ChronicleTools.deleteOnExit(name);
    long start = System.nanoTime();
    int size = 0;
    {
      Chronicle chronicle = new IndexedChronicle(name);
      DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
      MapWrapper<String, String> strings =
          new MapWrapper<String, String>(
              dataStore,
              "strings",
              String.class,
              String.class,
              new LinkedHashMap<String, String>(),
              16);
      MapWrapper<Integer, Integer> ints =
          new MapWrapper<Integer, Integer>(
              dataStore,
              "ints",
              Integer.class,
              Integer.class,
              new LinkedHashMap<Integer, Integer>(),
              16);
      dataStore.start();
      ints.clear();
      strings.clear();

      for (int j = 0; j < 10000; j++) {
        for (int i = 0; i < 100; i++) {
          ints.put(i, i + j);
          strings.put(Integer.toString(i), Integer.toString(i + j));
        }
        size += Math.min(strings.size(), ints.size());
        for (int i = 0; i < 100; i++) {
          ints.remove(i);
          strings.remove(Integer.toString(i));
        }
      }

      chronicle.close();
    }
    long mid = System.nanoTime();
    {
      Chronicle chronicle = new IndexedChronicle(name);
      DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
      MapWrapper<String, String> strings =
          new MapWrapper<String, String>(
              dataStore,
              "strings",
              String.class,
              String.class,
              new LinkedHashMap<String, String>(),
              16);
      MapWrapper<Integer, Integer> ints =
          new MapWrapper<Integer, Integer>(
              dataStore,
              "ints",
              Integer.class,
              Integer.class,
              new LinkedHashMap<Integer, Integer>(),
              16);
      dataStore.start();
      chronicle.close();
    }
    long end = System.nanoTime();
    System.out.printf(
        "Took %.1f seconds avg to add&remove %,d elements and %.1f seconds avg to reload them%n",
        (mid - start) / 2e9, size, (end - mid) / 2e9);
  }