Archives de catégorie : Snippet

Récupèrer une liste contenant une partie des noms de fichiers

Publié dans Snippet | Laisser un commentaire

But

Dans un dossier, j’ai quelques fichiers se nommant LocalSettings_Wikimachin.php, LocalSettings_Wikitruc.php, … Je souhaite récupérer une liste contenant seulement « machin » et « truc ».

Snippet

wikis=`ls my-folder | sed \'/^LocalSettings_Wiki/!d\' | sed -e \'s/^LocalSettings_Wiki\\(.\\+\\)\\.php/\\1/g\'`
for wiki in $wikis
do
   echo $wiki
done

Ce qui donne :

machin
truc

Explication

  • ls my-folder : Liste les fichiers et répertoires du dossier « my-folder »
  • sed \'/^LocalSettings_Wiki/!d\' : On ne garde que les lignes commençant par « LocalSettings_Wiki ».
    En effet, le flag « d » permet de supprimer les lignes correspondantes au pattern. Donc le flag « !d » ne conserve que les lignes correspondant au pattern.
  • sed -e \'s/^LocalSettings_Wiki\\(.\\+\\)\\.php/\\1/g\'` : Le flag « s » lance une substitution : « s/pattern/replacement/g ».
    On cherche toutes les lignes qui contiennent par « LocalSettings_Wiki(quelque chose).php » et on les remplace par « quelque chose ».
    En ligne de commande, j’avais une étoile à chaque fin de ligne, j’ai donc modifié la commande comme suite : sed -e \'s/^LocalSettings_Wiki\\(.\\+\\)\\.php\\*/\\1/g\'`

Corriger une string JSON en Qt

Publié dans Snippet | Laisser un commentaire

La méthode ci-dessous permet d’autoriser une syntaxe moins rigoureuse en prenant soin de modifier les petites erreurs qui ont pu être commises.

/**
 * Clean a string
 * * Remove comments ("//" and "/*")
 * * Add first and last braces ("{" and "}") if missing
 * * Remove unauthorized commas
 *
 * @param data Almost JSON string that will be cleaned to become a valid JSON string
 * @return Valid JSON string (or at least, a more valid one)
 */
QString cleanJsonString(QString data)
{
    // Remove inline comms
    QRegExp pattern = QRegExp("(^|\\[|\\{|,|\\n|\\s)//.*($|\\n)");
    pattern.setMinimal(true); //ungreedy
    data.replace(pattern, "\\1\n");
    data.replace(pattern, "\\1\n"); //2 times, I am not sure why...
    // Remove bloc comms
    pattern = QRegExp("/\\*.*\\*/");
    pattern.setMinimal(true); //ungreedy
    data.replace(pattern, "");
    // Add first and last brace
    if (!data.startsWith("{")) {
        data = "{\n"+data;
    }
    if (!data.endsWith("}")) {
        data += "\n}";
    }
    // Remove commas before } or ]
    pattern = QRegExp(",(\\s*[}\\]])");
    pattern.setMinimal(true); //non-greedy
    data.replace(pattern, "\\1");
    return data;
}

J’ai commis une méthode similaire en PHP : Manipuler du JSON en PHP.

Atteindre la fin d’un document avec less

Publié dans Snippet | Laisser un commentaire
prompt$ less myDocument.text

Puis : shift+g

Attendre la fin d’un signal Qt de manière synchrone

Publié dans Snippet | Laisser un commentaire

Ou comment attendre la fin d’une méthode asynchrone.

Snippet

/**
 * Wait synchronously for a Qt signal (+ timeout management)
 * May be useful for test purpose
 * Not recommended for production usage
 */

// -- Configure the waiting
// Signal to wait
QEventLoop loop;
QObject::connect(&anObject, SIGNAL(signalToWait()), &loop, SLOT(quit()));
// Timeout to avoid infite waiting
QTimer timer;
timer.setInterval(10*1000); //10s
timer.setSingleShot(true);
QObject::connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));

// -- Do stuff that should trigger the signal
// ...

// -- Start to wait
// What is done after "loop.exec()" is not executed until "loop.quit()" is called
timer.start();
loop.exec();
timer.stop(); // Just in case there is no timeout

// -- Other stuff
// ...

jUnit et les tests asynchrones

Publié dans Snippet | Laisser un commentaire

Où comment tester des méthodes asynchrones (avec listaner ou callback) en Java, par exemple avec jUnit. En fait c’est un moyen rapide et relativement sûr (quoique non conseillé pour du vrai code) de rendre une méthode synchrone.

Snippet

public class AsynchronousTest
{
    /**
    * Asynchronous helper
    */
    private CountDownLatch lock = new CountDownLatch(1);
    /**
    * Received data from the asynchronous call
    */
    private Object receiveddata;

    @Test
    public void testAsynchronousCall() throws Exception {
        Object parameters = null;
        myAsynchronousCall(parameters, new MyCallback() {
                @Override
                public void onSuccess(Object data) {
                    receiveddata = data;
                    lock.countDown();
                }
            });

        boolean releaseBeforeTimeout = lock.await(2000, TimeUnit.MILLISECONDS);
        // Check timeout
        if (!releaseBeforeTimeout) {
            // Do stuff
            fail("Timeout");
        }

        assertNotNull(receiveddata);
        // Other tests
    }
}

Explications

L’idée de base est la suivante :

  • On initialise un CountDownLatch à 1, c’est-à-dire à un seul usage. Chaque appel à CountDownLatch::countDow() représente une utilisation.
  • On exécute la méthode asynchrone. La fin de cette méthode appelle CountDownLatch::countDow(). Mais avant d’en arriver là, pendant que la méthode s’exécute…
  • On regarde si le CountDownLatch est à 0 (dans le cas où la méthode asynchrone a déjà terminé) ou on attend qu’il passe à 0 (c’est-à-dire que la méthode asynchrone s’est terminée), ou on attend jusqu’à la fin d’un timeout (temps défini après lequel on considère que l’exécution de la méthode a échoué.

Trier une liste en Java

Publié dans Snippet | Laisser un commentaire
Collections.sort(myList, new MyComparator());

public class MyComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject  o2) {
        if (o1.getInt() == o2.getInt()) {
            return 0;
        }
        if (o1.getInt() < o2.getInt()) {
            return -1;
        }
        return 1;
    }
}

Dernière itération d’une boucle avec le moteur de template RainTPL

Publié dans Snippet | Laisser un commentaire
{loop="list"}
  {if="$counter==count($list)-1"}
      This is the last element
  {/if}
{/loop}

En savoir plus.

Trier un array en Javascript

Publié dans Snippet | Laisser un commentaire

Simple sort

var myArray = ["var2", "var1", "var3"];
console.log("Before:", myArray); // Output: "Before: ["var2", "var1", "var3"]"
myArray.sort();
console.log("After:", myArray); // Output: "After: ["var1", "var2", "var3"]"

More complex sort

var myComplexArray = [{"id":"3", "data":"var2"}, {"id":"2", "data":"var1"}, {"id":"1", "data":"var3"}];
console.log("Before:", myComplexArray ); // Output: "Before: [{"id":"3", "data":"var2"}, {"id":"2", "data":"var1"}, {"id":"1", "data":"var3"}]"
myComplexArray .sort(function(a, b){ return a.id < b.id; });
console.log("After:", myComplexArray ); // Output: "After: [{"id":"1", "data":"var3"}, {"id":"2", "data":"var1"}, {"id":"3", "data":"var2"}]"

Array en C/C++

Publié dans Snippet | Laisser un commentaire

Static

int anArray[] = { 1, 2 };
// OR
int anArray[2] = { 1, 2 };
// OR
int anArray[2];
anArray[0] = 1;
anArray[1] = 2;

Dynamic (C++)

int anArray = new int[2]
anArray[0] = 1;
anArray[1] = 2;

Et ne pas oublier la suppression :

delete[] anArrat;

Array en Java

Publié dans Snippet | Laisser un commentaire
String[] anArray = new String[10];
// OR
String[] anArray = {"Val1", "Val2"};