001/* 002 * Copyright 2008-2017 UnboundID Corp. 003 * All Rights Reserved. 004 */ 005/* 006 * Copyright (C) 2008-2017 UnboundID Corp. 007 * 008 * This program is free software; you can redistribute it and/or modify 009 * it under the terms of the GNU General Public License (GPLv2 only) 010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 011 * as published by the Free Software Foundation. 012 * 013 * This program is distributed in the hope that it will be useful, 014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 016 * GNU General Public License for more details. 017 * 018 * You should have received a copy of the GNU General Public License 019 * along with this program; if not, see <http://www.gnu.org/licenses>. 020 */ 021package com.unboundid.ldap.matchingrules; 022 023 024 025import com.unboundid.asn1.ASN1OctetString; 026import com.unboundid.ldap.sdk.LDAPException; 027import com.unboundid.util.Extensible; 028import com.unboundid.util.ThreadSafety; 029import com.unboundid.util.ThreadSafetyLevel; 030 031import static com.unboundid.util.Debug.*; 032 033 034 035/** 036 * This class provides a common matching rule framework that may be extended by 037 * matching rule implementations in which equality, ordering, and substring 038 * matching can all be made based on byte-for-byte comparisons of the normalized 039 * value, and any value is acceptable. 040 */ 041@Extensible() 042@ThreadSafety(level=ThreadSafetyLevel.INTERFACE_THREADSAFE) 043public abstract class AcceptAllSimpleMatchingRule 044 extends SimpleMatchingRule 045{ 046 /** 047 * The serial version UID for this serializable class. 048 */ 049 private static final long serialVersionUID = -7450007924568660003L; 050 051 052 053 /** 054 * {@inheritDoc} 055 */ 056 @Override() 057 public boolean valuesMatch(final ASN1OctetString value1, 058 final ASN1OctetString value2) 059 { 060 return normalize(value1).equals(normalize(value2)); 061 } 062 063 064 065 /** 066 * {@inheritDoc} 067 */ 068 @Override() 069 public boolean matchesSubstring(final ASN1OctetString value, 070 final ASN1OctetString subInitial, 071 final ASN1OctetString[] subAny, 072 final ASN1OctetString subFinal) 073 { 074 try 075 { 076 return super.matchesSubstring(value, subInitial, subAny, subFinal); 077 } 078 catch (LDAPException le) 079 { 080 debugException(le); 081 082 // This should never happen, as the only reason the superclass version of 083 // this method will throw an exception is if an exception is thrown by 084 // normalize or normalizeSubstring. 085 return false; 086 } 087 } 088 089 090 091 /** 092 * {@inheritDoc} 093 */ 094 @Override() 095 public int compareValues(final ASN1OctetString value1, 096 final ASN1OctetString value2) 097 { 098 try 099 { 100 return super.compareValues(value1, value2); 101 } 102 catch (LDAPException le) 103 { 104 debugException(le); 105 106 // This should never happen, as the only reason the superclass version of 107 // this method will throw an exception is if an exception is thrown by 108 // normalize or normalizeSubstring. 109 return 0; 110 } 111 } 112 113 114 115 /** 116 * {@inheritDoc} This variant of the {@code normalize} method is not allowed 117 * to throw exceptions. 118 */ 119 @Override() 120 public abstract ASN1OctetString normalize(final ASN1OctetString value); 121 122 123 124 /** 125 * {@inheritDoc} This variant of the {@code normalizeSubstring} method is not 126 * allowed to throw exceptions. 127 */ 128 @Override() 129 public abstract ASN1OctetString normalizeSubstring( 130 final ASN1OctetString value, 131 final byte substringType); 132}