text:
package dk.statsbiblioteket.medieplatform.hadoop;

import dk.statsbiblioteket.medieplatform.autonomous.ConfigConstants;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mrunit.mapreduce.MapDriver;
import org.testng.annotations.Test;

import java.io.IOException;

public class ConvertMapperTest {

    @Test
    public void testSimplest() throws IOException {
        MapDriver<Text, Text, Text, Text> mapDriver;
        ConvertMapper mapper = new ConvertMapper();
        mapDriver = MapDriver.newMapDriver(mapper);
        mapDriver.getConfiguration().set(ConvertMapper.HADOOP_CONVERTER_PATH, "echo");
        mapDriver.getConfiguration().set(ConfigConstants.BATCH_ID, "test");
        mapDriver.getConfiguration().set(ConvertMapper.HADOOP_CONVERTER_OUTPUT_PATH, "/tmp/");
        mapDriver.getConfiguration().set(ConvertMapper.HADOOP_CONVERTER_OUTPUT_EXTENSION_PATH, ".pgm");

        mapDriver.withInput(new Text("1"), new Text("ein"));
        mapDriver.withOutput(new Text("1"), new Text("/tmp/test/ein.pgm"));
        mapDriver.runTest();
    }

}


text:
// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.siyeh.ig.threading;

import com.intellij.codeInspection.ui.InspectionOptionsPanel;
import com.intellij.codeInspection.ui.ListTable;
import com.intellij.codeInspection.ui.ListWrappingTableModel;
import com.intellij.java.JavaBundle;
import com.intellij.openapi.util.InvalidDataException;
import com.intellij.openapi.util.WriteExternalException;
import com.intellij.psi.*;
import com.intellij.psi.util.InheritanceUtil;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.util.PsiUtil;
import com.siyeh.InspectionGadgetsBundle;
import com.siyeh.ig.BaseInspection;
import com.siyeh.ig.BaseInspectionVisitor;
import com.siyeh.ig.psiutils.MethodMatcher;
import com.siyeh.ig.psiutils.ParenthesesUtils;
import com.siyeh.ig.psiutils.VariableAccessUtils;
import com.siyeh.ig.ui.UiUtils;
import org.jdom.Element;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;

import javax.swing.*;
import java.util.Arrays;

/**
 * @author Bas Leijdekkers
 */
public class SharedThreadLocalRandomInspection extends BaseInspection {

  protected final MethodMatcher myMethodMatcher;

  public SharedThreadLocalRandomInspection() {
    myMethodMatcher = new MethodMatcher(false, "ignoreArgumentToMethods")
      .add("java.math.BigInteger", ".*")
      .add("java.util.Collections", "shuffle")
      .finishDefault();
  }

  @Override
  public JComponent createOptionsPanel() {
    final ListTable table = new ListTable(new ListWrappingTableModel(
      Arrays.asList(myMethodMatcher.getClassNames(), myMethodMatcher.getMethodNamePatterns()),
      InspectionGadgetsBundle.message("result.of.method.call.ignored.class.column.title"),
      InspectionGadgetsBundle.message("result.of.method.call.ignored.method.column.title")));
    final var panel = new InspectionOptionsPanel();
    panel.addGrowing(UiUtils.createAddRemoveTreeClassChooserPanel(table, JavaBundle.message("dialog.title.choose.class")));
    return panel;
  }

  @NotNull
  @Override
  protected String buildErrorString(Object... infos) {
    return InspectionGadgetsBundle.message("shared.thread.local.random.problem.descriptor");
  }

  @Override
  public void readSettings(@NotNull Element element) throws InvalidDataException {
    super.readSettings(element);
    myMethodMatcher.readSettings(element);
  }

  @Override
  public void writeSettings(@NotNull Element element) throws WriteExternalException {
    super.writeSettings(element);
    myMethodMatcher.writeSettings(element);
  }

  @Override
  public BaseInspectionVisitor buildVisitor() {
    return new SharedThreadLocalRandomVisitor();
  }

  private class SharedThreadLocalRandomVisitor extends BaseInspectionVisitor {

    @Override
    public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
      super.visitMethodCallExpression(expression);
      final PsiReferenceExpression methodExpression = expression.getMethodExpression();
      @NonNls final String name = methodExpression.getReferenceName();
      if (!"current".equals(name)) {
        return;
      }
      final PsiMethod method = expression.resolveMethod();
      if (method == null) {
        return;
      }
      final PsiClass aClass = method.getContainingClass();
      if (!InheritanceUtil.isInheritor(aClass, "java.util.concurrent.ThreadLocalRandom")) {
        return;
      }
      if (isArgumentToMethodCall(expression)) {
        registerMethodCallError(expression);
      }
      else {
        final PsiVariable variable = assignedToVariable(expression);
        if (variable instanceof PsiField) {
          registerMethodCallError(expression);
        }
        else if (variable instanceof PsiLocalVariable) {
          final PsiCodeBlock context = PsiTreeUtil.getParentOfType(variable, PsiCodeBlock.class);
          final boolean passed = VariableAccessUtils.variableIsPassedAsMethodArgument(variable, context, myMethodMatcher::matches);
          if (passed || VariableAccessUtils.variableIsUsedInInnerClass(variable, context)) {
            registerMethodCallError(expression);
          }
        }
      }
    }

    private boolean isArgumentToMethodCall(PsiExpression expression) {
      final PsiElement parent = ParenthesesUtils.getParentSkipParentheses(expression);
      if (!(parent instanceof PsiExpressionList)) {
        return false;
      }
      final PsiElement grandParent = parent.getParent();
      if (!(grandParent instanceof PsiMethodCallExpression)) {
        return false;
      }
      final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)grandParent;
      return !myMethodMatcher.matches(methodCallExpression);
    }

    private PsiVariable assignedToVariable(PsiMethodCallExpression expression) {
      final PsiElement parent = PsiTreeUtil.skipParentsOfType(expression, PsiParenthesizedExpression.class);
      if (parent instanceof PsiVariable) {
        return (PsiVariable)parent;
      }
      if (!(parent instanceof PsiAssignmentExpression)) {
        return null;
      }
      final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)parent;
      final PsiExpression rhs = assignmentExpression.getRExpression();
      if (!PsiTreeUtil.isAncestor(rhs, expression, false)) {
        return null;
      }
      final PsiExpression lhs = PsiUtil.skipParenthesizedExprDown(assignmentExpression.getLExpression());
      if (!(lhs instanceof PsiReferenceExpression)) {
        return null;
      }
      final PsiReferenceExpression referenceExpression = (PsiReferenceExpression)lhs;
      final PsiElement target = referenceExpression.resolve();
      if (!(target instanceof PsiVariable)) {
        return null;
      }
      return (PsiVariable)target;
    }
  }
}

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="UTF-8" ?>

<!--
  ~ $Id: struts-plugin.xml 1081295 2011-03-14 09:54:09Z mcucchiara $
  ~
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements.  See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership.  The ASF licenses this file
  ~ to you under the Apache License, Version 2.0 (the
  ~ "License"); you may not use this file except in compliance
  ~ with the License.  You may obtain a copy of the License at
  ~
  ~  http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied.  See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->

<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>

    <bean type="org.apache.struts2.components.template.TemplateEngine" name="java" class="org.apache.struts2.views.java.JavaTemplateEngine" />
    <constant name="struts.templateEngines" value="ftl,jsp,vm,java" />
</struts>


text:
switch_area = function(area)
{
	$$('#dialog_menu_left span.selected_radio').each(function(span)
	{
		span.removeClassName('selected_radio');
	});
	$($(area).parentNode).addClassName('selected_radio');

	$$('#dialog_main div.dialog_area').each(function(div)
	{
		div.hide();
	});

	$(area.value + '_area').show();
}

FastInit.addOnLoad(function()
{
	radios = $$('#dialog_menu_left input[type=radio]');
	selected = $$('#dialog_menu_left .selected_radio input[type=radio]')[0] || radios[0];

	radios.each(function(input)
	{
		input.observe('click', function()
		{
			switch_area(this);
		});
	});

	if (selected)
	{
		selected.checked = true;
		switch_area(selected);
	}

	$$('.close_dialog').each(function(close) {
		close.observe('click', function(e)
		{
			if (parent && typeof(parent.tb_remove) == "function") {
				parent.tb_remove();
			}
			else if (typeof(tb_remove) == 'function') {
				tb_remove();
			}

			if (e)
			{
				e.stop();
			}
		});
	});
});


text:
/**
 * Provides basic statistics associated with a Lucene index.
 */
package com.esri.gpt.catalog.lucene.stats;


text:
class AddAccountNameToBank < ActiveRecord::Migration
  def change
    add_column :spree_banks, :account_name, :string
  end
end


text:
import asyncio
import logging
import json
from datetime import datetime
from dateutil.parser import parse as parse_date
import aiobotocore
from botocore.exceptions import BotoCoreError
from livebridge.storages.base import BaseStorage

logger = logging.getLogger(__name__)

class DynamoClient(BaseStorage):

    # date format for datetime values in DynamoDB
    date_fmt = "%Y-%m-%dT%H:%M:%S+00:00"

    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(DynamoClient, cls).__new__(cls)
            logger.debug("Dynamo client: {}".format(cls._instance))
        return cls._instance

    def __init__(self, **kwargs):
        self.access_key = kwargs.get("access_key") or None
        self.secret_key = kwargs.get("secret_key") or None
        self.region = kwargs.get("region")
        self.endpoint_url = kwargs.get("endpoint_url") or None
        self.table_name = kwargs.get("table_name")
        self.table_schema = {
            "TableName": self.table_name,
            "KeySchema": [
                {"AttributeName": "target_id", "KeyType": "HASH"},
                {"AttributeName": "post_id", "KeyType": "RANGE"}
            ],
            "AttributeDefinitions": [
                {"AttributeName": "updated", "AttributeType": "S"},
                {"AttributeName": "target_id", "AttributeType": "S"},
                {"AttributeName": "post_id", "AttributeType": "S"},
                {"AttributeName": "source_id", "AttributeType": "S"}
            ],
            "ProvisionedThroughput": {"ReadCapacityUnits": 3, "WriteCapacityUnits": 3},
            "GlobalSecondaryIndexes": [
                {
                    "IndexName": "source_id-updated-index",
                    "KeySchema": [
                        {"AttributeName": "source_id", "KeyType": "HASH"},
                        {"AttributeName": "updated", "KeyType": "RANGE"}
                    ],
                    "Projection": {"ProjectionType": "KEYS_ONLY"},
                    "ProvisionedThroughput": {"ReadCapacityUnits": 2, "WriteCapacityUnits": 2},
                }
            ]
        }
        self.control_table_name = kwargs.get("control_table_name")
        self.control_table_schema = {
            "TableName": self.control_table_name,
            "KeySchema": [
                {"AttributeName": "id", "KeyType": "HASH"},
            ],
            "AttributeDefinitions": [
                {"AttributeName": "id", "AttributeType": "S"},
            ],
            "ProvisionedThroughput": {"ReadCapacityUnits": 3, "WriteCapacityUnits": 3},
        }

    async def shutdown(self):
        if hasattr(self, "db_client") and self.db_client:
            await self.db_client.close()

    @property
    async def db(self):
        if hasattr(self, "db_client") and self.db_client:
            return self.db_client
        logger.info("DynamoDB: Connecting to region [{}] with endpoint_url [{}] and table [{}]".format(
            self.region, self.endpoint_url or "-", self.table_name or "-"))
        loop = asyncio.get_event_loop()
        session = aiobotocore.get_session(loop=loop)
        self.db_client = session.create_client('dynamodb',
                                               region_name=self.region,
                                               endpoint_url=self.endpoint_url,
                                               aws_secret_access_key=self.secret_key,
                                               aws_access_key_id=self.access_key)
        # dirty fix for disabling crc32 checks
        self.db_client._endpoint._aio_session._default_headers["Accept-Encoding"] = ""
        return self.db_client

    async def setup(self):
        """Setting up DynamoDB table, if it not exists."""
        try:
            client = await self.db
            response = await client.list_tables()
            created = False
            # create table if not already created.
            if self.table_name not in response["TableNames"]:
                logger.info("Creating DynamoDB table [{}]".format(self.table_name))
                resp = await client.create_table(**self.table_schema)
                if resp.get("ResponseMetadata", {}).get("HTTPStatusCode") == 200:
                    logger.info("DynamoDB table [{}] successfully created!".format(self.table_name))
                    created = True
            # create control table if not already created.
            if self.control_table_name and self.control_table_name not in response["TableNames"]:
                logger.info("Creating DynamoDB control_table [{}]".format(self.control_table_name))
                resp = await client.create_table(**self.control_table_schema)
                if resp.get("ResponseMetadata", {}).get("HTTPStatusCode") == 200:
                    logger.info("DynamoDB control table [{}] successfully created!".format(self.control_table_name))
                    created = True
            return created
        except Exception as exc:
            logger.error("[DB] Error when setting up DynamoDB.")
            logger.error(exc)
        return False

    async def scan(self):
        scan_params = {
            "TableName": self.table_name,
            "Select": "ALL_ATTRIBUTES",
            "Limit": 5
        }
        db = await self.db
        try:
            response = await db.scan(**scan_params)
            if response.get("ResponseMetadata", {}).get("HTTPStatusCode") == 200:
                return response["Items"]
        except BotoCoreError as exc:
            logger.error("[DB] Error when scanning db")
            logger.error(exc)
        return []

    async def insert_post(self, **kwargs):
        params = {
            "TableName": self.table_name,
            "Item": {
                "target_id": {"S": kwargs.get("target_id")},
                "post_id": {"S": str(kwargs.get("post_id"))},
                "source_id": {"S": kwargs.get("source_id")},
                "text": {"S": kwargs.get("text") or " "},
                "sticky": {"N": str(int(kwargs.get("sticky", False)))},
                "created": {"S": datetime.strftime(kwargs.get("created"), self.date_fmt)},
                "updated": {"S": datetime.strftime(kwargs.get("updated"), self.date_fmt)},
            }
        }
        # add doc at target if present
        if kwargs.get("target_doc"):
            params["Item"]["target_doc"] = {"S": json.dumps(kwargs["target_doc"])}
        db = await self.db
        try:
            response = await db.put_item(**params)
            if response.get("ResponseMetadata", {}).get("HTTPStatusCode") == 200:
                logger.info("[DB] Post {} {} was saved!".format(kwargs["source_id"], kwargs["post_id"]))
                return True
        except BotoCoreError as exc:
            logger.error("[DB] Error when saving {}".format(kwargs))
            logger.error(exc)
        return False

    async def get_last_updated(self, source_id):
        params = {
            "TableName": self.table_name,
            "IndexName": "source_id-updated-index",
            "KeyConditionExpression": "source_id = :value",
            "ExpressionAttributeValues": {
                ":value": {"S": str(source_id)},
            },
            "ProjectionExpression": "source_id, updated, post_id",
            "ScanIndexForward": False,
            "Limit": 1,
        }
        db = await self.db
        try:
            response = await db.query(**params)
            if response.get("ResponseMetadata", {}).get("HTTPStatusCode") == 200:
                updated = response["Items"][0]["updated"]["S"] if response["Count"] == 1 else None
                tstamp = parse_date(updated) if updated else None
                return tstamp
        except BotoCoreError as exc:
            logger.error("[DB] Error when querying for last updated item on {}".format(source_id))
            logger.error(exc)
        return None

    async def get_known_posts(self, source_id, post_ids):
        results = []
        try:
            # build ExpressionAttributeValues
            expr_attr = {":value": {"S": str(source_id)}}
            for x, pid in enumerate(post_ids):
                expr_attr[":post_id_{}".format(x)] = {"S": str(pid)}

            # build KeyConditionExpression
            filter_expr = " OR ".join(["post_id= :post_id_{}".format(x) for x in range(len(post_ids))])

            params = {
                "TableName": self.table_name,
                "IndexName": "source_id-updated-index",
                "KeyConditionExpression": "source_id = :value ",
                "ExpressionAttributeValues": expr_attr,
                "ScanIndexForward": False,
                "ProjectionExpression": "post_id",
                "FilterExpression": filter_expr,
            }
            db = await self.db
            response = await db.query(**params)
            if response.get("ResponseMetadata", {}).get("HTTPStatusCode") == 200:
                for item in response.get("Items", []):
                    results.append(item["post_id"]["S"])
        except Exception as exc:
            logger.error("[DB] Error when querying for posts {}".format(post_ids))
            logger.exception(exc)
        return results

    async def get_post(self, target_id, post_id):
        params = {
            "TableName": self.table_name,
            "KeyConditionExpression": "target_id = :value AND post_id= :post_id",
            "ExpressionAttributeValues": {
                ":value": {"S": str(target_id)},
                ":post_id": {"S": str(post_id)}
            },
            "ScanIndexForward": False,
            "ProjectionExpression": "target_id, source_id, updated, post_id, target_doc, sticky",
        }
        db = await self.db
        try:
            response = await db.query(**params)
            if response.get("ResponseMetadata", {}).get("HTTPStatusCode") == 200:
                db_post = response["Items"][0] if response["Count"] >= 1 else None
                if db_post:
                    db_post["sticky"] = db_post.get("sticky", {}).get("N")
                    db_post["updated"] = db_post.get("updated", {}).get("S")
                    db_post["source_id"] = db_post.get("source_id", {}).get("S")
                    db_post["post_id"] = db_post.get("post_id", {}).get("S")
                    db_post["target_id"] = db_post.get("target_id", {}).get("S")
                    db_post["target_doc"] = json.loads(db_post["target_doc"]["S"]) \
                        if db_post.get("target_doc", {}).get("S") else {}
                return db_post
        except BotoCoreError as exc:
            logger.error("[DB] Error when querying for a post [{}] on {}".format(post_id, target_id))
            logger.error(exc)
        return None

    async def update_post(self, **kwargs):
        try:
            target_id = kwargs.get("target_id")
            post_id = kwargs.get("post_id")
            if await self.delete_post(target_id, post_id) is True:
                await self.insert_post(**kwargs)
                logger.info("[DB] Post {} {} was updated!".format(target_id, post_id))
                return True
        except Exception as exc:
            logger.error("[DB] Error when updating for a post [{}] on {}".format(
                kwargs.get("post_id"), kwargs.get("target_id")))
            logger.error(exc)
        return False

    async def delete_post(self, target_id, post_id):
        params = {
            "TableName": self.table_name,
            "Key": {
                "target_id": {"S": str(target_id)},
                "post_id": {"S": str(post_id)},
            },
        }
        db = await self.db
        try:
            response = await db.delete_item(**params)
            if response.get("ResponseMetadata", {}).get("HTTPStatusCode") == 200:
                logger.info("[DB] Post {} {} was deleted!".format(target_id, post_id))
                return True
        except Exception as exc:
            logger.error("[DB] Error when deleting for a post [{}] on {}".format(post_id, target_id))
            logger.error(exc)
        return False

    async def get_control(self):
        params = {
            "TableName": self.control_table_name,
            "KeyConditionExpression": "id= :value",
            "ExpressionAttributeValues": {
                ":value": {"S": "control"}
            },
            "ScanIndexForward": False,
        }
        try:
            db = await self.db
            response = await db.query(**params)
            if response.get("ResponseMetadata", {}).get("HTTPStatusCode") == 200:
                db_post = response["Items"][0] if response["Count"] >= 1 else None
                if db_post:
                    return json.loads(db_post["data"]["S"])
        except BotoCoreError as exc:
            logger.error("[DB] Error when querying for control_data on {}".format(self.control_table_name))
            logger.error(exc)
        return False

    async def save_control(self, data):
        params = {
            "TableName": self.control_table_name,
            "ConditionExpression": "id = :value OR attribute_not_exists(id)",
            "ExpressionAttributeValues": {
                ":value": {"S": "control"},
            },
            "Item": {
                "id": {"S": "control"},
                "data": {"S": json.dumps(data)}
            }
        }
        try:
            db = await self.db
            await db.put_item(**params)
            logger.info("[DB] Control data was saved.")
            return True
        except BotoCoreError as exc:
            logger.error("[DB] Error when saving control_data on {}".format(self.control_table_name))
            logger.error(exc)
        return False


text:
package org.opencompare.api.java.impl;

import org.opencompare.api.java.PCM;
import org.opencompare.api.java.PCMContainer;
import org.opencompare.api.java.PCMMetadata;
import org.opencompare.api.java.PCMTest;
import org.opencompare.api.java.impl.io.KMFJSONExporter;
import org.opencompare.api.java.impl.io.KMFJSONLoader;

import static org.junit.Assert.*;

import org.junit.Test;

import java.io.IOException;
import java.util.List;

/**
 * Created by gbecan on 09/10/14.
 */
public class PCMImplTest extends PCMTest {

    @Override
    public void setUp() {
        factory = new PCMFactoryImpl();
    }

    @Test
    public void testJSONSaveAndLoad() throws IOException {

        // Create a PCM
        PCM pcm = factory.createPCM();
        PCMMetadata metadata = new PCMMetadata(pcm);
        PCMContainer container = new PCMContainer();
        container.setPcm(pcm);
        container.setMetadata(metadata);
        pcm.setName("test");

        // Serialize
        KMFJSONExporter serializer = new KMFJSONExporter();
        String json = serializer.export(container);

        // Load
        KMFJSONLoader loader = new KMFJSONLoader();
        List<PCMContainer> containers = loader.load(json);

        for (PCMContainer cont : containers) {
            assertEquals(pcm, cont.getPcm());
        }

    }

    @Test
    public void testUTF8Encoding() throws IOException {

        // Create PCM with non ASCII characters
        PCM pcm = factory.createPCM();
        pcm.setName("こんにちは");
        PCMContainer pcmContainer = new PCMContainer(pcm);

        // Serialize & load
        KMFJSONExporter serializer = new KMFJSONExporter();
        String serializedPCM = serializer.export(pcmContainer);

        KMFJSONLoader loader = new KMFJSONLoader();
        PCM loadedPCM = loader.load(serializedPCM).get(0).getPcm();

        assertEquals("load(serialize(pcm)).name = pcm.name", pcm.getName(), loadedPCM.getName());
    }
}


text:
{% extends "opstel/base_entries.html" %}

{% block title %}{{ block.super }} | Latest entries{% endblock %}

{% block content %}
{% for entry in latest %}

{{ entry.title }}

entry_archive

  Published on {{ entry.pub_date|date:"F j, Y" }}
>

	{% if entry.thumb %}

	 {% endif %}

	{% if entry.excerpt %}
		{{ entry.excerpt|safe }}
	{% else %}
		{{ entry.body|truncatewords_html:"50"|safe }}
	{% endif %}

Read more. . .

{% endfor %}
{% endblock %}


text:
#include "model_base.sep.0.h"
/* method model_base#Model#init for (self: Model) */
void model_base__Model__init(val* self) {
RET_LABEL:;
}
/* method model_base#Model#init for (self: Object) */
void VIRTUAL_model_base__Model__init(val* self) {
model_base__Model__init(self);
RET_LABEL:;
}
/* method model_base#MVisibility#to_s for (self: MVisibility): String */
val* model_base__MVisibility__to_s(val* self) {
val* var /* : String */;
val* var1 /* : String */;
var1 = self->attrs[COLOR_model_base__MVisibility___64dto_s].val; /* @to_s on <self:MVisibility> */
if (var1 == NULL) {
fprintf(stderr, "Runtime error: %s", "Uninitialized attribute @to_s");
fprintf(stderr, " (%s:%d)\n", "src/model/model_base.nit", 39);
show_backtrace(1);
}
var = var1;
RET_LABEL:;
return var;
}
/* method model_base#MVisibility#to_s for (self: Object): String */
val* VIRTUAL_model_base__MVisibility__to_s(val* self) {
val* var /* : String */;
val* var1 /* : String */;
var1 = model_base__MVisibility__to_s(self);
var = var1;
RET_LABEL:;
return var;
}
/* method model_base#MVisibility#to_s= for (self: MVisibility, String) */
void model_base__MVisibility__to_s_61d(val* self, val* p0) {
self->attrs[COLOR_model_base__MVisibility___64dto_s].val = p0; /* @to_s on <self:MVisibility> */
RET_LABEL:;
}
/* method model_base#MVisibility#to_s= for (self: Object, String) */
void VIRTUAL_model_base__MVisibility__to_s_61d(val* self, val* p0) {
model_base__MVisibility__to_s_61d(self, p0);
RET_LABEL:;
}
/* method model_base#MVisibility#level for (self: MVisibility): Int */
long model_base__MVisibility__level(val* self) {
long var /* : Int */;
long var1 /* : Int */;
var1 = self->attrs[COLOR_model_base__MVisibility___64dlevel].l; /* @level on <self:MVisibility> */
var = var1;
RET_LABEL:;
return var;
}
/* method model_base#MVisibility#level for (self: Object): Int */
long VIRTUAL_model_base__MVisibility__level(val* self) {
long var /* : Int */;
long var1 /* : Int */;
var1 = model_base__MVisibility__level(self);
var = var1;
RET_LABEL:;
return var;
}
/* method model_base#MVisibility#level= for (self: MVisibility, Int) */
void model_base__MVisibility__level_61d(val* self, long p0) {
self->attrs[COLOR_model_base__MVisibility___64dlevel].l = p0; /* @level on <self:MVisibility> */
RET_LABEL:;
}
/* method model_base#MVisibility#level= for (self: Object, Int) */
void VIRTUAL_model_base__MVisibility__level_61d(val* self, long p0) {
model_base__MVisibility__level_61d(self, p0);
RET_LABEL:;
}
/* method model_base#MVisibility#init for (self: MVisibility, String, Int) */
void model_base__MVisibility__init(val* self, val* p0, long p1) {
val* var_s /* var s: String */;
long var_level /* var level: Int */;
var_s = p0;
var_level = p1;
((void (*)(val*, val*))(self->class->vft[COLOR_model_base__MVisibility__to_s_61d]))(self, var_s) /* to_s= on <self:MVisibility>*/;
((void (*)(val*, long))(self->class->vft[COLOR_model_base__MVisibility__level_61d]))(self, var_level) /* level= on <self:MVisibility>*/;
RET_LABEL:;
}
/* method model_base#MVisibility#init for (self: Object, String, Int) */
void VIRTUAL_model_base__MVisibility__init(val* self, val* p0, long p1) {
model_base__MVisibility__init(self, p0, p1);
RET_LABEL:;
}
/* method model_base#MVisibility#< for (self: MVisibility, MVisibility): Bool */
short int model_base__MVisibility___60d(val* self, val* p0) {
short int var /* : Bool */;
short int var1 /* : Bool */;
int cltype;
int idtype;
const struct type* type_struct;
const char* var_class_name;
val* var_other /* var other: MVisibility */;
long var2 /* : Int */;
long var3 /* : Int */;
short int var4 /* : Bool */;
short int var6 /* : Bool */;
int cltype7;
int idtype8;
const char* var_class_name9;
short int var10 /* : Bool */;
/* Covariant cast for argument 0 (other) <p0:MVisibility> isa OTHER */
/* <p0:MVisibility> isa OTHER */
type_struct = self->type->resolution_table->types[COLOR_kernel__Comparable_VTOTHER];
cltype = type_struct->color;
idtype = type_struct->id;
if(cltype >= p0->type->table_size) {
var1 = 0;
} else {
var1 = p0->type->type_table[cltype] == idtype;
}
if (!var1) {
var_class_name = p0 == NULL ? "null" : p0->type->name;
fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name);
fprintf(stderr, " (%s:%d)\n", "src/model/model_base.nit", 49);
show_backtrace(1);
}
var_other = p0;
var2 = ((long (*)(val*))(self->class->vft[COLOR_model_base__MVisibility__level]))(self) /* level on <self:MVisibility>*/;
var3 = ((long (*)(val*))(var_other->class->vft[COLOR_model_base__MVisibility__level]))(var_other) /* level on <var_other:MVisibility>*/;
{ /* Inline kernel#Int#< (var2,var3) */
/* Covariant cast for argument 0 (i) <var3:Int> isa OTHER */
/* <var3:Int> isa OTHER */
var6 = 1; /* easy <var3:Int> isa OTHER*/
if (!var6) {
var_class_name9 = type_kernel__Int.name;
fprintf(stderr, "Runtime error: Cast failed. Expected `%s`, got `%s`", "OTHER", var_class_name9);
fprintf(stderr, " (%s:%d)\n", "lib/standard/kernel.nit", 265);
show_backtrace(1);
}
var10 = var2 < var3;
var4 = var10;
goto RET_LABEL5;
RET_LABEL5:(void)0;
}
var = var4;
goto RET_LABEL;
RET_LABEL:;
return var;
}
/* method model_base#MVisibility#< for (self: Object, Comparable): Bool */
short int VIRTUAL_model_base__MVisibility___60d(val* self, val* p0) {
short int var /* : Bool */;
short int var1 /* : Bool */;
var1 = model_base__MVisibility___60d(self, p0);
var = var1;
RET_LABEL:;
return var;
}
/* method model_base#Object#intrude_visibility for (self: Object): MVisibility */
val* model_base__Object__intrude_visibility(val* self) {
val* var /* : MVisibility */;
static val* varonce;
static int varonce_guard;
val* var1 /* : MVisibility */;
val* var2 /* : MVisibility */;
static val* varonce3;
val* var4 /* : String */;
char* var5 /* : NativeString */;
long var6 /* : Int */;
val* var7 /* : String */;
long var8 /* : Int */;
if (varonce_guard) {
var1 = varonce;
} else {
var2 = NEW_model_base__MVisibility(&type_model_base__MVisibility);
if (varonce3) {
var4 = varonce3;
} else {
var5 = "intrude";
var6 = 7;
var7 = string__NativeString__to_s_with_length(var5, var6);
var4 = var7;
varonce3 = var4;
}
var8 = 4;
((void (*)(val*, val*, long))(var2->class->vft[COLOR_model_base__MVisibility__init]))(var2, var4, var8) /* init on <var2:MVisibility>*/;
var1 = var2;
varonce = var1;
varonce_guard = 1;
}
var = var1;
goto RET_LABEL;
RET_LABEL:;
return var;
}
/* method model_base#Object#intrude_visibility for (self: Object): MVisibility */
val* VIRTUAL_model_base__Object__intrude_visibility(val* self) {
val* var /* : MVisibility */;
val* var1 /* : MVisibility */;
var1 = model_base__Object__intrude_visibility(self);
var = var1;
RET_LABEL:;
return var;
}
/* method model_base#Object#public_visibility for (self: Object): MVisibility */
val* model_base__Object__public_visibility(val* self) {
val* var /* : MVisibility */;
static val* varonce;
static int varonce_guard;
val* var1 /* : MVisibility */;
val* var2 /* : MVisibility */;
static val* varonce3;
val* var4 /* : String */;
char* var5 /* : NativeString */;
long var6 /* : Int */;
val* var7 /* : String */;
long var8 /* : Int */;
if (varonce_guard) {
var1 = varonce;
} else {
var2 = NEW_model_base__MVisibility(&type_model_base__MVisibility);
if (varonce3) {
var4 = varonce3;
} else {
var5 = "public";
var6 = 6;
var7 = string__NativeString__to_s_with_length(var5, var6);
var4 = var7;
varonce3 = var4;
}
var8 = 4;
((void (*)(val*, val*, long))(var2->class->vft[COLOR_model_base__MVisibility__init]))(var2, var4, var8) /* init on <var2:MVisibility>*/;
var1 = var2;
varonce = var1;
varonce_guard = 1;
}
var = var1;
goto RET_LABEL;
RET_LABEL:;
return var;
}
/* method model_base#Object#public_visibility for (self: Object): MVisibility */
val* VIRTUAL_model_base__Object__public_visibility(val* self) {
val* var /* : MVisibility */;
val* var1 /* : MVisibility */;
var1 = model_base__Object__public_visibility(self);
var = var1;
RET_LABEL:;
return var;
}
/* method model_base#Object#protected_visibility for (self: Object): MVisibility */
val* model_base__Object__protected_visibility(val* self) {
val* var /* : MVisibility */;
static val* varonce;
static int varonce_guard;
val* var1 /* : MVisibility */;
val* var2 /* : MVisibility */;
static val* varonce3;
val* var4 /* : String */;
char* var5 /* : NativeString */;
long var6 /* : Int */;
val* var7 /* : String */;
long var8 /* : Int */;
if (varonce_guard) {
var1 = varonce;
} else {
var2 = NEW_model_base__MVisibility(&type_model_base__MVisibility);
if (varonce3) {
var4 = varonce3;
} else {
var5 = "protected";
var6 = 9;
var7 = string__NativeString__to_s_with_length(var5, var6);
var4 = var7;
varonce3 = var4;
}
var8 = 3;
((void (*)(val*, val*, long))(var2->class->vft[COLOR_model_base__MVisibility__init]))(var2, var4, var8) /* init on <var2:MVisibility>*/;
var1 = var2;
varonce = var1;
varonce_guard = 1;
}
var = var1;
goto RET_LABEL;
RET_LABEL:;
return var;
}
/* method model_base#Object#protected_visibility for (self: Object): MVisibility */
val* VIRTUAL_model_base__Object__protected_visibility(val* self) {
val* var /* : MVisibility */;
val* var1 /* : MVisibility */;
var1 = model_base__Object__protected_visibility(self);
var = var1;
RET_LABEL:;
return var;
}
/* method model_base#Object#private_visibility for (self: Object): MVisibility */
val* model_base__Object__private_visibility(val* self) {
val* var /* : MVisibility */;
static val* varonce;
static int varonce_guard;
val* var1 /* : MVisibility */;
val* var2 /* : MVisibility */;
static val* varonce3;
val* var4 /* : String */;
char* var5 /* : NativeString */;
long var6 /* : Int */;
val* var7 /* : String */;
long var8 /* : Int */;
if (varonce_guard) {
var1 = varonce;
} else {
var2 = NEW_model_base__MVisibility(&type_model_base__MVisibility);
if (varonce3) {
var4 = varonce3;
} else {
var5 = "private";
var6 = 7;
var7 = string__NativeString__to_s_with_length(var5, var6);
var4 = var7;
varonce3 = var4;
}
var8 = 2;
((void (*)(val*, val*, long))(var2->class->vft[COLOR_model_base__MVisibility__init]))(var2, var4, var8) /* init on <var2:MVisibility>*/;
var1 = var2;
varonce = var1;
varonce_guard = 1;
}
var = var1;
goto RET_LABEL;
RET_LABEL:;
return var;
}
/* method model_base#Object#private_visibility for (self: Object): MVisibility */
val* VIRTUAL_model_base__Object__private_visibility(val* self) {
val* var /* : MVisibility */;
val* var1 /* : MVisibility */;
var1 = model_base__Object__private_visibility(self);
var = var1;
RET_LABEL:;
return var;
}
/* method model_base#Object#none_visibility for (self: Object): MVisibility */
val* model_base__Object__none_visibility(val* self) {
val* var /* : MVisibility */;
static val* varonce;
static int varonce_guard;
val* var1 /* : MVisibility */;
val* var2 /* : MVisibility */;
static val* varonce3;
val* var4 /* : String */;
char* var5 /* : NativeString */;
long var6 /* : Int */;
val* var7 /* : String */;
long var8 /* : Int */;
if (varonce_guard) {
var1 = varonce;
} else {
var2 = NEW_model_base__MVisibility(&type_model_base__MVisibility);
if (varonce3) {
var4 = varonce3;
} else {
var5 = "none";
var6 = 4;
var7 = string__NativeString__to_s_with_length(var5, var6);
var4 = var7;
varonce3 = var4;
}
var8 = 2;
((void (*)(val*, val*, long))(var2->class->vft[COLOR_model_base__MVisibility__init]))(var2, var4, var8) /* init on <var2:MVisibility>*/;
var1 = var2;
varonce = var1;
varonce_guard = 1;
}
var = var1;
goto RET_LABEL;
RET_LABEL:;
return var;
}
/* method model_base#Object#none_visibility for (self: Object): MVisibility */
val* VIRTUAL_model_base__Object__none_visibility(val* self) {
val* var /* : MVisibility */;
val* var1 /* : MVisibility */;
var1 = model_base__Object__none_visibility(self);
var = var1;
RET_LABEL:;
return var;
}


text:
TEST(WindowsVersion, GetWindowsVersion) {
  ASSERT_THAT(orbit_base::GetWindowsVersion(), orbit_test_utils::HasNoError());
}

TEST(WindowsVersion, GetWindowsVersionAsString) {
  auto result = orbit_base::GetWindowsVersionAsString();
  ASSERT_TRUE(result.has_value());
}

#endif  // _WIN32


text:
from nose.tools import *  # flake8: noqa

from tests.base import ApiTestCase
from osf_tests.factories import AuthUserFactory, PreprintFactory, ProjectFactory

from api.base.settings.defaults import API_BASE

class TestUserPreprints(ApiTestCase):

    def setUp(self):
        super(TestUserPreprints, self).setUp()
        self.user_one = AuthUserFactory()
        self.user_two = AuthUserFactory()
        self.preprint = PreprintFactory(title="Preprint User One", creator=self.user_one)
        self.public_project = ProjectFactory(title="Public Project User One", is_public=True, creator=self.user_one)
        self.private_project = ProjectFactory(title="Private Project User One", is_public=False, creator=self.user_one)

    def tearDown(self):
        super(TestUserPreprints, self).tearDown()

    def test_authorized_in_gets_200(self):
        url = "/{}users/{}/preprints/".format(API_BASE, self.user_one._id)
        res = self.app.get(url, auth=self.user_one.auth)
        assert_equal(res.status_code, 200)
        assert_equal(res.content_type, 'application/vnd.api+json')

    def test_anonymous_gets_200(self):
        url = "/{}users/{}/preprints/".format(API_BASE, self.user_one._id)
        res = self.app.get(url)
        assert_equal(res.status_code, 200)
        assert_equal(res.content_type, 'application/vnd.api+json')

    def test_get_preprints_logged_in(self):
        url = "/{}users/{}/preprints/".format(API_BASE, self.user_one._id)
        res = self.app.get(url, auth=self.user_one.auth)
        node_json = res.json['data']

        ids = [each['id'] for each in node_json]
        assert_in(self.preprint._id, ids)
        assert_not_in(self.public_project._id, ids)
        assert_not_in(self.private_project._id, ids)

    def test_get_projects_not_logged_in(self):
        url = "/{}users/{}/preprints/".format(API_BASE, self.user_one._id)
        res = self.app.get(url)
        node_json = res.json['data']

        ids = [each['id'] for each in node_json]
        assert_in(self.preprint._id, ids)
        assert_not_in(self.public_project._id, ids)
        assert_not_in(self.private_project._id, ids)

    def test_get_projects_logged_in_as_different_user(self):
        url = "/{}users/{}/preprints/".format(API_BASE, self.user_one._id)
        res = self.app.get(url, auth=self.user_two.auth)
        node_json = res.json['data']

        ids = [each['id'] for each in node_json]
        assert_in(self.preprint._id, ids)
        assert_not_in(self.public_project._id, ids)
        assert_not_in(self.private_project._id, ids)


text:
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {Injectable, Injector} from '@angular/core';
import {AbstractService} from '@common/service/abstract.service';
import {CommonUtil} from '@common/util/common.util';

@Injectable()
export class ColumnDictionaryService extends AbstractService {

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Private Variables
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  // Dictionary url
  private URL_DICTIONARY = this.API_URL + 'dictionaries';

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Protected Variables
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Public Variables
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Constructor
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  // 생성자
  constructor(protected injector: Injector) {
    super(injector);
  }

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Override Method
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  | Public Method
  |-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

  /**
   * 컬럼 사전 생성
   * @param {Object} params
   * @returns {Promise<any>}
   */
  public createColumnDictionary(params: object): Promise<any> {
    return this.post(this.URL_DICTIONARY, params);
  }

  /**
   * 컬럼 사전 목록 조회
   * @param {Object} params
   * @param {string} projection
   * @returns {Promise<any>}
   */
  public getColumnDictionaryList(params: object, projection: string = 'forListView'): Promise<any> {
    let url = this.URL_DICTIONARY + `?projection=${projection}`;
    (params) && (url += '&' + CommonUtil.objectToUrlString(params));
    return this.get(url);
  }

  /**
   * 컬럼 사전 상세정보 조회
   * @param {string} dictionaryId
   * @param {string} projection
   * @returns {Promise<any>}
   */
  public getColumnDictionaryDetail(dictionaryId: string, projection: string = 'forDetailView'): Promise<any> {
    const url = this.URL_DICTIONARY + `/${dictionaryId}?projection=${projection}`;
    return this.get(url);
  }

  /**
   * 컬럼 사전에 중복된 논리명이 있는지 조회
   * @param {string} logicalName
   * @returns {Promise<any>}
   */
  public getDuplicateLogicalNameInColumnDictionary(logicalName: string): Promise<any> {
    return this.get(this.URL_DICTIONARY + `/name/${logicalName}/duplicated`);
  }

  /**
   * 컬럼 사전 수정
   * @param {string} dictionaryId
   * @param {Object} params
   * @returns {Promise<any>}
   */
  public updateColumnDictionary(dictionaryId: string, params: object): Promise<any> {
    return this.patch(this.URL_DICTIONARY + '/' + dictionaryId, params);
  }

  /**
   * 컬럼 사전 제거
   * @param {string} dictionaryId
   * @returns {Promise<any>}
   */
  public deleteColumnDictionary(dictionaryId: string): Promise<any> {
    return this.delete(this.URL_DICTIONARY + '/' + dictionaryId);
  }

  /**
   * 컬럼 사전과 코드테이블 연결
   * @param {string} dictionaryId
   * @param {string} codeTableId
   * @returns {Promise<any>}
   */
  public linkCodeTableWithColumnDictionary(dictionaryId: string, codeTableId: string): Promise<any> {
    return this.put(this.URL_DICTIONARY + `/${dictionaryId}/codetable`, `/api/codetables/${codeTableId}`,
      'text/uri-list');
  }

  /**
   * 컬럼 사전과 연결된 코드테이블 제거
   * @param {string} dictionaryId
   * @param {string} codeTableId
   * @returns {Promise<any>}
   */
  public unlinkCodeTableWithColumnDictionary(dictionaryId: string, codeTableId: string): Promise<any> {
    return this.delete(this.URL_DICTIONARY + `/${dictionaryId}/codetable/${codeTableId}`);
  }

  /**
   * 컬럼 사전에 연결된 코드테이블 조회
   * @param {string} dictionaryId
   * @param {string} projection
   * @returns {Promise<any>}
   */
  public getCodeTableInColumnDictionary(dictionaryId: string, projection: string = 'forCodeView'): Promise<any> {
    return this.get(this.URL_DICTIONARY + `/${dictionaryId}/codetable?projection=${projection}`);
  }

  /**
   * 컬럼 사전에 연결된 메타데이터 조회
   * @param {string} dictionaryId
   * @param {Object} params
   * @param {string} projection
   * @returns {Promise<any>}
   */
  public getMetadataInColumnDictionary(
    dictionaryId: string, params: object, projection: string = 'forDictionaryListView'): Promise<any> {
    let url = this.URL_DICTIONARY + `/${dictionaryId}/columns?projection=${projection}`;
    (params) && (url += '&' + CommonUtil.objectToUrlString(params));
    return this.get(url);
  }
}


text:
  background-image: url("http://example.com/assets/css/folder/relative/path");
  background-image: url("http://example.com/assets/css/relative/path");
  background-image: url("http://example.com/assets/relative/path");
  background-image: url("module");
  background-image: url("module/path");
  background-image: url("module/relative/path");
}
#rootpath-rewrite-urls-local {
  background-image: url("http://example.com/assets/css/relative/path");
  background-image: url("http://example.com/assets/relative/path");
  background-image: url("http://example.com/assets/css/path");
  background-image: url("http://example.com/assets/css");
  background-image: url("module");
  background-image: url("module/path");
  background-image: url("module/relative/path");
}


text:
"""
Coordinate frames tied to the Equator and Equinox of Earth.

TEME is a True equator, Mean Equinox coordinate frame used in NORAD TLE
satellite files.

TETE is a True equator, True Equinox coordinate frame often called the
"apparent" coordinates. It is the same frame as used by JPL Horizons
and can be combined with Local Apparent Sidereal Time to calculate the
hour angle.
"""

from astropy.utils.decorators import format_doc
from astropy.coordinates.representation import (CartesianRepresentation, CartesianDifferential)
from astropy.coordinates.baseframe import BaseCoordinateFrame, base_doc
from astropy.coordinates.builtin_frames.baseradec import BaseRADecFrame, doc_components
from astropy.coordinates.attributes import TimeAttribute, EarthLocationAttribute
from .utils import DEFAULT_OBSTIME, EARTH_CENTER

__all__ = ['TEME', 'TETE']

doc_footer_teme = """
    Other parameters
    ----------------
    obstime : `~astropy.time.Time`
        The time at which the frame is defined.  Used for determining the
        position of the Earth.
"""

doc_footer_tete = """
    Other parameters
    ----------------
    obstime : `~astropy.time.Time`
        The time at which the observation is taken.  Used for determining the
        position of the Earth.
    location : `~astropy.coordinates.EarthLocation`
        The location on the Earth.  This can be specified either as an
        `~astropy.coordinates.EarthLocation` object or as anything that can be
        transformed to an `~astropy.coordinates.ITRS` frame. The default is the
        centre of the Earth.
"""

@format_doc(base_doc, components=doc_components, footer=doc_footer_tete)
class TETE(BaseRADecFrame):
    """
    An equatorial coordinate or frame using the True Equator and True Equinox (TETE).

    Equatorial coordinate frames measure RA with respect to the equinox and declination
    with with respect to the equator. The location of the equinox and equator vary due
    the gravitational torques on the oblate Earth. This variation is split into precession
    and nutation, although really they are two aspects of a single phenomena. The smooth,
    long term variation is known as precession, whilst smaller, periodic components are
    called nutation.

    Calculation of the true equator and equinox involves the application of both precession
    and nutation, whilst only applying precession gives a mean equator and equinox.

    TETE coordinates are often referred to as "apparent" coordinates, or
    "apparent place". TETE is the apparent coordinate system used by JPL Horizons
    and is the correct coordinate system to use when combining the right ascension
    with local apparent sidereal time to calculate the apparent (TIRS) hour angle.

    For more background on TETE, see the references provided in the
    :ref:`astropy:astropy-coordinates-seealso` section of the documentation.
    Of particular note are Sections 5 and 6 of
    `USNO Circular 179 <https://arxiv.org/abs/astro-ph/0602086>`_) and
    especially the diagram at the top of page 57.

    This frame also includes frames that are defined *relative* to the center of the Earth,
    but that are offset (in both position and velocity) from the center of the Earth. You
    may see such non-geocentric coordinates referred to as "topocentric".

    The frame attributes are listed under **Other Parameters**.
    """

    obstime = TimeAttribute(default=DEFAULT_OBSTIME)
    location = EarthLocationAttribute(default=EARTH_CENTER)

# Self transform goes through ICRS and is defined in icrs_cirs_transforms.py

@format_doc(base_doc, components="", footer=doc_footer_teme)
class TEME(BaseCoordinateFrame):
    """
    A coordinate or frame in the True Equator Mean Equinox frame (TEME).

    This frame is a geocentric system similar to CIRS or geocentric apparent place,
    except that the mean sidereal time is used to rotate from TIRS. TEME coordinates
    are most often used in combination with orbital data for satellites in the
    two-line-ephemeris format.

    Different implementations of the TEME frame exist. For clarity, this frame follows the
    conventions and relations to other frames that are set out in Vallado et al (2006).

    For more background on TEME, see the references provided in the
    :ref:`astropy:astropy-coordinates-seealso` section of the documentation.
    """

    default_representation = CartesianRepresentation
    default_differential = CartesianDifferential

    obstime = TimeAttribute()

# Transformation functions for getting to/from TEME and ITRS are in
# intermediate rotation transforms.py


text:
package main

import (
	"strings"

	"github.com/currantlabs/ble"
	"github.com/urfave/cli"
)

func filter(c *cli.Context) ble.AdvFilter {
	if c.String("name") != "" {
		return func(a ble.Advertisement) bool {
			return strings.ToLower(a.LocalName()) == strings.ToLower(c.String("name"))
		}
	}
	if c.String("addr") != "" {
		return func(a ble.Advertisement) bool {
			return a.Address().String() == strings.ToLower(c.String("addr"))
		}
	}
	if svc := strings.ToLower(c.String("svc")); svc != "" {
		return func(a ble.Advertisement) bool {
			for _, s := range a.Services() {
				if s.String() == svc {
					return true
				}
			}
			return false
		}
	}
	return nil
}


text:
package org.apache.ode.bpel.rtrep.v2;

import org.apache.ode.bpel.rapi.PartnerLinkModel;
import org.apache.ode.bpel.rapi.CorrelationSetModel;

import javax.wsdl.Operation;
import javax.wsdl.PortType;
import javax.xml.namespace.QName;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Compiled representation of a BPEL partnerLink.
 */
public class OPartnerLink extends OBase implements PartnerLinkModel {
    static final long serialVersionUID = -1L  ;
    /** partnerLink name. */
    public String name;

    /** Scope in which this partnerLink is declared. */
    public OScope declaringScope;

    /** The type of this partnerLink. */
    public QName partnerLinkType;

    public String partnerRoleName;

    public String myRoleName;

    public PortType myRolePortType;

    public PortType partnerRolePortType;

    public boolean initializePartnerRole;

    /** The set of CorrelationSets that may be used as a match criteria, organized by {@link Operation} */
    private final HashMap<String,Set<CorrelationSetModel>> _nonIntitiatingCorrelationSets = new HashMap<String,Set<CorrelationSetModel>>();

    /** The set of initiating CorrelationSets that may be used as an uniqueness criteria, organized by {@link Operation} */
    private final HashMap<String,Set<CorrelationSetModel>> _uniqueInitiatingCorrelationSets = new HashMap<String,Set<CorrelationSetModel>>();

    /** The set of {@link Operation}s that can be used to create a process instance. */
    private final HashSet<String> _createInstanceOperations = new HashSet<String>();

    public OPartnerLink(OProcess owner) {
        super(owner);
    }

    public String getName() {
        return name;
    }

    public String getMyRoleName() {
        return myRoleName;
    }

    public String getPartnerRoleName() {
        return partnerRoleName;
    }

    public boolean isInitializePartnerRoleSet() {
        return initializePartnerRole;
    }

    public PortType getMyRolePortType() {
        return myRolePortType;
    }

    public PortType getPartnerRolePortType() {
        return partnerRolePortType;
    }

    public boolean hasMyRole() {
        return myRolePortType != null;
    }

    public boolean hasPartnerRole() {
        return partnerRolePortType != null;
    }

    public boolean isCreateInstanceOperation(Operation op) {
        return _createInstanceOperations.contains(op.getName());
    }

    public void addCreateInstanceOperation(Operation operation) {
        _createInstanceOperations.add(operation.getName());
    }

    /**
     * Add a {@link org.apache.ode.bpel.o.OScope.CorrelationSet} to an {@link Operation}'s list
     * of "non-initiating" correlation sets. The non-initiating correlation sets are those
     * sets that are used (along with the operation) to "match" incoming messages.
     * We need to know which correlation sets are used with which operation in order to
     * pre-compute correlation keys at the time of message receipt.
     * @param operation WSDL {@link Operation}
     * @param cset non-initiating correlation used in this operation
     */
    public void addCorrelationSetForOperation(Operation operation, CorrelationSetModel cset) {
        Set<CorrelationSetModel> ret = _nonIntitiatingCorrelationSets.get(operation.getName());
        if (ret == null) {
            ret = new HashSet<CorrelationSetModel>();
            _nonIntitiatingCorrelationSets.put(operation.getName(), ret);
        }
        ret.add(cset);

    }

    /**
     * Get all non-initiating correlation sets that are ever used to qualify a receive for a the given
     * operation.
     * @param operation the operation
     * @return all non-initiating correlation sets used in the given operation
     */
    @SuppressWarnings("unchecked")
    public Set<CorrelationSetModel> getCorrelationSetsForOperation(Operation operation) {
        Set<CorrelationSetModel> ret = _nonIntitiatingCorrelationSets.get(operation.getName());
        if (ret == null) {
            return Collections.EMPTY_SET;
        }
        return Collections.unmodifiableSet(ret);
    }

    /**
     * Add a {@link org.apache.ode.bpel.o.OScope.CorrelationSet} to an {@link Operation}'s list
     * of "unique-initiating" correlation sets. The unique-initiating correlation sets are those
     * sets that are used (along with the operation) to "initiate" incoming messages, provided
     * that there doesn't already exist a process instance with that correlation key.
     * We need to know which correlation sets are used with which operation in order to
     * pre-compute correlation keys at the time of message receipt.
     * @param operation WSDL {@link Operation}
     * @param cset unique-initiating correlation used in this operation
     */
    public void addUniqueCorrelationSetForOperation(Operation operation, CorrelationSetModel cset) {
    	if (cset.isUnique()) {
	        Set<CorrelationSetModel> ret = _uniqueInitiatingCorrelationSets.get(operation.getName());
	        if (ret == null) {
	            ret = new HashSet<CorrelationSetModel>();
	            _uniqueInitiatingCorrelationSets.put(operation.getName(), ret);
	        }
	        ret.add(cset);
    	}
    }

    /**
     * Get all unique initiating correlation sets that are ever used to qualify a receive for a the given
     * operation.
     * @param operation the operation
     * @return all unique-initiating correlation sets used in the given operation
     */
    @SuppressWarnings("unchecked")
    public Set<CorrelationSetModel> getUniqueCorrelationSetsForOperation(Operation operation) {
        Set<CorrelationSetModel> ret = _uniqueInitiatingCorrelationSets.get(operation.getName());
        if (ret == null) {
            return Collections.EMPTY_SET;
        }
        return Collections.unmodifiableSet(ret);
    }

    @SuppressWarnings("unchecked")
    public Operation getMyRoleOperation(String name) {
        for (Operation op : (List<Operation>)myRolePortType.getOperations())
            if (op.getName().equals(name))
                return op;
        return null;
    }

    @SuppressWarnings("unchecked")
    public Operation getPartnerRoleOperation(String name) {
        for (Operation op : (List<Operation>)partnerRolePortType.getOperations())
            if (op.getName().equals(name))
                return op;
        return null;
    }
}


text:
#ifndef _PATH_MANAGER
#define _PATH_MANAGER

#include "followtherider/model/path/Path.hpp"
#include "followtherider/utils/tile_id.hpp" // for the zoom level

namespace FollowTheRider {

/**
 * Forward declaration.
 */
namespace App {
    class LockManager;
} // namespace App

namespace Connector {
namespace Osrm {
    class OSRMConnectorFactory;
} // namespace Osrm
} // namespace Connector

namespace Element {
    class ElementFactory;
} // namespace Element

namespace Explore {
    class RegionExplorer;
} // namespace Explore

namespace Model {
namespace Path {
    class Path;
} // namespace Path

namespace Rider {
    class Rider;
} // namespace Rider
} // namespace Model

namespace Persistence {
    class RTree;
} // namespace Persistence

namespace Rider {
    class RiderManager;
} // namespace Rider

namespace SRTM {
    class SRTMHandler;
} // namespace SRTM

namespace Path {

/**
 * The path manager base class.
 * The path manager creates, updates, removes, shares paths.
 */
class PathManager {
public:
    /**
     * Action enum
     */
    enum Action : int {
        ADD = 0,    /**< add coordinates */
        REMOVE = 1, /**< remove coordinates */
    };

    /**
     * Routing type enum.
     * TODO: naming needs to be reviewed. routing type initial purpose was to
     *       influence the way routes are computed by OSRM routing machine.
     *       At this point it is only used when similar segments are being recognized.
     */
    enum RoutingType : uint8_t {
        NONE    = 0x00,
        STRAVA  = 0x01, /**< Strava */  /* (1 << 0), 0000 0001 */
    };

    /**
     * Virtual destructor.
     */
    virtual ~PathManager() = default;

    /**
     * Initializes the path manager.
     */
    virtual void init() = 0;

    /**
     * Adds an editor to a path.
     * @param pathId the id of the path.
     * @param pathEditorId the id of the path editor.
     * @param role the role of the path editor.
     * @return an updated path with the path editor added.
     */
    virtual std::shared_ptr<Model::Path::Path> addPathEditor(uint64_t pathId,
                                                             uint64_t pathEditorId,
                                                             Model::Path::PathEdition::Role role) = 0;

    /**
     * Removes an editor from a path.
     * @param pathId the id of the path.
     * @param pathEditorId the id of the path editor.
     * @return an updated path with the path editor added.
     */
    virtual std::shared_ptr<Model::Path::Path> removePathEditor(uint64_t pathId,
                                                                uint64_t pathEditorId) = 0;

    /**
     * Handles given action by creating or removing segments and updating path given its id.
     * @param pathId the id of the path.
     * @param pathEditorId the id of the path editor.
     * @param action the action. ADD or REMOVE.
     * @param coordinates the coordinates. a linestring drawn and sent by the client.
     * @param routingType the routing type. ::NONE by default.
     * @param zoomLevel the zoom level.
     * @return a new or an updated path containing a collection of computed segments.
     * @see Action
     */
    virtual std::shared_ptr<Model::Path::Path> handleCoordinates(uint64_t pathId,
                                                                 uint64_t pathEditorId,
                                                                 Action action,
                                                                 const Element::WayCoordinates& coordinates,
                                                                 RoutingType routingType = RoutingType::NONE,
                                                                 int zoomLevel = Utils::TileID::s_defaultZoomLevel) = 0;

    /**
     * Adds or removes a via points to / from a path segment given path and segment ids.
     * @param pathId the id of the path.
     * @param pathEditorId the id of the path editor.
     * @param segmentId the id of the segment of the path.
     * @param action the action. ADD or REMOVE.
     * @param viaPoint the coordinates of the via point.
     * @param routingType the routing type. ::NONE by default.
     * @param zoomLevel the zoom level.
     * @return an updated path containing a collection of computed segments.
     * @see Action
     */
    virtual std::shared_ptr<Model::Path::Path> handleViaPoint(uint64_t pathId,
                                                              uint64_t pathEditorId,
                                                              uint64_t segmentId,
                                                              Action action,
                                                              const Element::NodeCoordinates& viaPoint,
                                                              RoutingType routingType = RoutingType::NONE,
                                                              int zoomLevel = Utils::TileID::s_defaultZoomLevel) = 0;

    /**
     * Imports given coordinates as a new path given id and origin type.
     * @param pathId the id of the path.
     * @param coordinates the coordinates of an already existing path.
     * @param originType the origin type.
     * @param title the title of the path.
     * @param description the description of the path.
     * @param images the urls of the images of the path. can be nullptr.
     * @return a new path containing the given coordinates. can be nullptr.
     * @see Path::OriginType
     */
    virtual std::shared_ptr<Model::Path::Path> importCoordinates(uint64_t pathId,
                                                                 const Element::WayCoordinates& coordinates,
                                                                 Model::Path::Path::OriginType originType,
                                                                 std::unique_ptr<std::string>&& title,
                                                                 std::unique_ptr<std::string>&& description = nullptr,
                                                                 std::unique_ptr<std::vector<std::string>>&& images = nullptr) = 0;

    /**
     * Rolls back to the previous version of the path if it exists.
     * Otherwise does nothing and returns nullptr.
     * @param pathId the id of the path.
     * @return the previous version of the path given its id or nullptr if it did not exist.
     * @note specific to server. version management is handled on client side for offline mode.
     * @see updatePath
     */
    virtual std::shared_ptr<Model::Path::Path> updateToPreviousPath(uint64_t pathId) = 0;

    /**
     * Rolls back to the next version of the path if it exists.
     * Otherwise does nothing and returns nullptr.
     * @param pathId the id of the path.
     * @return the next version of the path given its id or nullptr if it did not exist.
     * @note specific to server. version management is handled on client side for offline mode.
     * @see updatePath
     */
    virtual std::shared_ptr<Model::Path::Path> updateToNextPath(uint64_t pathId) = 0;

    /**
     * Updates the existing path if any with the given path.
     * @param path the path to update.
     * @note specific to offline mode. version management is handled by #updateToPreviousPath
     *       and #updateToNextPath on server side.
     * @see ClientPathManager::updateToPreviousPath
     * @see ClientPathManager::updateToNextPath
     */
    virtual void updatePath(const Model::Path::Path& path) = 0;

    /**
     * Removes the path matching the given id if any.
     * @param pathId the id of the path to remove.
     * @return whether the removal operation has succeeded or not.
     */
    virtual bool removePath(uint64_t pathId) = 0;

    /**
     * Creates a PathManager instance.
     * @param rtree the rtree.
     * @param elementFactory the element factory.
     * @param riderManager the rider manager.
     * @param osrmConnectorFactory the osrm connector factory.
     * @param regionExplorer the region explorer.
     * @param srtmHandler the srtm handler.
     * @return an instance of PathManager.
     */
    static std::unique_ptr<PathManager> createInstance(const std::shared_ptr<Persistence::RTree> rtree,
                                                       const std::shared_ptr<Element::ElementFactory> elementFactory,
                                                       const std::shared_ptr<Rider::RiderManager> riderManager,
                                                       const std::shared_ptr<Connector::Osrm::OSRMConnectorFactory> osrmConnectorFactory,
                                                       const std::shared_ptr<Explore::RegionExplorer> regionExplorer,
                                                       const std::shared_ptr<SRTM::SRTMHandler> srtmHandler);
};

using PathManagerSP = std::shared_ptr<PathManager>;
using PathManagerUP = std::unique_ptr<PathManager>;

} // namespace Path
} // namespace FollowTheRider

#endif


text:
    <meta http-equiv="Content-Type" content="text/html; charset=Windows-1252" />
    <meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5" />
    <title>IndexReader.IsLocked Method (Directory)</title>
    <xml>
    </xml>
    <link rel="stylesheet" type="text/css" href="MSDN.css" />

            Apache Lucene.Net 2.4.0 Class Library API

IndexReader.IsLocked Method (Directory)

          NOTE: This method is now obsolete.

        Please use IndexWriter.IsLocked(Directory) instead.

 Returns
true
 iff the index in the named directory is currently locked.

public static bool IsLocked(
   Directory directory
);

Parameters

          directory

the directory to check for a lock

See Also

        IndexReader Class | Lucene.Net.Index Namespace | IndexReader.IsLocked Overload List

      <object type="application/x-oleobject" classid="clsid:1e2a7bd0-dab9-11d0-b93a-00c04fc99f9e" viewastext="true" style="display: none;">
        <param name="Keyword" value="IsLocked method">
        </param>
        <param name="Keyword" value="IsLocked method, IndexReader class">
        </param>
        <param name="Keyword" value="IndexReader.IsLocked method">
        </param>
      </object>

Generated from assembly Lucene.Net [2.4.0.2]


text:
set -o nounset
set -o errexit
set -o pipefail

if [[ -n "${BUILD_WORKSPACE_DIRECTORY:-}" ]]; then # Running inside bazel
  echo "Updating modules..." >&2
elif ! command -v bazel &>/dev/null; then
  echo "This script is preserved for legacy reasons and requires bazel. You shouldn't need to run this as part of your normal development workflow" >&2
  echo "If you need to run this script, install bazel from https://bazel.build" >&2
  exit 1
else
  (
    set -o xtrace
    bazel run //hack:update-deps -- "$@"
  )
  exit 0
fi

go=$(realpath "$1")
export PATH=$(dirname "$go"):$PATH
gazelle=$(realpath "$2")
kazel=$(realpath "$3")
update_bazel=(
  $(realpath "$4")
  "$gazelle"
  "$kazel"
)
update_deps_licenses=(
  $(realpath "$5")
  "$go"
)

shift 5

cd "$BUILD_WORKSPACE_DIRECTORY"
trap 'echo "FAILED" >&2' ERR

# Update hack/build/repos.bzl based of the go.mod file
"$gazelle" update-repos \
  --from_file=go.mod --to_macro=hack/build/repos.bzl%go_repositories \
  --build_file_generation=on --build_file_proto_mode=disable -prune=true

# `gazelle update-repos` adds extra unneeded entries to the
# go.sum file, run `go mod tidy` to remove them
"$go" mod tidy

# Update Bazel (changes in hack/build/repos.bzl might affect other bazel files)
"${update_bazel[@]}"

# Update LICENSES
"${update_deps_licenses[@]}"

echo "SUCCESS: updated modules"


text:
from __future__ import unicode_literals

from django.db import migrations, models
import django.db.models.deletion

class Migration(migrations.Migration):

    dependencies = [
        ('marketing', '0001_initial'),
    ]

    operations = [
        migrations.CreateModel(
            name='UploadedCell',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('cell_order', models.IntegerField()),
                ('content', models.TextField()),
            ],
        ),
        migrations.RemoveField(
            model_name='uploadedfile',
            name='filetype',
        ),
        migrations.RemoveField(
            model_name='uploadedfile',
            name='first_row',
        ),
        migrations.RemoveField(
            model_name='uploadedrow',
            name='row',
        ),
        migrations.AddField(
            model_name='uploadedfile',
            name='num_columns',
            field=models.IntegerField(default=4),
            preserve_default=False,
        ),
        migrations.AddField(
            model_name='uploadedrow',
            name='row_is_first',
            field=models.BooleanField(default=False),
        ),
        migrations.AddField(
            model_name='uploadedrow',
            name='row_number',
            field=models.IntegerField(default=0),
            preserve_default=False,
        ),
        migrations.AddField(
            model_name='uploadedcell',
            name='parent_row',
            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='marketing.UploadedRow'),
        ),
    ]


text:
// <license>
// The MIT License (MIT)
// </license>
// <copyright company="TTRider Technologies, Inc.">
// Copyright (c) 2014-2015 All Rights Reserved
// </copyright>

namespace TTRider.FluidSql
{
    public class DropSchemaStatement : IStatement
    {
        public Name Name { get; set; }
        public bool CheckExists { get; set; }

        //for postgresqls
        public bool? IsCascade { get; set; }
    }
}


text:
package com.simple.utils;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import javax.servlet.http.HttpServletRequest;

/**
 *
 * @author chenxi
 */
public class GHttpUtils {
    /**
     * Get user real ip.
     * @param request
     * @return
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip != null) {
            if (ip.indexOf(',') == -1) {
                return ip;
            }
            return ip.split(",")[0];
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }

    /**
     * Get mac address by ip.
     * @param ip
     * @return
     */
    public String getMACAddress(String ip) {
        String str = "";
        String macAddress = "";
        try {
            Process p = Runtime.getRuntime().exec("netstat -A " + ip);
            InputStreamReader ir = new InputStreamReader(p.getInputStream());
            LineNumberReader input = new LineNumberReader(ir);
            for (int i = 1; i < 100; i++) {
                str = input.readLine();
                if (str != null) {
                    if (str.indexOf("MAC Address") > 1) {
                        macAddress = str.substring(
                                str.indexOf("MAC Address") + 14, str.length());
                        break;
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace(System.out);
        }
        return macAddress;
    }
}


text:
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">

  <title>FAQ - ODGG</title>
  <meta name="description" content="Benvenuti nel portale ufficiale per gli OpenData del Comune di Gioia del Colle">

  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">

    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootswatch/3.3.6/cosmo/bootstrap.min.css">

  <link rel="alternate" type="application/rss+xml" title="OpenDataGentediGioia" href="/feed.xml">

  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/select2/4.0.2/css/select2.min.css">
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/notie/3.0.0/notie.min.css">
  <link rel="stylesheet" href="/opendatagentedigioia/css/main.css">
  <link rel="canonical" href="http://gioialab.github.io/opendatagentedigioia//opendatagentedigioia/faq/">

    <meta property="og:title" content="FAQ" />
<meta property="og:site_name" content="ODGG" />

<meta property="og:description" content="Benvenuti nel portale ufficiale per gli OpenData del Comune di Gioia del Colle" />
<meta name="og:image" content="/opendatagentedigioia/img/jkan.png" />
<meta name="og:image:width" content="150" />
<meta name="og:image:height" content="150" />

    <meta name="twitter:card" content="summary" />
<meta name="twitter:site" content="@" />

<meta name="twitter:title" content="FAQ - ODGG" />

<meta name="twitter:description" content="Benvenuti nel portale ufficiale per gli OpenData del Comune di Gioia del Colle" />
<meta name="twitter:image" content="/opendatagentedigioia/img/jkan.png" />

      <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
        Toggle navigation

      </button>
      ODGG

Datasets

Organizzazioni

FAQ (current)

API

Login

            User

Administration

Logout

F.A.Q.

Riferimenti normativi

D.Lgs. n.33/2013

Legge 7 agosto 2015, n. 124

Bozza Regolamento Accesso Civico del Comune di Gioia del Colle

Bozza Regolamento Team Open Data del Comune di Gioia del Colle

TITOLARITÀ, AMBITO DI APPLICAZIONE E OGGETTO DEL DIRITTO DI ACCESSO GENERALIZZATO

 Chi può presentare richiesta di accesso generalizzato ai sensi dell'art. 5, comma 2 del d. lgs. n. 33/2013?

L'accesso generalizzato può essere presentato da chiunque. Infatti, non occorre possedere, né dimostrare, una specifica legittimazione soggettiva, e chiunque può presentare richiesta, anche indipendentemente dall'essere cittadino italiano o residente nel territorio dello Stato.

 Qual è l'ambito soggettivo di applicazione del diritto di accesso generalizzato?

Il diritto di accesso generalizzato si applica:

 1) a tutte le amministrazioni pubbliche,come esemplificate all'articolo 1,comma 2, del decreto legislativo 30 marzo 2001, n. 165 e successive modificazioni, ivi comprese le autorità portuali, nonché le autorità amministrative indipendenti di garanzia, vigilanza e regolazione

 2) agli enti pubblici economici e ordini professionali;

 3) alle società incontrollo pubblico come definite dal decreto legislativo emanato in attuazione  dell'art.18 della legge 7 agosto 2015, n. 124  (d.lgs. 175/2016 c.d. Testo unico in materia di società a partecipazione pubblica);

 4) alle associazioni,fondazioni e enti di diritto privato comunque denominati, anche privi di personalità giuridica, con bilancio superiore a cinquecentomila euro, la cui attività sia finanziata in modo maggioritario per almeno due esercizi finanziari consecutivi nell'ultimo triennio da pubbliche amministrazioni e in cui la totalità dei titolari o dei componenti dell'organo d'amministrazione o di indirizzo sia designata da pubbliche amministrazioni;

Il diritto di accesso generalizzato si applica, limitatamente ai dati e ai documenti inerenti all'attività di pubblico interesse disciplinata dal diritto nazionale o dell'Unione europea, anche:

 1) alle società in sola partecipazione pubblica come definite dal  decreto legislativo emanato in attuazione  dell'art.18 della legge 7 agosto 2015, n. 124  (d.lgs. 175/2016 c.d. Testo unico in materia di società a partecipazione pubblica);

 2) alle associazioni, alle fondazioni e agli enti di diritto privato, anche privi di personalita ̀giuridica,con bilancio superiore a 500.000 (cinquecentomila) euro, che esercitano funzioni amministrative, attività di produzione di beni e servizi a favore delle amministrazioni pubbliche o di gestione di servizi pubblici.

 È necessario motivare la richiesta di accesso generalizzato?

Per presentare la richiesta di accesso generalizzato non è necessario fornire una motivazione: tutti i soggetti cui si applica il diritto di accesso generalizzato sono tenuti a prendere in considerazione le richieste di accesso generalizzato, a prescindere dal fatto che queste rechino o meno una motivazione o una giustificazione a sostegno della richiesta.

Che cosa si può richiedere con l'accesso generalizzato?

 Con la richiesta di accesso generalizzato possono essere richiesti i documenti, dati e informazioni in possesso dell'amministrazione.

	Ciò significa:

che l'amministrazione non è tenuta a raccogliere informazioni che non sono in suo possesso per rispondere ad una richiesta di accesso generalizzato, ma deve limitarsi a rispondere sulla base dei documenti e delle informazioni che sono già in suo possesso che l'amministrazione non è tenuta a rielaborare informazioni in suo possesso, per rispondere ad una richiesta di accesso generalizzato: deve consentire l'accesso ai documenti, ai dati ed alle informazioni così come sono già detenuti, organizzati, gestiti e fruiti.

che sono ammissibili, invece, le operazioni di elaborazione che consistono nell'oscuramento dei dati personali presenti nel documento o nell'informazione richiesta, e più in generale nella loro anonimizzazione, qualora ciò sia funzionale a rendere possibile l'accesso.

La richiesta di accesso generalizzato deve identificare i documenti e i dati richiesti. Ciò significa:

che la richiesta indica i documenti o i dati richiesti, ovvero

che la richiesta consente all'amministrazione di identificare agevolmente i documenti o i dati richiesti.

Devono essere ritenute inammissibili le richieste formulate in modo così vago da non permettere all'amministrazione di identificare i documenti o le informazioni richieste.In questi casi, l'amministrazione destinataria della domanda dovrebbe chiedere di precisare l'oggetto della richiesta.

Richieste massive

L'amministrazione è tenuta a consentire l'accesso generalizzato anche quando riguarda un numero cospicuo di documenti ed informazioni, a meno che la richiesta risulti manifestamente irragionevole, tale cioè da comportare un carico di lavoro in grado di interferire con il buon funzionamento dell'amministrazione. Tali circostanze, adeguatamente motivate nel provvedimento di rifiuto, devono essere individuate secondo un criterio di stretta interpretazione, ed in presenza di oggettive condizioni suscettibili di pregiudicare in modo serio ed immediato il buon funzionamento dell'amministrazione.

IL PROCEDIMENTO DI ACCESSO GENERALIZZATO

A quale ufficio va presentata la richiesta di accesso generalizzato?

		La richiesta di accesso generalizzato può essere presentata, alternativamente:

 1) all'ufficio che detiene i dati, le informazioni o i documenti;

 2) all'Ufficio relazioni con il pubblico;

 3) ad altro ufficio, che l'amministrazione abbia indicato nella sezione "Amministrazione trasparente" – "Altri contenuti –Accesso civico" del sito istituzionale.

Come si fa a presentare l'istanza di accesso generalizzato?

	Ai sensi del comma 3 dell'art. 5 del d. lgs. n. 33/2013, l'istanza può essere trasmessa per via telematica secondo le modalità previste dal decreto legislativo 7 marzo 2005, n. 82 recante il «Codice dell'amministrazione digitale» (CAD). Tra queste modalità, l'amministrazione o l'ente è opportuno privilegi quella meno onerosa per chi presenta l'istanza.

	Ai sensi dell'art. 65, co. 1 lett. c) del CAD, le richieste presentate per via telematica alle pubbliche amministrazioni e ai gestori dei servizi pubblici sono valide anche se sottoscritte e presentate unitamente alla copia del documento d'identità.

	Resta fermo che l'istanza può essere presentata anche a mezzo posta, fax o direttamente presso gli uffici indicati dall'art. 5, comma 3, del d. lgs. n. 33/2013, e che laddove la richiesta di accesso generalizzato non sia sottoscritta dall'interessato in presenza del dipendente addetto, la stessa debba essere sottoscritta e presentata unitamente a copia fotostatica non autenticata di un documento di identità del sottoscrittore, che va inserita nel fascicolo (cfr. art. 38, commi 1 e 3, del d.P.R. 28 dicembre 2000, n. 445).

Bisogna pagare per poter effettuare l'accesso generalizzato?

	Il rilascio di dati o documenti in formato elettronico, in risposta alla richiesta di accesso generalizzato, è gratuito. Quando l'amministrazione risponde alla richiesta di accesso generalizzato mediante il rilascio di documenti ed informazioni in formato cartaceo, può richiedere il rimborso dei soli costi effettivamente sostenuti e documentati per la riproduzione su supporti materiali.

	È da preferire il rilascio dei documenti e dei dati in formato elettronico quando il rilascio dei documenti o dei dati in formato elettronico è indicato dal richiedente, nei limiti in cui tale modalità risulti comunque agevole per l'amministrazione che detiene di dati.

L'amministrazione o l'ente destinatario dell'istanza è obbligato a darne comunicazione a eventuali soggetti controinteressati?

	Laddove la richiesta di accesso generalizzato possa incidere su interessi connessi alla protezione dei dati personali, o alla libertà e segretezza della corrispondenza oppure agli interessi economici e commerciali (ivi compresi la proprietà intellettuale, il diritto d'autore e i segreti commerciali), l'ente destinatario della richiesta di accesso deve darne comunicazione ai soggetti titolari di tali interessi, mediante invio di copia con raccomandata con avviso di ricevimento (o per via telematica per coloro che abbiano consentito tale forma di comunicazione).

	Il soggetto controinteressato può presentare (anche per via telematica) una eventuale e motivata opposizione all'istanza di accesso generalizzato, entro dieci giorni dalla ricezione della comunicazione della richiesta di accesso generalizzato. Decorso tale termine, l'amministrazione provvede sulla richiesta di accesso generalizzato, accertata la ricezione della comunicazione da parte del controinteressato.

Quanto tempo ha l'amministrazione per rispondere alle richieste di accesso generalizzato?

	Il procedimento di accesso generalizzato deve concludersi con provvedimento espresso e motivato nel termine di trenta giorni dalla presentazione dell'istanza, con la comunicazione dell'esito al richiedente e agli eventuali controinteressati. Tali termini sono sospesi (fino ad un massimo di dieci giorni) nel caso di comunicazione della richiesta al controinteressato.

I diritti procedimentali dei controinteressati

	Quando la richiesta di accesso generalizzato riguarda documenti o dati la cui divulgazione può comportare un pregiudizio ad uno degli interessi individuati dall'art. 5-bis, comma 2, se l'amministrazione individua dei privati controinteressati comunica loro la richiesta. Entro dieci giorni, i controinteressati possono presentare una motivata opposizione alla richiesta di accesso.

Accoglimento della richiesta di accesso generalizzato

	In caso di accoglimento, l'amministrazione provvede a trasmettere tempestivamente al richiedente i dati o i documenti richiesti.

	Nel caso in cui l'accesso sia consentito nonostante l'opposizione del controinteressato, i dati o i documenti richiesti possono essere trasmessi al richiedente non prima di quindici giorni dalla ricezione della stessa comunicazione da parte del controinteressato.

La motivazione del provvedimento

	Il provvedimento di rifiuto adottato in applicazione dei limiti di cui all'art. 5 bis, commi 1 e 2 contiene una adeguata motivazione che dà conto della sussistenza degli elementi che integrano l'esistenza del pregiudizio concreto. Va parimenti motivato adeguatamente il provvedimento di rifiuto adottato in applicazione delle esclusioni di cui all'art. 5-bis, co. 3.

	Anche il provvedimento di accoglimento contiene una adeguata motivazione che dà conto della insussistenza di uno o più elementi che integrano l'esistenza del pregiudizio concreto, specie quando è adottato nonostante l'opposizione del controinteressato.

LA TUTELA

Come può tutelarsi il richiedente in caso di rifiuto o di mancata risposta da parte dell'amministrazione?

	In caso di diniego totale o parziale dell'accesso o di mancata risposta entro il termine indicato dal comma 6 del d. lgs. n. 33/2013, il richiedente può presentare richiesta di riesame al responsabile della prevenzione della corruzione e della trasparenza, che decide con provvedimento motivato, entro il termine di venti giorni.

	In alternativa, laddove si tratti di atti delle amministrazioni delle regioni o degli enti locali, il richiedente può presentare ricorso al difensore civico competente per ambito territoriale (qualora tale organo non sia stato istituito, la competenza è attribuita al difensore civico competente, per l'ambito territoriale immediatamente superiore, se presente). In tal caso, il ricorso deve comunque essere notificato anche all'amministrazione interessata. È previsto che il difensore civico si pronunci entro trenta giorni dalla presentazione del ricorso e che se il difensore civico ritiene illegittimo il diniego o il differimento, ne debba informare il richiedente e comunicarlo all'amministrazione competente. Se questa non conferma il diniego o il differimento entro trenta giorni dal ricevimento della comunicazione del difensore civico, l'accesso è consentito.

	In ogni caso, a fronte del rifiuto espresso, del differimento o dell'inerzia dell'amministrazione, il richiedente può attivare la tutela giurisdizionale davanti al giudice amministrativo, ai sensi dell'articolo 116 del Codice del processo amministrativo.

L'ente destinatario della richiesta di accesso generalizzato può chiedere un parere al Garante per la protezione dei dati personali?

	È previsto che il Garante per la protezione dei dati personali sia sentito solo dal responsabile della prevenzione della corruzione nel caso di richiesta di riesame e dal difensore civico nel caso di ricorso laddove l'accesso generalizzato sia stato negato o differito per motivi attinenti la tutela della «protezione dei dati personali, in conformità con la disciplina legislativa in materia» (art. 5-bis, comma 2, lett. a, d. lgs. n. 33/2013). In tali ipotesi, il Garante si pronuncia entro il termine di dieci giorni dalla richiesta, durante i quali il termine per l'adozione del provvedimento da parte del responsabile della prevenzione della corruzione o per la pronuncia del difensore civico sono sospesi.

Quali sono i rimedi previsti per i controinteressati nel caso di accoglimento dell'istanza da parte dell'amministrazione o dell'ente, nonostante l'opposizione presentata?

	Ai sensi del co. 9 dell'art. 5 del d.lgs. 33/2013, nei casi di accoglimento della richiesta, il controinteressato può presentare richiesta di riesame al Responsabile per la prevenzione della corruzione e della trasparenza (RPCT) e, per i soli atti di Regioni ed enti locali, ricorso al difensore civico. Avverso la decisione dell'ente o dell'amministrazione ovvero a quella del RPCT dell'amministrazione o dell'ente o a quella del difensore civico, il controinteressato può proporre ricorso al TAR ai sensi dell'art. 116 del d.lgs. 104/2010 sul codice del processo amministrativo.

Entro quali termini si pronuncia il RPCT sulla richiesta di riesame?

	Il RPCT decide con provvedimento motivato, entro il termine di venti giorni dall'istanza di riesame. Il termine è sospeso qualora il RPCT senta il Garante per la protezione dei dati personali se l'accesso è stato negato o differito a tutela degli interessi di cui all'art. 5 bis co. 2 lett. a) (relativi alla protezione dei dati personali). Il Garante si pronuncia entro 10 giorni dalla richiesta.

	Gli stessi termini valgono nel caso la richiesta di riesame sia avanzata dal controinteressato in caso di accoglimento dell'istanza nonostante la sua opposizione.

Quale è il procedimento da seguire davanti al difensore civico?

	Laddove si tratti di atti delle amministrazioni delle regioni o degli enti locali, il richiedente o il controinteressato può presentare ricorso al difensore civico competente per ambito territoriale (qualora tale organo non sia stato istituito, la competenza è attribuita al difensore civico competente per l'ambito territoriale immediatamente superiore). In tal caso, il ricorso deve comunque essere notificato anche all'amministrazione interessata. La norma (art. 5 co 8) prevede che il difensore civico si pronunci entro trenta giorni dalla presentazione del ricorso. Il termine è sospeso qualora il difensore civico senta il Garante per la protezione dei dati personali se l'accesso è stato negato o differito a tutela degli interessi di cui all'art. 5 bis co. 2 lett. a) (relativi alla protezione dei dati personali). Il Garante si pronuncia entro 10 giorni dalla richiesta.

	Se il difensore civico ritiene illegittimo il diniego o il differimento, deve informarne il richiedente e darne comunicazione all'amministrazione competente. Se questa non conferma il diniego o il differimento entro trenta giorni dal ricevimento della comunicazione del difensore civico, l'accesso è consentito.

È possibile in ogni caso ricorrere al giudice?

	La normativa prevede che si può impugnare la decisione dell'amministrazione competente o, in caso di richiesta di riesame, la decisione del responsabile della prevenzione della corruzione e della trasparenza, di fronte al Tribunale amministrativo regionale ai sensi dell'articolo 116 del Codice del processo amministrativo di cui al decreto legislativo 2 luglio 2010, n. 104.

Quest'opera è distribuita con Licenza Creative Commons Attribuzione 4.0 Internazionale.

	Follow @comunegioialive

	Follow @gzileni


text:
/* $Id$ */

package org.apache.fop.pdf;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

/**
 * Test case for {@link PDFReference}.
 */
public class PDFReferenceTestCase {

    /**
     * Tests outputInline() - ensure that this object is properly formatted when printed to the
     * output stream.
     * @throws IOException if an I/O error occurs
     */
    @Test
    public void testOutputInline() throws IOException {
        PDFName name = new PDFName("Test name");
        name.setObjectNumber(2);
        PDFReference pdfRef = new PDFReference(name);

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        StringBuilder textBuffer = new StringBuilder();
        // Ensure that text before outputInline() is kept
        textBuffer.append("Text ");

        pdfRef.outputInline(out, textBuffer);
        assertEquals("Text 2 0 R", textBuffer.toString());
    }

    /**
     * Tests toString() - since this is used quite a lot, we have to ensure the format is correct.
     */
    @Test
    public void testToString() {
        PDFName name = new PDFName("arbitrary");
        name.setObjectNumber(10);
        PDFReference ref = new PDFReference(name);
        assertEquals("10 0 R", ref.toString());
    }
}


text:
document.addEventListener("turbolinks:load", function() {
  $(".codemirror").each(function(){
    var myCodeMirror = CodeMirror.fromTextArea(this)
  })
});


text:
Player::Player(Camera* camera, ResourcesManager* rm, StateController* stateController) : GameObject(rm, GO_TYPE_PLAYER) {
    this->camera = camera;

    this->firstMouse = true;
    this->lastMouseX = 0.0f;
    this->lastMouseY = 0.0f;
    this->pitch = 0;
    this->yaw = 0;
    this->pitchLimit = 70.0f;

    this->headBobbingDirection = 0;
    this->headBobbing = 0.0f;

    this->velocity = 0.0f;
    this->isFirstFrame = true;

    this->mouseSens = 0.5f;
    tJson confiData = rm->getConfigData();

    this->position = vec3(0.0f);
    camera->setPosition(this->position);

    this->stateController = stateController;
}

void Player::setPosition(vec3 position) {
    this->position = position;
    camera->setPosition(this->position);
}

bool Player::isGrounded() {
    glm::vec3 groundPos = glm::vec3(this->position.x, this->position.y, this->position.z);
    groundPos.x = round(groundPos.x);
    groundPos.y -= 1.0f;
    groundPos.z = round(groundPos.z);

    float groundDiff = abs( groundPos.y - floor( groundPos.y ) );
    if(groundDiff > .1f) return false;

    groundPos.y = round( groundPos.y );

    return this->stateController->hasGroundAtPosition(groundPos);
}

void Player::applyPhysics(float deltaTime) {
    bool isGrounded = this->isGrounded();
    if(!isGrounded) {
        this->velocity -= 9.8f * deltaTime;
    }

    this->position.y += this->velocity * deltaTime;
    if(isGrounded) {
        this->velocity = 0.0f;
        this->position.y = floor( this->position.y );
    }
}

void Player::moveTo(glm::vec3 position) {
    glm::vec3 nextPos = glm::vec3( position );

    nextPos.x = round(nextPos.x);
    nextPos.y = round(nextPos.y);
    nextPos.z = round(nextPos.z);

    bool hasGround = false;
    hasGround = this->stateController->hasGroundAtPosition(nextPos);
    if(!hasGround) {
        this->position = position;
    }

    nextPos.x = round(nextPos.x);
    nextPos.y = round(nextPos.y);
    nextPos.z = round(this->position.z);

    hasGround = this->stateController->hasGroundAtPosition(nextPos);
    if(!hasGround) {
        glm::vec3 zPosition = glm::vec3( position );
        zPosition.z = this->position.z;
        this->position = zPosition;
    }

    nextPos.x = round(this->position.x);
    nextPos.y = round(nextPos.y);
    nextPos.z = round(nextPos.z);

    hasGround = this->stateController->hasGroundAtPosition(nextPos);
    if(!hasGround) {
        glm::vec3 xPosition = glm::vec3( position );
        xPosition.x = this->position.x;
        this->position = xPosition;
    }
}

void Player::update(GLFWwindow* window, float deltaTime) {
    if(this->isFirstFrame) {
        deltaTime = 0.0f;
        this->isFirstFrame = false;
    }
    // Get the cursor position
    double mouseX, mouseY;
    glfwGetCursorPos(window, &mouseX, &mouseY);

    if(this->firstMouse) {
        this->lastMouseY = mouseY;
        this->lastMouseX = mouseX;
        this->firstMouse = false;
    }

    // Compute the mouse position
    float mouseOffsetX = (mouseX - this->lastMouseX) * mouseSens;
    float mouseOffsetY = (this->lastMouseY - mouseY) * mouseSens;
    this->lastMouseY = mouseY;
    this->lastMouseX = mouseX;

    this->pitch += mouseOffsetY;
    this->yaw += mouseOffsetX;
    if(this->pitch > this->pitchLimit) this->pitch =  this->pitchLimit;
    if(this->pitch < -this->pitchLimit) this->pitch = -this->pitchLimit;

    vec3 playerFrontMovement = normalize( vec3(cos(radians(this->yaw)), 0, sin(radians(this->yaw))) );

    float playerSpeed = 10.0f * deltaTime;
    vec3 nextPosition = vec3(this->position);
    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
        nextPosition += playerSpeed * playerFrontMovement;
    } else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
        nextPosition -= playerSpeed * playerFrontMovement;
    }

    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
        nextPosition -= normalize(cross(playerFrontMovement, camera->getUp())) * playerSpeed;
    } else if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
        nextPosition += normalize(cross(playerFrontMovement, camera->getUp())) * playerSpeed;
    }

    bool isGrounded = this->isGrounded();
    if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS && isGrounded) {
        nextPosition.y += .2f;
        this->velocity = 5.0f;
    }
    this->moveTo(nextPosition);
    this->applyPhysics(deltaTime);

    vec3 lookingDirection = vec3(
        cos(radians(this->pitch)) * cos(radians(this->yaw)),
        sin(radians(this->pitch)),
        cos(radians(this->pitch)) * sin(radians(this->yaw))
    );
    camera->setFront( normalize(lookingDirection) );

    vec3 cameraPos = vec3( this->position );

    if( isGrounded && (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS || glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS || glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS || glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) ) {
        if(this->headBobbingDirection == 1) {
            this->headBobbing += 1.0f * deltaTime;
            if(this->headBobbing > 0.1f) this->headBobbingDirection = 0;
        } else {
            this->headBobbing -= 1.0f * deltaTime;
            if(this->headBobbing < -0.1f) this->headBobbingDirection = 1;
        }
    } else {
        this->headBobbing = 0.0f;
    }
    cameraPos.y += 1.0f + this->headBobbing;
    camera->setPosition( cameraPos );
}