Пример #1
0
  @Override
  public int compareTo(E that) {
    if (that == null) throw new NullPointerException("You cannot compare with null");

    if (this.equals(that)) return 0;

    String thisId = this.getId();
    String thatId = that.getId();

    if (thisId == null) return -1;
    if (thatId == null) return +1;

    int ret = NaturalOrderComparator.get().compare(thisId, thatId);

    // The id's may be the same if these are objects from different collections
    // We avoid zero in an ugly way like this.
    // TODO: Improve by comparing collections and then databases.
    if (ret == 0) {
      ret = -1;
    }

    return ret;
  }
Пример #2
0
public class Coll<E> implements CollInterface<E> {
  // -------------------------------------------- //
  // GLOBAL REGISTRY
  // -------------------------------------------- //

  public static final String TOTAL = "*total*";

  // All instances registered here are considered inited.
  private static Map<String, Coll<?>> name2instance =
      new ConcurrentSkipListMap<String, Coll<?>>(NaturalOrderComparator.get());

  private static Map<String, Coll<?>> umap = Collections.unmodifiableMap(name2instance);
  private static Set<String> unames = Collections.unmodifiableSet(name2instance.keySet());
  private static Collection<Coll<?>> uinstances =
      Collections.unmodifiableCollection(name2instance.values());

  public static Map<String, Coll<?>> getMap() {
    return umap;
  }

  public static Set<String> getNames() {
    return unames;
  }

  public static Collection<Coll<?>> getInstances() {
    return uinstances;
  }

  // -------------------------------------------- //
  // WHAT DO WE HANDLE?
  // -------------------------------------------- //

  protected final String name;

  @Override
  public String getName() {
    return this.name;
  }

  protected final String basename;

  @Override
  public String getBasename() {
    return this.basename;
  }

  protected final String universe;

  @Override
  public String getUniverse() {
    return this.universe;
  }

  protected final Class<E> entityClass;

  @Override
  public Class<E> getEntityClass() {
    return this.entityClass;
  }

  // -------------------------------------------- //
  // SUPPORTING SYSTEM
  // -------------------------------------------- //

  protected Plugin plugin;

  @Override
  public Plugin getPlugin() {
    return this.plugin;
  }

  public Gson getGson() {
    if (this.getPlugin() instanceof MPlugin) {
      return ((MPlugin) this.getPlugin()).gson;
    } else {
      return MCore.gson;
    }
  }

  protected Db db;

  @Override
  public Db getDb() {
    return this.db;
  }

  @Override
  public Driver getDriver() {
    return this.db.getDriver();
  }

  protected Object collDriverObject;

  @Override
  public Object getCollDriverObject() {
    return this.collDriverObject;
  }

  // -------------------------------------------- //
  // STORAGE
  // -------------------------------------------- //

  // All
  protected Set<String> ids;

  // Loaded
  protected Map<String, E> id2entity;
  protected Map<E, String> entity2id;

  @Override
  public Collection<String> getIds() {
    return Collections.unmodifiableCollection(this.ids);
  }

  @Override
  public Map<String, E> getId2entity() {
    return Collections.unmodifiableMap(this.id2entity);
  }

  @Override
  public E get(Object oid) {
    return this.get(oid, this.isCreative());
  }

  @Override
  public E get(Object oid, boolean creative) {
    return this.get(oid, creative, true);
  }

  protected E get(Object oid, boolean creative, boolean noteChange) {
    String id = this.fixId(oid);
    if (id == null) return null;
    E ret = this.id2entity.get(id);
    if (ret != null) return ret;
    if (!creative) return null;
    return this.create(id, noteChange);
  }

  @Override
  public Collection<String> getIdsLoaded() {
    return Collections.unmodifiableCollection(this.id2entity.keySet());
  }

  @Override
  public Collection<String> getIdsRemote() {
    return this.getDb().getDriver().getIds(this);
  }

  @Override
  public boolean containsId(Object oid) {
    String id = this.fixId(oid);
    if (id == null) return false;
    return this.ids.contains(id);
  }

  @Override
  public Map<E, String> getEntity2id() {
    return Collections.unmodifiableMap(this.entity2id);
  }

  @Override
  public String getId(Object entity) {
    return this.entity2id.get(entity);
  }

  @Override
  public boolean containsEntity(Object entity) {
    return this.entity2id.containsKey(entity);
  };

  @Override
  public Collection<E> getAll() {

    return Collections.unmodifiableCollection(this.entity2id.keySet());
  }

  @Override
  public Collection<E> getAll(Predictate<? super E> where) {
    return MStoreUtil.uglySQL(this.getAll(), where, null, null, null);
  }

  @Override
  public Collection<E> getAll(Predictate<? super E> where, Comparator<? super E> orderby) {
    return MStoreUtil.uglySQL(this.getAll(), where, orderby, null, null);
  }

  @Override
  public Collection<E> getAll(
      Predictate<? super E> where, Comparator<? super E> orderby, Integer limit) {
    return MStoreUtil.uglySQL(this.getAll(), where, orderby, limit, null);
  }

  @Override
  public Collection<E> getAll(
      Predictate<? super E> where, Comparator<? super E> orderby, Integer limit, Integer offset) {
    return MStoreUtil.uglySQL(this.getAll(), where, orderby, limit, offset);
  }

  @Override
  public String fixId(Object oid) {
    if (oid == null) return null;

    String ret = null;
    if (oid instanceof String) {
      ret = (String) oid;
    } else if (oid.getClass() == this.entityClass) {
      ret = this.entity2id.get(oid);
    }
    if (ret == null) return null;

    return this.isLowercasing() ? ret.toLowerCase() : ret;
  }

  // -------------------------------------------- //
  // BEHAVIOR
  // -------------------------------------------- //

  protected boolean lazy;

  @Override
  public boolean isLazy() {
    return this.lazy;
  }

  @Override
  public void setLazy(boolean lazy) {
    this.lazy = lazy;
  }

  protected boolean creative;

  @Override
  public boolean isCreative() {
    return this.creative;
  }

  @Override
  public void setCreative(boolean creative) {
    this.creative = creative;
  }

  // "Lowercasing" means that the ids are always converted to lower case when fixed.
  // This is highly recommended for sender colls.
  // The senderIds are case insensitive by nature and some times you simply can't know the correct
  // casing.
  protected boolean lowercasing;

  @Override
  public boolean isLowercasing() {
    return this.lowercasing;
  }

  @Override
  public void setLowercasing(boolean lowercasing) {
    this.lowercasing = lowercasing;
  }

  // Should that instance be saved or not?
  // If it is default it should not be saved.
  @SuppressWarnings("rawtypes")
  @Override
  public boolean isDefault(E entity) {
    if (entity instanceof Entity) {
      return ((Entity) entity).isDefault();
    } else {
      return false;
    }
  }

  // This is used in parallel with the isDefault.
  // Parallel usage is useful since we can then override isDeafult just like before.
  public static boolean isCustomDataDefault(Object entity) {
    if (!(entity instanceof Entity)) return true;
    JsonObject customData = ((Entity<?>) entity).getCustomData();
    if (customData == null) return true;
    if (customData.entrySet().size() == 0) return true;
    return false;
  }

  // -------------------------------------------- //
  // COPY AND CREATE
  // -------------------------------------------- //

  @SuppressWarnings({"rawtypes", "unchecked"})
  public void copy(Object ofrom, Object oto) {
    if (ofrom == null) throw new NullPointerException("ofrom");
    if (oto == null) throw new NullPointerException("oto");

    if (ofrom instanceof Entity) {
      Entity efrom = (Entity) ofrom;
      Entity eto = (Entity) oto;

      eto.load(efrom);
      eto.setCustomData(efrom.getCustomData());
    } else {
      Accessor.get(this.getEntityClass()).copy(ofrom, oto);
    }
  }

  // This simply creates and returns a new instance
  // It does not detach/attach or anything. Just creates a new instance.
  @Override
  public E createNewInstance() {
    try {
      return this.entityClass.newInstance();
    } catch (Exception e) {
      return null;
    }
  }

  // Create new instance with automatic id
  @Override
  public E create() {
    return this.create(null);
  }

  // Create new instance with the requested id
  @Override
  public synchronized E create(Object oid) {
    return this.create(oid, true);
  }

  public synchronized E create(Object oid, boolean noteChange) {
    E entity = this.createNewInstance();
    if (this.attach(entity, oid, noteChange) == null) return null;
    return entity;
  }

  // -------------------------------------------- //
  // ATTACH AND DETACH
  // -------------------------------------------- //

  @Override
  public String attach(E entity) {
    return this.attach(entity, null);
  }

  @Override
  public synchronized String attach(E entity, Object oid) {
    return this.attach(entity, oid, true);
  }

  @SuppressWarnings({"unchecked", "rawtypes"})
  protected synchronized String attach(E entity, Object oid, boolean noteChange) {
    // Check entity
    if (entity == null) return null;
    String id = this.getId(entity);
    if (id != null) return id;

    // Check/Fix id
    if (oid == null) {
      id = MStore.createId();
    } else {
      id = this.fixId(oid);
      if (id == null) return null;
      if (this.id2entity.containsKey(id)) return null;
    }

    // PRE
    this.preAttach(entity, id);

    // Add entity reference info
    if (entity instanceof Entity) {
      ((Entity) entity).setColl(this);
      ((Entity) entity).setid(id);
    }

    // Attach
    this.ids.add(id);
    this.id2entity.put(id, entity);
    this.entity2id.put(entity, id);

    // Make note of the change
    if (noteChange) {
      this.localAttachIds.add(id);
      this.changedIds.add(id);
    }

    // POST
    this.postAttach(entity, id);

    return id;
  }

  @SuppressWarnings("unchecked")
  @Override
  public E detachEntity(Object entity) {
    E e = (E) entity;
    String id = this.getId(e);
    this.detach(e, id);
    return e;
  }

  @Override
  public E detachId(Object oid) {
    String id = this.fixId(oid);
    E e = this.get(id);
    this.detach(e, id);
    return e;
  }

  private void detach(E entity, String id) {
    // PRE
    this.preDetach(entity, id);

    // Remove @ local
    this.removeAtLocal(id);

    // Identify the change
    this.localDetachIds.add(id);
    this.changedIds.add(id);

    // POST
    this.postDetach(entity, id);
  }

  @Override
  public void preAttach(E entity, String id) {
    if (entity instanceof Entity) {
      ((Entity<?>) entity).preAttach(id);
    }
  }

  @Override
  public void postAttach(E entity, String id) {
    if (entity instanceof Entity) {
      ((Entity<?>) entity).postAttach(id);
    }
  }

  @Override
  public void preDetach(E entity, String id) {
    if (entity instanceof Entity) {
      ((Entity<?>) entity).preDetach(id);
    }
  }

  @Override
  public void postDetach(E entity, String id) {
    if (entity instanceof Entity) {
      ((Entity<?>) entity).postDetach(id);
    }
  }

  // -------------------------------------------- //
  // IDENTIFIED CHANGES
  // -------------------------------------------- //

  protected Set<String> localAttachIds;
  protected Set<String> localDetachIds;
  protected Set<String> changedIds;

  protected synchronized void clearIdentifiedChanges(Object oid) {
    String id = this.fixId(oid);
    this.localAttachIds.remove(id);
    this.localDetachIds.remove(id);
    this.changedIds.remove(id);
  }

  // -------------------------------------------- //
  // SYNCLOG
  // -------------------------------------------- //

  protected Map<String, Long> lastMtime;
  protected Map<String, JsonElement> lastRaw;
  protected Set<String> lastDefault;

  protected synchronized void clearSynclog(Object oid) {
    String id = this.fixId(oid);
    this.lastMtime.remove(id);
    this.lastRaw.remove(id);
    this.lastDefault.remove(id);
  }

  // Log database syncronization for display in the "/mcore mstore stats" command.
  private Map<String, Long> id2out = new TreeMap<String, Long>();
  private Map<String, Long> id2in = new TreeMap<String, Long>();

  public Map<String, Long> getSyncMap(boolean in) {
    return in ? this.id2in : this.id2out;
  }

  public long getSyncCount(String id, boolean in) {
    Long count = this.getSyncMap(in).get(id);
    if (count == null) return 0;
    return count;
  }

  public void addSyncCount(String id, boolean in) {
    long count = this.getSyncCount(id, in);
    count++;
    this.getSyncMap(in).put(id, count);
  }

  // -------------------------------------------- //
  // SYNC LOWLEVEL IO ACTIONS
  // -------------------------------------------- //

  @SuppressWarnings({"unchecked", "rawtypes"})
  @Override
  public synchronized E removeAtLocal(Object oid) {
    String id = this.fixId(oid);
    this.clearIdentifiedChanges(id);
    this.clearSynclog(id);

    E entity = this.id2entity.remove(id);
    if (entity == null) return null;

    this.entity2id.remove(entity);

    this.ids.remove(id);

    // Remove entity reference info
    if (entity instanceof Entity) {
      ((Entity) entity).setColl(null);
      ((Entity) entity).setid(null);
    }

    return entity;
  }

  @Override
  public synchronized void removeAtRemote(Object oid) {
    String id = this.fixId(oid);

    this.clearIdentifiedChanges(id);
    this.clearSynclog(id);

    this.getDb().getDriver().delete(this, id);
  }

  @Override
  public synchronized void saveToRemote(Object oid) {
    String id = this.fixId(oid);

    this.clearIdentifiedChanges(id);
    this.clearSynclog(id);

    E entity = this.id2entity.get(id);
    if (entity == null) return;

    JsonElement raw = this.getGson().toJsonTree(entity, this.getEntityClass());
    this.lastRaw.put(id, raw);

    if (this.isDefault(entity) && isCustomDataDefault(entity)) {
      this.db.getDriver().delete(this, id);
      this.lastDefault.add(id);
    } else {
      Long mtime = this.db.getDriver().save(this, id, raw);
      if (mtime == null)
        return; // This fail should not happen often. We could handle it better though.
      this.lastMtime.put(id, mtime);
    }
  }

  @Override
  public synchronized void loadFromRemote(Object oid) {
    String id = this.fixId(oid);

    this.clearIdentifiedChanges(id);

    Entry<JsonElement, Long> entry = null;
    try {
      entry = this.getDriver().load(this, id);
    } catch (Exception e) {
      MCore.get()
          .log(
              Txt.parse(
                  "<b>Database could not load entity. You edited a file manually and made wrong JSON?"));
      MCore.get().log(Txt.parse("<k>Error: <v>%s", e.getMessage()));
      MCore.get().log(Txt.parse("<k>Entity: <v>%s", id));
      MCore.get().log(Txt.parse("<k>Collection: <v>%s", this.getName()));
      return;
    }
    if (entry == null) return;

    JsonElement raw = entry.getKey();
    if (raw == null) return;

    Long mtime = entry.getValue();
    if (mtime == null) return;

    E entity = this.get(id, false);
    if (entity != null) {
      // It did already exist
      this.copy(this.getGson().fromJson(raw, this.getEntityClass()), entity);
    } else {
      // Create first
      entity = this.createNewInstance();

      // Copy over data first
      this.copy(this.getGson().fromJson(raw, this.getEntityClass()), entity);

      // Then attach!
      this.attach(entity, oid, false);
    }

    this.lastRaw.put(id, raw);
    this.lastMtime.put(id, mtime);
    this.lastDefault.remove(id);
  }

  // -------------------------------------------- //
  // SYNC DECIDE AND BASIC DO
  // -------------------------------------------- //

  @Override
  public ModificationState examineId(Object oid) {
    String id = this.fixId(oid);
    return this.examineId(id, null, false);
  }

  @Override
  public ModificationState examineId(Object oid, Long remoteMtime) {
    String id = this.fixId(oid);
    return this.examineId(id, remoteMtime, true);
  }

  protected ModificationState examineId(Object oid, Long remoteMtime, boolean remoteMtimeSupplied) {
    String id = this.fixId(oid);

    if (this.localDetachIds.contains(id)) return ModificationState.LOCAL_DETACH;
    if (this.localAttachIds.contains(id)) return ModificationState.LOCAL_ATTACH;

    E localEntity = this.id2entity.get(id);
    if (!remoteMtimeSupplied) {
      remoteMtime = this.getDriver().getMtime(this, id);
    }

    boolean existsLocal = (localEntity != null);
    boolean existsRemote = (remoteMtime != null);

    if (!existsLocal && !existsRemote) return ModificationState.UNKNOWN;

    if (existsLocal && existsRemote) {
      Long lastMtime = this.lastMtime.get(id);
      if (remoteMtime.equals(lastMtime) == false) return ModificationState.REMOTE_ALTER;

      if (this.examineHasLocalAlter(id, localEntity)) return ModificationState.LOCAL_ALTER;
    } else if (existsLocal) {
      if (this.lastDefault.contains(id)) {
        if (this.examineHasLocalAlter(id, localEntity)) return ModificationState.LOCAL_ALTER;
      } else {
        return ModificationState.REMOTE_DETACH;
      }
    } else if (existsRemote) {
      return ModificationState.REMOTE_ATTACH;
    }

    return ModificationState.NONE;
  }

  protected boolean examineHasLocalAlter(String id, E entity) {
    JsonElement lastRaw = this.lastRaw.get(id);
    JsonElement currentRaw = null;

    try {
      currentRaw = this.getGson().toJsonTree(entity, this.getEntityClass());
    } catch (Exception e) {
      MCore.get()
          .log(
              Txt.parse(
                  "<b>Database examineHasLocalAlter failed convert current entity to JSON tree."));
      MCore.get().log(Txt.parse("<k>Error: <v>%s", e.getMessage()));
      MCore.get().log(Txt.parse("<k>Entity: <v>%s", id));
      MCore.get().log(Txt.parse("<k>Collection: <v>%s", this.getName()));
      throw e;
    }

    return !MStore.equal(lastRaw, currentRaw);
  }

  @Override
  public ModificationState syncId(Object oid) {
    String id = this.fixId(oid);

    ModificationState mstate = this.examineId(id);

    // mplugin.log("syncId: It seems", id, "has state", mstate);

    switch (mstate) {
      case LOCAL_ALTER:
      case LOCAL_ATTACH:
        this.saveToRemote(id);
        if (this.inited()) {
          this.addSyncCount(TOTAL, false);
          this.addSyncCount(id, false);
        }
        break;
      case LOCAL_DETACH:
        this.removeAtRemote(id);
        if (this.inited()) {
          this.addSyncCount(TOTAL, false);
          this.addSyncCount(id, false);
        }
        break;
      case REMOTE_ALTER:
      case REMOTE_ATTACH:
        this.loadFromRemote(id);
        if (this.inited()) {
          this.addSyncCount(TOTAL, true);
          this.addSyncCount(id, true);
        }
        break;
      case REMOTE_DETACH:
        this.removeAtLocal(id);
        if (this.inited()) {
          this.addSyncCount(TOTAL, true);
          this.addSyncCount(id, true);
        }
        break;
      default:
        this.clearIdentifiedChanges(id);
        break;
    }

    return mstate;
  }

  @Override
  public void syncSuspects() {
    for (String id : this.changedIds) {
      this.syncId(id);
    }
  }

  @Override
  public void syncAll() {
    // Find all ids
    Set<String> allids = new HashSet<String>(this.id2entity.keySet());
    allids.addAll(this.getDriver().getIds(this));
    for (String id : allids) {
      this.syncId(id);
    }
  }

  @Override
  public void findSuspects() {
    // Get remote id and mtime snapshot
    Map<String, Long> id2RemoteMtime = this.getDb().getDriver().getId2mtime(this);

    // Compile a list of all ids (both remote and local)
    Set<String> allids = new HashSet<String>();
    allids.addAll(id2RemoteMtime.keySet());
    allids.addAll(this.ids);

    // Check for modifications
    for (String id : allids) {
      Long remoteMtime = id2RemoteMtime.get(id);
      ModificationState state = this.examineId(id, remoteMtime);
      // mplugin.log("findSuspects: It seems", id, "has state", state);
      if (state.isModified()) {
        // System.out.println("It seems "+id+" has state "+state);
        this.changedIds.add(id);
      }
    }
  }

  // -------------------------------------------- //
  // SYNC RUNNABLES / SCHEDULING
  // -------------------------------------------- //

  protected Runnable tickTask;

  @Override
  public Runnable getTickTask() {
    return this.tickTask;
  }

  @Override
  public void onTick() {
    this.syncSuspects();
  }

  // -------------------------------------------- //
  // CONSTRUCT
  // -------------------------------------------- //

  public Coll(
      String name,
      Class<E> entityClass,
      Db db,
      Plugin plugin,
      boolean lazy,
      boolean creative,
      boolean lowercasing,
      Comparator<? super String> idComparator,
      Comparator<? super E> entityComparator) {
    // Setup the name and the parsed parts
    this.name = name;
    String[] nameParts = this.name.split("\\@");
    this.basename = nameParts[0];
    if (nameParts.length > 1) {
      this.universe = nameParts[1];
    } else {
      this.universe = null;
    }

    // WHAT DO WE HANDLE?
    this.entityClass = entityClass;
    this.lazy = lazy;
    this.creative = creative;
    this.lowercasing = lowercasing;

    // SUPPORTING SYSTEM
    this.plugin = plugin;
    this.db = db;
    this.collDriverObject = db.getCollDriverObject(this);

    // STORAGE
    this.ids = new ConcurrentSkipListSet<String>(idComparator);
    this.id2entity = new ConcurrentSkipListMap<String, E>(idComparator);
    this.entity2id = new ConcurrentSkipListMap<E, String>(entityComparator);

    // IDENTIFIED CHANGES
    this.localAttachIds = new ConcurrentSkipListSet<String>(idComparator);
    this.localDetachIds = new ConcurrentSkipListSet<String>(idComparator);
    this.changedIds = new ConcurrentSkipListSet<String>(idComparator);

    // SYNCLOG
    this.lastMtime = new ConcurrentSkipListMap<String, Long>(idComparator);
    this.lastRaw = new ConcurrentSkipListMap<String, JsonElement>(idComparator);
    this.lastDefault = new ConcurrentSkipListSet<String>(idComparator);

    final Coll<E> me = this;
    this.tickTask =
        new Runnable() {
          @Override
          public void run() {
            me.onTick();
          }
        };
  }

  public Coll(
      String name,
      Class<E> entityClass,
      Db db,
      Plugin plugin,
      boolean lazy,
      boolean creative,
      boolean lowercasing) {
    this(name, entityClass, db, plugin, lazy, creative, lowercasing, null, null);
  }

  public Coll(String name, Class<E> entityClass, Db db, Plugin plugin) {
    this(name, entityClass, db, plugin, false, false, false);
  }

  @Override
  public void init() {
    if (this.inited()) return;

    // TODO: Could this be more efficient by considering it's the first sync?
    this.syncAll();

    name2instance.put(this.getName(), this);
  }

  @Override
  public void deinit() {
    if (!this.inited()) return;

    // TODO: Save outwards only? We may want to avoid loads at this stage...
    this.syncAll();

    name2instance.remove(this.getName());
  }

  @Override
  public boolean inited() {
    return name2instance.containsKey(this.getName());
  }
}