IBMz13

      

Computer science is not about machines, in the same way that astronomy is not about telescopes.                                         

                                Edsger Dijkstra

Categorie:IBM MAINFRAME

[DELPHI] – Split a string with more than one delimiter

Sometimes we need to split a string in tokens delimited by more one delimiter …

… for example, we have a string and we want to split it in tokens delimited by the characters: space, comma, greater than sign, etc.. :


String := 'EXEC SQL
                DECLARE STAFF_LIST CURSOR FOR
                     SELECT EMPID,
                            LNAME,
                            FNAME,
                            SALARY
                       FROM QMT_STAFF
                      WHERE SALARY > 10000
                   ORDER BY EMPID
           END-EXEC.'

… here’s a simple function :

// .............................................................................
//    FUNCTION : SplitStringInTokens
//               SPILT STRING IN TOKENS
//       PARMS : Source          - String to Split
//               DelimiterList   - TStringList of Delimiters
//               TokenList       - TStringList of Tokens
//      RETURN : Count of Tokens
.............................................................................
function TForm1.SplitStringInTokens(const Source: String; const DelimitersList : TStringList; var TokensList : TStringList) : Integer;
var
    SourceString    : String;
    Token           : String;
    Char            : String;
    IndexChar       : Integer;
    IndexDelimiters : Integer;
    FoundDelimiter  : Boolean;
begin

    // ... TRIM STRING
    SourceString := Trim(Source);

    IndexChar := 1;
    Token     := '';
    while ( IndexChar <= Length(SourceString) ) do begin
        // ... GET CURRENT CHAR
        Char := Copy(SourceString, IndexChar, 1);

        // ... CHECK IF THE CHAR IS A DELIMITER (SEARCH IN THE LIST)
        IndexDelimiters := 0;
        FoundDelimiter  := FALSE;
        while (FoundDelimiter = FALSE) and (IndexDelimiters < DelimitersList.Count) do begin
            if (Char = DelimitersList[IndexDelimiters]) then begin
                // ... YES, IT'S A DELIMITER! EXIT
                FoundDelimiter := TRUE;
            end
            else begin
                // ... NO, CONTINUE
                IndexDelimiters := IndexDelimiters + 1;
            end;
        end;

        // ... FOUND A DELIMITER?
        if (FoundDelimiter = TRUE) then begin
            // ... YES, SAVE TOKEN (IF NOT NULL)
            if (Token <> '') then begin
                TokensList.Add(Token);
            end;
            // ... SAVE DELIMITER (IF NOT SPACE)
            if (Char <> ' ') then begin
                TokensList.Add(Char);
            end;
            // ... COPY THE REST OF STRING TO SPLIT
            SourceString := Trim(Copy(SourceString, IndexChar+1, Length(SourceString)));
            Token        := '';
            IndexChar    := 1;
        end
        else begin
            // ... CHAR IS NOT A DELIMITER, ADD CHAR TO TOKEN
            Token := Token + Char;
            // ... INC. INDEX
            IndexChar := IndexChar + 1;
        end;
    end;
    // ... END OF STRING

    // ... ADD LAST TOKEN
    if (Token <> '') then begin
        TokensList.Add(Token);
    end;

    // ... RETURN THE COUNT OF TOKENS
    Result := TokensList.Count;
end;
//..............................................................................

… here’s how to call the function with the arguments :


...
var
    StringToSplit  : String;
    DelimitersList : TStringList;
    TokensList     : TStringList;
    i              : Integer;
begin 

    // ... CREATE THE TOKENS LIST
    TokensList      := TStringList.Create;

    // ... CREATE THE DELIMITERS LIST
    DelimitersList  := TStringList.Create;

    // ... ASSIGN THE STRING TO SPLIT
    StringToSplit   := 'EXEC SQL
                           DECLARE STAFF_LIST CURSOR FOR
                             SELECT EMPID,
                                    LNAME,
                                    FNAME,
                                    SALARY
                               FROM QMT_STAFF
                           ORDER BY EMPID
                        END-EXEC.'

    // ... ADD DELIMITERS TO THE LIST
    DelimitersList.Add(' ');
    DelimitersList.Add(',');
    DelimitersList.Add('>');
    // ... etc..

    // ... CLEAR TOKENS LIST
    TokensList.Clear;

    // ... SPLIT STRING IN TOKENS
    SplitStringInTokens(TextSource, DelimitersList, TokensList);

    // ... SHOW TOKENS LIST
    i := 0;
    While (i < TokensList.Count) do begin
        ShowMessage(TokensList[i]);
        i := i + 1;
    end;    

    // ... end  

 

 

 

… relax

[AS3] – Come creare un oggetto leggendo il nome della Classe e delle sue proprietà da un file XML.

A volte può esserci l’esigenza di dover generalizzare il processo di creazione degli oggetti, e di conseguenza acquisire i riferimenti delle Classi in maniera dinamica.

La funzione getDefinitionByName() di AS3, presente nel package flash.utils, consente di ottenere un riferimento della Classe, passando, come argomento, il nome della classe ( in formato stringa ).

Una volta acquisito il riferimento alla Classe, l’oggetto potrà essere istanziato utilizzando l’operatore new e la variabile contenente il “reference” della Classe.

// ...
var className         :String;
var classReference    :Class;
var objectReference   :Object;

// ... class name ( string );
// ... nome della Classe ( string )   
className       = flash.display.MovieClip

// ... ottieni il riferimento all'oggetto Class
// ... get Class object reference 
classReference  = Class(getDefinitionByName(className));

// ... crea l'oggetto
// ... create the object
objectReference = classReference(new classReference());

// ... 

 

E’ necessario, comunque, che la Classe venga importata al momento della compilazione del .fla o .as.

Nota : la maggior parte delle classi predefinite di AS3 ( presenti nei pacchetti flash.*) sono importate automaticamente dal compilatore. 

 

Per importare in maniera “esplicita” una Classe ( propria o tra quelle presenti nei pacchetti di AS3 non caricate automaticamente ) basterà dichiarare una variabile di quel tipo ( di quella Classe ). 

// ...
// ... declare a dummy variable of type : myClass
// ... dichiarazione di una variabile del tipo : myClass 
var dummyRef : myClass;
// ...

 

Ciò servirà ad “avvertire” il compilatore che “intendiamo utilizzare quella Classe” e lo “costringerà” ad importare la definizione della Classe.

Nota : la sola indicazione della dichiarativa import myclass non è sufficiente a far importare la Classe, in quanto, il compilatore, per motivi di ottimizzazione, non importerà la Classe fin tanto che non incontrerà almeno una dichiarazione di variabile di quella Classe.

 

Qui di seguito un esempio che mostra come creare un oggetto il cui nome della Classe ed alcune delle sue proprietà sono lette da un file XML.

// ...................................................................
//   NAME : buildForm.fla
//          QUESTO ESEMPIO MOSTRA COME CREARE UN OGGETTO LEGGENDO IL 
//          NOME DELLA CLASSE E LE SUE PROPRIETA' DA UN FILE XML. 
//
//          THIS EXAMPLE SHOWS HOW TO CREATE AN OBJECT READING CLASS 
//          NAME AND ITS PROPERTIES AS STRINGS FROM AN XML FILE 
//
// 
// sample XML file : 
// 
// <?xml version="1.0" encoding="UTF-8"?>
// <form>
//   <editField className="flash.text.TextField" >
//     <type>input</type>
//     <maxChars>200</maxChars>
//     <text>... that was only yesterday</text>
//     <textColor>0x00CC00</textColor> 
//     <background>true</background> 
//     <backgroundColor>0x333333</backgroundColor> 
//     <border>true</border> 
//     <borderColor>0x888888</borderColor> 
//     <width>300</width> 
//     <height>25</height> 
//     <x>100</x> 
//     <y>50</y> 
//   </editField>
// </form>
//
// ...................................................................
var XMLRequest        :URLRequest; 
var XMLLoader         :URLLoader; 
var XMLObejct         :XML; 
var myObject          :XMLList; 

var classReference    :Class;
var className         :String;
var objectReference   :Object;

var propertyClass     :Class;
var propertyObject    :XML;
var propertyName      :String;
var propertyValue     :String;
var booleanValue      :Boolean;


XMLRequest     = new URLRequest(); 
XMLLoader      = new URLLoader(); 
XMLLoader.addEventListener(Event.COMPLETE, XMLLoaded); 

XMLRequest.url = "form.xml";
XMLLoader.load(XMLRequest);

// ... 

// .................................................. 
//  FUNCTION : XMLLoaded - Event.COMPLETE
// .................................................. 
function XMLLoaded(evento:Event):void  
{
    // ... ACQUISIZIONE DELL'XML  
    // ... GET XML  
    XMLObejct = new XML(XMLLoader.data); 

    // ... ACQUISIZONE DEL TAG <editField>	
    // ... GET <editField> TAG 
    myObject = XMLObejct.editField; 
    // ... oppure  
    // ... or   
    // ... ( myObject = XMLObejct.children()[0]; ) 
	
	
    // ... ACQUISIZIONE DELL'ATTRIBUTO className 
    // ... GET className ATTRIBUTE 
    //     ( es. : <editField className="flash.text.TextField" > ) 
    className       = myObject[0].@className; 
	
    // ... SYSOUT 
    trace("className : " + className);
	
    // ... ACQUISIZIONE DELLA CLASSE 
    // ... GET CLASS REFERENCE 
    classReference  = Class(getDefinitionByName(className));
	
    // ... CREAZIONE DELL'OGGETTO 
    // ... CREATE THE OBJECT 
    objectReference = classReference(new classReference());
	
    // ... LETTURA DELLE PROPRIETA' DELL'OGGETTO  
    // ... READ OBJECT'S PROPERTIES 
    for( var i:int = 0; i < myObject.children().length(); i++ )
    {
        // ... ACQUISIZIONE DEL i-esimo TAG ( PROPRIETA' )        		
        // ... GET i-th TAG ( PROPERTY )  
        //     ( es. : <maxChars>200</maxChars> ) 
        propertyObject = myObject.children()[i];
		
        // ... NOME DEL TAG ( NOME DELLA PROPRIETA' )  
        // ... TAG NAME ( PROPERTY NAME )  
        //     ( es. "maxChars" ) 
        propertyName   = propertyObject.name();
	    
        // ... VALORE DELLA PROPRIETA' 
        // ... PROPERTY VALUE 
        //     ( es. : 200 ) 
        propertyValue  = propertyObject;
		
        // ... SYSOUT 
        trace(propertyName + "=" + propertyValue);
		
        // ... ACQUISISCI LA CLASSE DELLA PROPRIETA' 
        // ... GET PROPERTY CLASS 
        propertyClass = Object(objectReference[propertyName]).constructor;
		
        // ... SYSOUT 
        trace("propertyClass : " + propertyClass);
		
        // ... SE LA PROPRIETA' E' DI CLASSE BOOLEAN, DOBBIAMO CONVERTIRE 
        //     LE STRINGHE "true" O "false" IN BOOLEAN. 
        // ... IF PROPERTY CLASS IS BOOLEAN, WE NEED TO CONVERT 
        //     THE STRINGS VALUES "true" OR "false" IN BOOLEAN. 
        if (propertyClass == Boolean) 
        {
            // ... RICHIAMO DELLA FUNZIONE strToBoolean() PRIMA DEL CASTING 
            // ... CALL strToBoolean() FUNCTION BEFORE CASTING			
            booleanValue                  = strToBoolean(propertyValue);

            // ... ASSEGNAZIONE DEL VALORE DELLA PROPRIETA' (boolean)
            // ... ASSIGN PROPERTY VALUE (boolean) 
            objectReference[propertyName] = propertyClass(booleanValue);
        }
        else 
        {
            // ... ASSGNAZIONE DEL VALORE DELLA PROPRIETA' 
            // ... ASSIGN PROPERTY VALUE  
            objectReference[propertyName] = propertyClass(propertyValue);
        }
    }	
	
    // ... AGGIUNGI L'OGGETTO 
    // ... ADD CHILD 
    addChild(classReference(objectReference));

    // ... 
} 
// ...................................................................


// ...................................................................
//   FUNCTION : strToBoolean() 
//              CONVERTE LE STRINGHE "true" O "false" IN BOOLEAN 
//              CONVERTS THE STRINGS "true" OR "false" INTO BOOLEAN 
// ...................................................................
function strToBoolean(p_string:String):Boolean
{
    var retValue:Boolean;
	
    retValue = false;
    if (p_string == "true" ) 
    { 
        retValue = true;
    }
    return retValue;
}
// ...................................................................

// ... END 
Categorie:ACTIONSCRIPT 3.0

[DB2] – I Tipi di Dati del DB2

La Tabella seguente mostra i tipi di Dati del DB2 e le corrispondenti clausole PICTURE e USAGE in COBOL

Tipo DB2 PICTURE USAGE Descrizione
CHAR(n) PIC X(n) DISPLAY Caratteri a lunghezza Fissa (EBCDIC). Fino ad un massimo di 254 bytes di caratteri alfanumerici. In COBOL è definito come PIC X(n), dove n è il numero di caratteri della colonna.
es. : 01  COD-CLI  PIC X(10).
VARCHAR(n) PIC X(n) DISPLAY Caratteri a lunghezza variabile (EBCDIC). Un numero variabile di caratteri alfanumerici. Il numero di bytes di caratteri è memorizzato in una Halfword (mezzavoce).
es. : 01 NOTE.
49 NOTE-LUNG  PIC S9(4) COMP.
49 NOTE-TXT     PIC X(2000).
SMALLINT PIC S9(4) COMP o
COMP-4
Un valore intero (Halfword). Valori compresi tra -32.768 e +32.767. Definito in COBOL come PIC S9(4) COMP.
es. : 01 CTR-RIGA    PIC S9(4) COMP. 
INTEGER PIC S9(9) COMP o
COMP-4
Un valore intero (Fullword). Valori compresi tra -2.147.485.648 e +2.147.485.648. Definito in COBOL come PIC S9(9) COMP.
es. : 01 CTR-OPE     PIC S9(4) COMP.
DECIMAL(n,d) PIC S9(i)V9(d) COMP-3 Packed Decimal. Contiene valori decimali (il segno della virgola è implicito). Il valore n indica il numero complessivo di cifre e d quante di quelle sono a destra del segno decimale.
es. : 01 TOT-FATT    PIC S9(7).V99 COMP-3.
L’esempio è la corrispondente dichiarazione di una variabile HOST per una COLONNA definita come : DECIMAL(9,2).
DATE PIC X(10) DISPLAY Una stringa di 10 caratteri. La struttura interna è nella forma : yyyy-mm-dd.
es. : 01 DATA-FATT     PIC X(10).
TIME PIC X(8) DISPLAY Una stringa di 8 caratteri (hh.mm.ss).
es. : 01 ORA-INIZIO     PIC X(8).
TIMESTAMP PIC X(26) DISPLAY Una stringa di 26 caratteri. La struttura interna è : yyyy-mm-dd-hh.mm.ss.mmmmmm
es. : 01 DATA-ORA-INIZIO     PIC X(26)
GRAPHIC PIC G(n) DISPLAY-1 Una Stringa grafica a lunghezza fissa che contiene n word (double-byte) di caratteri. Il valore n deve essere  maggiore di 0 e minore di 128.
VARGRAPHIC PIC G(n) DISPLAY-1 Una Stringa grafica a lunghezza variabile. Il valore massimo della lunghezza, n, deve essere maggiore di 0 e minore di un numero che dipende dalla taglia della pagina del table space. La lunghezza massima è di 16.352.
FLOAT No COMP-1 o
COMP-2
Floating Point (singola o doppia precisione). Singola precisione per n minore di 22, doppia precisione se n è compreso tra 22 e 53. La corrispondente dichiarazione COBOL non include la clausola PIC. Va indicato COMP-1 per la singola precisione, COMP-2 per la doppia precisione.
es. : 01 VALORE-SP  COMP-1.
01 VALORE-DP  COMP-2.
Categorie:DB2 - SQL

[AS3] – Invio e ricezione Array tra FLASH e PHP

Questo esempio mostra come inviare un’Array da FLASH ad uno script PHP e ricevere dallo script PHP un altro Array.
 
Un modo elementare :
Un Array di nomi viene ‘impacchettato’ in un unica stringa con il metodo : join() della Classe String ( tutti gli elementi dell’Array sono concatenati utilizzando un delimitatore ), quindi inviato allo script PHP.

Lo script PHP riceve la stringa, la ‘esplode’ con la funzione : explode() e riottiene l’Array originale.
L’Array (originale) ottenuto è copiato in un nuovo Array e rispedito all’SWF chiamante.
 
 

 

 

// ...............................................................
//   NAME : flashToPhp.fla
//          QUESTO ESEMPIO MOSTRA COME INVIARE E RICEVERE UN ARRAY
//          TRA FLASH ED UNO SCRIPT PHP
// ...............................................................

import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.net.URLVariables;

var richiestaPHP  :URLRequest;
var caricatorePHP :URLLoader;
var varsToPHP     :URLVariables;
var arrayNomi     :Array;

// ... CREAZIONE OGGETTO RICHIESTA DI ESECUZIONE DELLO SCRIPT PHP
richiestaPHP        = new URLRequest("PhpToFLASH_02.php");

// ... CREAZIONE OGGETTO CARICATORE SCRIPT PHP
caricatorePHP       = new URLLoader(richiestaPHP);
// ... CREAZIONE OGGETTO URLVariables PER L'INVIO DELLE VARIABILI
//     ALLO SCRIPT PHP
varsToPHP           = new URLVariables();

// ... IMPOSTAZIONE METODO PASSAGGIO VARIABILI ALLO SCRIPT (GET | POST)
richiestaPHP.method = URLRequestMethod.POST;
// ... FORMATO IN CUI SI DESIDERA RICEVERE I DATI DALLO SCRIPT PHP :

// ... in formato VARIABLES
//     i dati ricevuti sono costituiti da un oggetto :URLVariables
//     che contiene le variabili con codifica URL
caricatorePHP.dataFormat = URLLoaderDataFormat.VARIABLES;

// ... ALTRI FORMATI IN CUI POSSONO ESSERE RICEVUTI I DATI DALLO SCRIPT :
//
//     - in fomato TEXT ( URLLoaderDataFormat.TEXT )
//       i dati sono costituiti da una stringa contenente il testo
//
//     - in formato BINARY ( URLLoaderDataFormat.BINARY )
//       i dati sono costituiti da un oggetto ByteArray

// ... CREAZIONE DELL'ARRAY DA INVIARE ALLO SCRIPT PHP
arrayNomi = new Array();

// ... INIZIALIZZAZIONE
arrayNomi.push('giulio');
arrayNomi.push('alina');
arrayNomi.push('carlo');
arrayNomi.push('anna');

// ...

// ... COMPONENETI PRESENTI SULLO STAGE (per il test) :

// ... UN BUTTON PER L'AVVIO DEL CARICAMENTO DELLO SCRIPT PHP
btn_invia.addEventListener(MouseEvent.CLICK, onClickInvia);

// ... UN CAMPO TextField (multiline) CHE CONTERRA' L'ARRAY
//     RICEVUTO DALLO SCRIPT PHP
kmessaggi.text = "";
// ...

// ...............................................................
//  FUNCTION : onClickInvia() - MouseEvent.CLICK
//             AVVIO CARICAMENTO ED ESECUZIONE DELLO SCRIPT PHP
// ...............................................................
function onClickInvia(evento:MouseEvent):void
{
// ... AVVIO DELLO SCRIPT PHP

// ... 'impacchetta' GLI ELEMENTI DELL'ARRAY IN UN'UNICA
//     STRING, UTILIZZANDO COME DELIMITATORE IL CARATTERE "|"
var stringNomi = arrayNomi.join("|");

// ... DOPO LA join(), L'ARRAY DIVENBTA UN'INICA STRING
// stringNomi = 'giulio|alina|carlo|anna';

// ... ASSEGNAZIONE DELLA VARIABILI DA INVIARE COME PROPRIETA'
//     DELL'OGGETTO URLVariables
varsToPHP.nomi = stringNomi;

// ... AGGIUNTA DELL'ASCOLTATORE EVENTO : OPEN
//     per sapere quando il caricamento dello script PHP è iniziato
caricatorePHP.addEventListener(Event.OPEN, onOpenScript);

// ... AGGIUNTA DELL'ASCOLTATORE EVENTO : PROGRESS
//     per sapere che lo script è in fase di caricamento ed esecuzione
caricatorePHP.addEventListener(ProgressEvent.PROGRESS, onProgressScript);

// ... AGGIUNTA DELL'ASCOLTATORE EVENTO : COMPLETE
//     per sapere quando lo script PHP termina ed i dati saranno dati
//     ricevuti.
caricatorePHP.addEventListener(Event.COMPLETE, onCompleteScript);

// ... AGGIUNTA DELL'ASCOLTATORE EVENTO : IO_ERROR
//     per gestire eventuali errori durante il caricamento o esecuzione
//     dello script PHP.
caricatorePHP.addEventListener(IOErrorEvent.IO_ERROR, onErrorScript);

// ... ASSEGNAZIONE DELL'OGGETTO URLVariables ALLA PROPRIETA' .data
//     DELL'OGGETTO URLRequest ( invio dei dati )
richiestaPHP.data = varsToPHP;

// ... AVVIA LA RICHIESTA DI CARICAMENTO ED ESECUZIONE DELLO SCRIPT PHP
caricatorePHP.load(richiestaPHP);

// ...
}
// ...............................................................

// ...............................................................
//  FUNCTION : onOpenScript() - Event.OPEN
//             NOTIFICATO ALL'AVVIO DEL CARICAMENTO DELLO SCRIPT
// ...............................................................
function onOpenScript(evento:Event):void
{
// ... IL CARICAMENTO ED ESECUZIONE DELLO SCRIPT PHP
//     ( SUL SERVER ) E' AVVIATO
kmessaggi.text = '... avvio caricamento Script PHP';
}
// ...............................................................

// ...............................................................
//  FUNCTION : onProgressScript() - ProgressEvent.PROGRESS
//             EVENTO NOTIFICATO DURANTE IL CARICAMENTO
//             ED ESECUZIONE DELLO SCRIPT PHP
// ...............................................................
function onProgressScript(evento:ProgressEvent):void
{
// ... LO SCRIPT PHP E' IN ESECUZIONE ( SUL SERVER )
kmessaggi.text = '... attendere prego!';
}
// ...............................................................

// ...............................................................
//  FUNCTION : onComplteScript()
//             EVENTO NOTIFICATO AL COMPLETAMENTO DELL'ESECUZIONE
//             DELLO SCRIPT PHP
// ...............................................................
function onComplteScript(evento:Event):void
{
// ... LO SCRIPT PHP E' STATO CARICATO ED ESEQUITO, ED I DATI
//     SONO STATI RICEVUTI ...

// ... CREAZIONE DI UN OGGETTO URLVariables, PASSANDO AL
//     COSTRUTTORE I DATI RICEVUTI DALLO SCRIPT PHP
var varsFromPHP = new URLVariables(evento.target.data);

// ... DICHIARAZIONE DI UNA VARIABILE STRING IN CUI COPIARE
//     LA VARIABILE RICEVUTA DALLO SCRIPT PHP
var stringMessaggi:String;

// ... CREAZIONE DI UN NUOVO ARRAY
var arrayMessaggi :Array = new Array();

// ... ACQUISIZIONE DELLA VARIABILE RICEVUTA
stringMessaggi = varsFromPHP.messaggi;
// ... NOTA : il nome della proprietà messaggi è quello
//            indicato nell'echo dello script PHP

// ... 'spacchetta' LA STRINGA IN ELEMENTI DELL'ARRAY
arrayMessaggi  = stringMessaggi.split("|");

// ... VISUALIZZA GLI ELEMENTI DELL'ARRAY
kmessaggi.text = "";
for (var i=0; i < arrayMessaggi.length; i++)
{
kmessaggi.appendText(arrayMessaggi[i] + "\n");
};

// ... RIMUOVI GLI ASCOLTATORI
caricatorePHP.removeEventListener(Event.OPEN, onOpenScript);
caricatorePHP.removeEventListener(ProgressEvent.PROGRESS, onProgressScript);
caricatorePHP.removeEventListener(Event.COMPLETE, onCompleteScript);
caricatorePHP.removeEventListener(IOErrorEvent.IO_ERROR, onErrorScript);
}
// ...............................................................

// ...............................................................
//  FUNCTION : onErrorScript() - IOErrorEvent.IO_ERROR
//             EVENTO NOTIFICATO IN CASO DI ERRORE DURANTE IL
//             CARICAMENTO DELLO SCRIPT
// ...............................................................
function onErrorScript(evento:IOErrorEvent):void
{
// ... ERRORE DURANTE LA FASE DI CARICAMENTO DELLO SCRIPT
kmessaggi.text = '... errore di caricamento dello script PHP';
}
// ...............................................................

// ... END

 
… lo script PHP

 


<?
// .....................................................
//  NAME : PhpToFLASH_02.php
//         Ricezione ed invio di Array tra FLASH e PHP
// .....................................................

// ... acquisizione delle variabili inviate dall'SWF

// ... la stringa 'impacchettata' contenete l'Array
//     inviato dall'SWF
$stringNomi = $_POST['nomi'];

// ... crea l'Array da ricostruire
$arrayNomi = array();

// ... 'spacchetta' la stringa in elementi dell'Array
$arrayNomi = explode("|", $stringNomi);

// ... l'Array e' stato ricostruito!

// ... crea un nuovo Array, quello che verra' rispedito
//     all'SWF
$arrayMessaggi = array();

// ... copia i nomi presenti nell'Array ricevuto negli
//     elementi del nuovo array, aggiugendo '... hello '
for ($i = 0; $i < sizeof($arrayNomi); $i++)
{
$arrayMessaggi[$i] = '... hello ' . $arrayNomi[$i];
}

// ... 'impacchetta' l'Array in una stringa da rispedire
//     all'SWF
$stringMessaggi = implode("|", $arrayMessaggi);

// ... invia la stringa all'SWF chiamante
echo "messaggi=" . urlencode($stringMessaggi);

// ... la funzione urlencode() effettua l'encoding di
//     una stringa, covertendo la stringa in un formato
//     URL valido (conversione di caratteri speciali).

// ... i caratteri '/', '%', '&', etc..., sono
//     convertiti con il segno % seguito dalla codifica
//     HEX del carattere.

// ... la funzione inversa e' : urldecode()

// ... end of JOB
?>

Categorie:ACTIONSCRIPT 3.0

[AS3] – Invio e ricezione Dati tra FLASH e PHP

L’esempio seguente mostra come inviare una variabile ( il contenuto di un TextField ) ad uno script PHP (Server-Side), e ricevere dallo script PHP un messaggio di risposta.

// .........................................................
//     NAME : FlashPhp.fla
//            ESEMPIO MINIMALISTA DI INVIO E RICEZIONE DATI
//            TRA FLASH E PHP
// .........................................................

// ... IMPORT DELLE CLASSI PER IL CARICAMENTO E LO SCAMBIO
//     DEI DATI CON LO SCRIPT PHP
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.net.URLVariables;

// ... DICHIARAZIONE DELLE VARIABILI RELATIVE AI REFERENCE
//     DEGLI OGGETTI
var phpRequest : URLRequest;
var phpLoader  : URLLoader;
var dataToPHP  : URLVariables;

// ... CREAZIONE DELL'OGGETTO URLRequest PER LA RICHIESTA
//     DI ESECUZIONE DELLO SCRIPT PHP (LATO SERVER)
phpRequest = new URLRequest();

// ... CREAZIONE DELL'OGGETTO URLLoader PER IL CARICAMENTO
//     DELLO SCRIPT PHP (LATO SERVER)
phpLoader  = new URLLoader();

// ... CREAZIONE DELL'OGGETTO URLVariables PER L'INVIO
//     DELLE VARIABILI DA FLASH A PHP
dataToPHP  = new URLVariables();

// ... IMPOSTAZIONE DEL METODO DI PASSAGGIO DELLE VARIABILI
//     (GET | POST)
phpRequest.method = URLRequestMethod.POST;

// ... ASSEGNAZIONE DEL TIPO DI FORMATO IN CUI SI DESIDERA
//     RICEVERE I DATI DALLO SCRIPT PHP :

// ... in formato VARIABLES :
//     (i dati ricevuti sono costituiti da un oggetto URLVariables
//      che contiene le variabili con codifica URL)
phpLoader.dataFormat = URLLoaderDataFormat.VARIABLES;

// ... altri modi in cui possono essere ricevuti i dati
//     dallo script PHP :

//     - in formato testo (URLLoaderDataFormat.TEXT)
//       i dati sono costituiti da una stringa contenente il testo

//     - in formato binaro (URLLoaderDataFormat.BINARY)
//       i dati sono costituiti da un oggetto di Classe ByteArray

// ***

// ... I COMPONENTI PRESENTI SULLO STAGE (per il test) :

// ... UN TextField PER L'IMMISSIONE DI UN CAMPO DA INVIARE
//     ALLO SCRIPT PHP
nickName.text = "";

// ... UN TextField CHE CONTERRA' IL MESSAGGIO RICEVUTO
//     DALLO SCRIPT PHP
msg.text      = "";

// ... UN Button PER L'AVVIO DEL CARICAMENTO ED ESECUZIONE
//     DELLO SCRIPT PHP (sul server)
btn_Send.addEventListener(MouseEvent.CLICK, onClickSend);

// ...

// .........................................................
//     FUNCTION : onClickSend() - MouseEvent.CLICK
//                AVVIO DEL CARICAMENTO ED ESECUZIONE DELLO
//                SCRIPT PHP SUL SERVER
// .........................................................
function onClickSend(evento:MouseEvent):void
{
    // ... PREPARAZIONE DEI DATI DA INVIARE ALLO SCRIPT PHP

    // ... ASSEGNAZIONE DELLE VARIABILI DA INVIARE
    //     (come proprietà dinamiche dell'oggetto : URLVariables)
    dataToPHP.nickname = nickName.text;
    // ... etc..

    // ... AGGIUNTA DEGLI ASCOLTATORI PER LA GESTIONE DEGLI EVENTI :

    // ... AGGIUNTA DELL'ASCOLTATORE PER LA GESTIONE
    //     DELL'EVENTO : COMPLETE
    //     (la funzione sarà invocata al termine dell'esecuzione
    //      dello script PHP ed eventuali dati, inviati da questi,
    //      saranno pervenuti)
    phpLoader.addEventListener(Event.COMPLETE, onCompleteScript);

    // ... AGGIUNTA DELL'ASCOLTATORE PER LA GESTIONE
    //     DELL'EVENTO : IO_ERROR
    //     (la funzione sarà invocata in caso di errore durante
    //      il caricamento dello script PHP)
    phpLoader.addEventListener(IOErrorEvent.IO_ERROR, onErrorScript);

    // ... AGGIUNTA DELL'ASCOLTATORE PER LA GESTIONE
    //     DELL'EVENTO : OPEN
    //     (la funzione sarà invocata quando il caricamento
    //       dello script PHP e' iniziato)
    phpLoader.addEventListener(Event.OPEN, onOpenScript);

    // ... AGGIUNTA DELL'ASCOLTATORE PER LA GESTIONE
    //     DELL'EVENTO : PROGRESS
    //     (la funzione sarà invocata durante il caricamento
    //      dello script PHP)
    phpLoader.addEventListener(ProgressEvent.PROGRESS, onProgressScript);

    // ... ASSEGNAZIONE DELL'OGGETTO: URLVariables ALLA
    //     PROPRIETA' .data DELL'OGGETTO : URLRequest
    phpRequest.data = dataToPHP;

    // ... ASSEGNAZIONE DELLO SCRIPT PHP ALLA PROPRIETA' .url
    //     DELL'OGGETTO : URLRequest
    phpRequest.url  = "flashPhp.php";

    // ... AVVIO DELLA RICHIESTA DI CARICAMNETO ED ESECUZIONE
    //     DELLO SCRIPT PHP SUL SERVER
    phpLoader.load(phpRequest);

    // ...
}
// .........................................................

// .........................................................
//     FUNCTION : onCompleteScript() - Event.COMPLETE
//                EVENTO NOTOFICATO AL COMPLETAMENTO ED
//                ESECUZIONE DELLO SCRIPT PHP SUL SERVER
// .........................................................
function onCompleteScript(evento:Event):void
{
    var dataFromPHP : URLVariables;
    var msgFromPHP  : String;

    // ... LO SCRIPT PHP E' STATO CARICATO ED ESEGUITO, ED
    //     I DATI SONO STATI RICEVUTI!

    // ... CREAZIONE DI UN OGGETTO : URLVariables IN CUI
    //     ACQUISIRE I DATI RICEVUTI DALLO SCRIPT PHP
    //     (al metodo costruttore viene passato come argomento
    //      la proprietà .data contenente i dati ricevuti)
    dataFromPHP = new URLVariables(evento.target.data);

    // ... ACQUISIZIONE DELLE VARIABILI INVIATE DALLO SCRIPT PHP
    //     (il nome della proprieta' .messaggio e' quello
    //      indicato nell'echo dello script PHP)
    msgFromPHP = dataFromPHP.messaggio;
    // ... etc..

    // ... VISUALIZZAZIONE
    msg.text = String(dataFromPHP.messaggio);
    // ... etc..

    // ... RIMOZIONE DEGLI ASCOLTATORI
    phpLoader.removeEventListener(Event.COMPLETE, onCompleteScript);
    phpLoader.removeEventListener(IOErrorEvent.IO_ERROR, onErrorScript);
    phpLoader.removeEventListener(Event.OPEN, onOpenScript);
    phpLoader.removeEventListener(ProgressEvent.PROGRESS, onProgressScript);
}
// .........................................................

// .........................................................
//     FUNCTION : onErrorScript() - IOErrorEvent.IO_ERROR
//                EVENTO NOTIFICATO IN CASO DI ERRORE DI
//                CARICAMENTO DELLO SCRIPT PHP SUL SERVER
// .........................................................
function onErrorScript(evento:IOErrorEvent):void
{
    // ... SI E' VERIFICATO UN ERRORE DURANTE IL CARICAMENTO
    msg.text = '... errore caricamento Script PHP';
}
// .........................................................

// .........................................................
//     FUNCTION : onOpenScript() - Event.OPEN
//                EVENTO NOTIFICATO ALL'AVVIO DEL CARICAMENTO
//                DELLO SCRIPT PHP SUL SERVER
// .........................................................
function onOpenScript(evento:Event):void
{
    // ... AVVIO RICHIESTA CARICAMENTO ED ESECUZIONE
    //     DELLO SCRIPT PHP SUL SERVER
    msg.text = '... avvio caricamento Script PHP.';
}
// .........................................................

// .........................................................
//     FUNCTION : onProgressScript() - ProgressEvent.PROGRESS
//                EVENTO NOTIFICATO DURANTE I CARICAMENTO
//                DELLO SCRIPT PHP SUL SERVER
// .........................................................
function onProgressScript(evento:ProgressEvent):void
{
    // ... LO SCRIPT E' IN ESECUZIONE SUL SERVER
    msg.text = '... attendere, prego.';
}
// .........................................................

// ... END

… lo script PHP

<?
    // .....................................................
    //  NAME : flashPhp.php
    //         ESEMPIO DI SCAMBIO DATI TRA FLASH E PHP
    // .....................................................

    // ... acquisizione delle variabili inviate dall'SWF

    // ... il nick name
    $nickName   = $_POST['nickname'];
    // ... etc..

    // ... prepara risposta
    $msg        = '... hello ' . $nickName;

    // ... invia messaggio di ritorno all'SWF chiamante
    echo "messaggio=" . urlencode($msg);

    // ... la funzione urlencode() effettua l'encoding di una
    //     stringa, covertendo la stringa in un formato URL
    //     valido (conversione di caratteri speciali).

    // ... i caratteri '/', '%', '&', etc..., sono convertiti
    //     con il segno % seguito dalla codifica HEX del
    //     carattere.
    //     ( la funzione inversa e' : urldecode() )

    // ... end of script
?>

Categorie:ACTIONSCRIPT 3.0

[DB2] – Cos’è un DBRM, un Plan, ed un Package ?

10 ottobre 2008 4 commenti

Quando si sviluppa un Programma COBOLII ( ambiente MainframeMVS ) che accede al Data Base DB2, si devono effettuare una serie di funzioni che non sono necessarie quando un Programma utilizza solo files di tipo VSAM.

Queste funzioni sono eseguite, in maniera semplificata, attraverso il DB2 Interface – ( DB2I ).

Il DB2I è una serie di pannelli ISPF che consentono la “preparazione” dei programmi COBOL – DB2.

Passi per lo sviluppo di un programma COBOLDB2

1. La Precompilazione DB2

Un programma contenente statements SQL deve essere preventivamente analizzato e modificato prima che possa essere compilato. Il Precompilatore DB2 esegue queste funzioni, ed in particolare :

  • – ricerca ed espande i membri realtivi alle INCLUDE
  • – ricerca gli statements EXEC SQL …. END-EXEC
  • – crea una versione del sorgente modificata, in cui ogni statement SQL è commentato e viene  sostituito da un’istruzione CALL ai moduli di interfaccia di runtime del DB2
  • – estrae tutte le istruzioni SQL dal programma e le inserisce in un modulo chiamato DBRM – (Data Base Request Module)
  • – pone un ‘timestamp’ nel sorgente modificato e nel DBRM affinchè ci sia una “corrispondenza esatta” tra i due
  • – riporta gli esiti della precompilazione (eventuali errori, etc…)

Dopo che la fase di precompilazione è terminata, inizia quella della compilazione. Il compilatore COBOL compila il programma sorgente modificato (dal precompilatore) e produce un modulo oggetto.

Il Linkage Editor “links” (collega) il modulo oggetto (object module) con altri moduli richiesti includendo tutti i moduli necessari per l’interfaccia al DB2; questo produrrà un modulo caricabile (load module) …

… ma prima che il programma possa essere eseguito,  il DB2 deve eseguire la fase di BIND !

 

2. La fase di BIND

Il comando BIND è un tipo di “compilazione” delle istruzioni SQL.

In generale, il comando BIND legge gli statements SQL dai DBRMs e produce un meccanismo per accedere ai dati come indicato dagli statements SQL.

Ci sono due tipi di comandi BIND :

     – BIND PLAN e

     – BIND PACKAGE

 

2.1  Il comando BIND PLAN

Il comando BIND PLAN accetta in INPUT :

  • Uno o più DBRMs prodotti dalla precompilazione
  • Uno o più PACKAGEs prodotti da una precedente BIND PACKAGE
  • … oppure una combinazione di liste di DBRMs e PACKAGEs

 

L’OUTPUT del comando BIND PLAN è un PIANO APPLICATIVO contenente la rappresentazione della logica eseguibile degli accessi ottimizzati ai dati del DB2.

Un PLAN (PIANO APPLICATIVO) è eseguibile solo con un modulo caricabile (load module) corrispondente !

Prima di eseguire un Programma COBOL-DB2, si deve specificare il PLAN corispondente.

 

 

2.2  Il comando BIND PACKAGE

Il comando BIND PACKAGE accetta in INPUT :

  • Un solo DBRM e produce (OUTPUT) un singolo PACKAGE contenente la logica ottimizzata di accesso ai dati.

Successivamente, i PACKAGEs prodotti devono essere collegati in un PLAN (PIANO APPLICATIVO) con il comando BIND PLAN.

Un PACKAGE non è eseguibile e non può essere specificato quando si esegue il programma DB2!

dobbiamo sempre ottenere prima un PLAN (PIANO APPLICATIVO) !

 

Il processo di BIND

La fase di BIND esegue una serie di funzioni per creare i PACKAGEs o i PLANs che accedono ai dati DB2 richiesti, tra cui :

  • – lettura e controllo della sintassi SQL dai DBRMs
  • – controllo delle TABELLE DB2 e delle COLONNE a cui si accede se conformi a quelle presenti nel CATALOGO DB2
  • – validazione delle AUTORIZZAZIONI
  • – ottimizzazione degli statements SQL in “paths” (cammini) più efficienti (DB2 optimizer)

 

 

Al termine di queste due fasi (precompilazione DB2 / compilazione COBOL e BIND) , sono stati prodotti due COMPONENTI (separati)

  • Il PLAN DB2
  • … ed il modulo caricabile linkato (load module); il nostro programma eseguibile 🙂

… ma nessuno dei due è eseguibile senza l’altro!

Quando si esegue un programma contenente istruzioni SQL si deve specificare il PLAN che verrà utilizzato.

 

 

Cos’è un DBRM ?

Spesso si fa confusione con la definizione di DBRM e le sue relazioni ai programmi, plans e packages.

Un DBRM è un modulo contenente gli statements SQL estratti dal programma sorgente ( dal precompilatore ).

Esso è memorizzato come membro di un data set partizionato; non è memorizzato nel Catalogo DB2.

 

Cos’è un PLAN ?

Un PLAN è un modulo eseguibile contenete la logica dei ‘paths’ di accesso (ai dati), prodotti dal DB2 Optimizer.

Esso può essere composto da uno o più DBRMs o PACKAGEs.

 

Cos’è un PACKAGE ?

Un PACKAGE è il prodotto del comando BIND su di un singlo DBRM contenete i ‘paths’ ottimizzati di accesso ai dati (dalla v2.3 del DB2).

Per eseguire un PACKAGE, bisogna prima inserirlo nella lista dei PACKAGEs di un PLAN.

Un PACKAGE non è mai eseguito direttamente, esso è eseguito indirettamente quando verrà eseguito il PLAN che lo contiene.

Un PLAN può consistere di uno o più DBRMs, uno o più PACKAGEs, o combinazioni di DBRMs e PACKAGEs.

 

Ma qual’è la differenza tra un PLAN ed un PACKAGE ?

Prima di andare al supermercato,  in genere,  prepariamo la LISTA dei PRODOTTI da acquistare.

Una volta li, come troviamo un prodotto presente nella nostra LISTA, lo mettiamo nel carrello; arrivati alla cassa, paghiamo 😦 ed inseriamo tutti PRODOTTI acquistati in una BUSTA.

  • I PRODOTTI acquistati, sono i DBRMs
  • … e la BUSTA, è il PLAN (PIANO APPLICATIVO)

Ci possono essere più DBRMs in un PLAN (ci sono più PRODOTTI acquistati nella BUSTA).

… abbiamo effettuato una fase di BIND PLAN indicando come INPUT uno o più DBRMs.

Se invece di prendere i PRODOTTI dallo scaffale e metterli nel carrello segniamo la loro ubicazione sulla nostra LISTA, una volta alla cassa, possiamo consegnare la LISTA al cassiere per il conteggio.

Dopo il conteggio ed il pagamento :(, inseriamo la LISTA dei PRODOTTI acquistati con le relative ubicazioni nella BUSTA, … e non i PRODOTTI !

Il PLAN (la BUSTA) ora contiene la LISTA che fa riferimento alla posizione fisica dei PRODOTTI sugli scaffali.

  • La LISTA dei PRODOTTI con le relative ubicazioni, è la lista dei PACKAGEs

… abbiamo prima effettuato le fasi di BIND PACKAGE indicando in INPUT i DBRMs (ubicazione dei prodotti), e poi la fase di BIND PLAN indicando in INPUT la LISTA dei PACKAGEs. 

 

… dedicato a tutti quei giovani che ancora oggi sono “reclutati” nel mondo dei mainframe.

“Una nuova vita vi attende nelle colonie Extra-Mondo. L’occasione per ricominciare in un Eldorado di buone  occasioni e di avventure, un nuovo clima, divertimenti ricreativi…”
                                              ( Annuncio pubblicitario dall’alto, dal film Blade Runner – Ridley Scott 1982 )

Categorie:DB2 - SQL

[DELPHI] – Impostare e ripristinare la risoluzione del Video

L’esempio di seguito mostra come impostare e ripristinare la risoluzione video richiamando l’API di Windows : ChangeDisplaySettings().


unit USetVideo;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Buttons;

type
  TForm1 = class(TForm)
    B_SET: TBitBtn;
    B_RESET: TBitBtn;

    procedure B_SETClick(Sender: TObject);
    procedure B_RESETClick(Sender: TObject);

    function  ImpostaRisoluzioneVideo(pWidth:Integer; pHeight:Integer): Integer;

  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1 : TForm1;

  // ... Variabili globali contenenti i valori della risoluzione
  //     del video prima della nuova impostazione
  OldWidth  : Integer;
  OldHeight : Integer;

implementation
{$R *.DFM}
// .........................................................................
//   PROCEDURE : B_SETClick()
//               CLICK SUL BOTTONE : B_SET
// .........................................................................
procedure TForm1.B_SETClick(Sender: TObject);
begin
    // ... salva la risoluzione del Video Corrente
    OldWidth    := GetSystemMetrics(SM_CXSCREEN);
    OldHeight   := GetSystemMetrics(SM_CYSCREEN);

    // ... imposta la risoluzione Video ( es.: 1024 x 768 )
    ImpostaRisoluzioneVideo(1024, 768);
end;
// .........................................................................

// .........................................................................
//   FUNCTION : ImpostaRisoluzioneVideo()
//              IMPOSTAZIONE DELLA RISOLUZIONE VIDEO
// .........................................................................
function TForm1.ImpostaRisoluzioneVideo(pWidth, pHeight:Integer):Integer;
var
    DeviceMode: TDeviceMode;
begin

    // ... imposta i parametri della struttura TDeviceMode
    DeviceMode.dmSize       := SizeOf(TDeviceMode);
    DeviceMode.dmPelsWidth  := pWidth;
    DeviceMode.dmPelsHeight := pHeight;
    DeviceMode.dmFields     := DM_PELSWIDTH or DM_PELSHEIGHT;

    // ... richiama l'API di Windows per il set della risoluzione.
    //     Il secondo parametro rappresenta il Flag per il set.
    //
    //     Valori :
    //
    //    0                   = La risoluzione e' cambiata dinamicamente
    //    CDS_UPDATEREGISTRY  = La risoluzione e' cambiata dinamicamente e
    //                          sara' aggiornata nel registro
    //                          La modalita' e' memorizzata nel profilo
    //                          utente
    //    CDS_TEST            = Il sistema verifica se e' possibile impostare
    //                          la risoluzione (effettua un TEST)

    // ... per maggiori dettagli vedere l'SDK di Windows.

    Result := ChangeDisplaySettings(DeviceMode, CDS_UPDATEREGISTRY);

    //  ... possibili valori di ritorno :
    //
    //  DISP_CHANGE_SUCCESSFUL	= Impostazione effettuata con successo.
    //  DISP_CHANGE_RESTART	    = Il Sistema deve essere riavviato affinche'
    //                            l'impostazione abbia effetto.
    //  DISP_CHANGE_BADFLAGS	= Valore dei Flags passati errati.
    //  DISP_CHANGE_FAILED	    = Errore durante l'impostazione della
    //                            risoluzione.
    //  DISP_CHANGE_BADMODE	    = Risoluzione Video non supportata.
    //  DISP_CHANGE_NOTUPDATED  = Windows NT solo : non in grado di scrivere
    //                            nel registro.
end;
// .........................................................................

// .........................................................................
//   PROCEDURE : B_RESETClick()
//               CLICK SUL BOTTONE : B_RESET
// .........................................................................
procedure TForm1.B_RESETClick(Sender: TObject);
begin
    // ... Ripristina la risoluzione video con i valori salvati
    ImpostaRisoluzioneVideo(OldWidth, OldHeight);
end;
// .........................................................................

// ... END OF JOB

end.