qleany-common 1.8.0

// Generated by Qleany v1.7.0 from common_entity_table.tera

// ═══════════════════════════════════════════════════════════════════════
// Entity WITH forward relationships — explicit struct implementation
// ═══════════════════════════════════════════════════════════════════════

use crate::database::hashmap_store::{
    HashMapStore, delete_from_backward_junction, junction_get, junction_remove, junction_set,
};
use crate::entities::UseCase;
use crate::error::RepositoryError;
use crate::types::EntityId;
use crate::{impl_relationship_methods, impl_write_relationship_methods};
use im::HashMap;
use std::sync::RwLock;

use super::use_case_repository::UseCaseRelationshipField;
use super::use_case_repository::UseCaseTable;
use super::use_case_repository::UseCaseTableRO;

pub struct UseCaseHashMapTable<'a> {
    store: &'a HashMapStore,
}

impl<'a> UseCaseHashMapTable<'a> {
    pub fn new(store: &'a HashMapStore) -> Self {
        Self { store }
    }

    fn resolve_junction(
        &self,
        field: &UseCaseRelationshipField,
    ) -> &RwLock<HashMap<EntityId, Vec<EntityId>>> {
        match field {
            UseCaseRelationshipField::DtoIn => &self.store.jn_dto_from_use_case_dto_in,
            UseCaseRelationshipField::DtoOut => &self.store.jn_dto_from_use_case_dto_out,
            UseCaseRelationshipField::Entities => &self.store.jn_entity_from_use_case_entities,
        }
    }

    fn hydrate(&self, entity: &mut UseCase) {
        entity.entities = junction_get(&self.store.jn_entity_from_use_case_entities, &entity.id);
        entity.dto_in = junction_get(&self.store.jn_dto_from_use_case_dto_in, &entity.id)
            .into_iter()
            .next();
        entity.dto_out = junction_get(&self.store.jn_dto_from_use_case_dto_out, &entity.id)
            .into_iter()
            .next();
    }
}

impl<'a> UseCaseTable for UseCaseHashMapTable<'a> {
    fn create(&mut self, entity: &UseCase) -> Result<UseCase, RepositoryError> {
        self.create_multi(std::slice::from_ref(entity))
            .map(|v| v.into_iter().next().unwrap())
    }

    fn create_multi(&mut self, entities: &[UseCase]) -> Result<Vec<UseCase>, RepositoryError> {
        let mut created = Vec::with_capacity(entities.len());
        let mut use_case_map = self.store.use_cases.write().unwrap();

        for entity in entities {
            let new_entity = if entity.id == EntityId::default() {
                let id = self.store.next_id("use_case");
                UseCase {
                    id,
                    ..entity.clone()
                }
            } else {
                if use_case_map.contains_key(&entity.id) {
                    return Err(RepositoryError::DuplicateId {
                        entity: "UseCase",
                        id: entity.id,
                    });
                }
                entity.clone()
            };

            // one-to-one constraint check: ensure dto_in is not already referenced by another use_case
            {
                let jn = self.store.jn_dto_from_use_case_dto_in.read().unwrap();
                for (&existing_id, right_ids) in jn.iter() {
                    if let Some(ref right_id) = new_entity.dto_in
                        && existing_id != new_entity.id
                        && right_ids.contains(right_id)
                    {
                        return Err(RepositoryError::ConstraintViolation(format!(
                            "One-to-one constraint violation: Dto {} is already referenced by UseCase {}",
                            right_id, existing_id
                        )));
                    }
                }
            }
            // one-to-one constraint check: ensure dto_out is not already referenced by another use_case
            {
                let jn = self.store.jn_dto_from_use_case_dto_out.read().unwrap();
                for (&existing_id, right_ids) in jn.iter() {
                    if let Some(ref right_id) = new_entity.dto_out
                        && existing_id != new_entity.id
                        && right_ids.contains(right_id)
                    {
                        return Err(RepositoryError::ConstraintViolation(format!(
                            "One-to-one constraint violation: Dto {} is already referenced by UseCase {}",
                            right_id, existing_id
                        )));
                    }
                }
            }

            use_case_map.insert(new_entity.id, new_entity.clone());

            junction_set(
                &self.store.jn_dto_from_use_case_dto_in,
                new_entity.id,
                new_entity.dto_in.into_iter().collect::<Vec<EntityId>>(),
            );
            junction_set(
                &self.store.jn_dto_from_use_case_dto_out,
                new_entity.id,
                new_entity.dto_out.into_iter().collect::<Vec<EntityId>>(),
            );
            junction_set(
                &self.store.jn_entity_from_use_case_entities,
                new_entity.id,
                new_entity.entities.clone(),
            );

            created.push(new_entity);
        }
        Ok(created)
    }

    fn get(&self, id: &EntityId) -> Result<Option<UseCase>, RepositoryError> {
        let use_case_map = self.store.use_cases.read().unwrap();
        match use_case_map.get(id) {
            Some(entity) => {
                let mut e = entity.clone();
                drop(use_case_map);
                self.hydrate(&mut e);
                Ok(Some(e))
            }
            None => Ok(None),
        }
    }

    fn get_multi(&self, ids: &[EntityId]) -> Result<Vec<Option<UseCase>>, RepositoryError> {
        let mut result = Vec::with_capacity(ids.len());
        for id in ids {
            result.push(self.get(id)?);
        }
        Ok(result)
    }

    fn get_all(&self) -> Result<Vec<UseCase>, RepositoryError> {
        let use_case_map = self.store.use_cases.read().unwrap();
        let entries: Vec<UseCase> = use_case_map.values().cloned().collect();
        drop(use_case_map);
        let mut result = Vec::with_capacity(entries.len());
        for mut entity in entries {
            self.hydrate(&mut entity);
            result.push(entity);
        }
        Ok(result)
    }

    fn update(&mut self, entity: &UseCase) -> Result<UseCase, RepositoryError> {
        self.update_multi(std::slice::from_ref(entity))
            .map(|v| v.into_iter().next().unwrap())
    }

    // Scalar-only update: writes entity data but does NOT touch junction tables.
    fn update_multi(&mut self, entities: &[UseCase]) -> Result<Vec<UseCase>, RepositoryError> {
        let mut use_case_map = self.store.use_cases.write().unwrap();
        for entity in entities {
            use_case_map.insert(entity.id, entity.clone());
        }
        drop(use_case_map);
        let ids: Vec<EntityId> = entities.iter().map(|e| e.id).collect();
        let result = self.get_multi(&ids)?;
        Ok(result.into_iter().flatten().collect())
    }

    fn update_with_relationships(&mut self, entity: &UseCase) -> Result<UseCase, RepositoryError> {
        self.update_with_relationships_multi(std::slice::from_ref(entity))
            .map(|v| v.into_iter().next().unwrap())
    }

    fn update_with_relationships_multi(
        &mut self,
        entities: &[UseCase],
    ) -> Result<Vec<UseCase>, RepositoryError> {
        let mut use_case_map = self.store.use_cases.write().unwrap();
        for entity in entities {
            // one-to-one constraint check: ensure dto_in is not already referenced by another use_case
            {
                let jn = self.store.jn_dto_from_use_case_dto_in.read().unwrap();
                for (&existing_id, right_ids) in jn.iter() {
                    if let Some(ref right_id) = entity.dto_in
                        && existing_id != entity.id
                        && right_ids.contains(right_id)
                    {
                        return Err(RepositoryError::ConstraintViolation(format!(
                            "One-to-one constraint violation: Dto {} is already referenced by UseCase {}",
                            right_id, existing_id
                        )));
                    }
                }
            }
            // one-to-one constraint check: ensure dto_out is not already referenced by another use_case
            {
                let jn = self.store.jn_dto_from_use_case_dto_out.read().unwrap();
                for (&existing_id, right_ids) in jn.iter() {
                    if let Some(ref right_id) = entity.dto_out
                        && existing_id != entity.id
                        && right_ids.contains(right_id)
                    {
                        return Err(RepositoryError::ConstraintViolation(format!(
                            "One-to-one constraint violation: Dto {} is already referenced by UseCase {}",
                            right_id, existing_id
                        )));
                    }
                }
            }
            use_case_map.insert(entity.id, entity.clone());

            junction_set(
                &self.store.jn_entity_from_use_case_entities,
                entity.id,
                entity.entities.clone(),
            );
            junction_set(
                &self.store.jn_dto_from_use_case_dto_in,
                entity.id,
                entity.dto_in.into_iter().collect::<Vec<EntityId>>(),
            );
            junction_set(
                &self.store.jn_dto_from_use_case_dto_out,
                entity.id,
                entity.dto_out.into_iter().collect::<Vec<EntityId>>(),
            );
        }
        drop(use_case_map);
        let ids: Vec<EntityId> = entities.iter().map(|e| e.id).collect();
        let result = self.get_multi(&ids)?;
        Ok(result.into_iter().flatten().collect())
    }

    fn remove(&mut self, id: &EntityId) -> Result<(), RepositoryError> {
        self.remove_multi(std::slice::from_ref(id))
    }

    fn remove_multi(&mut self, ids: &[EntityId]) -> Result<(), RepositoryError> {
        let mut use_case_map = self.store.use_cases.write().unwrap();
        for id in ids {
            use_case_map.remove(id);

            // Remove forward junction entries

            junction_remove(&self.store.jn_entity_from_use_case_entities, id);
            junction_remove(&self.store.jn_dto_from_use_case_dto_in, id);
            junction_remove(&self.store.jn_dto_from_use_case_dto_out, id);

            // Clean up backward references (uses the owning entity's forward junction)

            delete_from_backward_junction(&self.store.jn_use_case_from_file_use_case, id);
            delete_from_backward_junction(&self.store.jn_use_case_from_feature_use_cases, id);
        }
        Ok(())
    }

    impl_write_relationship_methods!(UseCaseHashMapTable<'a>, UseCaseRelationshipField);
}

pub struct UseCaseHashMapTableRO<'a> {
    store: &'a HashMapStore,
}

impl<'a> UseCaseHashMapTableRO<'a> {
    pub fn new(store: &'a HashMapStore) -> Self {
        Self { store }
    }

    fn resolve_junction(
        &self,
        field: &UseCaseRelationshipField,
    ) -> &RwLock<HashMap<EntityId, Vec<EntityId>>> {
        match field {
            UseCaseRelationshipField::DtoIn => &self.store.jn_dto_from_use_case_dto_in,
            UseCaseRelationshipField::DtoOut => &self.store.jn_dto_from_use_case_dto_out,
            UseCaseRelationshipField::Entities => &self.store.jn_entity_from_use_case_entities,
        }
    }

    fn hydrate(&self, entity: &mut UseCase) {
        entity.entities = junction_get(&self.store.jn_entity_from_use_case_entities, &entity.id);
        entity.dto_in = junction_get(&self.store.jn_dto_from_use_case_dto_in, &entity.id)
            .into_iter()
            .next();
        entity.dto_out = junction_get(&self.store.jn_dto_from_use_case_dto_out, &entity.id)
            .into_iter()
            .next();
    }
}

impl<'a> UseCaseTableRO for UseCaseHashMapTableRO<'a> {
    fn get(&self, id: &EntityId) -> Result<Option<UseCase>, RepositoryError> {
        let use_case_map = self.store.use_cases.read().unwrap();
        match use_case_map.get(id) {
            Some(entity) => {
                let mut e = entity.clone();
                drop(use_case_map);
                self.hydrate(&mut e);
                Ok(Some(e))
            }
            None => Ok(None),
        }
    }

    fn get_multi(&self, ids: &[EntityId]) -> Result<Vec<Option<UseCase>>, RepositoryError> {
        let mut result = Vec::with_capacity(ids.len());
        for id in ids {
            result.push(self.get(id)?);
        }
        Ok(result)
    }

    fn get_all(&self) -> Result<Vec<UseCase>, RepositoryError> {
        let use_case_map = self.store.use_cases.read().unwrap();
        let entries: Vec<UseCase> = use_case_map.values().cloned().collect();
        drop(use_case_map);
        let mut result = Vec::with_capacity(entries.len());
        for mut entity in entries {
            self.hydrate(&mut entity);
            result.push(entity);
        }
        Ok(result)
    }

    impl_relationship_methods!(UseCaseHashMapTableRO<'a>, UseCaseRelationshipField);
}