// already heard about null-containing collections ? I do know them, and they're pure EVIL

          if(v!=null) {

              Vertex valueVertex = service.getVertexFor(v, CascadeType.REFRESH, objectsBeingAccessed);

              if (valueVertex !=null && oldVertices.containsKey(valueVertex)) {

                  GraphUtils.removeSafely(database, oldEdge);

                  if (toCascade.contains(CascadeType.REMOVE)) {

                      service.deleteOutEdgeVertex(objectVertex, valueVertex, v, objectsBeingAccessed);

                  }

              }

            }

            // And finally add new vertices

            int order = 0;

            for (Vertex newVertex : newVertices) {

                // Add a fancy-schmancy property to maintain order in this town

                // This property is not indexed, as it would have absolutely no meaning to query that index

            }

        }

    }

        /* Totally crazy confident non-nullity lack of test :

         * this method is only called when cascade type is either PERSIST or MERGE. In both cases the call to getVertexFor will create the vertex if missing.

         * As a consequence there is no need for nullity check.

         */

        // Get previously existing vertex

        Iterator<Edge> existingIterator = service.getStrategy().getOutEdgesFor(rootVertex, p).iterator();

        // property is single-valued, so iteration can be done at most one

        if (existingIterator.hasNext()) {

            // There is an existing edge, change its target and maybe delete previous one

                // Nothing to do

                link = existing;

            } else {

                // delete old edge (if it exists)

              GraphUtils.removeSafely(database, existing);

    private <DataType> void loadSingle(GraphDatabaseDriver driver, GraphMappingStrategy strategy, ClassLoader classloader, ServiceRepository repository, Property p, DataType returned, Vertex objectVertex, Map<String, Object> objectsBeingAccessed) {

        Iterator<Edge> iterator = strategy.getOutEdgesFor(objectVertex, p).iterator();

        if (iterator.hasNext()) {

            // yeah, there is a value !

            Object value = GraphUtils.createInstance(driver, strategy, classloader, firstVertex, p.getType(), repository, objectsBeingAccessed);

            if (repository.containsKey(value.getClass())) {

                // value requires fields loading

                AbstractBluePrintsBackedFinderService<IndexableGraph, DataType, ?> blueprints = (AbstractBluePrintsBackedFinderService<IndexableGraph, DataType, ?>) repository.get(value.getClass());

                value = loadObject(blueprints, firstVertex, objectsBeingAccessed);

  public static void removeSafely(Graph database, Edge existing) {

    if (logger.isLoggable(REMOVAL_LOG_LEVEL)) {

      logger.log(REMOVAL_LOG_LEVEL, "removing safely " + existing);

    }

    if ((toRemove = database.getEdge(existing.getId())) == null) {

      if (logger.isLoggable(Level.WARNING)) {

        logger.log(Level.WARNING, "We tried to remove non existing edge " + toString(existing));

      }

    } else {

        setIndexedProperty(returned, Properties.kind.name(), Tuples.get(valueClass).getKind().name(), IndexNames.VERTICES);

      }

      // obtain vertex for type

      Vertex classVertex = classTransformer.getVertexFor(getDriver(), valueClass, CascadeType.PERSIST);

      /*

       * Make sure literals are literals by changing that particular edge

       * context to a null value. Notice we COULD have stored literal type

       * as a property, instead of using

       */

 

  }

  public Edge createEdgeFor(Vertex fromVertex, Vertex toVertex, Property property) {

    String edgeNameFor = GraphUtils.getEdgeNameFor(property);

    // Did you know labels are not edges properties ? Absolutely stunning discovery !

    database.getIndex(IndexNames.EDGES.getIndexName(), Edge.class).put("label", edgeNameFor, returned);

    String predicateProperty = GraphUtils.asSailProperty(GraphUtils.getEdgeNameFor(property));

    setIndexedProperty(returned, GraphSail.PREDICATE_PROP, predicateProperty, IndexNames.EDGES);

    Collection<String> contexts = getLens();

          returned = database.addVertex(tupleTransformer.getKind().getURIFor(vertexId, valueClass));

        }

        // obtain vertex for type

        Vertex classVertex = classTransformer.getVertexFor(getDriver(), valueClass, CascadeType.PERSIST);

        /*

         * Make sure literals are literals by changing that particular

         * edge context to a null value. Notice we COULD have stored

         * literal type as a property, instead of using

         */

      }

      // Yup, this if has no default else statement, and that's normal.

      // returned.setProperty(Properties.value.name(), vertexId);

    } catch (RuntimeException e) {

      throw e;

  protected String getEffectiveType(Vertex vertex) {

    if (vertex.getProperty(Properties.type.name()) != null) {

      return TypeUtils.getClass(vertex.getProperty(Properties.type.name()).toString());

    } else {

      // Do not use ClassLiteral here as this method must be blazing fast

      return classTransformer.extractClassIn(getValue(type).toString());

    }

  }

  }

  public Edge createEdgeFor(Vertex fromVertex, Vertex toVertex, Property property) {

    String edgeNameFor = GraphUtils.getEdgeNameFor(property);

    // edge.setProperty(GraphSail.PREDICATE_PROP,

    // GraphSail.URI_PREFIX+" "+GraphUtils.getDefaultEdgeNameFor(property));

    // Create a common context for all gaedo relationships

    // edge.setProperty(GraphSail.CONTEXT_PROP,

    // GraphUtils.asSailProperty(GraphUtils.GAEDO_CONTEXT));