Add the provided nonce value. The {@value #NONCE_PREFIX} and
{@link #NONCE_SUFFIX} are added automatically. The byte array is
automatically Bas64 encoded!

@param aNonceValue
The plain nonce value. May not be <code>null</code>.
@return this for chaining
499997
@Nonnull
  public CSP2SourceList addNonce (@Nonnull @Nonempty final byte [] aNonceValue)
  {
    ValueEnforcer.notEmpty (aNonceValue, "NonceValue");
    return addNonce (Base64.safeEncodeBytes (aNonceValue));
  }
37250
public int checkNonce(String nonce, HttpRequest request)
    {
        try
        {
            byte[] n = B64Code.decode(nonce.toCharArray());
            if (n.length!=24)
                return -1;
            
            long ts=0;
            long sk=nonceSecret;
            byte[] n2 = new byte[16];
            for (int i=0;i<8;i++)
            {
                n2[i]=n[i];
                n2[8+i]=(byte)(sk&0xff);
                sk=sk>>8;
                ts=(ts<<8)+(0xff&(long)n[7-i]);
            }
            
            long age=request.getTimeStamp()-ts;
	    if (log.isDebugEnabled()) log.debug("age="+age);
            
            byte[] hash=null;
            try
            {
                MessageDigest md = MessageDigest.getInstance("MD5");
                md.reset();
                md.update(n2,0,16);
                hash = md.digest();
            }
            catch(Exception e)
            {
                log.fatal(this,e);
            }
            
            for (int i=0;i<16;i++)
                if (n[i+8]!=hash[i])
                    return -1;
                
            if(maxNonceAge>0 && (age<0 || age>maxNonceAge))
                return 0; // stale
            
            return 1;
        }
        catch(Exception e)
        {
            log.debug("",e);
        }
        return -1;
    }
923716
public Object put(String propertyName, Object newValue) {
        if (VALID_KEY.matcher(propertyName).matches() == false) {
            throw new IllegalArgumentException("Invalid key for FlexiBean: " + propertyName);
        }
        return dataWritable().put(propertyName, newValue);
    }
79548
@Indexable(type = IndexableType.REINDEX)
	@Override
	public CPOptionValue addCPOptionValue(CPOptionValue cpOptionValue) {
		cpOptionValue.setNew(true);

		return cpOptionValuePersistence.update(cpOptionValue);
	}
507716
private String addAndEncodeValue(String originalValue, String newValue,
      boolean encode) {
    return addAndEncode(originalValue, null, newValue, encode);
  }
1370524
@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public XAnnotationValue<Enum<?>> visit(FieldAccessExpr n, Void arg) {
		try {
			final Class<? extends Enum> enumClass = (Class<? extends Enum>) this.targetClass;
			return new XEnumAnnotationValue(Enum.valueOf(enumClass,
					n.getField()));
		} catch (Exception ex) {
			// BUG
			throw new RuntimeException(ex);
		}
	}
807550
public EqualsBuilder append(Object objectFieldValue, Object otherFieldValue) {
		if (equals && !same) {
			delegate.append(objectFieldValue, otherFieldValue);
		}
		return this;
	}
458385
public int add(byte[] value, int valueOffset, int valueLength) {
    grow(length + valueLength);
    data.setBytes(length, value, valueOffset, valueLength);
    int result = length;
    length += valueLength;
    return result;
  }
351783
public CompletableFuture<Version> addNewEntryIfAbsent(String tableName, String key, @NonNull byte[] value) {
        // if entry exists, we will get write conflict in attempting to create it again. 
        return expectingDataExists(addNewEntry(tableName, key, value), null);
    }
770300
public byte[] sign(byte[] nonce) {
        try {
            char[] keyChars = this.readKeyChars();
            NKey nkey =  NKey.fromSeed(keyChars);
            byte[] sig = nkey.sign(nonce);
            nkey.clear();
            return sig;
        } catch (Exception exp) {
            throw new IllegalStateException("problem signing nonce", exp);
        }
    }
696989
public Payload setNonce(String nonce) {
        this.nonce = nonce;
        this.put(PayloadConstants.NONCE, nonce);
        return this;
    }
704996
public T addDelayedEvaluator(@NonNull DelayedEvaluator delayed) {
        if (mDelayed == null) {
            mDelayed = new ArrayList<>(4);
        }
        mDelayed.add(delayed);
        return self();
    }
698828
def nonce(self, value):
        

        if not isinstance(value, bool):
            raise TypeError(_pretty_message(
                '''
                nonce must be a boolean, not %s
                ''',
                _type_name(value)
            ))

        self._nonce = value
651525
public ElementDefinitionDt addCode(CodingDt theValue) {
		if (theValue == null) {
			throw new NullPointerException("theValue must not be null");
		}
		getCode().add(theValue);
		return this;
	}
813893
@Nonnull
  public CSSSimpleValueWithUnit setValue (@Nonnull final BigDecimal aValue)
  {
    m_aValue = ValueEnforcer.notNull (aValue, "Value");
    return this;
  }
457414
public final Object[][] addNameValue(Map<String, Object> properties, String strName, Object[][] mxProperties)
    {
        if (properties != null)
            mxProperties = this.addNameValue(mxProperties, strName, properties.get(strName));
        return mxProperties;
    }
558274
protected function readNonceValue($nonce)
    {
        $value = null;

        if (null === $this->registryRepository) {
            if (true === is_readable($this->nonceDir.DIRECTORY_SEPARATOR.$nonce)) {
                $value = file_get_contents($this->nonceDir.DIRECTORY_SEPARATOR.$nonce);
            }
        } else {
            $value = $this->getRegistry($nonce)->getValue();
        }

        if (null !== $value) {
            $value = explode(';', $value);
        }

        return $value;
    }