Qual è uno schema utile per mantenere uno stato di oggetto in una relazione uno a molti?

1

Sto cercando un design per la mia applicazione, qui ci sono i giocatori (classi) coinvolti.

struct Transform {
    // Uses a matrix to transform the position.
    // Also acts acts as the state of a Dialog.
    Position transform(Position p);

    //other methods.
};

struct Dialog {
     // There are multiple dialog for the user to transform the output.

     Transform& t;
     void ChangeTranformation(){t.rotate(360);}
}

struct Algorithm {
    //gives us a position based on an implementation. For example this can return points on a circle or line.

    Transform& t;
    Position m_p;
    Dialog& d;
    Position GetCurrentPosition(){ return t.transform(m_p);}

    //other methods.
}

Proprietà di cui ho bisogno:

  1. Ogni algoritmo ha una finestra di dialogo e ogni finestra di dialogo può avere molti algoritmi ad essa associati.
  2. Quando l'utente seleziona un algoritmo viene visualizzata una finestra di dialogo associata a quell'algoritmo.
  3. Se l'utente seleziona un algoritmo diverso, quindi seleziona nuovamente lo stato viene ripristinato nella finestra di dialogo.

Fondamentalmente voglio un buon modello di progettazione per mantenere lo stato del dialogo dato che molti algoritmi lo usano e possono essere commutati avanti e indietro. Qualcuno ha qualche suggerimento?

Ecco un caso d'uso:

Dialog1 ha una sola casella di modifica per controllare il raggio.

Algorithm1 genera punti su un cerchio unitario.

Algorithm2 è lo stesso di Algorithm1.

L'utente ha selezionato Algorithm1 e inserito 2 nella casella di modifica. Questo genererà punti su un cerchio di raggio 2.

L'utente seleziona Algorithm2 e inserisce 10 nella casella di modifica di Dialog1 . Questo genererà punti su un cerchio di raggio 10.

Infine Algorithm1 è nuovamente selezionato. La casella di modifica di Dialog1 dovrebbe mostrare 2 e i punti su un cerchio di raggio 2 dovrebbero essere generati.

    
posta ahenderson 13.11.2012 - 18:51
fonte

2 risposte

2

Non hai bisogno di schemi di fantasia. Devi separare il modello dall'interfaccia utente . Gli algoritmi e i loro dati di input correnti formano il modello.

Le finestre di dialogo fanno parte dell'interfaccia utente. Quando viene selezionato un algoritmo, viene visualizzata la finestra di dialogo corrispondente, che mostra i dati correnti dell'algoritmo. Se l'utente modifica i dati, tale modifica viene passata all'algoritmo.

Tutto ciò di cui hai bisogno è una relazione uno a uno tra gli algoritmi e i loro dati di input e una relazione molti-a-uno tra algoritmi e finestre di dialogo.

    
risposta data 13.11.2012 - 22:49
fonte
1

Basically I want a good design pattern to maintain the state of the dialog given that many algorithms use it and they can be switched back and forth.

Sembra un lavoro per Memento .

The memento pattern is a software design pattern that provides the ability to restore an object to its previous state...

Stai cercando di associare lo stato di una finestra di dialogo con un algoritmo. Dato che l'attuale algoritmo è stato rimosso, avere la corrente richiede un promemoria dalla finestra di dialogo. Il memento è un oggetto opaco (dalla prospettiva dell'algoritmo) che codifica lo stato della finestra di dialogo. Quando l'algoritmo appena selezionato viene aggiunto alla finestra, fornisce il ricordo che it aveva precedentemente richiesto (se ne esiste uno) alla finestra di dialogo, e la finestra di dialogo lo utilizza per configurarsi.

Detto questo, il mantenimento dello stato della finestra di dialogo sta facendo le cose all'indietro. Lo scopo di una finestra di dialogo è di consentire all'utente di vedere, e forse modificare, i dati su cui il programma opera. Nel tuo caso, sembra che gli algoritmi facciano parte di questo. Quando l'utente modifica qualcosa nella finestra di dialogo, ciò dovrebbe causare una modifica corrispondente nell'algoritmo corrente e tale modifica dovrebbe essere memorizzata in un posto diverso dai controlli della finestra di dialogo. Se organizzi il tuo programma in questo modo, puoi consentire alla selezione dell'algoritmo di guidare il contenuto della finestra di dialogo. Questo è esattamente come lo faresti se usi il Model-View-Controller paradigma (o uno dei suoi cugini). Se l'utente cambia qualcosa nella finestra di dialogo, quella modifica modifica l'algoritmo (cioè il modello). Se l'utente seleziona un algoritmo diverso, lo stato corrente del nuovo algoritmo viene utilizzato per impostare i valori nella finestra di dialogo.

    
risposta data 13.11.2012 - 19:39
fonte

Leggi altre domande sui tag