~ubuntu-branches/ubuntu/raring/rygel/raring

 * generated from rygel-log-handler.vala, do not modify */

 

/*

 

 

static gpointer _g_object_ref0 (gpointer self) {

        return self ? g_object_ref (self) : NULL;

}

 

 

        RygelLogHandler* _tmp0_;

        RygelLogHandler* _tmp2_;

        RygelLogHandler* _tmp3_;

        _tmp0_ = rygel_log_handler_log_handler;

        if (_tmp0_ == NULL) {

                RygelLogHandler* _tmp1_;

                _tmp1_ = rygel_log_handler_new ();

                _g_object_unref0 (rygel_log_handler_log_handler);

                rygel_log_handler_log_handler = _tmp1_;

        }

        _tmp2_ = rygel_log_handler_log_handler;

        _tmp3_ = _g_object_ref0 (_tmp2_);

        result = _tmp3_;

        return result;

}

 

 

static void _rygel_log_handler_log_func_glog_func (const gchar* log_domain, GLogLevelFlags log_levels, const gchar* message, gpointer self) {

        rygel_log_handler_log_func (self, log_domain, log_levels, message);

}

 

 

        gchar** _tmp10_;

        gchar** _tmp11_ = NULL;

        GError * _inner_error_ = NULL;

        self = (RygelLogHandler*) g_object_new (object_type, NULL);

        _tmp0_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_INT, NULL, NULL, NULL, NULL, NULL);

        _g_object_unref0 (self->priv->log_level_hash);

        self->priv->log_level_hash = _tmp0_;

        _tmp1_ = rygel_meta_config_get_default ();

        config = _tmp1_;

        {

                RygelMetaConfig* _tmp2_;

                gchar* _tmp3_ = NULL;

                gchar* _tmp4_;

                _tmp2_ = config;

                _tmp3_ = rygel_configuration_get_log_levels ((RygelConfiguration*) _tmp2_, &_inner_error_);

                _tmp4_ = _tmp3_;

                if (_inner_error_ != NULL) {

                        goto __catch6_g_error;

                }

                _g_free0 (log_levels);

                log_levels = _tmp4_;

        }

        goto __finally6;

        __catch6_g_error:

                const gchar* _tmp6_ = NULL;

                GError* _tmp7_;

                const gchar* _tmp8_;

                err = _inner_error_;

                _inner_error_ = NULL;

                _tmp5_ = g_strdup (RYGEL_LOG_HANDLER_DEFAULT_LEVELS);

                _g_free0 (log_levels);

                log_levels = _tmp5_;

                _tmp6_ = _ ("Failed to get log level from configuration: %s");

                _tmp7_ = err;

                _tmp8_ = _tmp7_->message;

                g_warning (_tmp6_, _tmp8_);

                _g_error_free0 (err);

        }

        __finally6:

        if (_inner_error_ != NULL) {

                _g_free0 (log_levels);

                _g_object_unref0 (config);

                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

                g_clear_error (&_inner_error_);

                return NULL;

        }

        _tmp9_ = log_levels;

        _tmp11_ = _tmp10_ = g_strsplit (_tmp9_, ",", 0);

        {

                gchar** pair_collection = NULL;

                gint pair_collection_length1 = 0;

                gint _pair_collection_size_ = 0;

                gint pair_it = 0;

                pair_collection = _tmp11_;

                pair_collection_length1 = _vala_array_length (_tmp10_);

                for (pair_it = 0; pair_it < _vala_array_length (_tmp10_); pair_it = pair_it + 1) {

                        gchar* _tmp12_;

                        gchar* pair = NULL;

                        _tmp12_ = g_strdup (pair_collection[pair_it]);

                        pair = _tmp12_;

                        {

                                const gchar* _tmp13_;

                                gchar** _tmp14_;

                                GeeHashMap* _tmp30_;

                                const gchar* _tmp31_;

                                GLogLevelFlags _tmp32_;

                                _tmp13_ = pair;

                                _tmp15_ = _tmp14_ = g_strsplit (_tmp13_, ":", 0);

                                tokens = _tmp15_;

                                tokens_length1 = _vala_array_length (_tmp14_);

                                _tokens_size_ = tokens_length1;

                                _tmp16_ = tokens;

                                _tmp16__length1 = tokens_length1;

                                if (_tmp16__length1 < 1) {

                                        tokens = (_vala_array_free (tokens, tokens_length1, (GDestroyNotify) g_free), NULL);

                                        _g_free0 (pair);

                                        break;

                                }

                                _tmp17_ = tokens;

                                _tmp17__length1 = tokens_length1;

                                if (_tmp17__length1 == 1) {

                                        gchar** _tmp18_;

                                        gint _tmp18__length1;

                                        const gchar* _tmp19_;

                                        gint _tmp20_ = 0;

                                        gchar* _tmp21_;

                                        _tmp18_ = tokens;

                                        _tmp18__length1 = tokens_length1;

                                        _tmp19_ = _tmp18_[0];

                                        _tmp20_ = atoi (_tmp19_);

                                        level = (RygelLogLevel) _tmp20_;

                                        _tmp21_ = g_strdup ("*");

                                        _g_free0 (domain);

                                        domain = _tmp21_;

                                } else {

                                        gchar** _tmp22_;

                                        gint _tmp22__length1;

                                        gint _tmp25__length1;

                                        const gchar* _tmp26_;

                                        gint _tmp27_ = 0;

                                        _tmp22_ = tokens;

                                        _tmp22__length1 = tokens_length1;

                                        _tmp23_ = _tmp22_[0];

                                        _tmp24_ = g_strdup (_tmp23_);

                                        _g_free0 (domain);

                                        domain = _tmp24_;

                                        _tmp25_ = tokens;

                                        _tmp25__length1 = tokens_length1;

                                        _tmp26_ = _tmp25_[1];

                                        _tmp27_ = atoi (_tmp26_);

                                        level = (RygelLogLevel) _tmp27_;

                                }

                                _tmp28_ = level;

                                _tmp29_ = rygel_log_handler_log_level_to_flags (self, _tmp28_);

                                flags = _tmp29_;

                                _tmp30_ = self->priv->log_level_hash;

                                _tmp31_ = domain;

                                _tmp32_ = flags;

                                _g_free0 (domain);

                                tokens = (_vala_array_free (tokens, tokens_length1, (GDestroyNotify) g_free), NULL);

                                _g_free0 (pair);

                        }

                }

                pair_collection = (_vala_array_free (pair_collection, pair_collection_length1, (GDestroyNotify) g_free), NULL);

        }

        g_log_set_default_handler (_rygel_log_handler_log_func_glog_func, self);

        _g_free0 (log_levels);

        _g_object_unref0 (config);

        return self;

}

 

 

static RygelLogHandler* rygel_log_handler_new (void) {

        return rygel_log_handler_construct (RYGEL_TYPE_LOG_HANDLER);

}

 

 

        GLogLevelFlags _tmp4_;

        GLogLevelFlags _tmp7_;

        GLogLevelFlags _tmp8_;

        g_return_if_fail (self != NULL);

        g_return_if_fail (message != NULL);

        flags = 0;

        _tmp0_ = log_domain;

        if (_tmp0_ != NULL) {

                GeeHashMap* _tmp1_;

                const gchar* _tmp2_;

                gpointer _tmp3_ = NULL;

                _tmp1_ = self->priv->log_level_hash;

                _tmp2_ = log_domain;

                _tmp3_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp1_, _tmp2_);

        }

        _tmp4_ = flags;

        if (_tmp4_ == 0) {

                GeeHashMap* _tmp5_;

                gpointer _tmp6_ = NULL;

                _tmp5_ = self->priv->log_level_hash;

                _tmp6_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp5_, "*");

        }

        _tmp7_ = log_levels;

        _tmp8_ = flags;

        if ((_tmp8_ & _tmp7_) == _tmp7_) {

                GLogFunc _tmp9_;

                void* _tmp9__target;

                const gchar* _tmp10_;

                GLogLevelFlags _tmp11_;

                const gchar* _tmp12_;

                _tmp9_ = g_log_default_handler;

                _tmp9__target = NULL;

                _tmp10_ = log_domain;

                _tmp11_ = log_levels;

                _tmp12_ = message;

                _tmp9_ (_tmp10_, _tmp11_, _tmp12_, _tmp9__target);

        }

}

 

        GLogLevelFlags result = 0;

        GLogLevelFlags flags;

        RygelLogLevel _tmp0_;

        g_return_val_if_fail (self != NULL, 0);

        flags = RYGEL_LOG_HANDLER_DEFAULT_FLAGS;

        _tmp0_ = level;

        switch (_tmp0_) {

                case RYGEL_LOG_LEVEL_CRITICAL:

                {

                        flags = G_LOG_LEVEL_CRITICAL;

                        break;

                }

                case RYGEL_LOG_LEVEL_ERROR:

                {

                        flags = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR;

                        break;

                }

                case RYGEL_LOG_LEVEL_WARNING:

                {

                        flags = (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL) | G_LOG_LEVEL_ERROR;

                        break;

                }

                case RYGEL_LOG_LEVEL_INFO:

                {

                        flags = (((G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL) | G_LOG_LEVEL_ERROR) | G_LOG_LEVEL_MESSAGE) | G_LOG_LEVEL_INFO;

                        break;

                }

                case RYGEL_LOG_LEVEL_DEBUG:

                {

                        flags = ((((G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL) | G_LOG_LEVEL_ERROR) | G_LOG_LEVEL_MESSAGE) | G_LOG_LEVEL_INFO) | G_LOG_LEVEL_DEBUG;

                        break;

                }

                default:

                {

                        flags = RYGEL_LOG_HANDLER_DEFAULT_FLAGS;

                        break;

                }

        }

        result = flags;

        return result;

}

 

 

static void rygel_log_handler_class_init (RygelLogHandlerClass * klass) {

        rygel_log_handler_parent_class = g_type_class_peek_parent (klass);

        g_type_class_add_private (klass, sizeof (RygelLogHandlerPrivate));

        G_OBJECT_CLASS (klass)->finalize = rygel_log_handler_finalize;

}

 

 

static void rygel_log_handler_instance_init (RygelLogHandler * self) {

        self->priv = RYGEL_LOG_HANDLER_GET_PRIVATE (self);

}

 

 

static void rygel_log_handler_finalize (GObject* obj) {

        RygelLogHandler * self;

        _g_object_unref0 (self->priv->log_level_hash);

        G_OBJECT_CLASS (rygel_log_handler_parent_class)->finalize (obj);

}