<?php
/**
 * PHP implementation of JSON-LD.
 *
 * @author Dave Longley
 *
 * Copyright (c) 2011 Digital Bazaar, Inc. All rights reserved.
 */
define('__S', '@subject');
define('__T', '@type');
define('JSONLD_RDF', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#');
define('JSONLD_RDF_TYPE', JSONLD_RDF . 'type');
define('JSONLD_XSD', 'http://www.w3.org/2001/XMLSchema#');
define('JSONLD_XSD_ANY_TYPE', JSONLD_XSD . 'anyType');
define('JSONLD_XSD_BOOLEAN', JSONLD_XSD . 'boolean');
define('JSONLD_XSD_DOUBLE', JSONLD_XSD . 'double');
define('JSONLD_XSD_INTEGER', JSONLD_XSD . 'integer');
define('JSONLD_XSD_ANY_URI', JSONLD_XSD . 'anyURI');

/**
 * Normalizes a JSON-LD object.
 *
 * @param input the JSON-LD object to normalize.
 *
 * @return the normalized JSON-LD object.
 */
function jsonld_normalize($input)
{
   $p = new JsonLdProcessor();
   return $p->normalize($input);
};

/**
 * Removes the context from a JSON-LD object, expanding it to full-form.
 *
 * @param input the JSON-LD object to remove the context from.
 *
 * @return the context-neutral JSON-LD object.
 */
function jsonld_expand($input)
{
   $rval = null;

   if($input !== null)
   {
      $rval = _expand(new stdClass(), null, $input, false);
   }

   return $rval;
};

/**
 * Expands the given JSON-LD object and then compacts it using the
 * given context.
 *
 * @param ctx the new context to use.
 * @param input the input JSON-LD object.
 *
 * @return the output JSON-LD object.
 */
function jsonld_compact($ctx, $input)
{
   $rval = null;

   // TODO: should context simplification be optional? (ie: remove context
   // entries that are not used in the output)

   if($input !== null)
   {
      // fully expand input
      $input = jsonld_expand($input);

      if(is_array($input))
      {
         $rval = array();
         $tmp = $input;
      }
      else
      {
         $tmp = array($input);
      }

      foreach($tmp as $value)
      {
         // setup output context
         $ctxOut = new stdClass();

         // compact
         $out = _compact(_clone($ctx), null, $value, $ctxOut);

         // add context if used
         if(count(array_keys((array)$ctxOut)) > 0)
         {
            $out->{'@context'} = $ctxOut;
         }

         if($rval === null)
         {
            $rval = $out;
         }
         else
         {
            $rval[] = $out;
         }
      }
   }

   return $rval;
}

/**
 * Merges one context with another.
 *
 * @param ctx1 the context to overwrite/append to.
 * @param ctx2 the new context to merge onto ctx1.
 *
 * @return the merged context.
 */
function jsonld_merge_contexts($ctx1, $ctx2)
{
   // copy contexts
   $merged = _clone($ctx1);
   $copy = _clone($ctx2);

   // if the new context contains any IRIs that are in the merged context,
   // remove them from the merged context, they will be overwritten
   foreach($copy as $key => $value)
   {
      // ignore special keys starting with '@'
      if(strpos($key, '@') !== 0)
      {
         foreach($merged as $mkey => $mvalue)
         {
            if($mvalue === $value)
            {
               unset($merged->$mkey);
               break;
            }
         }
      }
   }

   // @coerce must be specially-merged, remove from contexts
   $coerceExists =
      property_exists($merged, '@coerce') or
      property_exists($copy, '@coerce');
   if($coerceExists)
   {
      $c1 = property_exists($merged, '@coerce') ?
         $merged->{'@coerce'} : new stdClass();
      $c2 = property_exists($copy, '@coerce') ?
         $copy->{'@coerce'} : new stdClass();
      unset($merged->{'@coerce'});
      unset($copy->{'@coerce'});
   }

   // merge contexts
   foreach($copy as $key => $value)
   {
      $merged->$key = $value;
   }

   // special-merge @coerce
   if($coerceExists)
   {
      foreach($c1 as $type => $p1)
      {
         // append existing-type properties that don't already exist
         if(property_exists($c2, $type))
         {
            $p2 = $c2->$type;

            // normalize props in c2 to array for single-code-path iterating
            if(!is_array($p2))
            {
               $p2 = array($p2);
            }

            // add unique properties from p2 to p1
            foreach($p2 as $i => $p)
            {
               if((!is_array($p1) and $p1 !== $p) or
                  (is_array($p1) and array_search($p, $p1) === false))
               {
                  if(is_array($p1))
                  {
                     $p1[] = $p;
                  }
                  else
                  {
                     $p1 = array($p1, $p);
                  }
               }
            }

            $c1->$type = $p1;
         }
      }

      // add new types from new @coerce
      foreach($c2 as $type => $value)
      {
         if(!property_exists($c1, $type))
         {
            $c1->$type = $value;
         }
      }

      // ensure there are no property duplicates in @coerce
      $unique = new stdClass();
      $dups = array();
      foreach($c1 as $type => $p)
      {
         if(is_string($p))
         {
            $p = array($p);
         }
         foreach($p as $v)
         {
            if(!property_exists($unique, $v))
            {
               $unique->$v = true;
            }
            else if(!in_array($v, $dups))
            {
               $dups[] = $v;
            }
         }
      }

      if(count($dups)> 0)
      {
         throw new Exception(
            'Invalid type coercion specification. More than one ' .
            'type specified for at least one property. duplicates=' .
            print_r(dups, true));
      }

      $merged->{'@coerce'} = $c1;
   }

   return $merged;
}

/**
 * Expands a term into an absolute IRI. The term may be a regular term, a
 * CURIE, a relative IRI, or an absolute IRI. In any case, the associated
 * absolute IRI will be returned.
 *
 * @param ctx the context to use.
 * @param term the term to expand.
 *
 * @return the expanded term as an absolute IRI.
 */
function jsonld_expand_term($ctx, $term)
{
   return _expandTerm($ctx, $term);
}

/**
 * Compacts an IRI into a term or CURIE if it can be. IRIs will not be
 * compacted to relative IRIs if they match the given context's default
 * vocabulary.
 *
 * @param ctx the context to use.
 * @param iri the IRI to compact.
 *
 * @return the compacted IRI as a term or CURIE or the original IRI.
 */
function jsonld_compact_iri($ctx, $iri)
{
   return _compactIri($ctx, $iri, null);
}

/**
 * Frames JSON-LD input.
 *
 * @param input the JSON-LD input.
 * @param frame the frame to use.
 * @param options framing options to use.
 *
 * @return the framed output.
 */
function jsonld_frame($input, $frame, $options=null)
{
   $rval;

   // normalize input
   $input = jsonld_normalize($input);

   // save frame context
   $ctx = null;
   if(property_exists($frame, '@context'))
   {
      $ctx = _clone($frame->{'@context'});
   }

   // remove context from frame
   $frame = jsonld_expand($frame);

   // create framing options
   // TODO: merge in options from function parameter
   $options = new stdClass();
   $options->defaults = new stdClass();
   $options->defaults->embedOn = true;
   $options->defaults->explicitOn = false;
   $options->defaults->omitDefaultOn = false;

   // build map of all subjects
   $subjects = new stdClass();
   foreach($input as $i)
   {
      $subjects->{$i->{__S}->{'@iri'}} = $i;
   }

   // frame input
   $rval = _frame($subjects, $input, $frame, new stdClass(), $options);

   // apply context
   if($ctx !== null and $rval !== null)
   {
      $rval = jsonld_compact($ctx, $rval);
   }

   return $rval;
}

/**
 * Compacts an IRI into a term or CURIE if it can be. IRIs will not be
 * compacted to relative IRIs if they match the given context's default
 * vocabulary.
 *
 * @param ctx the context to use.
 * @param iri the IRI to compact.
 * @param usedCtx a context to update if a value was used from "ctx".
 *
 * @return the compacted IRI as a term or CURIE or the original IRI.
 */
function _compactIri($ctx, $iri, $usedCtx)
{
   $rval = null;

   // check the context for a term that could shorten the IRI
   // (give preference to terms over CURIEs)
   foreach($ctx as $key => $value)
   {
      // skip special context keys (start with '@')
      if(strlen($key) > 0 and $key[0] !== '@')
      {
         // compact to a term
         if($iri === $ctx->$key)
         {
            $rval = $key;
            if($usedCtx !== null)
            {
               $usedCtx->$key = $ctx->$key;
            }
            break;
         }
      }
   }

   // term not found, if term is rdf type, use built-in keyword
   if($rval === null and $iri === JSONLD_RDF_TYPE)
   {
      $rval = __T;
   }

   // term not found, check the context for a CURIE prefix
   if($rval === null)
   {
      foreach($ctx as $key => $value)
      {
         // skip special context keys (start with '@')
         if(strlen($key) > 0 and $key[0] !== '@')
         {
            // see if IRI begins with the next IRI from the context
            $ctxIri = $ctx->$key;
            $idx = strpos($iri, $ctxIri);

            // compact to a CURIE
            if($idx === 0 and strlen($iri) > strlen($ctxIri))
            {
               $rval = $key . ':' . substr($iri, strlen($ctxIri));
               if($usedCtx !== null)
               {
                  $usedCtx->$key = $ctxIri;
               }
               break;
            }
         }
      }
   }

   // could not compact IRI
   if($rval === null)
   {
      $rval = $iri;
   }

   return $rval;
}

/**
 * Expands a term into an absolute IRI. The term may be a regular term, a
 * CURIE, a relative IRI, or an absolute IRI. In any case, the associated
 * absolute IRI will be returned.
 *
 * @param ctx the context to use.
 * @param term the term to expand.
 * @param usedCtx a context to update if a value was used from "ctx".
 *
 * @return the expanded term as an absolute IRI.
 */
function _expandTerm($ctx, $term, $usedCtx)
{
   $rval;

   // 1. If the property has a colon, then it is a CURIE or an absolute IRI:
   $idx = strpos($term, ':');
   if($idx !== false)
   {
      // get the potential CURIE prefix
      $prefix = substr($term, 0, $idx);

      // 1.1. See if the prefix is in the context:
      if(property_exists($ctx, $prefix))
      {
         // prefix found, expand property to absolute IRI
         $rval = $ctx->$prefix . substr($term, $idx + 1);
         if($usedCtx !== null)
         {
            $usedCtx->$prefix = $ctx->$prefix;
         }
      }
      // 1.2. Prefix is not in context, property is already an absolute IRI:
      else
      {
         $rval = $term;
      }
   }
   // 2. If the property is in the context, then it's a term.
   else if(property_exists($ctx, $term))
   {
      $rval = $ctx->$term;
      if($usedCtx !== null)
      {
         $usedCtx->$term = $rval;
      }
   }
   // 3. The property is the special-case subject.
   else if($term === __S)
   {
      $rval = __S;
   }
   // 4. The property is the special-case rdf type.
   else if($term === __T)
   {
      $rval = JSONLD_RDF_TYPE;
   }
   // 5. The property is a relative IRI, prepend the default vocab.
   else
   {
      $rval = $term;
      if(property_exists($ctx, '@vocab'))
      {
         $rval = $ctx->{'@vocab'} . $rval;
         if($usedCtx !== null)
         {
            $usedCtx->{'@vocab'} = $ctx->{'@vocab'};
         }
      }
   }

   return $rval;
}

/**
 * Sets a subject's property to the given object value. If a value already
 * exists, it will be appended to an array.
 *
 * @param s the subject.
 * @param p the property.
 * @param o the object.
 */
function _setProperty($s, $p, $o)
{
   if(property_exists($s, $p))
   {
      if(is_array($s->$p))
      {
         array_push($s->$p, $o);
      }
      else
      {
         $s->$p = array($s->$p, $o);
      }
   }
   else
   {
      $s->$p = $o;
   }
}

/**
 * Clones an object, array, or string/number. If cloning an object, the keys
 * will be sorted.
 *
 * @param value the value to clone.
 *
 * @return the cloned value.
 */
function _clone($value)
{
   $rval;

   if(is_object($value))
   {
      $rval = new stdClass();
      $keys = array_keys((array)$value);
      sort($keys);
      foreach($keys as $key)
      {
         $rval->$key = _clone($value->$key);
      }
   }
   else if(is_array($value))
   {
      $rval = array();
      foreach($value as $v)
      {
         $rval[] = _clone($v);
      }
   }
   else
   {
      $rval = $value;
   }

   return $rval;
}

/**
 * Gets the coerce type for the given property.
 *
 * @param ctx the context to use.
 * @param property the property to get the coerced type for.
 * @param usedCtx a context to update if a value was used from "ctx".
 *
 * @return the coerce type, null for none.
 */
function _getCoerceType($ctx, $property, $usedCtx)
{
   $rval = null;

   // get expanded property
   $p = _expandTerm($ctx, $property, null);

   // built-in type coercion JSON-LD-isms
   if($p === __S or $p === JSONLD_RDF_TYPE)
   {
      $rval = JSONLD_XSD_ANY_URI;
   }
   // check type coercion for property
   else if(property_exists($ctx, '@coerce'))
   {
      // force compacted property
      $p = _compactIri($ctx, $p, null);

      foreach($ctx->{'@coerce'} as $type => $props)
      {
         // get coerced properties (normalize to an array)
         if(!is_array($props))
         {
            $props = array($props);
         }

         // look for the property in the array
         foreach($props as $prop)
         {
            // property found
            if($prop === $p)
            {
               $rval = _expandTerm($ctx, $type, $usedCtx);
               if($usedCtx !== null)
               {
                  if(!property_exists($usedCtx, '@coerce'))
                  {
                     $usedCtx->{'@coerce'} = new stdClass();
                  }

                  if(!property_exists($usedCtx->{'@coerce'}, $type))
                  {
                     $usedCtx->{'@coerce'}->$type = $p;
                  }
                  else
                  {
                     $c = $usedCtx->{'@coerce'}->$type;
                     if(is_array($c) and in_array($p, $c) or
                        is_string($c) and $c !== $p)
                     {
                        _setProperty($usedCtx->{'@coerce'}, $type, $p);
                     }
                  }
               }
               break;
            }
         }
      }
   }

   return $rval;
}

/**
 * Recursively compacts a value. This method will compact IRIs to CURIEs or
 * terms and do reverse type coercion to compact a value.
 *
 * @param ctx the context to use.
 * @param property the property that points to the value, NULL for none.
 * @param value the value to compact.
 * @param usedCtx a context to update if a value was used from "ctx".
 *
 * @return the compacted value.
 */
function _compact($ctx, $property, $value, $usedCtx)
{
   $rval;

   if($value === null)
   {
      // return null, but check coerce type to add to usedCtx
      $rval = null;
      _getCoerceType($ctx, $property, $usedCtx);
   }
   else if(is_array($value))
   {
      // recursively add compacted values to array
      $rval = array();
      foreach($value as $v)
      {
         $rval[] = _compact($ctx, $property, $v, $usedCtx);
      }
   }
   // graph literal/disjoint graph
   else if(
      is_object($value) and
      property_exists($value, __S) and is_array($value->{__S}))
   {
      $rval = new stdClass();
      $rval->{__S} = _compact($ctx, $property, $value->{__S}, $usedCtx);
   }
   // value has sub-properties if it doesn't define a literal or IRI value
   else if(
      is_object($value) and
      !property_exists($value, '@literal') and
      !property_exists($value, '@iri'))
   {
      // recursively handle sub-properties that aren't a sub-context
      $rval = new stdClass();
      foreach($value as $key => $v)
      {
         if($v !== '@context')
         {
            // set object to compacted property, only overwrite existing
            // properties if the property actually compacted
            $p = _compactIri($ctx, $key, $usedCtx);
            if($p !== $key or !property_exists($rval, $p))
            {
               $rval->$p = _compact($ctx, $key, $v, $usedCtx);
            }
         }
      }
   }
   else
   {
      // get coerce type
      $coerce = _getCoerceType($ctx, $property, $usedCtx);

      // get type from value, to ensure coercion is valid
      $type = null;
      if(is_object($value))
      {
         // type coercion can only occur if language is not specified
         if(!property_exists($value, '@language'))
         {
            // datatype must match coerce type if specified
            if(property_exists($value, '@datatype'))
            {
               $type = $value->{'@datatype'};
            }
            // datatype is IRI
            else if(property_exists($value, '@iri'))
            {
               $type = JSONLD_XSD_ANY_URI;
            }
            // can be coerced to any type
            else
            {
               $type = $coerce;
            }
         }
      }
      // type can be coerced to anything
      else if(is_string($value))
      {
         $type = $coerce;
      }

      // types that can be auto-coerced from a JSON-builtin
      if($coerce === null and
         ($type === JSONLD_XSD_BOOLEAN or $type === JSONLD_XSD_INTEGER or
         $type === JSONLD_XSD_DOUBLE))
      {
         $coerce = $type;
      }

      // do reverse type-coercion
      if($coerce !== null)
      {
         // type is only null if a language was specified, which is an error
         // if type coercion is specified
         if($type === null)
         {
            throw new Exception(
               'Cannot coerce type when a language is specified. ' .
               'The language information would be lost.');
         }
         // if the value type does not match the coerce type, it is an error
         else if($type !== $coerce)
         {
            throw new Exception(
               'Cannot coerce type because the datatype does not match.');
         }
         // do reverse type-coercion
         else
         {
            if(is_object($value))
            {
               if(property_exists($value, '@iri'))
               {
                  $rval = $value->{'@iri'};
               }
               else if(property_exists($value, '@literal'))
               {
                  $rval = $value->{'@literal'};
               }
            }
            else
            {
               $rval = $value;
            }

            // do basic JSON types conversion
            if($coerce === JSONLD_XSD_BOOLEAN)
            {
               $rval = ($rval === 'true' or $rval != 0);
            }
            else if($coerce === JSONLD_XSD_DOUBLE)
            {
               $rval = floatval($rval);
            }
            else if($coerce === JSONLD_XSD_INTEGER)
            {
               $rval = intval($rval);
            }
         }
      }
      // no type-coercion, just copy value
      else
      {
         $rval = _clone($value);
      }

      // compact IRI
      if($type === JSONLD_XSD_ANY_URI)
      {
         if(is_object($rval))
         {
            $rval->{'@iri'} = _compactIri($ctx, $rval->{'@iri'}, $usedCtx);
         }
         else
         {
            $rval = _compactIri($ctx, $rval, $usedCtx);
         }
      }
   }

   return $rval;
}

/**
 * Recursively expands a value using the given context. Any context in
 * the value will be removed.
 *
 * @param ctx the context.
 * @param property the property that points to the value, NULL for none.
 * @param value the value to expand.
 * @param expandSubjects true to expand subjects (normalize), false not to.
 *
 * @return the expanded value.
 */
function _expand($ctx, $property, $value, $expandSubjects)
{
   $rval;

   // TODO: add data format error detection?

   // value is null, nothing to expand
   if($value === null)
   {
      $rval = null;
   }
   // if no property is specified and the value is a string (this means the
   // value is a property itself), expand to an IRI
   else if($property === null and is_string($value))
   {
      $rval = _expandTerm($ctx, $value, null);
   }
   else if(is_array($value))
   {
      // recursively add expanded values to array
      $rval = array();
      foreach($value as $v)
      {
         $rval[] = _expand($ctx, $property, $v, $expandSubjects);
      }
   }
   else if(is_object($value))
   {
      // value has sub-properties if it doesn't define a literal or IRI value
      if(!(property_exists($value, '@literal') or
         property_exists($value, '@iri')))
      {
         // if value has a context, use it
         if(property_exists($value, '@context'))
         {
            $ctx = jsonld_merge_contexts($ctx, $value->{'@context'});
         }

         // recursively handle sub-properties that aren't a sub-context
         $rval = new stdClass();
         foreach($value as $key => $v)
         {
            // preserve frame keywords
            if($key === '@embed' or $key === '@explicit' or
               $key === '@default' or $key === '@omitDefault')
            {
               _setProperty($rval, $key, _clone($v));
            }
            else if($key !== '@context')
            {
               // set object to expanded property
               _setProperty(
                  $rval, _expandTerm($ctx, $key, null),
                  _expand($ctx, $key, $v, $expandSubjects));
            }
         }
      }
      // value is already expanded
      else
      {
         $rval = _clone($value);
      }
   }
   else
   {
      // do type coercion
      $coerce = _getCoerceType($ctx, $property, null);

      // automatic coercion for basic JSON types
      if($coerce === null and !is_string($value) and
         (is_numeric($value) or is_bool($value)))
      {
         if(is_bool($value))
         {
            $coerce = JSONLD_XSD_BOOLEAN;
         }
         else if(is_int($value))
         {
            $coerce = JSONLD_XSD_INTEGER;
         }
         else
         {
            $coerce = JSONLD_XSD_DOUBLE;
         }
      }

      // coerce to appropriate datatype, only expand subjects if requested
      if($coerce !== null and ($property !== __S or $expandSubjects))
      {
         $rval = new stdClass();

         // expand IRI
         if($coerce === JSONLD_XSD_ANY_URI)
         {
            $rval->{'@iri'} = _expandTerm($ctx, $value, null);
         }
         // other datatype
         else
         {
            $rval->{'@datatype'} = $coerce;
            if($coerce === JSONLD_XSD_DOUBLE)
            {
               // do special JSON-LD double format
               $value = preg_replace(
                  '/(e(?:\+|-))([0-9])$/', '${1}0${2}',
                  sprintf('%1.6e', $value));
            }
            else if($coerce === JSONLD_XSD_BOOLEAN)
            {
               $value = $value ? 'true' : 'false';
            }
            $rval->{'@literal'} = '' . $value;
         }
      }
      // nothing to coerce
      else
      {
         $rval = '' . $value;
      }
   }

   return $rval;
}

function _isBlankNodeIri($v)
{
   return strpos($v, '_:') === 0;
}

function _isNamedBlankNode($v)
{
   // look for "_:" at the beginning of the subject
   return (
      is_object($v) and property_exists($v, __S) and
      property_exists($v->{__S}, '@iri') and
      _isBlankNodeIri($v->{__S}->{'@iri'}));
}

function _isBlankNode($v)
{
   // look for no subject or named blank node
   return (
      is_object($v) and
      !(property_exists($v, '@iri') or property_exists($v, '@literal')) and
      (!property_exists($v, __S) or _isNamedBlankNode($v)));
}

/**
 * Compares two values.
 *
 * @param v1 the first value.
 * @param v2 the second value.
 *
 * @return -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2.
 */
function _compare($v1, $v2)
{
   $rval = 0;

   if(is_array($v1) and is_array($v2))
   {
      $length = count($v1);
      for($i = 0; $i < $length and $rval === 0; ++$i)
      {
         $rval = _compare($v1[$i], $v2[$i]);
      }
   }
   else
   {
      $rval = ($v1 < $v2 ? -1 : ($v1 > $v2 ? 1 : 0));
   }

   return $rval;
}

/**
 * Compares two keys in an object. If the key exists in one object
 * and not the other, the object with the key is less. If the key exists in
 * both objects, then the one with the lesser value is less.
 *
 * @param o1 the first object.
 * @param o2 the second object.
 * @param key the key.
 *
 * @return -1 if o1 < o2, 0 if o1 == o2, 1 if o1 > o2.
 */
function _compareObjectKeys($o1, $o2, $key)
{
   $rval = 0;
   if(property_exists($o1, $key))
   {
      if(property_exists($o2, $key))
      {
         $rval = _compare($o1->$key, $o2->$key);
      }
      else
      {
         $rval = -1;
      }
   }
   else if(property_exists($o2, $key))
   {
      $rval = 1;
   }
   return $rval;
}

/**
 * Compares two object values.
 *
 * @param o1 the first object.
 * @param o2 the second object.
 *
 * @return -1 if o1 < o2, 0 if o1 == o2, 1 if o1 > o2.
 */
function _compareObjects($o1, $o2)
{
   $rval = 0;

   if(is_string($o1))
   {
      if(!is_string($o2))
      {
         $rval = -1;
      }
      else
      {
         $rval = _compare($o1, $o2);
      }
   }
   else if(is_string($o2))
   {
      $rval = 1;
   }
   else
   {
      $rval = _compareObjectKeys($o1, $o2, '@literal');
      if($rval === 0)
      {
         if(property_exists($o1, '@literal'))
         {
            $rval = _compareObjectKeys($o1, $o2, '@datatype');
            if($rval === 0)
            {
               $rval = _compareObjectKeys($o1, $o2, '@language');
            }
         }
         // both are '@iri' objects
         else
         {
            $rval = _compare($o1->{'@iri'}, $o2->{'@iri'});
         }
      }
   }

   return $rval;
}

/**
 * Filter function for bnodes.
 *
 * @param e the array element.
 *
 * @return true to return the element in the filter results, false not to.
 */
function _filterBlankNodes($e)
{
   return (is_string($e) or
      !(property_exists($e, '@iri') and _isBlankNodeIri($e->{'@iri'})));
}

/**
 * Compares the object values between two bnodes.
 *
 * @param a the first bnode.
 * @param b the second bnode.
 *
 * @return -1 if a < b, 0 if a == b, 1 if a > b.
 */
function _compareBlankNodeObjects($a, $b)
{
   $rval = 0;

   /*
   3. For each property, compare sorted object values.
   3.1. The bnode with fewer objects is first.
   3.2. For each object value, compare only literals and non-bnodes.
   3.2.1.  The bnode with fewer non-bnodes is first.
   3.2.2. The bnode with a string object is first.
   3.2.3. The bnode with the alphabetically-first string is first.
   3.2.4. The bnode with a @literal is first.
   3.2.5. The bnode with the alphabetically-first @literal is first.
   3.2.6. The bnode with the alphabetically-first @datatype is first.
   3.2.7. The bnode with a @language is first.
   3.2.8. The bnode with the alphabetically-first @language is first.
   3.2.9. The bnode with the alphabetically-first @iri is first.
   */

   foreach($a as $p => $value)
   {
      // step #3.1
      $lenA = is_array($a->$p) ? count($a->$p) : 1;
      $lenB = is_array($b->$p) ? count($b->$p) : 1;
      $rval = _compare($lenA, $lenB);

      // step #3.2.1
      if($rval === 0)
      {
         // normalize objects to an array
         $objsA = $a->$p;
         $objsB = $b->$p;
         if(!is_array($objsA))
         {
            $objsA = array($objsA);
            $objsB = array($objsB);
         }

         // filter non-bnodes (remove bnodes from comparison)
         $objsA = array_filter($objsA, '_filterBlankNodes');
         $objsB = array_filter($objsB, '_filterBlankNodes');
         $objsALen = count($objsA);
         $rval = _compare($objsALen, count($objsB));
      }

      // steps #3.2.2-3.2.9
      if($rval === 0)
      {
         usort($objsA, '_compareObjects');
         usort($objsB, '_compareObjects');
         for($i = 0; $i < $objsALen and $rval === 0; ++$i)
         {
            $rval = _compareObjects($objsA[$i], $objsB[$i]);
         }
      }

      if($rval !== 0)
      {
         break;
      }
   }

   return $rval;
}

/**
 * A blank node name generator that uses a prefix and counter.
 */
class NameGenerator
{
   public function __construct($prefix)
   {
      $this->count = -1;
      $this->base = '_:' . $prefix;
   }

   public function next()
   {
      $this->count += 1;
      return $this->current();
   }

   public function current()
   {
      return $this->base . $this->count;
   }

   public function inNamespace($iri)
   {
      return strpos($iri, $this->base) === 0;
   }
}

/**
 * Populates a map of all named subjects from the given input and an array
 * of all unnamed bnodes (includes embedded ones).
 *
 * @param input the input (must be expanded, no context).
 * @param subjects the subjects map to populate.
 * @param bnodes the bnodes array to populate.
 */
function _collectSubjects($input, $subjects, $bnodes)
{
   if($input === null)
   {
      // nothing to collect
   }
   else if(is_array($input))
   {
      foreach($input as $value)
      {
         _collectSubjects($value, $subjects, $bnodes);
      }
   }
   else if(is_object($input))
   {
      if(property_exists($input, __S))
      {
         // graph literal
         if(is_array($input->{__S}))
         {
            _collectSubjects($input->{__S}, $subjects, $bnodes);
         }
         // named subject
         else
         {
            $subjects->{$input->{__S}->{'@iri'}} = $input;
         }
      }
      // unnamed blank node
      else if(_isBlankNode($input))
      {
         $bnodes[] = $input;
      }

      // recurse through subject properties
      foreach($input as $value)
      {
         _collectSubjects($value, $subjects, $bnodes);
      }
   }
}

/**
 * Filters duplicate IRIs.
 */
class DuplicateIriFilter
{
   public function __construct($iri)
   {
      $this->iri = $iri;
   }

   public function filter($e)
   {
      return (is_object($e) and property_exists($e, '@iri') and
         $e->{'@iri'} === $this->iri);
   }
}

/**
 * Flattens the given value into a map of unique subjects. It is assumed that
 * all blank nodes have been uniquely named before this call. Array values for
 * properties will be sorted.
 *
 * @param parent the value's parent, NULL for none.
 * @param parentProperty the property relating the value to the parent.
 * @param value the value to flatten.
 * @param subjects the map of subjects to write to.
 */
function _flatten($parent, $parentProperty, $value, $subjects)
{
   $flattened = null;

   if($value === null)
   {
      // drop null values
   }
   else if(is_array($value))
   {
      // list of objects or a disjoint graph
      foreach($value as $v)
      {
         _flatten($parent, $parentProperty, $v, $subjects);
      }
   }
   else if(is_object($value))
   {
      // graph literal/disjoint graph
      if(property_exists($value, __S) and is_array($value->{__S}))
      {
         // cannot flatten embedded graph literals
         if($parent !== null)
         {
            throw new Exception('Embedded graph literals cannot be flattened.');
         }

         // top-level graph literal
         foreach($value->{__S} as $k => $v)
         {
            _flatten($parent, $parentProperty, $v, $subjects);
         }
      }
      // already-expanded value
      else if(
         property_exists($value, '@literal') or
         property_exists($value, '@iri'))
      {
         $flattened = _clone($value);
      }
      // subject
      else
      {
         // create or fetch existing subject
         if(property_exists($subjects, $value->{__S}->{'@iri'}))
         {
            // FIXME: __S might be a graph literal (as {})
            $subject = $subjects->{$value->{__S}->{'@iri'}};
         }
         else
         {
            $subject = new stdClass();
            if(property_exists($value, __S))
            {
               // FIXME: __S might be a graph literal (as {})
               $subjects->{$value->{__S}->{'@iri'}} = $subject;
            }
         }
         $flattened = $subject;

         // flatten embeds
         foreach($value as $key => $v)
         {
            // drop null values
            if($v !== null)
            {
               if(property_exists($subject, $key))
               {
                  if(!is_array($subject->$key))
                  {
                     $subject->$key = new ArrayObject(array($subject->$key));
                  }
                  else
                  {
                     $subject->$key = new ArrayObject($subject->$key);
                  }
               }
               else
               {
                  $subject->$key = new ArrayObject();
               }

               _flatten($subject->$key, null, $value->$key, $subjects);
               $subject->$key = (array)$subject->$key;
               if(count($subject->$key) === 1)
               {
                  // convert subject[key] to object if it has only 1
                  $arr = $subject->$key;
                  $subject->$key = $arr[0];
               }
            }
         }
      }
   }
   // string value
   else
   {
      $flattened = $value;
   }

   // add flattened value to parent
   if($flattened !== null and $parent !== null)
   {
      // remove top-level __s for subjects
      // 'http://mypredicate': {'@subject': {'@iri': 'http://mysubject'}}
      // becomes
      // 'http://mypredicate': {'@iri': 'http://mysubject'}
      if(is_object($flattened) and property_exists($flattened, __S))
      {
         $flattened = $flattened->{__S};
      }

      if($parent instanceof ArrayObject)
      {
         // do not add duplicate IRIs for the same property
         $duplicate = false;
         if(is_object($flattened) and property_exists($flattened, '@iri'))
         {
            $duplicate = count(array_filter(
               (array)$parent, array(
                  new DuplicateIriFilter($flattened->{'@iri'}), 'filter'))) > 0;
         }
         if(!$duplicate)
         {
            $parent[] = $flattened;
         }
      }
      else
      {
         $parent->$parentProperty = $flattened;
      }
   }
};

/**
 * A MappingBuilder is used to build a mapping of existing blank node names
 * to a form for serialization. The serialization is used to compare blank
 * nodes against one another to determine a sort order.
 */
class MappingBuilder
{
   /**
    * Constructs a new MappingBuilder.
    */
   public function __construct()
   {
      $this->count = 1;
      $this->processed = new stdClass();
      $this->mapping = new stdClass();
      $this->adj = new stdClass();
      $this->keyStack = array();
      $entry = new stdClass();
      $entry->keys = array('s1');
      $entry->idx = 0;
      $this->keyStack[] = $entry;
      $this->done = new stdClass();
      $this->s = '';
   }

   /**
    * Copies this MappingBuilder.
    *
    * @return the MappingBuilder copy.
    */
   public function copy()
   {
      $rval = new MappingBuilder();
      $rval->count = $this->count;
      $rval->processed = _clone($this->processed);
      $rval->mapping = _clone($this->mapping);
      $rval->adj = _clone($this->adj);
      $rval->keyStack = _clone($this->keyStack);
      $rval->done = _clone($this->done);
      $rval->s = $this->s;
      return $rval;
   }

   /**
    * Maps the next name to the given bnode IRI if the bnode IRI isn't already
    * in the mapping. If the given bnode IRI is canonical, then it will be
    * given a shortened form of the same name.
    *
    * @param iri the blank node IRI to map the next name to.
    *
    * @return the mapped name.
    */
   public function mapNode($iri)
   {
      if(!property_exists($this->mapping, $iri))
      {
         if(strpos($iri, '_:c14n') === 0)
         {
            $this->mapping->$iri = 'c' . substr($iri, 6);
         }
         else
         {
            $this->mapping->$iri = 's' . $this->count++;
         }
      }
      return $this->mapping->$iri;
   }
}

/**
 * Rotates the elements in an array one position.
 *
 * @param a the array.
 */
function _rotate(&$a)
{
  $e = array_shift($a);
  array_push($a, $e);
  return $e;
}

/**
 * Compares two serializations for the same blank node. If the two
 * serializations aren't complete enough to determine if they are equal (or if
 * they are actually equal), 0 is returned.
 *
 * @param s1 the first serialization.
 * @param s2 the second serialization.
 *
 * @return -1 if s1 < s2, 0 if s1 == s2 (or indeterminate), 1 if s1 > v2.
 */
function _compareSerializations($s1, $s2)
{
   $rval = 0;

   $s1Len = strlen($s1);
   $s2Len = strlen($s2);
   if($s1Len == $s2Len)
   {
      $rval = strcmp($s1, $s2);
   }
   else
   {
      $rval = strncmp($s1, $s2, ($s1Len > $s2Len) ? $s2Len : $s1Len);
   }

   return $rval;
}

/**
 * Compares two nodes based on their iris.
 *
 * @param a the first node.
 * @param b the second node.
 *
 * @return -1 if iriA < iriB, 0 if iriA == iriB, 1 if iriA > iriB.
 */
function _compareIris($a, $b)
{
   return _compare($a->{__S}->{'@iri'}, $b->{__S}->{'@iri'});
}

/**
 * Filters blank node edges.
 *
 * @param e the edge to check.
 *
 * @return true if the edge is a blank node edge.
 */
function _filterBlankNodeEdges($e)
{
   return _isBlankNodeIri($e->s);
}

/**
 * Sorts mapping keys based on their associated mapping values.
 */
class MappingKeySorter
{
   public function __construct($mapping)
   {
      $this->mapping = $mapping;
   }

   public function compare($a, $b)
   {
      return _compare($this->mapping->$a, $this->mapping->$b);
   }
}

/**
 * A container for JSON-LD processing state.
 */
class JsonLdProcessor
{
   /**
    * Constructs a JSON-LD processor.
    */
   public function __construct()
   {
      $this->ng = new stdClass();
      $this->ng->tmp = null;
      $this->ng->c14n = null;
   }

   /**
    * Normalizes a JSON-LD object.
    *
    * @param input the JSON-LD object to normalize.
    *
    * @return the normalized JSON-LD object.
    */
   public function normalize($input)
   {
      $rval = array();

      // TODO: validate context

      if($input !== null)
      {
         // expand input
         $expanded = _expand(new stdClass(), null, $input, true);

         // assign names to unnamed bnodes
         $this->nameBlankNodes($expanded);

         // flatten
         $subjects = new stdClass();
         _flatten(null, null, $expanded, $subjects);

         // append subjects with sorted properties to array
         foreach($subjects as $key => $s)
         {
            $sorted = new stdClass();
            $keys = array_keys((array)$s);
            sort($keys);
            foreach($keys as $i => $k)
            {
               $sorted->$k = $s->$k;
            }
            $rval[] = $sorted;
         }

         // canonicalize blank nodes
         $this->canonicalizeBlankNodes($rval);

         // sort output
         usort($rval, '_compareIris');
      }

      return $rval;
   }

   /**
    * Assigns unique names to blank nodes that are unnamed in the given input.
    *
    * @param input the input to assign names to.
    */
   public function nameBlankNodes($input)
   {
      // create temporary blank node name generator
      $ng = $this->ng->tmp = new NameGenerator('tmp');

      // collect subjects and unnamed bnodes
      $subjects = new stdClass();
      $bnodes = new ArrayObject();
      _collectSubjects($input, $subjects, $bnodes);

      // uniquely name all unnamed bnodes
      foreach($bnodes as $i => $bnode)
      {
         if(!property_exists($bnode, __S))
         {
            // generate names until one is unique
            while(property_exists($subjects, $ng->next()));
            $bnode->{__S} = new stdClass();
            $bnode->{__S}->{'@iri'} = $ng->current();
            $subjects->{$ng->current()} = $bnode;
         }
      }
   }

   /**
    * Renames a blank node, changing its references, etc. The method assumes
    * that the given name is unique.
    *
    * @param b the blank node to rename.
    * @param id the new name to use.
    */
   public function renameBlankNode($b, $id)
   {
      $old = $b->{__S}->{'@iri'};

      // update bnode IRI
      $b->{__S}->{'@iri'} = $id;

      // update subjects map
      $subjects = $this->subjects;
      $subjects->$id = $subjects->$old;
      unset($subjects->$old);

      // update reference and property lists
      $this->edges->refs->$id = $this->edges->refs->$old;
      $this->edges->props->$id = $this->edges->props->$old;
      unset($this->edges->refs->$old);
      unset($this->edges->props->$old);

      // update references to this bnode
      $refs = $this->edges->refs->$id->all;
      foreach($refs as $i => $r)
      {
         $iri = $r->s;
         if($iri === $old)
         {
            $iri = $id;
         }
         $ref = $subjects->$iri;
         $props = $this->edges->props->$iri->all;
         foreach($props as $prop)
         {
            if($prop->s === $old)
            {
               $prop->s = $id;

               // normalize property to array for single code-path
               $p = $prop->p;
               $tmp = is_object($ref->$p) ? array($ref->$p) :
                  (is_array($ref->$p) ? $ref->$p : array());
               $length = count($tmp);
               for($n = 0; $n < $length; ++$n)
               {
                  if(is_object($tmp[$n]) and
                     property_exists($tmp[$n], '@iri') and
                     $tmp[$n]->{'@iri'} === $old)
                  {
                     $tmp[$n]->{'@iri'} = $id;
                  }
               }
            }
         }
      }

      // update references from this bnode
      $props = $this->edges->props->$id->all;
      foreach($props as $prop)
      {
         $iri = $prop->s;
         $refs = $this->edges->refs->$iri->all;
         foreach($refs as $r)
         {
            if($r->s === $old)
            {
               $r->s = $id;
            }
         }
      }
   }

   /**
    * Canonically names blank nodes in the given input.
    *
    * @param input the flat input graph to assign names to.
    */
   public function canonicalizeBlankNodes($input)
   {
      // create serialization state
      $this->renamed = new stdClass();
      $this->mappings = new stdClass();
      $this->serializations = new stdClass();

      // collect subjects and bnodes from flat input graph
      $edges = $this->edges = new stdClass();
      $edges->refs = new stdClass();
      $edges->props = new stdClass();
      $subjects = $this->subjects = new stdClass();
      $bnodes = array();
      foreach($input as $v)
      {
         $iri = $v->{__S}->{'@iri'};
         $subjects->$iri = $v;
         $edges->refs->$iri = new stdClass();
         $edges->refs->$iri->all = array();
         $edges->refs->$iri->bnodes = array();
         $edges->props->$iri = new stdClass();
         $edges->props->$iri->all = array();
         $edges->props->$iri->bnodes = array();
         if(_isBlankNodeIri($iri))
         {
            $bnodes[] = $v;
         }
      }

      // collect edges in the graph
      $this->collectEdges();

      // create canonical blank node name generator
      $c14n = $this->ng->c14n = new NameGenerator('c14n');
      $ngTmp = $this->ng->tmp;

      // rename all bnodes that happen to be in the c14n namespace
      // and initialize serializations
      foreach($bnodes as $i => $bnode)
      {
         $iri = $bnode->{__S}->{'@iri'};
         if($c14n->inNamespace($iri))
         {
            // generate names until one is unique
            while(property_exists($subjects, $ngTmp->next()));
            $this->renameBlankNode($bnode, $ngTmp->current());
            $iri = $bnode->{__S}->{'@iri'};
         }
         $this->serializations->$iri = new stdClass();
         $this->serializations->$iri->props = null;
         $this->serializations->$iri->refs = null;
      }

      // keep sorting and naming blank nodes until they are all named
      while(count($bnodes) > 0)
      {
         usort($bnodes, array($this, 'deepCompareBlankNodes'));

         // name all bnodes according to the first bnode's relation mappings
         $bnode = array_shift($bnodes);
         $iri = $bnode->{__S}->{'@iri'};
         $dirs = array('props', 'refs');
         foreach($dirs as $dir)
         {
            // if no serialization has been computed, name only the first node
            if($this->serializations->$iri->$dir === null)
            {
               $mapping = new stdClass();
               $mapping->$iri = 's1';
            }
            else
            {
               $mapping = $this->serializations->$iri->$dir->m;
            }

            // sort keys by value to name them in order
            $keys = array_keys((array)$mapping);
            usort($keys, array(new MappingKeySorter($mapping), 'compare'));

            // name bnodes in mapping
            $renamed = array();
            foreach($keys as $i => $iriK)
            {
               if(!$c14n->inNamespace($iri) and
                  property_exists($subjects, $iriK))
               {
                  $this->renameBlankNode($subjects->$iriK, $c14n->next());
                  $renamed[] = $iriK;
               }
            }

            // only keep non-canonically named bnodes
            $tmp = $bnodes;
            $bnodes = array();
            foreach($tmp as $i => $b)
            {
               $iriB = $b->{__S}->{'@iri'};
               if(!$c14n->inNamespace($iriB))
               {
                  // mark serializations related to the named bnodes as dirty
                  foreach($renamed as $r)
                  {
                     $this->markSerializationDirty($iriB, $r, $dir);
                  }
                  $bnodes[] = $b;
               }
            }
         }
      }

      // sort property lists that now have canonically-named bnodes
      foreach($edges->props as $key => $value)
      {
         if(count($value->bnodes) > 0)
         {
            $bnode = $subjects->$key;
            foreach($bnode as $p => $v)
            {
               if(strpos($p, '@') !== 0 and is_array($v))
               {
                  usort($v, '_compareObjects');
                  $bnode->$p = $v;
               }
            }
         }
      }
   }

   /**
    * Marks a relation serialization as dirty if necessary.
    *
    * @param iri the IRI of the bnode to check.
    * @param changed the old IRI of the bnode that changed.
    * @param dir the direction to check ('props' or 'refs').
    */
   public function markSerializationDirty($iri, $changed, $dir)
   {
      $s = $this->serializations->$iri;
      if($s->$dir !== null and property_exists($s->$dir->m, $changed))
      {
         $s->$dir = null;
      }
   }

   /**
    * Serializes the properties of the given bnode for its relation
    * serialization.
    *
    * @param b the blank node.
    *
    * @return the serialized properties.
    */
   public function serializeProperties($b)
   {
      $rval = '';

      $first = true;
      foreach($b as $p => $o)
      {
         if($p !== '@subject')
         {
            if($first)
            {
               $first = false;
            }
            else
            {
               $rval .= '|';
            }

            // property
            $rval .= '<' . $p . '>';

            // object(s)
            $objs = is_array($o) ? $o : array($o);
            foreach($objs as $obj)
            {
               if(is_object($obj))
               {
                  // iri
                  if(property_exists($obj, '@iri'))
                  {
                     if(_isBlankNodeIri($obj->{'@iri'}))
                     {
                        $rval .= '_:';
                     }
                     else
                     {
                        $rval .= '<' . $obj->{'@iri'} . '>';
                     }
                  }
                  // literal
                  else
                  {
                     $rval .= '"' . $obj->{'@literal'} . '"';

                     // datatype literal
                     if(property_exists($obj, '@datatype'))
                     {
                        $rval .= '^^<' . $obj->{'@datatype'} . '>';
                     }
                     // language literal
                     else if(property_exists($obj, '@language'))
                     {
                        $rval .= '@' . $obj->{'@language'};
                     }
                  }
               }
               // plain literal
               else
               {
                  $rval .= '"' . $obj . '"';
               }
            }
         }
      }

      return $rval;
   }

   /**
    * Recursively increments the relation serialization for a mapping.
    *
    * @param mb the mapping builder to update.
    */
   public function serializeMapping($mb)
   {
      if(count($mb->keyStack) > 0)
      {
         // continue from top of key stack
         $next = array_pop($mb->keyStack);
         $len = count($next->keys);
         for(; $next->idx < $len; ++$next->idx)
         {
            $k = $next->keys[$next->idx];
            if(!property_exists($mb->adj, $k))
            {
               $mb->keyStack[] = $next;
               break;
            }

            if(property_exists($mb->done, $k))
            {
               // mark cycle
               $mb->s .= '_' . $k;
            }
            else
            {
               // mark key as serialized
               $mb->done->$k = true;

               // serialize top-level key and its details
               $s = $k;
               $adj = $mb->adj->$k;
               $iri = $adj->i;
               if(property_exists($this->subjects, $iri))
               {
                  $b = $this->subjects->$iri;

                  // serialize properties
                  $s .= '[' . $this->serializeProperties($b) . ']';

                  // serialize references
                  $s .= '[';
                  $first = true;
                  $refs = $this->edges->refs->$iri->all;
                  foreach($refs as $r)
                  {
                     if($first)
                     {
                        $first = false;
                     }
                     else
                     {
                        $s .= '|';
                     }
                     $s .= '<' . $r->p . '>';
                     $s .= _isBlankNodeIri($r->s) ?
                        '_:' : ('<' . $refs->s . '>');
                  }
                  $s .= ']';
               }

               // serialize adjacent node keys
               $s .= implode($adj->k);
               $mb->s .= $s;
               $entry = new stdClass();
               $entry->keys = $adj->k;
               $entry->idx = 0;
               $mb->keyStack[] = $entry;
               $this->serializeMapping($mb);
            }
         }
      }
   }

   /**
    * Recursively serializes adjacent bnode combinations.
    *
    * @param s the serialization to update.
    * @param iri the IRI of the bnode being serialized.
    * @param siri the serialization name for the bnode IRI.
    * @param mb the MappingBuilder to use.
    * @param dir the edge direction to use ('props' or 'refs').
    * @param mapped all of the already-mapped adjacent bnodes.
    * @param notMapped all of the not-yet mapped adjacent bnodes.
    */
   public function serializeCombos(
      $s, $iri, $siri, $mb, $dir, $mapped, $notMapped)
   {
      // handle recursion
      if(count($notMapped) > 0)
      {
         // copy mapped nodes
         $mapped = _clone($mapped);

         // map first bnode in list
         $mapped->{$mb->mapNode($notMapped[0]->s)} = $notMapped[0]->s;

         // recurse into remaining possible combinations
         $original = $mb->copy();
         $notMapped = array_slice($notMapped, 1);
         $rotations = max(1, count($notMapped));
         for($r = 0; $r < $rotations; ++$r)
         {
            $m = ($r === 0) ? $mb : $original->copy();
            $this->serializeCombos(
               $s, $iri, $siri, $m, $dir, $mapped, $notMapped);

            // rotate not-mapped for next combination
            _rotate($notMapped);
         }
      }
      // no more adjacent bnodes to map, update serialization
      else
      {
         $keys = array_keys((array)$mapped);
         sort($keys);
         $entry = new stdClass();
         $entry->i = $iri;
         $entry->k = $keys;
         $entry->m = $mapped;
         $mb->adj->$siri = $entry;
         $this->serializeMapping($mb);

         // optimize away mappings that are already too large
         if($s->$dir === null or
            _compareSerializations($mb->s, $s->$dir->s) <= 0)
         {
            // recurse into adjacent values
            foreach($keys as $i => $k)
            {
               $this->serializeBlankNode($s, $mapped->$k, $mb, $dir);
            }

            // update least serialization if new one has been found
            $this->serializeMapping($mb);
            if($s->$dir === null or
               (_compareSerializations($mb->s, $s->$dir->s) <= 0 and
               strlen($mb->s) >= strlen($s->$dir->s)))
            {
               $s->$dir = new stdClass();
               $s->$dir->s = $mb->s;
               $s->$dir->m = $mb->mapping;
            }
         }
      }
   }

   /**
    * Computes the relation serialization for the given blank node IRI.
    *
    * @param s the serialization to update.
    * @param iri the current bnode IRI to be mapped.
    * @param mb the MappingBuilder to use.
    * @param dir the edge direction to use ('props' or 'refs').
    */
   public function serializeBlankNode($s, $iri, $mb, $dir)
   {
      // only do mapping if iri not already processed
      if(!property_exists($mb->processed, $iri))
      {
         // iri now processed
         $mb->processed->$iri = true;
         $siri = $mb->mapNode($iri);

         // copy original mapping builder
         $original = $mb->copy();

         // split adjacent bnodes on mapped and not-mapped
         $adjs = $this->edges->$dir->$iri->bnodes;
         $mapped = new stdClass();
         $notMapped = array();
         foreach($adjs as $adj)
         {
            if(property_exists($mb->mapping, $adj->s))
            {
               $mapped->{$mb->mapping->{$adj->s}} = $adj->s;
            }
            else
            {
               $notMapped[] = $adj;
            }
         }

         // TODO: ensure this optimization does not alter canonical order

         // if the current bnode already has a serialization, reuse it
         /*$hint = property_exists($this->serializations, $iri) ?
            $this->serializations->$iri->$dir : null;
         if($hint !== null)
         {
            $hm = $hint->m;
            usort(notMapped,
            {
               return _compare(hm[a.s], hm[b.s]);
            });
            for($i in notMapped)
            {
               mapped[mb.mapNode(notMapped[i].s)] = notMapped[i].s;
            }
            notMapped = array();
         }*/

         // loop over possible combinations
         $combos = max(1, count($notMapped));
         for($i = 0; $i < $combos; ++$i)
         {
            $m = ($i === 0) ? $mb : $original->copy();
            $this->serializeCombos(
               $s, $iri, $siri, $mb, $dir, $mapped, $notMapped);
         }
      }
   }

   /**
    * Compares two blank nodes for equivalence.
    *
    * @param a the first blank node.
    * @param b the second blank node.
    *
    * @return -1 if a < b, 0 if a == b, 1 if a > b.
    */
   public function deepCompareBlankNodes($a, $b)
   {
      $rval = 0;

      // compare IRIs
      $iriA = $a->{__S}->{'@iri'};
      $iriB = $b->{__S}->{'@iri'};
      if($iriA === $iriB)
      {
         $rval = 0;
      }
      else
      {
         // do shallow compare first
         $rval = $this->shallowCompareBlankNodes($a, $b);

         // deep comparison is necessary
         if($rval === 0)
         {
            // compare property edges and then reference edges
            $dirs = array('props', 'refs');
            for($i = 0; $rval === 0 and $i < 2; ++$i)
            {
               // recompute 'a' and 'b' serializations as necessary
               $dir = $dirs[$i];
               $sA = $this->serializations->$iriA;
               $sB = $this->serializations->$iriB;
               if($sA->$dir === null)
               {
                  $mb = new MappingBuilder();
                  if($dir === 'refs')
                  {
                     // keep same mapping and count from 'props' serialization
                     $mb->mapping = _clone($sA->props->m);
                     $mb->count = count(array_keys((array)$mb->mapping)) + 1;
                  }
                  $this->serializeBlankNode($sA, $iriA, $mb, $dir);
               }
               if($sB->$dir === null)
               {
                  $mb = new MappingBuilder();
                  if($dir === 'refs')
                  {
                     // keep same mapping and count from 'props' serialization
                     $mb->mapping = _clone($sB->props->m);
                     $mb->count = count(array_keys((array)$mb->mapping)) + 1;
                  }
                  $this->serializeBlankNode($sB, $iriB, $mb, $dir);
               }

               // compare serializations
               $rval = _compare($sA->$dir->s, $sB->$dir->s);
            }
         }
      }

      return $rval;
   }

   /**
    * Performs a shallow sort comparison on the given bnodes.
    *
    * @param a the first bnode.
    * @param b the second bnode.
    *
    * @return -1 if a < b, 0 if a == b, 1 if a > b.
    */
   public function shallowCompareBlankNodes($a, $b)
   {
      $rval = 0;

      /* ShallowSort Algorithm (when comparing two bnodes):
         1. Compare the number of properties.
         1.1. The bnode with fewer properties is first.
         2. Compare alphabetically sorted-properties.
         2.1. The bnode with the alphabetically-first property is first.
         3. For each property, compare object values.
         4. Compare the number of references.
         4.1. The bnode with fewer references is first.
         5. Compare sorted references.
         5.1. The bnode with the reference iri (vs. bnode) is first.
         5.2. The bnode with the alphabetically-first reference iri is first.
         5.3. The bnode with the alphabetically-first reference property is
            first.
       */
      $pA = array_keys((array)$a);
      $pB = array_keys((array)$b);

      // step #1
      $rval = _compare(count($pA), count($pB));

      // step #2
      if($rval === 0)
      {
         sort($pA);
         sort($pB);
         $rval = _compare($pA, $pB);
      }

      // step #3
      if($rval === 0)
      {
         $rval = _compareBlankNodeObjects($a, $b);
      }

      // step #4
      if($rval === 0)
      {
         $edgesA = $this->edges->refs->{$a->{__S}->{'@iri'}}->all;
         $edgesB = $this->edges->refs->{$b->{__S}->{'@iri'}}->all;
         $edgesALen = count($edgesA);
         $rval = _compare($edgesALen, count($edgesB));
      }

      // step #5
      if($rval === 0)
      {
         for($i = 0; $i < $edgesALen and $rval === 0; ++$i)
         {
            $rval = $this->compareEdges($edgesA[$i], $edgesB[$i]);
         }
      }

      return $rval;
   }

   /**
    * Compares two edges. Edges with an IRI (vs. a bnode ID) come first, then
    * alphabetically-first IRIs, then alphabetically-first properties. If a
    * blank node has been canonically named, then blank nodes will be compared
    * after properties (with a preference for canonically named over
    * non-canonically named), otherwise they won't be.
    *
    * @param a the first edge.
    * @param b the second edge.
    *
    * @return -1 if a < b, 0 if a == b, 1 if a > b.
    */
   public function compareEdges($a, $b)
   {
      $rval = 0;

      $bnodeA = _isBlankNodeIri($a->s);
      $bnodeB = _isBlankNodeIri($b->s);
      $c14n = $this->ng->c14n;

      // if not both bnodes, one that is a bnode is greater
      if($bnodeA != $bnodeB)
      {
         $rval = $bnodeA ? 1 : -1;
      }
      else
      {
         if(!$bnodeA)
         {
            $rval = _compare($a->s, $b->s);
         }
         if($rval === 0)
         {
            $rval = _compare($a->p, $b->p);
         }

         // do bnode IRI comparison if canonical naming has begun
         if($rval === 0 and $c14n !== null)
         {
            $c14nA = $c14n->inNamespace($a->s);
            $c14nB = $c14n->inNamespace($b->s);
            if($c14nA != $c14nB)
            {
               $rval = $c14nA ? 1 : -1;
            }
            else if($c14nA)
            {
               $rval = _compare($a->s, $b->s);
            }
         }
      }

      return $rval;
   }

   /**
    * Populates the given reference map with all of the subject edges in the
    * graph. The references will be categorized by the direction of the edges,
    * where 'props' is for properties and 'refs' is for references to a subject
    * as an object. The edge direction categories for each IRI will be sorted
    * into groups 'all' and 'bnodes'.
    */
   public function collectEdges()
   {
      $refs = $this->edges->refs;
      $props = $this->edges->props;

      // collect all references and properties
      foreach($this->subjects as $iri => $subject)
      {
         foreach($subject as $key => $object)
         {
            if($key !== __S)
            {
               // normalize to array for single codepath
               $tmp = !is_array($object) ? array($object) : $object;
               foreach($tmp as $o)
               {
                  if(is_object($o) and property_exists($o, '@iri') and
                     property_exists($this->subjects, $o->{'@iri'}))
                  {
                     $objIri = $o->{'@iri'};

                     // map object to this subject
                     $e = new stdClass();
                     $e->s = $iri;
                     $e->p = $key;
                     $refs->$objIri->all[] = $e;

                     // map this subject to object
                     $e = new stdClass();
                     $e->s = $objIri;
                     $e->p = $key;
                     $props->$iri->all[] = $e;
                  }
               }
            }
         }
      }

      // create sorted categories
      foreach($refs as $iri => $ref)
      {
         usort($ref->all, array($this, 'compareEdges'));
         $ref->bnodes = array_filter($ref->all, '_filterBlankNodeEdges');
      }
      foreach($props as $iri => $prop)
      {
         usort($prop->all, array($this, 'compareEdges'));
         $prop->bnodes = array_filter($prop->all, '_filterBlankNodeEdges');
      }
   }
}

/**
 * Returns true if the given input is a subject and has one of the given types
 * in the given frame.
 *
 * @param input the input.
 * @param frame the frame with types to look for.
 *
 * @return true if the input has one of the given types.
 */
function _isType($input, $frame)
{
   $rval = false;

   // check if type(s) are specified in frame and input
   $type = JSONLD_RDF_TYPE;
   if(property_exists($frame, JSONLD_RDF_TYPE) and
      is_object($input) and property_exists($input, __S) and
      property_exists($input, JSONLD_RDF_TYPE))
   {
      $tmp = is_array($input->{JSONLD_RDF_TYPE}) ?
         $input->{JSONLD_RDF_TYPE} : array($input->{JSONLD_RDF_TYPE});
      $types = is_array($frame->$type) ?
         $frame->{JSONLD_RDF_TYPE} : array($frame->{JSONLD_RDF_TYPE});
      $length = count($types);
      for($t = 0; $t < $length and !$rval; ++$t)
      {
         $type = $types[$t]->{'@iri'};
         foreach($tmp as $e)
         {
            if($e->{'@iri'} === $type)
            {
               $rval = true;
               break;
            }
         }
      }
   }

   return $rval;
}

/**
 * Filters non-keywords.
 *
 * @param e the element to check.
 *
 * @return true if the element is a non-keyword.
 */
function _filterNonKeyWords($e)
{
   return strpos($e, '@') !== 0;
}

/**
 * Returns true if the given input matches the given frame via duck-typing.
 *
 * @param input the input.
 * @param frame the frame to check against.
 *
 * @return true if the input matches the frame.
 */
function _isDuckType($input, $frame)
{
   $rval = false;

   // frame must not have a specific type
   if(!property_exists($frame, JSONLD_RDF_TYPE))
   {
      // get frame properties that must exist on input
      $props = array_filter(array_keys((array)$frame), '_filterNonKeywords');
      if(count($props) === 0)
      {
         // input always matches if there are no properties
         $rval = true;
      }
      // input must be a subject with all the given properties
      else if(is_object($input) and property_exists($input, __S))
      {
         $rval = true;
         foreach($props as $prop)
         {
            if(!property_exists($input, $prop))
            {
               $rval = false;
               break;
            }
         }
      }
   }

   return $rval;
}

/**
 * Recursively frames the given input according to the given frame.
 *
 * @param subjects a map of subjects in the graph.
 * @param input the input to frame.
 * @param frame the frame to use.
 * @param embeds a map of previously embedded subjects, used to prevent cycles.
 * @param options the framing options.
 *
 * @return the framed input.
 */
function _frame($subjects, $input, $frame, $embeds, $options)
{
   $rval = null;

   // prepare output, set limit, get array of frames
   $limit = -1;
   if(is_array($frame))
   {
      $rval = array();
      $frames = $frame;
      if(count($frames) == 0)
      {
         $frames[] = new stdClass();
      }
   }
   else
   {
      $frames = array($frame);
      $limit = 1;
   }

   // iterate over frames adding input matches to list
   $frameLen = count($frames);
   $values = array();
   for($i = 0; $i < $frameLen and $limit !== 0; ++$i)
   {
      // get next frame
      $frame = $frames[$i];
      if(!is_object($frame))
      {
         throw new Exception(
            'Invalid JSON-LD frame. Frame type is not a map or array.');
      }

      // create array of values for each frame
      $inLen = count($input);
      $v = array();
      for($n = 0; $n < $inLen and $limit !== 0; ++$n)
      {
         // dereference input if it refers to a subject
         $next = $input[$n];
         if(is_object($next) and property_exists($next, '@iri') and
            property_exists($subjects, $next->{'@iri'}))
         {
            $next = $subjects->{$next->{'@iri'}};
         }

         // add input to list if it matches frame specific type or duck-type
         if(_isType($next, $frame) or _isDuckType($next, $frame))
         {
            $v[] = $next;
            --$limit;
         }
      }
      $values[$i] = $v;
   }

   // for each matching value, add it to the output
   $vaLen = count($values);
   for($i1 = 0; $i1 < $vaLen; ++$i1)
   {
      foreach($values[$i1] as $value)
      {
         $frame = $frames[$i1];

         // determine if value should be embedded or referenced
         $embedOn = property_exists($frame, '@embed') ?
            $frame->{'@embed'} : $options->defaults->embedOn;
         if(!$embedOn)
         {
            // if value is a subject, only use subject IRI as reference
            if(is_object($value) and property_exists($value, __S))
            {
               $value = $value->{__S};
            }
         }
         else if(
            is_object($value) and property_exists($value, __S) and
            property_exists($embeds, $value->{__S}->{'@iri'}))
         {
            // TODO: possibly support multiple embeds in the future ... and
            // instead only prevent cycles?
            throw new Exception(
               'Multiple embeds of the same subject is not supported. ' .
               'subject=' . $value->{__S}->{'@iri'});
         }
         // if value is a subject, do embedding and subframing
         else if(is_object($value) and property_exists($value, __S))
         {
            $embeds->{$value->{__S}->{'@iri'}} = true;

            // if explicit is on, remove keys from value that aren't in frame
            $explicitOn = property_exists($frame, '@explicit') ?
               $frame->{'@explicit'} : $options->defaults->explicitOn;
            if($explicitOn)
            {
               foreach($value as $key => $v)
               {
                  // do not remove subject or any key in the frame
                  if($key !== __S and !property_exists($frame, $key))
                  {
                     unset($value->$key);
                  }
               }
            }

            // iterate over frame keys to do subframing
            foreach($frame as $key => $f)
            {
               // skip keywords and type query
               if(strpos($key, '@') !== 0 and $key !== JSONLD_RDF_TYPE)
               {
                  if(property_exists($value, $key))
                  {
                     // build input and do recursion
                     $input = is_array($value->$key) ?
                        $value->$key : array($value->$key);
                     $length = count($input);
                     for($n = 0; $n < $length; ++$n)
                     {
                        // replace reference to subject w/subject
                        if(is_object($input[$n]) and
                           property_exists($input[$n], '@iri') and
                           property_exists($subjects, $input[$n]->{'@iri'}))
                        {
                           $input[$n] = $subjects->{$input[$n]->{'@iri'}};
                        }
                     }
                     $value->$key = _frame(
                        $subjects, $input, $f, $embeds, $options);
                  }
                  else
                  {
                     // add empty array/null property to value
                     $value->$key = is_array($f) ? array() : null;
                  }

                  // handle setting default value
                  if($value->$key === null)
                  {
                     // use first subframe if frame is an array
                     if(is_array($f))
                     {
                        $f = (count($f) > 0) ? $f[0] : new stdClass();
                     }

                     // determine if omit default is on
                     $omitOn = property_exists($f, '@omitDefault') ?
                        $f->{'@omitDefault'} :
                        $options->defaults->omitDefaultOn;
                     if($omitOn)
                     {
                        unset($value->$key);
                     }
                     else if(property_exists($f, '@default'))
                     {
                        $value->$key = $f->{'@default'};
                     }
                  }
               }
            }
         }

         // add value to output
         if($rval === null)
         {
            $rval = $value;
         }
         else
         {
            $rval[] = $value;
         }
      }
   }

   return $rval;
}

?>