Prints the container.

@return The Turtle short representation.
977082
String print() {
		StringBuilder sb = new StringBuilder();
		for (String subject : subjectToPredicates.keySet()) {
			sb.append(subject);
			sb.append(" ");
			boolean semiColonSeparator = false;
			for (String predicate : subjectToPredicates.get(subject)) {
				if (semiColonSeparator) {
					sb.append(" ; ");
				}
				sb.append(predicate);
				sb.append(" ");
				semiColonSeparator = true;

				boolean commaSeparator = false;
				for (String object : predicateToObjects.get(predicate+ "_" + subject)) {
					if (commaSeparator) {
						sb.append(" , ");
					}
					sb.append(object);
					commaSeparator = true;
				}
			}
			sb.append(" ");
			sb.append(".");
			sb.append(" ");
		}
		return sb.toString();
	}
1209457
public void print() {
        /*
        System.out.println(m00 + " " + m01 + " " + m02 + " " + m03 + "\n" +
                           m10 + " " + m11 + " " + m12 + " " + m13 + "\n" +
                           m20 + " " + m21 + " " + m22 + " " + m23 + "\n" +
                           m30 + " " + m31 + " " + m32 + " " + m33 + "\n");
         */
        int big = (int) Math.abs(Math.max(Math.max(Math.max(Math.max(Math.abs(m00), Math.abs(m01)),
            Math.max(Math.abs(m02), Math.abs(m03))),
            Math.max(Math.max(Math.abs(m10), Math.abs(m11)),
                Math.max(Math.abs(m12), Math.abs(m13)))),
                Math.max(Math.max(Math.max(Math.abs(m20), Math.abs(m21)),
                    Math.max(Math.abs(m22), Math.abs(m23))),
                    Math.max(Math.max(Math.abs(m30), Math.abs(m31)),
                        Math.max(Math.abs(m32), Math.abs(m33))))));

        int digits = 1;
        if (Double.isNaN(big) || Double.isInfinite(big)) {  // avoid infinite loop
            digits = 5;
        } else {
            while ((big /= 10) != 0) digits++;  // cheap log()
        }

        System.out.println(nfs(m00, digits, 4) + " " +
                           nfs(m01, digits, 4) + " " +
                           nfs(m02, digits, 4) + " " +
                           nfs(m03, digits, 4));

        System.out.println(nfs(m10, digits, 4) + " " +
                           nfs(m11, digits, 4) + " " +
                           nfs(m12, digits, 4) + " " +
                           nfs(m13, digits, 4));

        System.out.println(nfs(m20, digits, 4) + " " +
                           nfs(m21, digits, 4) + " " +
                           nfs(m22, digits, 4) + " " +
                           nfs(m23, digits, 4));

        System.out.println(nfs(m30, digits, 4) + " " +
                           nfs(m31, digits, 4) + " " +
                           nfs(m32, digits, 4) + " " +
                           nfs(m33, digits, 4));

        System.out.println();
    }
939044
public String getPrintName()
  {
    if (_typeArgs.length == 0)
      return _rawClass.getPrintName();

    StringBuilder cb = new StringBuilder();
    cb.append(_rawClass.getPrintName());
    cb.append('<');
    for (int i = 0; i < _typeArgs.length; i++) {
      if (i != 0)
        cb.append(',');
      
      cb.append(_typeArgs[i].getPrintName());
    }
    
    cb.append('>');

    return cb.toString();
  }
1322648
public static String print(final Object value) {
        if (value == null) {
            return "null";
        }
        if (value instanceof String) {
            return '"' + value.toString() + '"';
        }
        if (value instanceof Character) {
            return printChar((Character) value);
        }
        if (value instanceof Long) {
            return value + "L";
        }
        if (value instanceof Double) {
            return value + "d";
        }
        if (value instanceof Float) {
            return value + "f";
        }
        if (value instanceof Short) {
            return "(short) " + value;
        }
        if (value instanceof Byte) {
            return String.format("(byte) 0x%02X", (Byte) value);
        }
        if (value instanceof Map) {
            return printMap((Map<?, ?>) value);
        }
        if (value.getClass().isArray()) {
            return printValues("[", ", ", "]", new Iterator<Object>() {
                private int currentIndex = 0;

                public boolean hasNext() {
                    return currentIndex < Array.getLength(value);
                }

                public Object next() {
                    return Array.get(value, currentIndex++);
                }

                public void remove() {
                    throw new UnsupportedOperationException("cannot remove items from an array");
                }
            });
        }
        if (value instanceof FormattedText) {
            return (((FormattedText) value).getText());
        }

        return descriptionOf(value);
    }
409206
public String printDate()
  {
    if (_lastDate != null && _lastTime == _localTimeOfEpoch)
      return _lastDate;

    CharBuffer cb = new CharBuffer();

    printDate(cb);

    _lastDate = cb.toString();
    _lastTime = _localTimeOfEpoch;

    return _lastDate;
  }
1272360
public synchronized String getString() {
		// check state and initialize buffer
		if (outputFileName == null)
			throw new IllegalStateException();
		StringBuffer out = new StringBuffer();

		// start the SMAP
		out.append("SMAP\n");
		out.append(outputFileName + '\n');
		out.append(defaultStratum + '\n');

		// include embedded SMAPs
		if (doEmbedded) {
			int nEmbedded = embedded.size();
			for (int i = 0; i < nEmbedded; i++) {
				out.append(embedded.get(i));
			}
		}

		// print our StratumSections, FileSections, and LineSections
		int nStrata = strata.size();
		for (int i = 0; i < nStrata; i++) {
			SmapStratum s = strata.get(i);
			out.append(s.getString());
		}

		// end the SMAP
		out.append("*E\n");

		return out.toString();
	}
179589
public static String print(Type type) {
        return type.match(new Type.MatchBlock<String>(){
            @Override
            public String _case(Ref x) {
                return print(x.type);
            }

            @Override
            public String _case(Primitive x) {
                return print(x.type);
            }
            
        });
    }
79109
public String printDefaultValue() {
        if (setter instanceof Getter) {
            Getter getter = (Getter)setter;
            List<T> defaultValues = getter.getValueList();
            if (defaultValues != null && !defaultValues.isEmpty()) {
                StringBuilder buf = new StringBuilder();
                if (defaultValues.size()>1) {
                    for (T v : defaultValues) {
                        buf.append( buf.length()==0 ? '[' : ',' );
                        buf.append(print(v));
                    }
                    buf.append(']');
                } else {
                    buf.append(print(defaultValues.get(0)));
                }
                return buf.toString();
            }
        }
        return null;
    }
170883
public void print() {
		System.out.println("TechSet: " + this.hashCode());
		for (Tech tech : includeTech) {
			System.out.println("\tInclude: " + tech);
		}
		for (Tech tech : excludeTech) {
			System.out.println("\tExclude: " + tech);
		}
		
	}
728628
private String toStringIterative() {
		final String PADDING = "                                 ";
		final StringBuilder sb = new StringBuilder();
		int elements_debug_local_recounter = 0;
		Node<K, V> node = null;
		int nodeid = rootIdx;
		int depth = 0;
		stackSlots.clear();
		stackSlots.push(rootIdx); // init seed, root node
		boolean lastIsInternal = !Node.isLeaf(rootIdx);
		while (!stackSlots.isEmpty()) {
			nodeid = stackSlots.pop();
			node = getNode(nodeid);
			if (!node.isLeaf()) {
				for (int i = node.allocated; i >= 0; i--) {
					stackSlots.push(((InternalNode<K, V>) node).childs[i]);
				}
			} else {
				elements_debug_local_recounter += node.allocated;
			}
			// For Indentation
			if (lastIsInternal || !node.isLeaf()) { // Last or Curret are Internal
				depth += (lastIsInternal ? +1 : -1);
			}
			lastIsInternal = !node.isLeaf();
			sb.append(PADDING.substring(0, Math.min(PADDING.length(), Math.max(depth - 1, 0))));
			//
			sb.append(node.toString()).append("\n");
		}

		// Count elements
		sb.append("height=").append(getHeight()).append(" root=").append(rootIdx).append(" low=")
				.append(lowIdx).append(" high=").append(highIdx).append(" elements=").append(elements)
				.append(" recounter=").append(elements_debug_local_recounter);

		return sb.toString();
	}
1112315
public String printHead() throws IOException {
        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        this.printHead(baos);
        return new Utf8String(baos.toByteArray()).asString();
    }
247284
public String getShortName() {
        int endOfPkg = className.lastIndexOf('.');
        if (endOfPkg >= 0) {
            return className.substring(endOfPkg + 1);
        }
        return className;
    }
147416
public static String print(PrimitiveType type) {
        return type.match(new PrimitiveType.MatchBlock<String>() {

            @Override
            public String _case(BooleanType x) {
                return "boolean";
            }

            @Override
            public String _case(ByteType x) {
                return "byte";
            }

            @Override
            public String _case(CharType x) {
                return "char";
            }

            @Override
            public String _case(DoubleType x) {
                return "double";
            }

            @Override
            public String _case(FloatType x) {
                return "float";
            }

            @Override
            public String _case(IntType x) {
                return "int";
            }

            @Override
            public String _case(LongType x) {
                return "long";
            }

            @Override
            public String _case(ShortType x) {
                return "short";
            }});
    }
1304471
public JBBPTextWriter Short(final short[] values, int off, int len) throws IOException {
    while (len-- > 0) {
      this.Short(values[off++]);
    }
    return this;
  }
186101
@Override
  public Iterator<Integer> iterator() {
    return new Iterator<Integer>() {
      private int hs = 0;

      private ShortIterator iter;

      private int pos = 0;

      private int x;

      @Override
      public boolean hasNext() {
        return pos < RoaringBitmap.this.highLowContainer.size();
      }

      private Iterator<Integer> init() {
        if (pos < RoaringBitmap.this.highLowContainer.size()) {
          iter = RoaringBitmap.this.highLowContainer.getContainerAtIndex(pos).getShortIterator();
          hs = RoaringBitmap.this.highLowContainer.getKeyAtIndex(pos) << 16;
        }
        return this;
      }

      @Override
      public Integer next() {
        x = iter.nextAsInt() | hs;
        if (!iter.hasNext()) {
          ++pos;
          init();
        }
        return x;
      }

      @Override
      public void remove() {
        // todo: implement
        throw new UnsupportedOperationException();
      }

    }.init();
  }
1359366
protected String printList()
  {
    String output = "[";
    
    SimpleEntry pointer = first;
    int counter = 0;
    while((pointer != null) && (counter < 3))
    {
      output += "@"+Integer.toHexString(pointer.hashCode());
      pointer = pointer.next;
      if(pointer != null)
        output +=  ", ";
      counter++;
    }
    if(pointer != null)
    {
      output += "..., @"+Integer.toHexString(last.hashCode()) + "]";
    }
    else
      output += "]";
    
    return output;
  }
681844
public short getDepth() {
    if (0 == index) return 0;
    if (-1 == depth) {
      synchronized (this) {
        if (-1 == depth) {
          TrieNode parent = getParent();
          assert (null == parent || parent.index < index);
          depth = (short) (null == parent ? 0 : (parent.getDepth() + 1));
        }
      }
    }
    return depth;
  }