Lock's custom properties.

@param lockProps
@return
496388
public AbstractDLock setLockProperties(Properties lockProps) {
        this.lockProps = lockProps != null ? new Properties(lockProps) : new Properties();
        return this;
    }
212633
public KafkaMsgConsumer setConsumerProperties(Properties props) {
        if (props == null) {
            consumerProperties = null;
        } else {
            consumerProperties = new Properties();
            consumerProperties.putAll(props);
        }
        return this;
    }
36789
public static Properties mapToProperties(Map<String,Object> map)
    {
        Properties properties = new Properties();
        Iterator<? extends Map.Entry<?, ?>> i = map.entrySet().iterator();
        while (i.hasNext()) {
            Map.Entry<?, ?> e = i.next();
            properties.setProperty((String)e.getKey(), (e.getValue() != null) ? e.getValue().toString() : DBConstants.BLANK);
        }
        return properties;
    }
565615
public int setProperties(Map<String,Object> properties)
    {
        return this.setProperties(properties, DBConstants.DISPLAY, DBConstants.SCREEN_MOVE);
    }
1071802
public Configuration withProperties(java.util.Map<String, String> properties) {
        setProperties(properties);
        return this;
    }
1207301
public ValueContainer[] getCurrentLockingValues(Object o) throws PersistenceBrokerException
    {
        FieldDescriptor[] fields = getLockingFields();
        ValueContainer[] result = new ValueContainer[fields.length];
        for (int i = 0; i < result.length; i++)
        {
            result[i] = new ValueContainer(fields[i].getPersistentField().get(o), fields[i].getJdbcType());
        }
        return result;
    }
1298601
public static PrefixedProperties createCascadingPrefixProperties(final String[] prefixes) {
		PrefixedProperties properties = null;
		for (final String aPrefix : prefixes) {
			if (properties == null) {
				properties = new PrefixedProperties(aPrefix);
			} else {
				properties = new PrefixedProperties(properties, aPrefix);
			}
		}
		return properties;
	}
889731
public FieldDescriptor[] getLockingFields()
    {
        if (m_lockingFieldDescriptors == null)
        {
            // 1. collect all Primary Key fields from Field list
            Vector vec = new Vector();
            for (int i = 0; i < m_FieldDescriptions.length; i++)
            {
                FieldDescriptor fd = m_FieldDescriptions[i];
                if (fd.isLocking())
                {
                    vec.add(fd);
                }
            }
            // 2. Sort fields according to their getOrder() Property
            Collections.sort(vec, FieldDescriptor.getComparator());
            m_lockingFieldDescriptors =
                (FieldDescriptor[]) vec.toArray(new FieldDescriptor[vec.size()]);
        }
        return m_lockingFieldDescriptors;
    }
905462
public final MapDictionary<String, Object> getProperties() {
        if (this.properties.isReadyOnly()) {
            return this.properties;
        }
        return new MapDictionary<String, Object>(this.properties);
    }
975459
public CPSubsystemConfig setLockConfigs(Map<String, FencedLockConfig> lockConfigs) {
        this.lockConfigs.clear();
        this.lockConfigs.putAll(lockConfigs);
        for (Entry<String, FencedLockConfig> entry : this.lockConfigs.entrySet()) {
            entry.getValue().setName(entry.getKey());
        }
        return this;
    }
887629
private void setLockingValues(ClassDescriptor cld, Object obj, ValueContainer[] oldLockingValues)
    {
        FieldDescriptor fields[] = cld.getLockingFields();

        for (int i=0; i<fields.length; i++)
        {
            PersistentField field = fields[i].getPersistentField();
            Object lockVal = oldLockingValues[i].getValue();

            field.set(obj, lockVal);
        }
    }
531120
protected String buildSnapshotProps(Map<String, String> props) {
        Properties snapshotProperties = new Properties();
        for (String key : props.keySet()) {
            snapshotProperties.setProperty(key, props.get(key));
        }

        StringWriter writer = new StringWriter();
        try {
            snapshotProperties.store(writer, null);
        } catch (IOException e) {
            throw new TaskException("Could not write snapshot properties: " +
                                    e.getMessage(), e);
        }
        writer.flush();
        return writer.toString();
    }
706402
public Map<String, Class<?>> getPayloadPropertyNames(Map<String,Class<?>> mapPropertyNames)
    {
        mapPropertyNames = super.getPayloadPropertyNames(mapPropertyNames);
        if ((this.getKeyInformation() & STANDARD_PARAM) != 0)
        {   // Add this name and class to the map of property names
            if (mapPropertyNames == null)
                mapPropertyNames = new HashMap<String, Class<?>>();
            mapPropertyNames.put(this.getFullKey(null), this.getRawClassType());
        }
        return mapPropertyNames;
    }
434856
public Lock getLock(String lockName, LockType type, String comment) {
		return new SQLLock(lockName,type,comment, getSleepTime(), this);
	}
1274605
public void acquireAllLocks(List<Object> keys, boolean exclusive) {
      for (Object k : keys) {
        acquireLock(k, exclusive);
    }
   }
145881
public final List<Lock> lockAll(Object... keys) {
        List<Lock> locks = new ArrayList<>(keys.length);
        for (Object key : keys) {
            Lock lock = this.locks.get(key);
            locks.add(lock);
        }
        Collections.sort(locks, (a, b) -> {
            int diff = a.hashCode() - b.hashCode();
            if (diff == 0 && a != b) {
                diff = this.indexOf(a) - this.indexOf(b);
                assert diff != 0;
            }
            return diff;
        });
        for (int i = 0; i < locks.size(); i++) {
            locks.get(i).lock();
        }
        return Collections.unmodifiableList(locks);
    }
107026
private long[] lockAll() {
    OptimisticLock[] _locks = locks;
    int sn = _locks.length;
    long[] _stamps = new long[locks.length];
    for (int i = 0; i < sn; i++) {
      OptimisticLock l = _locks[i];
      _stamps[i] = l.writeLock();
    }
    return _stamps;
  }