Return true if given class supports back up. Currently this means a
    gludb.data.Storable-derived class that has a mapping as defined in
    gludb.config
978981
def is_backup_class(cls):
    """"""
    return True if (
        isclass(cls) and
        issubclass(cls, Storable) and
        get_mapping(cls, no_mapping_ok=True)
    ) else False
628767
protected boolean isLegalEmphOrStrongStartPos(){
        if( currentIndex() == 0 )
            return true;

        Object lastItem = peek(1);
        Class<?> lastClass = lastItem.getClass();

        SuperNode supernode;
        while( SuperNode.class.isAssignableFrom(lastClass) ) {
            supernode = (SuperNode) lastItem;

            if(supernode.getChildren().size() < 1 )
                return true;
            
            lastItem = supernode.getChildren().get( supernode.getChildren().size()-1 );
            lastClass = lastItem.getClass();
        }
                
        return     ( TextNode.class.equals(lastClass) && ( (TextNode) lastItem).getText().endsWith(" ") )
                || ( SimpleNode.class.equals(lastClass) )
                || ( java.lang.Integer.class.equals(lastClass) );
    }
1141354
public boolean isMapped(Class<?> classToCheck){
		return    !isNull(loadGlobals().get(classToCheck.getName()))
			   || !isEmpty(loadAttributes().get(classToCheck.getName()));
	}
1190708
private boolean isResetOp(int seen) {
        return resetOps.get(seen) || OpcodeUtils.isStore(seen) || OpcodeUtils.isReturn(seen)
                || ((OpcodeUtils.isInvoke(seen) && getSigConstantOperand().endsWith(")V")) || (isBranch(seen) && (getBranchOffset() < 0)));
    }
1004018
def ctor_overridable(cls):
    """"""
    prev_init = getattr(cls, "__init__", None)
    if not callable(prev_init):
        return True
    if prev_init in [object.__init__, _auto_init]:
        return True
    if getattr(prev_init, '_clobber_ok', False):
        return True

    print(cls, prev_init, getattr(prev_init, '_clobber_ok', 'missing'))
    return False
119953
protected final boolean supportsDataField(final String name) throws CouldNotPerformException {
        try {
            Descriptors.FieldDescriptor findFieldByName = dataBuilder.getDescriptorForType().findFieldByName(name);
            return findFieldByName != null;
        } catch (NullPointerException ex) {
            return false;
        }
    }
756431
private static boolean serialClassInclude(Utils utils, TypeElement te) {
        if (utils.isEnum(te)) {
            return false;
        }
        if (utils.isSerializable(te)) {
            if (!utils.getSerialTrees(te).isEmpty()) {
                return serialDocInclude(utils, te);
            } else if (utils.isPublic(te) || utils.isProtected(te)) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }
919773
private boolean isSupportedOnHub(Class<? extends HttpServlet> servlet) {
        LOGGER.entering();
        final boolean response = getRegistry().getHub().getConfiguration().servlets.contains(servlet.getCanonicalName());
        LOGGER.exiting(response);
        return response;
    }
1233228
@SuppressWarnings("unchecked")
    static <S extends Storable> Class<? extends S>
        getStorableClass(Class<S> type, boolean isMaster)
        throws SupportException
    {
        synchronized (cCache) {
            Class<? extends S> storableClass;

            RawStorableGenerator.Flavors<S> flavors =
                (RawStorableGenerator.Flavors<S>) cCache.get(type);

            if (flavors == null) {
                flavors = new RawStorableGenerator.Flavors<S>();
                cCache.put(type, flavors);
            } else if ((storableClass = flavors.getClass(isMaster)) != null) {
                return storableClass;
            }

            storableClass = generateStorableClass(type, isMaster);
            flavors.setClass(storableClass, isMaster);

            return storableClass;
        }
    }
1082330
public boolean supportsBatchUpdates(DatabaseMetaData meta) {
    try {
      return meta.supportsBatchUpdates();
    } catch(Throwable e) {
      getLogger().info("Missing DatabaseMetaData.supportsBatchUpdates method.");
      return false;
    }
  }
567313
@Override
	public boolean supports(LookupContext context) {

		Relation relation = lookupAnnotation(context.getType());

		if (relation == null) {
			return false;
		}

		if (context.isItemRelationLookup()) {
			return !relation.value().equals(Relation.NO_RELATION);
		}

		if (context.isCollectionRelationLookup()) {
			return !relation.collectionRelation().equals(Relation.NO_RELATION);
		}

		return false;
	}
151718
public static boolean checkIfClassVersionApplicable(Object cacheEntry, boolean useStructuredCache) {
        if (!useStructuredCache && cacheEntry instanceof CacheEntry) {
            return true;
        }

        if (useStructuredCache && cacheEntry instanceof Map) {
            return true;
        }
        return false;
    }
773218
<S extends Storable> JDBCStorableProperty<S>
        getJDBCStorableProperty(StorableProperty<S> property)
        throws RepositoryException, SupportException
    {
        JDBCStorableInfo<S> info = examineStorable(property.getEnclosingType());
        JDBCStorableProperty<S> jProperty = info.getAllProperties().get(property.getName());
        if (!jProperty.isSupported()) {
            throw new UnsupportedOperationException
                ("Property is not supported: " + property.getName());
        }
        return jProperty;
    }
837716
@Override
    public boolean supports(TherianContext context, Copy<? extends Object, ? extends Map> copy) {
        if (!super.supports(context, copy)) {
            return false;
        }
        final Type targetKeyType = getKeyType(copy.getTargetPosition());
        final Position.ReadWrite<?> targetKey = Positions.readWrite(targetKeyType);

        return getProperties(context, copy.getSourcePosition())
            .anyMatch(propertyName -> context.supports(Convert.to(targetKey, Positions.readOnly(propertyName))));
    }
338240
static boolean load(Map<String, String> storage, boolean reverse, String... pathArray)
    {
        StringDictionary dictionary = new StringDictionary("=");
        for (String path : pathArray)
        {
            if (!dictionary.load(path)) return false;
        }
        if (reverse) dictionary = dictionary.reverse();
        Set<Map.Entry<String, String>> entrySet = dictionary.entrySet();
        for (Map.Entry<String, String> entry : entrySet)
        {
            storage.put(entry.getKey(), entry.getValue());
        }

        return true;
    }
210046
def restore
      restore_class = self.revisionable_type.constantize

      # Check if we have a type field, if yes, assume single table inheritance and restore the actual class instead of the stored base class
      sti_type = self.revision_attributes[restore_class.inheritance_column]
      if sti_type
        begin
          if !restore_class.store_full_sti_class && !sti_type.start_with?("::")
            sti_type = "#{restore_class.parent.name}::#{sti_type}"
          end
          restore_class = sti_type.constantize
        rescue NameError => e
          raise e
          # Seems our assumption was wrong and we have no STI
        end
      end

      record = restore_class.new
      restore_record(record, revision_attributes)
      return record
    end
1070697
public boolean txnRollbackOfferBackup(long itemId) {
        QueueItem item = txMap.remove(itemId);
        if (item == null) {
            logger.warning("txnRollbackOffer operation-> No txn item for itemId: " + itemId);
            return false;
        }
        return true;
    }