Example #1
0
  /**
   * Creates a full path from given string. Creates sub-categories as needed.
   *
   * @param path String of the format /cat1/cat2/cat3
   * @param persistent whether persistent or transient category Meems should be created
   * @return Last category in path as a Meem
   */
  protected Meem createPath(String path, boolean persistent) {
    List<String> paths = new LinkedList<String>();

    StringTokenizer tok = new StringTokenizer(path, "/");
    while (tok.hasMoreTokens()) {
      paths.add(tok.nextToken());
    }

    // work backwards through path to see if any of the categories already exist.

    int iUpto = paths.size() + 1;

    Meem meem = null;
    do {
      iUpto--;

      StringBuffer pathBuffer = new StringBuffer();
      for (int i = 0; i < iUpto; i++) {
        pathBuffer.append("/");
        pathBuffer.append((String) paths.get(i));
      }

      MeemPath currentPath = MeemPath.spi.create(Space.HYPERSPACE, pathBuffer.toString());

      meem = MeemPathResolverHelper.getInstance().resolveMeemPath(currentPath);
    } while (meem == null);

    // meem should be a Category

    Category category = (Category) ReferenceHelper.getTarget(meem, "category", Category.class);

    Meem newCategoryMeem = meem;

    for (int i = iUpto; i < paths.size(); i++) {
      // create a new category
      if (persistent) {
        newCategoryMeem =
            LifeCycleManagerHelper.doCreateMeem(
                getCategoryDefinition(), newCategoryMeem, LifeCycleState.READY);
      } else {
        newCategoryMeem = LifeCycleManagerHelper.createTransientMeem(getCategoryDefinition());
      }

      category.addEntry((String) paths.get(i), newCategoryMeem);

      category = (Category) ReferenceHelper.getTarget(newCategoryMeem, "category", Category.class);

      ConfigurationHandler ch =
          (ConfigurationHandler)
              ReferenceHelper.getTarget(
                  newCategoryMeem, "configurationHandler", ConfigurationHandler.class);
      ConfigurationIdentifier ci = new ConfigurationIdentifier("MeemSystemWedge", "meemIdentifier");
      ch.valueChanged(ci, (String) paths.get(i));
    }

    return newCategoryMeem;
  }
Example #2
0
  public synchronized HyperSpace getHyperSpace() {
    if (hyperSpace == null && hyperSpaceMeem != null) {
      hyperSpace = ReferenceHelper.getTarget(getHyperSpaceMeem(), "hyperSpace", HyperSpace.class);
    }

    return hyperSpace;
  }
Example #3
0
  /**
   * Asynchronous and preferred way to get Hyperspace.
   *
   * @param callback
   */
  public synchronized void getHyperSpace(final AsyncCallback<HyperSpace> callback) {
    if (hyperSpace == null && hyperSpaceMeem != null) {
      ReferenceHelper.getTarget(
          getHyperSpaceMeem(),
          "hyperSpace",
          HyperSpace.class,
          new AsyncCallback<HyperSpace>() {
            public void result(HyperSpace result) {
              hyperSpace = result;
              callback.result(result);
            };

            public void exception(Exception e) {
              callback.exception(e);
            }
          });
    } else {
      callback.result(hyperSpace);
    }
  }
Example #4
0
 public Category getCategory(MeemPath meemPath) {
   Meem meem = MeemPathResolverHelper.getInstance().resolveMeemPath(meemPath);
   return (Category) ReferenceHelper.getTarget(meem, "category", Category.class);
 }