org.n52.sos.ds.hibernate.util.HibernateMetadataCache.java Source code

Introduction

Here is the source code for org.n52.sos.ds.hibernate.util.HibernateMetadataCache.java

Source

/**
 * Copyright (C) 2012-2015 52North Initiative for Geospatial Open Source
 * Software GmbH
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation.
 *
 * If the program is linked with libraries which are licensed under one of
 * the following licenses, the combination of the program with the linked
 * library is not considered a "derivative work" of the program:
 *
 *     - Apache License, version 2.0
 *     - Apache Software License, version 1.0
 *     - GNU Lesser General Public License, version 3
 *     - Mozilla Public License, versions 1.0, 1.1 and 2.0
 *     - Common Development and Distribution License (CDDL), version 1.0
 *
 * Therefore the distribution of the program linked with libraries licensed
 * under the aforementioned licenses, is permitted by the copyright holders
 * if the distribution is compliant with both the GNU General Public
 * License version 2 and the aforementioned licenses.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details.
 */
package org.n52.sos.ds.hibernate.util;

import java.util.Map;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.metadata.ClassMetadata;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;

public class HibernateMetadataCache {
    private static HibernateMetadataCache instance;
    private static final Object lock = new Object();
    private final Set<String> supportedEntities;
    private Map<String, ClassMetadata> classMetadata;

    private HibernateMetadataCache(Session session) {
        this.classMetadata = initClassMetadata(session);
        this.supportedEntities = initSupportedEntities(classMetadata);
    }

    private Map<String, ClassMetadata> initClassMetadata(Session session) {
        return ImmutableMap.copyOf(session.getSessionFactory().getAllClassMetadata());
    }

    private Set<String> initSupportedEntities(Map<String, ClassMetadata> classMetadata) {
        return ImmutableSet.copyOf(classMetadata.keySet());
    }

    public boolean isColumnSupported(Class<?> entityClass, String column) {
        if (isEntitySupported(entityClass)) {
            ClassMetadata classMetadata = this.classMetadata.get(entityClass.getName());
            for (String propertyName : classMetadata.getPropertyNames()) {
                if (propertyName.equals(column)) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean isEntitySupported(Class<?> entityClass) {
        return entityClass != null && isEntitySupported(entityClass.getName());
    }

    public boolean isEntitySupported(String entityClass) {
        return this.supportedEntities.contains(entityClass);
    }

    public static void init(Session session) {
        synchronized (lock) {
            if (instance == null) {
                instance = new HibernateMetadataCache(session);
            }
        }
    }

    public static HibernateMetadataCache getInstance() {
        synchronized (lock) {
            if (instance != null) {
                return instance;
            } else {
                throw new IllegalStateException("Not initialized");
            }
        }
    }
}