This location database abstraction and PHP layer is one of the best things I've ever done! It uses a mapper from a previous gist. Also contains a service that uses the abstraction layer.

Enderecamento.php

<?php
/**
 * Arquivo da classe Localidade_Db_Enderecamento
 *
 * PHP version 5
 *
 * @category  Db
 * @package   Localidade
 * @author    Alexandre Gomes Gaigalas <[email protected]>
 * @copyright 2008-2009 Acme Projetos e Serviços
 * @license   http://sistemas.Acme.com.br/l.txt AcmeL
 * @link      http://example.com
 */

/**
 * Interface para o banco de dados específica para localidade
 *
 * @category  Db
 * @package   Localidade
 * @author    Alexandre Gomes Gaigalas <[email protected]>
 * @copyright 2008-2009 Acme Projetos e Serviços
 * @license   http://sistemas.Acme.com.br/l.txt AcmeL
 * @version   Release: @package_version@
 * @link      http://example.com
 */
class Localidade_Db_Enderecamento
{
    /**
     * Cache de países
     *
     * @var Acme_Publico_Endereco_PaisRow[]
     */
    protected $dbPaises = array();
    /**
     * Cache de estados
     *
     * @var Acme_Publico_Endereco_EstadoRow[]
     */
    protected $dbEstados = array();
    /**
     * Cache de cidades
     *
     * @var Acme_Publico_Endereco_CidadeRow[]
     */
    protected $dbCidades = array();
    /**
     * Cache de ceps
     *
     * @var Acme_Publico_Endereco_CepRow[]
     */
    protected $dbCeps = array();
    /**
     * Método construtor
     *
     * @param Zend_Db_Adapter_Abstract $db Link de banco de dados
     */
    public function __construct(Zend_Db_Adapter_Abstract $db)
    {
        Zend_Db_Table_Abstract::setDefaultAdapter($db);
        $this->_db = $db;
    }
    /**
     * Lista todos os países
     *
     * @return Localidade_Pais[]
     */
    public function listarPaises()
    {
        $dbPaises = Acme_Publico_Endereco_Pais::getInstance();
        $paises = array();
        foreach ($dbPaises->fetchAll($dbPaises->select()
                ->order('descricao asc')) as $dbPais) {
            $paises[] = $this->importarPais($dbPais);
        }
        return $paises;
    }
    /**
     * Lista os tipos de logradouro disponíveis
     *
     * @return Localidade_Logradouro_Tipo[]
     */
    public function listarTiposDeLogradouro()
    {
        $dbTipos = Acme_Publico_Endereco_Tipo::getInstance();
        $tipos = array();
        foreach ($dbTipos->fetchAll($dbTipos->select()
                ->order('descricao asc')) as $dbTipo) {
            $tipos[] = $this->importarTipoDeLogradouro($dbTipo);
        }
        return $tipos;
    }
    /**
     * Retorna um objeto de domínio de tipo de logradouro
     *
     * @param Acme_Publico_Endereco_TipoRow $dbTipo Tipo
     *
     * @return Localidade_Logradouro_Tipo
     */
    public function importarTipoDeLogradouro(Acme_Publico_Endereco_TipoRow $dbTipo)
    {
        return Localidade_Local::criarLogradouroTipo(array(
            'codigo' => $dbTipo->codigo,
            'nome' => $dbTipo->descricao
        ));
    }
    /**
     * Retorna um objeto de banco de país a partir da sigla
     *
     * @param string $sigla Sigla a partir da qual o pais será extraído.
     *
     * @return Acme_Publico_Endereco_PaisRow
     */
    public function extrairPaisPorSigla($sigla)
    {
        $dbPais = Acme_Publico_Endereco_Pais::getInstance()
            ->fetchRowByAbreviacao($sigla);
        $this->dbPaises[$dbPais->codigo] = $dbPais;
        return $dbPais;
    }
    /**
     * Retorna um objeto de banco de país a partir do código
     *
     * @param integer $codigo Código a partir do qual o país será extraído.
     * 
     * @return Acme_Publico_Endereco_PaisRow
     */
    public function extrairPaisPorCodigo($codigo)
    {
        if (isset($this->dbPaises[$codigo])) {
            return $this->dbPaises[$codigo];
        }
        return $this->dbPaises[$codigo]
            = Acme_Publico_Endereco_Pais::getInstance()
                ->find($codigo)->current();
    }
    /**
     * Retorna um objeto de domínio a partir do objeto de banco
     *
     * @param Acme_Publico_Endereco_PaisRow $dbPais Objeto de banco do país
     *
     * @return Localidade_Pais
     */
    public function importarPais(Acme_Publico_Endereco_PaisRow $dbPais)
    {
        $pais = Localidade_Local::criarPais($dbPais->abreviacao);
        $pais->definirNome($dbPais->descricao);
        $pais->definirCodigo($dbPais->codigo);
        return $pais;
    }
    /**
     * Obtém um país pelo seu código no banco de dados
     *
     * @param int $codigo Código do país no banco de dados
     * 
     * @return Localidade_Pais
     */
    public function obterPaisPorCodigo($codigo)
    {
        return $this->importarPais($this->extrairPaisPorCodigo($codigo));
    }
    /**
     * Obtém um país pela sua sigla no banco de dados
     *
     * @param string $sigla Sigla do país
     *
     * @return Localidade_Pais
     */
    public function obterPaisPorSigla($sigla)
    {
        return $this->importarPais($this->extrairPaisPorSigla($sigla));
    }
    /**
     * Retorna um objeto de banco de estado a partir do objeto de banco de país
     * e da sigla do estado
     *
     * @param Acme_Publico_Endereco_PaisRow $dbPais      Objeto de banco do
     *                                                     país
     * @param string                          $siglaEstado Sigla do Estado
     * 
     * @return Acme_Publico_Endereco_EstadoRow
     */
    public function extrairEstadoPorSigla(
    Acme_Publico_Endereco_PaisRow $dbPais, $siglaEstado)
    {
        $dbEstados = Acme_Publico_Endereco_Estado::getInstance();
        $dbEstado = $dbPais->findAcme_Publico_Endereco_Estado($dbEstados
            ->select()->where('abreviacao = ?', $siglaEstado))->current();
        $this->dbEstados[$dbEstado->codigo] = $dbEstado;
        return $dbEstado;
    }
    /**
     * Retorna um objeto de banco de estado a partir do código
     *
     * @param integer $codigo Código do estado
     * 
     * @return Acme_Publico_Endereco_EstadoRow
     */
    public function extrairEstadoPorCodigo($codigo)
    {
        if (isset($this->dbEstados[$codigo])) {
            return $this->dbEstados[$codigo];
        }
        $dbEstado = Acme_Publico_Endereco_Estado::getInstance();
        return $this->dbEstados[$codigo] = $dbEstado->find($codigo)->current();
    }
    /**
     * Retorna um objeto de domínio a partir de um objeto de banco
     *
     * @param Acme_Publico_Endereco_EstadoRow $dbEstado Estado
     * 
     * @return Localidade_Estado
     */
    public function importarEstado(Acme_Publico_Endereco_EstadoRow $dbEstado)
    {
        $estado = Localidade_Local::criarEstado(array(
            'pais'=>$this->importarPais($this->extrairPaisPorCodigo($dbEstado
                    ->codigoEnderecoPais)), 'abreviacao' => $dbEstado
            ->abreviacao));
        $estado->definirCodigo($dbEstado->codigo);
        $estado->definirNome($dbEstado->descricao);
        return $estado;
    }
    /**
     * Obtém um estado de um determinado país
     *
     * @param string $pais  Sigla do País no qual esse estado localiza-se
     * @param string $sigla Sigla do Estado
     *
     * @return Localidade_Estado
     */
    public function obterEstadoPorSigla($pais, $sigla)
    {
        return $this->importarEstado($this->extrairEstadoPorSigla($this
                ->extrairPaisPorSigla($pais), $sigla));
    }
    /**
     * Obtém um estado pelo seu código no banco de dados
     *
     * @param int $codigo Código do estado no banco de dados
     * 
     * @return Localidade_Estado
     */
    public function obterEstadoPorCodigo($codigo)
    {
        return $this->importarEstado($this->extrairEstadoPorCodigo($codigo));
    }
    /**
     * Retorna um objeto de banco de cidade a partir do objeto de banco do
     * estado e do nome da cidade
     *
     * @param Acme_Publico_Endereco_EstadoRow $dbEstado   Objeto de banco do
     *                                                      estado
     * @param string                            $nomeCidade Nome da cidade
     *
     * @return Acme_Publico_Endereco_CidadeRow
     */
    public function extrairCidadePorNome(
    Acme_Publico_Endereco_EstadoRow $dbEstado, $nomeCidade)
    {
        $dbCidades = Acme_Publico_Endereco_Cidade::getInstance();
        $dbCidade = $dbEstado->findAcme_Publico_Endereco_Cidade($dbCidades
            ->select()->where('descricao = ?', utf8_decode($nomeCidade)))
        ->current();
        $this->dbCidades[$dbCidade->codigo] = $dbCidade;
        return $dbCidade;

    }
    /**
     * Retorna um objeto de domínio a partir de um objeto de banco
     *
     * @param Acme_Publico_Endereco_CidadeRow $dbCidade Objeto de banco da
     *                                                    cidade
     * 
     * @return Localidade_Cidade
     */
    public function importarCidade(Acme_Publico_Endereco_CidadeRow $dbCidade)
    {
        $dbEstado = $this->extrairEstadoPorCodigo($dbCidade
            ->codigoEnderecoEstado);
        $dbPais = $this->extrairPaisPorCodigo($dbEstado->codigoEnderecoPais);
        $cidade = Localidade_Local::criarCidade(array(
            'estado' => $this->importarEstado($dbEstado),
            'nome' => $dbCidade->descricao
        ));
        $cidade->definirCodigo($dbCidade->codigo);
        if (!empty($dbCidade->codigoEnderecoCep)) {
            $cidade->definirCep($this->obterCepPorCodigo($dbCidade->codigoEnderecoCep));
        }
        return $cidade;
    }
    /**
     * Obtém uma cidade pelo seu país, estado e nome
     *
     * @param string $pais   Sigla do país
     * @param string $estado Sigla do estado
     * @param string $nome   Nome completo da cidade
     *
     * @return Localidade_Cidade
     */
    public function obterCidadePorNome($pais, $estado, $nome)
    {
        return $this->importarCidade($this
            ->extrairCidadePorNome($this->extrairEstadoPorSigla($this
                    ->extrairPaisPorSigla($pais), $estado), $nome));
    }
    /**
     * Extrai um objeto de banco de dados de cidade pelo seu código
     *
     * @param int $codigo Código da cidade no banco de dados
     * 
     * @return Acme_Publico_Endereco_CidadeRow
     */
    public function extrairCidadePorCodigo($codigo)
    {
        if (isset($this->dbCidades[$codigo])) {
            return $this->dbCidades[$codigo];
        }
        return $this->dbCidades[$codigo]
            = Acme_Publico_Endereco_Cidade::getInstance()
                ->find($codigo)->current();
    }
    /**
     * Obtém uma cidade pelo seu código no banco de dados
     *
     * @param int $codigo Código da cidade no banco de dados
     *
     * @return Localidade_Cidade
     */
    public function obterCidadePorCodigo($codigo)
    {
        return $this->importarCidade($this->extrairCidadePorCodigo($codigo));
    }
    /**
     * Extrai um objeto de banco de dados de cep pelo seu código
     *
     * @param int $codigo Código do CEP
     * 
     * @return Acme_Publico_Endereco_CepRow
     */
    public function extrairCepPorCodigo($codigo)
    {
        if (isset($this->dbCeps[$codigo])) {
            return $this->dbCeps[$codigo];
        }
        $dbCep = Acme_Publico_Endereco_Cep::getInstance();
        return $this->dbCeps[$codigo] = $dbCep->find($codigo)->current();
    }
    /**
     * Extrai CEP pelo seu código
     *
     * @param int $codigo Código do CEP
     *
     * @return Localidade_Cep
     */
    public function obterCepPorCodigo($codigo)
    {
        return $this->importarCep($this->extrairCepPorCodigo($codigo));
    }
    /**
     * Converte um objeto de banco de dados de cep para objeto de domínio
     *
     * @param Acme_Publico_Endereco_CepRow $dbCep Objeto de banco de dados
     * 
     * @return Localidade_Cep
     */
    public function importarCep(Acme_Publico_Endereco_CepRow $dbCep)
    {
        $cep = Localidade_Local::criarCEP($this->obterPaisPorCodigo($dbCep
                ->codigoEnderecoPais), $dbCep->cep);
        return $cep;
    }
    /**
     * Busca estados (províncias e demais regiões administrativas de segundo nível)
     * de um determinado país
     *
     * @param string $pais Sigla do país a ser listado
     *
     * @return Localidade_Estado[]
     */
    public function listarEstadosPorPais($pais)
    {
        $dbPaises = Acme_Publico_Endereco_Pais::getInstance();
        $dbPais = $this->extrairPaisPorSigla($pais);
        $dbEstados = $dbPais->findAcme_Publico_Endereco_Estado($dbPaises
            ->select()->order('descricao asc'));
        $estados = array();
        foreach ($dbEstados as $dbEstado) {
            $estados[] = $this->importarEstado($dbEstado);
        }
        return $estados;
    }
    /**
     * Lista as cidades (municípios e demais regiões administrativas de
     * terceiro nível) de um determinado estado
     *
     * @param string $pais   Sigla do país
     * @param string $estado Sigla do estado/província
     *
     * @return Localidade_Cidade[]
     */
    public function listarCidadesPorEstado($pais, $estado)
    {
        $dbEstados = Acme_Publico_Endereco_Estado::getInstance();
        $dbEstado = $this->extrairEstadoPorSigla($this
            ->extrairPaisPorSigla($pais), $estado);
        $dbCidades = $dbEstado->findAcme_Publico_Endereco_Cidade($dbEstados
            ->select()->where('invalido = 0')->order('descricao asc'));
        $cidades = array();
        foreach ($dbCidades as $dbCidade) {
            $cidades[] = $this->importarCidade($dbCidade);
        }
        return $cidades;
    }
    /**
     * Lista os bairros (regiões não-administrativas locais)de uma determinada
     * cidade
     *
     * @param string $pais   Sigla do País
     * @param string $estado Sigla do estado ou província
     * @param string $cidade Nome completo da cidade
     *
     * @return Localidade_Bairro[]
     */
    public function listarBairrosPorCidade($pais, $estado, $cidade)
    {
        $dbCidade = $this->extrairCidadePorNome($this
            ->extrairEstadoPorSigla($this->extrairPaisPorSigla($pais), $estado),
            $cidade);
        $dbBairros = $dbCidade->findAcme_Publico_Endereco_Bairro();
        $bairros = array();
        foreach ($dbBairros as $dbBairro) {
            $bairros[] = $this->importarBairro($dbBairro);
        }
        return $bairros;
    }
    /**
     * Converte um objeto de banco de dados de bairro para domínio
     *
     * @param Acme_Publico_Endereco_BairroRow $dbBairro Objeto de banco de dados
     * 
     * @return Localidade_Bairro
     */
    public function importarBairro(Acme_Publico_Endereco_BairroRow $dbBairro)
    {
        $bairro = Localidade_Local::criarBairro(array(
            'cidade'=>$this->obterCidadePorCodigo($dbBairro->codigoEnderecoCidade),
            'nome'=>$dbBairro->descricao,
            'codigo'=>$dbBairro->codigo,
        ));
        return $bairro;
    }
    /**
     * Completa um objeto de localidade
     *
     * @param Localidade_Local $localidade Localidade
     *
     * @return Localidade_Local
     */
    public function completar(Localidade_Local $localidade)
    {
        if ($localidade instanceof Localidade_Logradouro) {
            return $this->completarLogradouro($localidade);
        } elseif ($localidade instanceof Localidade_Bairro) {
            return $this->completarBairro($localidade);
        } elseif ($localidade instanceof Localidade_CEP) {
            return $this->completarCEP($localidade);
        } elseif ($localidade instanceof Localidade_Cidade) {
            return $this->completarCidade($localidade);
        } elseif ($localidade instanceof Localidade_Endereco) {
            return $this->completarEndereco($localidade);
        } elseif ($localidade instanceof Localidade_Estado) {
            return $this->completarEstado($localidade);
        } elseif ($localidade instanceof Localidade_Pais) {
            return $this->completarPais($localidade);
        }
    }
    /**
     * Completa um logradouro
     *
     * @param Localidade_Logradouro $logradouro Logradouro
     *
     * @return Localidade_Logradouro
     */
    public function completarLogradouro(Localidade_Logradouro $logradouro)
    {
        $logradouroCompleto =  $this->obterLogradouroPorNome($logradouro
            ->obterCidade()->obterEstado()->obterPais()->obterAbreviacao(),
            $logradouro->obterCidade()->obterEstado()->obterAbreviacao(),
            $logradouro->obterCidade()->obterNome(),
            $logradouro->obterNome());
        $logradouro->definirPropriedades($logradouroCompleto->obterPropriedades());
        return $logradouro;
    }
    /**
     * Completa um bairro
     *
     * @param Localidade_Bairro $bairro Bairro
     *
     * @return Localidade_Bairro
     */
    public function completarBairro(Localidade_Bairro $bairro)
    {
    }
    /**
     * Compĺeta um CEP
     *
     * @param Localidade_CEP $cep CEP
     *
     * @return Localidade_CEP
     */
    public function completarCEP(Localidade_CEP $cep)
    {
    }
    /**
     * Completa uma cidade
     *
     * @param Localidade_Cidade $cidade Cidade
     * 
     * @return Localidade_Cidade
     */
    public function completarCidade(Localidade_Cidade $cidade)
    {
        $cidadeCompleta = $this->obterCidadePorNome($cidade->obterEstado()
            ->obterPais()->obterAbreviacao(), $cidade->obterEstado()
            ->obterAbreviacao(), $cidade->obterNome());
        $cidade->definirPropriedades($cidadeCompleta->obterPropriedades());
        return $cidade;
    }
    /**
     * Completa um endereço
     *
     * @param Localidade_Endereco $endereco Endereço
     *
     * @return Localidade_Endereco
     */
    public function completarEndereco(Localidade_Endereco $endereco)
    {
    }
    /**
     * Completa um objeto de estado
     *
     * @param Localidade_Estado $estado Estado
     * 
     * @return Localidade_Estado
     */
    public function completarEstado(Localidade_Estado $estado)
    {
        $estadoCompleto = $this->obterEstadoPorSigla($estado->obterPais()
            ->obterAbreviacao(), $estado->obterAbreviacao());
        $estado->definirPropriedades($estadoCompleto->obterPropriedades());
        return $estado;
    }
    /**
     * Completa um objeto de país com todos os seus dados
     *
     * @param Localidade_Pais $pais País a ser completado
     * 
     * @return Localidade_Pais
     */
    public function completarPais(Localidade_Pais $pais)
    {
        $paisCompleto =  $this->obterPaisPorSigla($pais->obterAbreviacao());
        $pais->definirPropriedades($paisCompleto->obterPropriedades());
        return $pais;
    }
    /**
     * Obtém um logradouro pelo CEP
     *
     * @param string $pais       Sigla do país
     * @param string $estado     Sigla do estado
     * @param string $cidade     Nome da cidade
     * @param srring $logradouro Nome do logradouro
     *
     * @return Localidade_Logradouro
     */
    public function obterLogradouroPorNome($pais, $estado, $cidade, $logradouro)
    {
        return $this->importarLogradouro($this
            ->extrairLogradouroPorNome($this
                ->extrairCidadePorNome($this
                    ->extrairEstadoPorSigla($this
                        ->extrairPaisPorSigla($pais), $estado), $cidade),
                $logradouro));
    }
    /**
     * Obtém um logradouro pelo CEP
     *
     * @param string $pais Sigla do país
     * @param string $cep  Número do CEP
     * @param srring $nome Nome do logradouro
     *
     * @return Localidade_Logradouro
     */
    public function obterLogradouroPorCep($pais, $cep, $nome)
    {
        return $this->importarLogradouro($this
            ->extrairLogradouroPorCepENome($pais, $cep, $nome));
    }
    /**
     * Extrair logradouro do banco de dados por nome
     *
     * @param Acme_Publico_Endereco_CidadeRow $dbCidade Cidade
     * @param nome                              $nome     Nome do logradouro
     * 
     * @return Acme_Publico_EnderecoRow
     */
    public function extrairLogradouroPorNome(
    Acme_Publico_Endereco_CidadeRow $dbCidade, $nome)
    {
        $dbLogradouros = Acme_Publico_Endereco::getInstance();
        return $dbCidade->findAcme_Publico_Endereco($dbLogradouros->select()
            ->where('descricao = ?', utf8_decode($nome)))->current();
    }
    /**
     * Extrai um logradouro do banco de dados pelo cep e nome
     *
     * @param string $pais Sigla do país
     * @param string $cep  Número do CEP
     * @param string $nome Nome do logradouro
     * 
     * @return Acme_Publico_EnderecoRow
     */
    public function extrairLogradouroPorCepENome($pais, $cep, $nome=null)
    {
        $dbPaises = $this->extrairPaisPorSigla($pais);
        $dbCeps = Acme_Publico_Endereco_Cep::getInstance();
        $dbCep = $dbPaises->findAcme_Publico_Endereco_Cep($dbCeps->select()
            ->where('cep = ?', $cep))->current();
        $dbLogradouros = Acme_Publico_Endereco::getInstance();
        if (!empty($nome)) {
            $condicao = $dbLogradouros->select()->where('descricao = ?',
                utf8_decode($nome));
        } else {
            $condicao = null;
        }
        $dbEndereco = $dbCep->findAcme_Publico_Endereco($condicao);
        return $dbEndereco->current();
    }
    /**
     * Importa um logradouro para o domínio
     *
     * @param Acme_Publico_EnderecoRow $dbEndereco Objeto de banco de dados
     *
     * @return Localidade_Logradouro
     */
    public function importarLogradouro(Acme_Publico_EnderecoRow $dbEndereco)
    {
        $dbCidade = $this->extrairCidadePorCodigo($dbEndereco
            ->codigoEnderecoCidade);
        $dbEstado = $this->extrairEstadoPorCodigo($dbCidade
            ->codigoEnderecoEstado);
        $dbPais = $this->extrairPaisPorCodigo($dbEstado->codigoEnderecoPais);
        $dbCep = $this->extrairCepPorCodigo($dbEndereco->codigoEnderecoCep);
        $dbLogradouroTipo
            = $dbEndereco->findParentAcme_Publico_Endereco_Tipo();
        $logradouro = Localidade_Local::criarLogradouro(array(
            'cidade' => $cidade = $this->importarCidade($dbCidade),
            'tipo'   => array('nome'=>$dbLogradouroTipo->descricao),
            'nome'   => $dbEndereco->descricao
        ));
        if (!empty($dbEndereco->codigoEnderecoBairroInicial)) {
            $logradouro->definirBairro($this->importarBairro($dbEndereco
                    ->findParentAcme_Publico_Endereco_BairroByEnderecoBairroInicial()));
        }
        $logradouro->definirCodigo($dbEndereco->codigo);
        return $logradouro;
    }
    /**
     * Busca os logradouros registrados para um determinado CEP
     *
     * @param string $cep CEP pelo qual os logradouros serão buscados
     *
     * @return Localidade_Logradouro[]
     */
    public function buscarLogradourosPorCep($cep)
    {
        $dbCeps = Acme_Publico_Endereco_Cep::getInstance();
        $dbCep = $dbCeps->fetchRowByCep($cep);
        if (is_null($dbCep)) {
            return null;
        }
        $logradouros = array();
        $dbEnderecos = $dbCep->findAcme_Publico_Endereco($dbCeps->select()
            ->order('descricao asc'));
        foreach ($dbEnderecos as $dbEndereco) {
            $logradouro = $this->importarLogradouro($dbEndereco);
            $logradouro->definirTipo($this->importarTipoDeLogradouro($dbEndereco
                    ->findParentAcme_Publico_Endereco_Tipo()));
            if (!is_null($dbEndereco->codigoEnderecoBairroInicial)) {
                $logradouro->definirBairro($this->importarBairro($dbEndereco
                        ->findParentAcme_Publico_Endereco_BairroByEnderecoBairroInicial()));
            } elseif (!is_null($dbEndereco->codigoEnderecoBairroFinal)) {
                $logradouro->definirBairro($this
                    ->importarBairro($dbEndereco
                        ->findParentAcme_Publico_Endereco_BairroByEnderecoBairroFinal()));
            }
            $logradouro->definirCidade($this
                ->importarCidade($dbCidade = $dbEndereco
                    ->findParentAcme_Publico_Endereco_Cidade()));
            $logradouro->obterCidade()->definirEstado($this
                ->importarEstado($dbEstado = $dbCidade
                    ->findParentAcme_Publico_Endereco_Estado()));
            $logradouro->obterCidade()->obterEstado()->definirPais($this
                ->importarPais($dbPais = $dbEstado
                    ->findParentAcme_Publico_Endereco_Pais()));
            $logradouros[] = $logradouro;
        }
        return $logradouros;
    }
    /**
     * Busca logradouros por uma string de endereço
     *
     * @param string $criterio String de endereço
     *
     * @return Localidade_Logradouro[]
     */
    public function buscarLogradouroPorTexto($criterio)
    {

    }
    /**
     * Busca cidades por um texto
     *
     * @param string $criterio Texto da cidade
     *
     * @return Localidade_Cidade[]
     */
    public function buscarCidadesPorTexto($criterio)
    {
        $criterio = trim($criterio);
        if (strlen($criterio) <= 3) return array();
        $criterio = str_replace(' ', '%', $criterio).'%';
        $dbCidadesTable = Acme_Publico_Endereco_Cidade::getInstance();
        $dbCidades = $dbCidadesTable->fetchAll($dbCidadesTable->select()
            ->where('descricao like ?', utf8_decode($criterio)));
        $pool = array();
        foreach ($dbCidades as $dbCidade) {
            $pool[] = $this->importarCidade($dbCidade);
        }
        return $pool;
    }
}

Service.php

<?php

/**
 * Arquivo da classe Service_Enderecamento
 *
 * PHP version 5
 *
 * @category  Enderecamento
 * @package   Service
 * @author    Alexandre Gomes Gaigalas <[email protected]>
 * @copyright 2008-2009 Acme Projetos e Serviços
 * @license   http://sistemas.Acme.com.br/l.txt AcmeL
 * @version   SVN: $Id: Grupo.php 62 2009-06-11 00:08:47Z webdesenv $
 * @link      http://example.com
 */

/**
 * Serviço de endereçamento
 *
 * @category  Enderecamento
 * @package   Service
 * @author    Alexandre Gomes Gaigalas <[email protected]>
 * @copyright 2008-2009 Acme Projetos e Serviços
 * @license   http://sistemas.Acme.com.br/l.txt AcmeL
 * @version   Release: @package_version@
 * @link      http://example.com
 */

class Service_Enderecamento
{
    /**
     *
     * @var Localidade_Db_Enderecamento
     */
    protected $enderecamento;
    /**
     * Construtor
     */
    public function __construct()
    {
        $db = new Zend_Db_Adapter_Pdo_Mssql(
            array(
                'host' => 'srvdesenvx',
                'dbname' => 'dbCakeLab',
                'username' => 'virgiliob',
                'password' => '1234',
                'pdoType' => 'dblib'
            )
        );
        $this->enderecamento = new Localidade_Db_Enderecamento($db);
    }
    /**
     * Obtém uma lista de países 
     *
     * @return Localidade_Pais[]
     */
    public function listarPaises()
    {
        return $this->enderecamento->listarPaises();
    }
    /**
     * Obtém uma lista de estados de um determinados país
     *
     * @param string $pais Sigla do país
     *
     * @return Localidade_Estado[]
     */
    public function listarEstadosPorPais($pais)
    {
        return $this->enderecamento->listarEstadosPorPais($pais);
    }
    /**
     * Obtém uma lista de cidades de um determinado estado
     *
     * @param string $pais   Sigla do país
     * @param string $estado Sigla do estado
     *
     * @return Localidade_Cidade[]
     */
    public function listarCidadesPorEstado($pais, $estado)
    {
        return $this->enderecamento->listarCidadesPorEstado($pais, $estado);
    }
    /**
     * Obtém todos os bairros de uma dada cidade
     *
     * @param string $pais   Sigla do país
     * @param string $estado Sigla do estado
     * @param string $cidade Nome da cidade
     *
     * @return Localidade_Bairro[]
     */
    public function listarBairrosPorCidade($pais, $estado, $cidade)
    {
        return $this->enderecamento->listarBairrosPorCidade($pais,
            $estado,
            $cidade);
    }
    /**
     * Lista todos os logradouros pertencentes a um CEP
     *
     * @param string $cep CEP
     *
     * @return Localidade_Logradouro[]
     */
    public function buscarLogradourosPorCep($cep)
    {
        return $this->enderecamento->buscarLogradouroPorCep($cep);
    }
    /**
     * Lista todos os possíveis tipos de logradouro
     *
     * @return Localidade_Logradouro_Tipo[]
     */
    public function listarTiposDeLogradouros()
    {
        
    }
}