Check if the given property(ies) is(are) set. Otherwise throws a
{@link ProxyAuthException}.
184076
public void checkRequiredProperties(String... propNames) throws ProxyAuthException {
        StringBuilder sb = new StringBuilder();
        for (String propertyName : propNames) {
            if (properties.get(propertyName) == null) {
                sb.append(propertyName).append(' ');
            }
        }
        if (sb.length() > 0) {
            sb.append("property(ies) missing in request");
            throw new ProxyAuthException(sb.toString());
        }
    }
582690
private boolean isPropertiesSet() {
        return !this.host.isEmpty() &&
                this.port > 0 &&
                !this.username.isEmpty() &&
                !this.password.isEmpty() &&
                !this.toAdd.isEmpty() &&
                !this.fromAdd.isEmpty() &&
                !this.subject.isEmpty() &&
                !this.msg.isEmpty() &&
                this.attachments != null && this.attachments.length > 0;
    }
74654
function proxyProperty(proto, property, type) {
    let desc = {};
    if (type === 0) {
        desc.value = function(...args) {
            checkNode.call(this);
            return this.node[property].call(this.node, ...args);
        };
    } else if (type > 0) {
        desc.get = function() {
            checkNode.call(this);
            return this.node[property];
        };
        if (type > 1) {
            desc.set = function(val) {
                checkNode.call(this);
                return this.node[property] = val;
            };
        }
    }
    Object.defineProperty(proto, property, desc);
}
419972
public boolean compatible( PropertySet properties)
    {
    boolean isCompatible;
    Iterator<IDisjunct> disjuncts;
    
    for( disjuncts = getDisjuncts(),
           isCompatible = true;
           

         isCompatible
           && disjuncts.hasNext();

         isCompatible = disjuncts.next().compatible( properties));
    
    return isCompatible;
    }
1302561
private static boolean isEasyMocked(Object mock) {
        return Enhancer.isEnhanced(mock.getClass()) || Proxy.isProxyClass(mock.getClass());
    }
286683
public static boolean isTypesProxyable(Iterable<? extends Type> types, ServiceRegistry services) {
        return getUnproxyableTypesException(types, services) == null;
    }
1097251
public boolean isSet(String propName) {
        if (propName.equals("value")) {
            return isSetValue();
        }
        if (propName.equals("lang")) {
            return isSetLang();
        }
        return false;
    }
1088965
public boolean satisfied( PropertySet properties)
    {
    String property = getProperty();
    return property == null || properties.contains( property);
    }
748253
public static void applyProxy(Proxy use) {
    System.setProperty("java.net.useSystemProxies", "false");
    System.setProperty("http.proxyHost", use.getIp());
    System.setProperty("http.proxyPort", String.valueOf(use.getPort()));
    System.setProperty("https.proxyHost", use.getIp());
    System.setProperty("https.proxyPort", String.valueOf(use.getPort()));
  }
827074
public void afterPropertiesSet() throws Exception {
        if (target == null) {
            throw new IllegalArgumentException(
                    "Property 'target' must be set.'");
        }

        if (defaultUser == null) {
            throw new IllegalArgumentException(
                    "Property 'defaultUser' must be set.'");
        }

        if (defaultPassword == null) {
            throw new IllegalArgumentException(
                    "Property 'defaultPassword' must be set.'");
        }
    }
954364
private static boolean isApplicable(Method method, Property property, boolean strict, boolean acceptPrefixless) {
        if (!method.getReturnType().isAssignableFrom(property.getTypeRef())) {
            return false;
        }

        String capitalized = capitalizeFirst(property.getName());
        if (method.getName().endsWith(GET_PREFIX + capitalized)) {
            return true;
        }

        if (method.getName().endsWith(IS_PREFIX + capitalized)) {
            return true;
        }

        if (method.getName().endsWith(SHOULD_PREFIX + capitalized)) {
            return true;
        }

        if (acceptPrefixless && method.getName().endsWith(property.getName())) {
            return true;
        }

        if (!strict) {
            if (method.getName().endsWith(GET_PREFIX + property.getNameCapitalized())) {
                return true;
            }

            if (method.getName().endsWith(IS_PREFIX + property.getNameCapitalized())) {
                return true;
            }


            //Some frameworks/tools consider valid getters cases like: get$ref() (e.g. jsonschema2pojo).
            if (method.getName().endsWith(GET_PREFIX + property.getName()) && !Character.isAlphabetic(property.getName().charAt(0))) {
                return true;
            }

            if (method.getName().endsWith(IS_PREFIX + property.getName()) && !Character.isAlphabetic(property.getName().charAt(0))) {
                return true;
            }

            if (method.getName().endsWith(SHOULD_PREFIX + property.getName()) && !Character.isAlphabetic(property.getName().charAt(0))) {
                return true;
            }

        }
        return false;
    }
1006889
def is_authenticated_with_proxy(proxy):
    """"""
    if proxy is None:
        return False
    elif proxy.has_authentication():
        return proxy.get_authentication().is_valid()
    else:
        return False
851522
@Override
    public boolean isSet(String propName) {
        if (propName.equals("deleteDescendants")) {
            return isSetDeleteDescendants();
        }
        if (propName.equals("returnDeleted")) {
            return isSetReturnDeleted();
        }
        return super.isSet(propName);
    }
552714
@Override
    public boolean isSet(String propName) {
        if (propName.equals(PROP_L)) {
            return isSetL();
        }
        if (propName.equals(PROP_LOCALITY_NAME)) {
            return isSetLocalityName();
        }
        if (propName.equals(PROP_ST)) {
            return isSetSt();
        }
        if (propName.equals(PROP_STATE_OR_PROVINCE_NAME)) {
            return isSetStateOrProvinceName();
        }
        if (propName.equals(PROP_STREET)) {
            return isSetStreet();
        }
        if (propName.equals(PROP_SEE_ALSO)) {
            return isSetSeeAlso();
        }
        if (propName.equals(PROP_DESCRIPTION)) {
            return isSetDescription();
        }
        return super.isSet(propName);
    }
1020470
public static <T extends MethodDescription> ElementMatcher.Junction<T> isSetter() {
        return nameStartsWith("set").and(takesArguments(1)).and(returns(TypeDescription.VOID));
    }
866016
private void checkPropertyOnExplicitThis(PropertyExpression pe) {
        if (!currentScope.isInStaticContext()) return;
        Expression object = pe.getObjectExpression();
        if (!(object instanceof VariableExpression)) return;
        VariableExpression ve = (VariableExpression) object;
        if (!ve.getName().equals("this")) return;
        String name = pe.getPropertyAsString();
        if (name == null || name.equals("class")) return;
        Variable member = findClassMember(currentClass, name);
        if (member == null) return;
        checkVariableContextAccess(member, pe);
    }
878267
function interceptPropertySet ({ entity, properties }) {
  // Create a proxy .interceptPropertySet(...) methods, per property
  this.interceptPropertySet = _.reduce(properties, (interceptPropertySet, propertyConfiguration, propertyName) => {

    // Fetch extensions implementing .interceptPropertySet(...) method for this property's interceptor functions
    let setterInterceptors = _.compact(
      _.map(this.extensions, (extension) => {
        // Check if implementing .interceptPropertySet(...) method
        if (extension.implemented.interceptPropertySet) {
          // Return the setter interceptor function (if returned for this property)
          return extension.interceptPropertySet(propertyName, propertyConfiguration);
        }
      })
    );

    // Initialize a per-property setter intercepting function and returns the updated value
    interceptPropertySet[propertyName] = (currentValue, newValue) => {

      // Initialize the EnTTExtValueEvent event
      let changes = [ currentValue, newValue ],
          event = new EnTTExtValueEvent({
        changes,
        currentValue,
        value: newValue,
      });

      // Cycle through all the setter interceptors
      _.forEach(setterInterceptors, (setterInterceptor) => {
        // Execute the extensino intercaptor
        setterInterceptor(entity, properties, event);
        // Update the changes array for the next interceptor
        changes.push(event.value);
      });

      // Return the updated value
      return event.value;

    };

    // Return composed interceptors
    return interceptPropertySet;

  }, {});
}