Blok sem, blok tam, nám už je to všechno jasné... - MujMAC.cz - Apple, Mac OS X, Apple iPod

Odběr fotomagazínu

Fotografický magazín "iZIN IDIF" každý týden ve Vašem e-mailu.
Co nového ve světě fotografie!

 

Zadejte Vaši e-mailovou adresu:

Kamarád fotí rád?

Přihlas ho k odběru fotomagazínu!

 

Zadejte e-mailovou adresu kamaráda:

Seriály

Více seriálů



Software

Blok sem, blok tam, nám už je to všechno jasné...

6. října 2009, 00.00 | Dnes se podíváme blíže na řadu dalších služeb, jež bloky v Mac OS X 10.6 usnadnily.

V minulém dílu našeho volného seriálu o programování v Cocoa jsme si ukázali první z novinek, jež Irbis přinesl programátorům – bloky. Zmínili jsme se také o tom, že firma Apple netroškařila, a hned rozšířila API o řadu služeb, jež jsou na blocích založeny (a jež jsou díky nim daleko pohodlnější, než tomu bylo doposavad): jako příklad jsme si vedle spíše okrajového atexit_b ukázali možnost třídění prvků pole, při němž blok zajišťuje roli komparačního algoritmu. Dnes se podíváme blíže na řadu dalších služeb, jež bloky v Mac OS X 10.6 usnadnily.


Procházení kontejnerů

Pro práci s objekty, uloženými v kontejnerech Cocoa, sice existuje v Objective C 2 speciální varianta příkazu for; ani ta ale není ideální, a navíc nejde o příliš čistou objektovou techniku – programovací jazyk nemá co do procházení kontejnerů mluvit; to je věc, jež patří do knihoven. Díky blokům – a díky novému API, jež Cocoa nabízí – tomu tak konečně nyní je; namísto dlouhých popisů si prostě ukažme několik příkladů a k jejich zajímavým rysům se vrátíme potom:


'NSArray *a=...; NSDictionary *d=...; NSSet *s=...; NSIndexSet *is=...;
[a enumerateObjectsUsingBlock:^(id o,NSUInteger n,BOOL *stop){
  NSLog(@"objekt %@ je na indexu %ul...",o,(unsigned long)n);
  if (...netřeba procházet dále...) *stop=YES;
}];
[d enumerateKeysAndObjectsUsingBlock:^(id key,id obj,BOOL *stop){...}];
[s enumerateObjectsWithOptions:NSEnumerationConcurrent 
usingBlock:^(id o,BOOL *stop){...}];
[is enumerateObjectsUsingBlock:^(NSUInteger idx,BOOL *stop){...}];
[a enumerateObjectsAtIndexes:is options:NSEnumerationReverse usingBlock:...];'


Smysl všech uvedených příkladů je snad vcelku zřejmý: NSEnumerationConcurrent je požadavek, aby se bloky pro jednotlivé objekty v kontejneru provedly paralelně (a je vhodné se zmínit o tom, že v závislosti na knihovnách, konkrétních objektech a momentálním stavu systému tento požadavek může, ale také nemusí být splněn – to souvisí s automatickou optimalizací vláken, s níž jsme se zběžně setkali v minulém dílu, a o níž si více řekneme později, až se budeme zabývat technologií Grand Central Dispatch). Pokud se bloky provádějí sekvenčně, můžeme si u pole a množiny indexů vyžádat procházení odzadu pomocí přepínače NSEnumerationReverse.


Za zmínku stojí argument stop: mají jej všechny bloky, užívané pro kontejnerové operace, a umožňuje procházení předčasně přerušit (podobně jako kdybychom v klasickém příkazu for užili příkaz break). Je implementován speciálním efektivním způsobem; proto jej můžeme pouze nastavit na hodnotu YES, chceme-li skončit (nelze jej např. později v bloku opět vrátit na NO).


Pole a množinu indexů můžeme také prohledávat; bloky se pak od těch výše uvedených liší tím, že mají návratovou hodnotu typu BOOL, a odpovídající zprávy vrací buď prvý nalezený objekt (či index), nebo jejich množinu:


'is=[a indexesOfObjectsPassingTest:^(id o,NSUInteger n,BOOL *stop){
  return [o isKindOfClass:[NSString class]];
}];
NSLog(@"%u",[is indexPassingTest:^BOOL(NSUInteger n,BOOL*s){return n>3;}]);'


Výše uvedený příklad nejprve najde indexy všech prvků v poli a, jež jsou textovými řetězci; pak se vypíše index prvého z nich, který je větší než 3 (nebo samozřejmě NSNotFound, pokud takový neexistuje). Pro pole je k dispozici i varianta indexOfObjectPassingTest:, jež nalezne prvý z objektů a dále nehledá; můžeme také použít přepínačů withOptions: a omezit prohledávání pomocí atIndexes: stejně, jako při procházení výše.


Za samostatnou zmínku stojí kvalifikace bloku „^BOOL(NSUInteger n,BOOL*s)“ ve srovnání s jednodušší „^(id o,NSUInteger n,BOOL *stop)“ výše. To je tak: typ návratové hodnoty bloku můžeme mezi znakem ‚^‘ a otvírací závorkou pro argumenty uvést vždy; mnohdy to ale není zapotřebí, neboť překladač si dokáže návratovou hodnotu automaticky odvodit. Nemůže ale vzájemně převádět hodnoty různé velikosti; jelikož výsledkem porovnání „n>3“ je v jazyce C standardně čtyřbytový int, není možné jej automaticky převést na jednobytový BOOL. Explicitní převod typu


'NSLog(@"%u",[is indexPassingTest:^(NSUInteger n,BOOL*s){return (BOOL)(n>3);}]);'


by fungoval stejně dobře; uvedení návratové hodnoty v kvalifikaci bloku však je lepší a bezpečnější.


Třídění už jsme si ukázali minule; jen se tedy zmíníme o tom, že jsou opět k dispozici varianty withOptions:, jež umožňují pomocí přepínače NSSortConcurrent vyžádat si paralelní vyhodnocení komparačních bloků, a pomocí přepínače NSSortStable stabilní třídění (tj. takové, jež pro „shodné“ objekty zachová jejich původní pořadí). Kromě pole můžeme samozřejmě třídit na místě prvky měnitelného pole pomocí zprávy sortUsingComparator:, a můžeme si vyžádat setříděné klíče slovníku pomocí zprávy keysSortedByValueUsingComparator:.


Na konci tohoto odstavce si ukážeme, jak podobné metody implementovat; je to velmi snadné. Možná jste si povšimli, že oproti standardní objektové sestavě kontejnerových operací „each, select, collect“ v Cocoa schází „collect“ (ačkoli explicitně není k dispozici ani operace „select“, snadno ji můžeme simulovat spojením služby indexesOfObjectsPassingTest: se standardní zprávou objectsAtIndexes:). Ukažme si tedy její jednoduchou implementaci:


'@implementation NSArray (Collect)
-(NSArray*)collectObjectsReturnedFromBlock:(id(^)(id,BOOL*))block {
  NSMutableArray *ra=[NSMutableArray array];
  [self enumerateObjectsUsingBlock:^(id o,NSUInteger n,BOOL *stop){
    [ra addObject:block(o,stop)?:[NSNull null]];
  }];
  return ra;
}'

(Ve skutečnosti je v takto implementované metodě drobná chyba; nalezení a případnou opravu této chyby ponechme jako triviální cvičení laskavému čtenáři :))


Procházení textů

Nové služby s využitím bloků nabízejí i texty – jak formátovaný NSAttributedString, tak i neformátovaný NSString. Ukážeme si je na konkrétním příkladu kódu, který používám pro převod těchto textů z RTF do HTML, jež vyžaduje redakční systém MujMac (pozn. kód je velmi mírně zjednodušen a pozměněn pro bohatší využití bloků i tam, kde skutečný program z historických důvodů užívá staršího API; schopnosti Cocoa přímo generovat HTML nevyužívá hlavně proto, že jsou pro tento účel zbytečně bohaté):


'NSAttributedString *as=... zdroj RTF ...;
NSMutableString *ms=[NSMutableString string]; // ... cíl HTML ...
__block BOOL bold=NO,italic=NO,para=NO; //4
void (^closeTags)(BOOL,BOOL,BOOL)=^(BOOL b,BOOL i,BOOL p){ //3
  if (!b && bold) [ms appendString:@"</b>"];
  if (!i && italic) [ms appendString:@"</i>"];
  if (!p && para) {
    [ms appendString:@"</p>\n\n"]; para=NO;
  }
};
NSFontManager *fm=[NSFontManager sharedFontManager];
[as enumerateAttributesInRange:NSMakeRange(0,[as length]) options:0
  usingBlock:^(NSDictionary *at,NSRange rr,BOOL*st) { //1
  NSFontTraitMask ftm=[fm traitsOfFont:[at objectForKey:NSFontAttributeName]];
  BOOL b=!!(ftm&NSBoldFontMask),i=!!(ftm&NSItalicFontMask);
  if (!bold && b) [ms appendString:@"<b>"]; bold=b;
  if (!italic && i) [ms appendString:@"<i>"]; italic=i;
  [[as string] enumerateSubstringsInRange:rr
    options:NSStringEnumerationByComposedCharacterSequences
    usingBlock:^(NSString *s,NSRange substringr,NSRange enclosingr,BOOL*st) { //2
        if (!para) [ms appendString:@"<p>"]; para=YES;
        if ([s isEqualToString:@"<"]) [ms appendString:@"&lt;"];
        else if ([s isEqualToString:@">"]) [ms appendString:@"&gt;"];
        else if ([s isEqualToString:@"&"]) [ms appendString:@"&amp;"];
        else if ([s isEqualToString:@"\n"])
            if (m) [ms appendString:@"<br>\n"];
            else {
                closeTags(NO,NO,NO,NO);
                bold=italic=mono=NO;
            }
        else [ms appendString:s];
    }];
}];
closeTags(NO,NO,NO,NO);'


Vidíme zde příklad bloku pro procházení formátovaného textu atribut po atributu („//1“) a procházení textového řetězce po částech („//2“).


Služba enumerateAttributesInRange:options:usingBlock: prostě volá blok na každý samostatný úsek formátovaného textu, uvnitř nějž se nemění formát; její blok dostane atributy nalezeného úseku v prvém argumentu a rozsah úseku ve druhém (argument stop má stejnou funkci, jako takřka ve všech blokových operacích v Cocoa: umožňuje procházení předčasně ukončit). Pokud bychom chtěli sledovat pouze změny jednoho určitého atributu, nabízí NSAttributedString alternativní službu enumerateAttribute:inRange:options:usingBlock:, jejímž prvým argumentem je požadovaný atribut; blok pak namísto slovníku všech atributů dostane v prvém argumentu hodnotu toho sledovaného.


Služba enumerateSubstringsInRange:options:usingBlock: dokáže procházet textový řetězec podle řady možných klíčů; v příkladu jsme využili variantu NSStringEnumerationByComposedCharacterSequences, jež v podstatě znamená „znak po znaku“; k dispozici jsou ale další klíče, jež umožňují procházení textu po slovech, řádcích, větách či odstavcích. Pomocí přepínačů lze určit, zda se má text procházet odpředu nebo odzadu, a má-li se využít aktuální lokalisace (to může hrát roli pro hledání vět a slov). Argumenty bloku jsou nalezený substring, jeho rozsah, rozsah včetně případných oddělovačů (a opět stop). Pro zjednodušení nejběžnějšího případu také třída NSString nabízí službu enumerateLinesUsingBlock: – jejím jediným argumentem je blok, který dostane v prvém argumentu postupně každý řádek textu (jeho druhým a posledním argumentem je opět stop).


Do třetice jsme bloku využili pro často opakovanou službu: uzavření otevřených tagů potřebujeme na dvou místech – při ukončení odstavce, a také na úplném konci zpracování. V klasickém případě bychom buď museli odpovídající kód zopakovat, nebo si na něj vytvořit funkci; s bloky ale máme k dispozici pohodlnější řešení: na řádku označeném komentářem „//3“ prostě uložíme blok s požadovanou funkčností do proměnné closeTags, a z ní jej pak na dvou místech voláme.


Na tom si také můžeme ilustrovat novou službu Objective C, o níž jsme se dosud nezmínili: víme, že blok v místě, kde je definován, má přístup ke všem proměnným – v našem případě jde o proměnné bold, italic a para –, a že ve chvíli volání má vždy k dispozici jejich kopie (ať již k volání dojde kdykoli a kdekoli). To ale není přesně to, co zde chceme: tentokrát nepotřebujeme, aby blok mohl číst kopie těchto proměnných; naopak požadujeme, aby měl přístup přímo k proměnným samotným, a aby jejich obsah mohl měnit. Objective C to umožňuje, a vyžádáme si to pomocí modifikátoru __block v deklaraci proměnných.

Obsah seriálu (více o seriálu):

Tématické zařazení:

 » Rubriky  » Novinky  

 » Rubriky  » Informace  

 » Rubriky  » Agregator  

 » Rubriky  » Tipy a Triky  

 » Rubriky  » Software  

 

 

 

 

Přihlášení k mému účtu

Uživatelské jméno:

Heslo: