Returns the parity schema as <tt>String</tt>.

@return the parity schema as <tt>String</tt>.
437932
public String getParityString() {
        switch (parity) {
            case AbstractSerialConnection.NO_PARITY:
                return "none";
            case AbstractSerialConnection.EVEN_PARITY:
                return "even";
            case AbstractSerialConnection.ODD_PARITY:
                return "odd";
            case AbstractSerialConnection.MARK_PARITY:
                return "mark";
            case AbstractSerialConnection.SPACE_PARITY:
                return "space";
            default:
                return "none";
        }
    }
141744
@Override
    public Schema schema() {
        LOG.ok("Schema retrieving");

        final Provisioning provisioning = connection.getProvisioning();

        if (provisioning == null) {
            throw new IllegalStateException("Web Service client not found");
        }

        if (wsAttributes != null) {
            wsAttributes.clear();
        }
        wsAttributes = new HashMap<String, WSAttribute>();

        final Set<AttributeInfo> attributes = new HashSet<AttributeInfo>();
        final List<WSAttribute> wsAttrs = provisioning.schema();
        for (WSAttribute attribute : wsAttrs) {

            wsAttributes.put(getAttributeName(attribute), attribute);

            if (LOG.isOk()) {
                LOG.ok("\nAttribute: "
                        + "\n\tName: " + attribute.getName()
                        + "\n\tType: " + attribute.getType()
                        + "\n\tIsKey: " + attribute.isKey()
                        + "\n\tIsPassword: " + attribute.isPassword()
                        + "\n\tIsNullable: " + attribute.isNullable());
            }

            try {
                attributes.add(buildAttribute(attribute));
            } catch (IllegalArgumentException ila) {

                LOG.error("Invalid attribute " + attribute.getName(), ila);
            }
        }

        final SchemaBuilder schemaBld = new SchemaBuilder(getClass());

        final ObjectClassInfoBuilder objectclassInfoBuilder = new ObjectClassInfoBuilder();
        objectclassInfoBuilder.setType(ObjectClass.ACCOUNT_NAME);
        objectclassInfoBuilder.addAllAttributeInfo(attributes);

        final ObjectClassInfo objectclassInfo = objectclassInfoBuilder.build();
        schemaBld.defineObjectClass(objectclassInfo);

        /*
         * Note: AuthenticateOp, and all the 'SPIOperation'-s are by default added by Reflection API to the Schema.
         *
         * See for details: FrameworkUtil.getDefaultSupportedOperations() ReflectionUtil.getAllInterfaces(connector); is
         * the line that *does* acquire the implemented interfaces by the connector class.
         */
        if (!provisioning.isAuthenticationSupported()) {
            LOG.ok("Authentication is not supported.");

            schemaBld.removeSupportedObjectClass(AuthenticateOp.class, objectclassInfo);
        }

        if (!provisioning.isSyncSupported()) {
            LOG.ok("Synchronization is not supported.");

            schemaBld.removeSupportedObjectClass(SyncOp.class, objectclassInfo);
        }

        schema = schemaBld.build();
        return schema;
    }
659250
public String getStr( ) {
        int len = ab.get4();
        return len == -1 ? null : new String(ab.getA1(len), UTF_8);
    }
114998
public java.lang.String getUfsType() {
    java.lang.Object ref = ufsType_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      if (bs.isValidUtf8()) {
        ufsType_ = s;
      }
      return s;
    }
  }
449073
public static String STOREtoString() {
    int[] cnts = new int[1];
    Object[] kvs = H2O.STORE.raw_array();
    // Start the walk at slot 2, because slots 0,1 hold meta-data
    for( int i=2; i<kvs.length; i += 2 ) {
      // In the raw backing array, Keys and Values alternate in slots
      Object ov = kvs[i+1];
      if( !(ov instanceof Value) ) continue; // Ignore tombstones and Primes and null's
      Value val = (Value)ov;
      if( val.isNull() ) { Value.STORE_get(val._key); continue; } // Another variant of NULL
      int t = val.type();
      while( t >= cnts.length ) cnts = Arrays.copyOf(cnts,cnts.length<<1);
      cnts[t]++;
    }
    StringBuilder sb = new StringBuilder();
    for( int t=0; t<cnts.length; t++ )
      if( cnts[t] != 0 )
        sb.append(String.format("-%30s %5d\n",TypeMap.CLAZZES[t],cnts[t]));
    return sb.toString();
  }
968275
public String getAsXMLString() {
        // Create a string XML representation:
        String rewardString = null;
        try {
            rewardString = SchemaHelper.serialiseObject(this.getAsReward(), Reward.class);
        } catch (JAXBException e) {
            System.out.println("Caught reward serialization exception: " + e);
        }
        return rewardString;
    }
760847
public Element getStringPatternsElement() {
        final Element referenceDataCatalogElement = getReferenceDataCatalogElement();

        final Element stringPatternsElement =
                getOrCreateChildElementByTagName(referenceDataCatalogElement, "string-patterns");
        if (stringPatternsElement == null) {
            throw new IllegalStateException("Could not find <string-patterns> element in configuration file");
        }
        return stringPatternsElement;
    }
274219
public GenericDataType[] getSchemaRow() {
		GenericDataType[] result = new GenericDataType[this.schemaRow.size()];
		this.schemaRow.toArray(result);
		return result;
	}
449554
@Override
    public int parity() {
        return parity(l1, l2, r) * parity(r1, r2, l);
    }
392989
public String getAlgorithm()
    {
        if (cipher == null)
        {
            return null;
        }

        String transformation = cipher.getAlgorithm();

        if (transformation == null)
        {
            return null;
        }

        // Separator position.
        int pos = transformation.indexOf('/');

        if (pos < 0)
        {
            return transformation;
        }

        return transformation.substring(0, pos);
    }
541719
public String getValuesAsString() {
		StringBuilder builder = new StringBuilder();
		for(E row: rowKeys.keySet())
			for(E col: colKeys.keySet()) {
				builder.append(getValueAsString(row, col, true));
				builder.append('\n');
			}
		return builder.toString();
	}
313590
public Result xml() {
        setContentType(MimeTypes.XML);
        charset = Charsets.UTF_8;
        // If we already have a String content, we must set the type.
        // The renderable object checks whether or not the given String is a valid XML string,
        // or if a transformation is required.
        if (getRenderable() instanceof RenderableString) {
            ((RenderableString) getRenderable()).setType(MimeTypes.XML);
        }
        return this;
    }
520112
@Override
	public String toNormalizedString() {
		String result = normalizedString;
		if(result == null) {
			normalizedString = result = toNormalizedString(false);
		}
		return result;
	}
305920
public String asString()
    {
        TreeMap<Tag, Value> orderedAttributes = new TreeMap<Tag, Value>(attributes);
        StringBuilder result = new StringBuilder();
        for (Iterator<Map.Entry<Tag, Value>> entries = orderedAttributes.entrySet().iterator(); entries.hasNext(); )
        {
            Map.Entry<Tag, Value> mapEntry = entries.next();
            Tag tag = mapEntry.getKey();
            Value value = mapEntry.getValue();
            if (value.isPresenceType())
            {
                result.append(tag.tag);
            }
            else
            {
                result.append("(").append(tag.tag).append("=");
                if (value.multiValued)
                {
                    Object[] values = value.getValues();
                    for (int i = 0; i < values.length; ++i)
                    {
                        if (i > 0) result.append(",");
                        if (value.isOpaqueType())
                            result.append(bytesToOpaque((byte[])values[i]));
                        else
                            result.append(escapeValue(String.valueOf(values[i])));
                    }
                }
                else
                {
                    if (value.isOpaqueType())
                        result.append(bytesToOpaque((byte[])value.getValue()));
                    else
                        result.append(escapeValue(String.valueOf(value.getValue())));
                }
                result.append(")");
            }
            if (entries.hasNext()) result.append(",");
        }
        return result.toString();
    }
60782
public String getSchema()
    {
        getEntityType();

        return this.entityType != null && !StringUtils.isBlank(((AbstractManagedType) this.entityType).getSchemaName()) ? ((AbstractManagedType) this.entityType)
                .getSchemaName() : schema;
    }
951872
public String getMarshallingType() {
        if (isList()) {
            return "LIST";
        } else if (isMap()) {
            return "MAP";
        } else if (isJsonValue()) {
            return "JSON_VALUE";
        } else if (!isSimple()) {
            return "STRUCTURED";
        } else {
            return TypeUtils.getMarshallingType(variable.getSimpleType());
        }
    }
874988
@Override
	public String toCanonicalString() {
		String result;
		if(hasNoStringCache() || (result = getStringCache().canonicalString) == null) {
			getStringCache().canonicalString = result = toNormalizedString(MACStringCache.canonicalParams);
		}
		return result;
	}