text:
package org.apache.qpid.proton.engine.impl;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import org.junit.Test;
import org.mockito.Mockito;

public class EndpointImplTest
{
    @Test
    public void testRepeatOpenDoesNotModifyEndpoint()
    {
        ConnectionImpl mockConnection = Mockito.mock(ConnectionImpl.class);
        MockEndpointImpl endpoint = new MockEndpointImpl(mockConnection);

        // Check starting state
        assertFalse("Should not be modified", endpoint.isModified());
        assertEquals("Unexpected localOpen call count", 0, endpoint.getLocalOpenCallCount());
        Mockito.verify(mockConnection, Mockito.times(0)).addModified(Mockito.any(EndpointImpl.class));

        endpoint.open();

        // Check endpoint was modified
        assertTrue("Should be modified", endpoint.isModified());
        assertEquals("Unexpected localOpen call count", 1, endpoint.getLocalOpenCallCount());
        Mockito.verify(mockConnection, Mockito.times(1)).addModified(Mockito.any(EndpointImpl.class));

        // Clear the modified state, open again, verify no change
        endpoint.clearModified();
        assertFalse("Should no longer be modified", endpoint.isModified());

        endpoint.open();

        assertFalse("Should not be modified", endpoint.isModified());
        assertEquals("Unexpected localOpen call count", 1, endpoint.getLocalOpenCallCount());
        Mockito.verify(mockConnection, Mockito.times(1)).addModified(Mockito.any(EndpointImpl.class));
    }

    @Test
    public void testRepeatCloseDoesNotModifyEndpoint()
    {
        ConnectionImpl mockConnection = Mockito.mock(ConnectionImpl.class);
        MockEndpointImpl endpoint = new MockEndpointImpl(mockConnection);

        // Open endpoint, clear the modified state, verify current state
        endpoint.open();
        endpoint.clearModified();
        assertFalse("Should no longer be modified", endpoint.isModified());
        assertEquals("Unexpected localClose call count", 0, endpoint.getLocalCloseCallCount());
        Mockito.verify(mockConnection, Mockito.times(1)).addModified(Mockito.any(EndpointImpl.class));

        // Now close, verify changes
        endpoint.close();

        // Check endpoint was modified
        assertTrue("Should be modified", endpoint.isModified());
        assertEquals("Unexpected localClose call count", 1, endpoint.getLocalCloseCallCount());
        Mockito.verify(mockConnection, Mockito.times(2)).addModified(Mockito.any(EndpointImpl.class));

        // Clear the modified state, close again, verify no change
        endpoint.clearModified();
        assertFalse("Should no longer be modified", endpoint.isModified());

        endpoint.close();

        assertFalse("Should not be modified", endpoint.isModified());
        assertEquals("Unexpected localClose call count", 1, endpoint.getLocalCloseCallCount());
        Mockito.verify(mockConnection, Mockito.times(2)).addModified(Mockito.any(EndpointImpl.class));
    }

    private class MockEndpointImpl extends EndpointImpl
    {
        private int localOpenCallCount;
        private int localCloseCallCount;
        private ConnectionImpl connectionImpl;
        public MockEndpointImpl(ConnectionImpl connectionImpl)
        {
            this.connectionImpl = connectionImpl;
        }

        @Override
        void localOpen()
        {
            localOpenCallCount++;
        }

        @Override
        void localClose()
        {
            localCloseCallCount++;
        }

        @Override
        protected ConnectionImpl getConnectionImpl()
        {
            return connectionImpl;
        }

        @Override
        void doFree() { }

        @Override
        void postFinal() { }

        public int getLocalOpenCallCount()
        {
            return localOpenCallCount;
        }

        public int getLocalCloseCallCount()
        {
            return localCloseCallCount;
        }
    }
}


text:
"use strict";

/**
 * @param {opentoken~genericFormatter} genericFormatter
 * @return {Function}
 */
module.exports = (genericFormatter) => {
    return genericFormatter.formatWithFallback((req, res, body) => {
        var content;

        if (Buffer.isBuffer(body)) {
            content = body.toString("base64");
        } else if (body) {
            content = JSON.stringify(body);
        } else {
            content = "null";
        }

        return Buffer.from(`${content}\n`, "binary");
    });
};

redpajama_set_name: RedPajamaGithub


text:
package it.reply.orchestrator.resource;

import it.reply.orchestrator.controller.DeploymentController;
import it.reply.orchestrator.controller.ResourceController;
import it.reply.orchestrator.controller.TemplateController;
import it.reply.orchestrator.dal.entity.Deployment;
import it.reply.orchestrator.dal.entity.OidcEntity;
import it.reply.orchestrator.dto.CloudProviderEndpoint;
import it.reply.orchestrator.utils.CommonUtils;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Optional;

import org.springframework.hateoas.core.DummyInvocationUtils;
import org.springframework.hateoas.mvc.ControllerLinkBuilder;
import org.springframework.hateoas.mvc.ResourceAssemblerSupport;
import org.springframework.stereotype.Component;

@Component
public class DeploymentResourceAssembler
    extends ResourceAssemblerSupport<Deployment, DeploymentResource> {

  public DeploymentResourceAssembler() {
    super(DeploymentController.class, DeploymentResource.class);
  }

  @Override
  public DeploymentResource toResource(Deployment entity) {
    return getDeploymentResource(entity, false);
  }

  @SuppressWarnings("rawtypes")
  private CloudProviderEndpointResource
      getCloudProviderEndpointResource(CloudProviderEndpoint endpoint) {
    if (endpoint != null) {
      Map<String, CloudProviderEndpointResource> hybridCloudProviderEndpointsResource =
          new HashMap<>();
      Iterator it = endpoint.getHybridCloudProviderEndpoints().entrySet().iterator();
      while (it.hasNext()) {
        Map.Entry pair = (Map.Entry)it.next();
        hybridCloudProviderEndpointsResource.put((String)pair.getKey(),
            getCloudProviderEndpointResource((CloudProviderEndpoint)pair.getValue()));
      }
      return new CloudProviderEndpointResource(endpoint.getCpEndpoint(),
          endpoint.getCpComputeServiceId(),
          endpoint.getVaultEndpoint(),
          endpoint.getIaasType(),
          hybridCloudProviderEndpointsResource);
    } else {
      return null;
    }
  }

  protected DeploymentResource getDeploymentResource(Deployment entity, boolean nested) {

    DeploymentResource resource = DeploymentResource.builder()
        .uuid(entity.getId())
        .creationTime(entity.getCreatedAt())
        .updateTime(entity.getUpdatedAt())
        .physicalId(entity.getEndpoint())
        .status(entity.getStatus())
        .statusReason(entity.getStatusReason())
        .cloudProviderName(entity.getCloudProviderName())
        .cloudProviderEndpoint(getCloudProviderEndpointResource(entity.getCloudProviderEndpoint()))
        .task(entity.getTask())
        .outputs(entity.getOutputs())
        .callback(entity.getCallback())
        .userGroup(entity.getUserGroup())
        .build();

    Optional.ofNullable(entity.getOwner())
        .map(OidcEntity::getOidcEntityId)
        .ifPresent(resource::setCreatedBy);

    // add hateoas links only if we are inside of a HTTP request otherwise, due to
    // https://github.com/spring-projects/spring-hateoas/issues/408, we'd have an error
    if (CommonUtils.isInHttpRequest() && !nested) {
      resource.add(ControllerLinkBuilder.linkTo(
          DummyInvocationUtils.methodOn(DeploymentController.class).getDeployment(entity.getId()))
          .withSelfRel());
      resource.add(ControllerLinkBuilder
          .linkTo(DummyInvocationUtils.methodOn(ResourceController.class, entity.getId())
              .getResources(entity.getId(), null, null))
          .withRel("resources"));
      resource.add(ControllerLinkBuilder
          .linkTo(DummyInvocationUtils.methodOn(TemplateController.class)
              .getDeploymentTemplate(entity.getId()))
          .withRel("template"));
    }

    return resource;
  }

}


text:
package org.apache.flink.runtime.resourcemanager.slotmanager;

import org.apache.flink.runtime.clusterframework.types.ResourceProfile;
import org.apache.flink.util.Preconditions;

/** Represents a pending task manager in the {@link SlotManager}. */
public class PendingTaskManager {
    private final PendingTaskManagerId pendingTaskManagerId;
    private final ResourceProfile totalResourceProfile;
    private final ResourceProfile defaultSlotResourceProfile;

    public PendingTaskManager(
            PendingTaskManagerId pendingTaskManagerId,
            ResourceProfile totalResourceProfile,
            ResourceProfile defaultSlotResourceProfile) {
        this.defaultSlotResourceProfile = Preconditions.checkNotNull(defaultSlotResourceProfile);
        this.totalResourceProfile = Preconditions.checkNotNull(totalResourceProfile);
        this.pendingTaskManagerId = Preconditions.checkNotNull(pendingTaskManagerId);
    }

    public ResourceProfile getTotalResourceProfile() {
        return totalResourceProfile;
    }

    public ResourceProfile getDefaultSlotResourceProfile() {
        return defaultSlotResourceProfile;
    }

    public PendingTaskManagerId getPendingTaskManagerId() {
        return pendingTaskManagerId;
    }

    @Override
    public String toString() {
        return String.format(
                "PendingTaskManager{id=%s, totalResourceProfile=%s, defaultSlotResourceProfile=%s}",
                pendingTaskManagerId, totalResourceProfile, defaultSlotResourceProfile);
    }
}


text:
namespace {

class TestClass : public testing::Test {
 protected:
};

void OSDTester(int expected_deg, const char* imgname, const char* tessdatadir) {
  // log.info() << tessdatadir << " for image: " << imgname << std::endl;
  std::unique_ptr<tesseract::TessBaseAPI> api(new tesseract::TessBaseAPI());
  ASSERT_FALSE(api->Init(tessdatadir, "osd"))
      << "Could not initialize tesseract.";
  Pix* image = pixRead(imgname);
  ASSERT_TRUE(image != nullptr) << "Failed to read test image.";
  api->SetImage(image);
  int orient_deg;
  float orient_conf;
  const char* script_name;
  float script_conf;
  bool detected = api->DetectOrientationScript(&orient_deg, &orient_conf,
                                               &script_name, &script_conf);
  ASSERT_FALSE(!detected) << "Failed to detect OSD.";
  printf(
      "************ Orientation in degrees: %d, Orientation confidence: %.2f\n"
      "             Script: %s, Script confidence: %.2f\n",
      orient_deg, orient_conf, script_name, script_conf);
  EXPECT_EQ(expected_deg, orient_deg);
  api->End();
  pixDestroy(&image);
}

class OSDTest : public TestClass,
                public ::testing::WithParamInterface<
                    std::tuple<int, const char*, const char*>> {};

TEST_P(OSDTest, MatchOrientationDegrees) {
  OSDTester(std::get<0>(GetParam()), std::get<1>(GetParam()),
            std::get<2>(GetParam()));
}

INSTANTIATE_TEST_CASE_P(
    TessdataEngEuroHebrew, OSDTest,
    ::testing::Combine(::testing::Values(0),
                       ::testing::Values(TESTING_DIR "/phototest.tif",
                                         TESTING_DIR "/eurotext.tif",
                                         TESTING_DIR "/hebrew.png"),
                       ::testing::Values(TESSDATA_DIR)));

INSTANTIATE_TEST_CASE_P(
    TessdataBestEngEuroHebrew, OSDTest,
    ::testing::Combine(::testing::Values(0),
                       ::testing::Values(TESTING_DIR "/phototest.tif",
                                         TESTING_DIR "/eurotext.tif",
                                         TESTING_DIR "/hebrew.png"),
                       ::testing::Values(TESSDATA_DIR "_best")));

INSTANTIATE_TEST_CASE_P(
    TessdataFastEngEuroHebrew, OSDTest,
    ::testing::Combine(::testing::Values(0),
                       ::testing::Values(TESTING_DIR "/phototest.tif",
                                         TESTING_DIR "/eurotext.tif",
                                         TESTING_DIR "/hebrew.png"),
                       ::testing::Values(TESSDATA_DIR "_fast")));

INSTANTIATE_TEST_CASE_P(
    TessdataFastRotated90, OSDTest,
    ::testing::Combine(::testing::Values(90),
                       ::testing::Values(TESTING_DIR
                                         "/phototest-rotated-R.png"),
                       ::testing::Values(TESSDATA_DIR "_fast")));

INSTANTIATE_TEST_CASE_P(
    TessdataFastRotated180, OSDTest,
    ::testing::Combine(::testing::Values(180),
                       ::testing::Values(TESTING_DIR
                                         "/phototest-rotated-180.png"),
                       ::testing::Values(TESSDATA_DIR "_fast")));

INSTANTIATE_TEST_CASE_P(
    TessdataFastRotated270, OSDTest,
    ::testing::Combine(::testing::Values(270),
                       ::testing::Values(TESTING_DIR
                                         "/phototest-rotated-L.png"),
                       ::testing::Values(TESSDATA_DIR "_fast")));

INSTANTIATE_TEST_CASE_P(
    TessdataFastDevaRotated270, OSDTest,
    ::testing::Combine(::testing::Values(270),
                       ::testing::Values(TESTING_DIR
                                         "/devatest-rotated-270.png"),
                       ::testing::Values(TESSDATA_DIR "_fast")));

INSTANTIATE_TEST_CASE_P(
    TessdataFastDeva, OSDTest,
    ::testing::Combine(::testing::Values(0),
                       ::testing::Values(TESTING_DIR "/devatest.png"),
                       ::testing::Values(TESSDATA_DIR "_fast")));

}  // namespace


text:
import { fireEvent, render } from '@testing-library/vue';
import { INumberInput } from '@inkline/inkline/components';
import { createMockInstance } from '@inkline/inkline/__mocks__/createMockInstance';

describe('Components', () => {
    describe('INumberInput', () => {
        const props = {
            color: 'light',
            size: 'md',
            modelValue: '0',
            name: 'number-input'
        };

        it('should be named correctly', () => {
            expect(INumberInput.name).toEqual('INumberInput');
        });

        it('should render correctly', () => {
            const wrapper = render(INumberInput, {
                props
            });

            expect(wrapper.html()).toMatchSnapshot();
        });

        describe('props', () => {
            describe('name', () => {
                it('should have randomly generated name uid', () => {
                    const wrapper = render(INumberInput, {
                        props: {
                            color: props.color,
                            size: props.size
                        }
                    });
                    const inputElement = wrapper.container.querySelector('input');

                    expect(inputElement).toHaveAttribute('name', expect.stringContaining('input'));
                });
            });
        });

        describe('methods', () => {
            describe('decrease()', () => {
                it('should decrease the current value by step', async () => {
                    const wrapper = render(INumberInput, {
                        props: {
                            step: 5,
                            ...props
                        }
                    });
                    const buttons = await wrapper.getAllByRole('button');

                    await fireEvent.click(buttons[0] as Element);

                    expect(wrapper.emitted()['update:modelValue'][1]).toEqual(['-5']);
                });
            });

            describe('increase()', () => {
                it('should increase the current value by step', async () => {
                    const wrapper = render(INumberInput, {
                        props: {
                            step: 5,
                            ...props
                        }
                    });
                    const buttons = await wrapper.getAllByRole('button');

                    await fireEvent.click(buttons[1] as Element);

                    expect(wrapper.emitted()['update:modelValue'][1]).toEqual(['5']);
                });
            });

            describe('onBlurFormatPrecision()', () => {
                it('should add decimals to current value', async () => {
                    const wrapper = render(INumberInput, {
                        props: {
                            ...props,
                            precision: 2
                        }
                    });
                    const input: HTMLElement = wrapper.container.querySelector('input')!;

                    await fireEvent.update(input as Element, '10.25');
                    await fireEvent.blur(input as Element);

                    expect(input).toHaveValue('10.25');
                });

                it('should add trailing zeroes to current value', () => {
                    const parent = {};
                    const wrapper = createMockInstance(INumberInput, {
                        props: {
                            ...props,
                            precision: 2,
                            modelValue: '10.2'
                        },
                        mocks: {
                            parent
                        }
                    });
                    const event: any = {};

                    wrapper.onBlurFormatPrecision(event);

                    expect(wrapper.$emit).toHaveBeenCalledWith('update:modelValue', '10.20');
                });

                it('should emit update:modelValue and parent.onBlur', () => {
                    const parent = {
                        onBlur: vi.fn()
                    };
                    const wrapper = createMockInstance(INumberInput, {
                        props: {
                            ...props,
                            precision: 2,
                            modelValue: '10.25'
                        },
                        mocks: {
                            parent
                        }
                    });
                    const event: any = {};

                    wrapper.onBlurFormatPrecision(event);

                    expect(wrapper.$emit).toHaveBeenCalledWith('update:modelValue', '10.25');
                    expect(wrapper.formatPrecision).toHaveBeenCalledWith('10.25');
                    expect(wrapper.parent.onBlur).toHaveBeenCalledWith(wrapper.name, event);
                });

                it('should not call parent.onBlur if no onBlur method', () => {
                    const parent = {};
                    const wrapper = createMockInstance(INumberInput, {
                        props: {
                            ...props,
                            precision: 2,
                            modelValue: '10.25'
                        },
                        mocks: {
                            parent
                        }
                    });
                    const event: any = {};

                    expect(() => wrapper.onBlurFormatPrecision(event)).not.toThrow();
                });
            });
        });

        describe('watch', () => {
            describe('modelValue', () => {
                it('should allow empty value', async () => {
                    const parent = {};
                    const modelValue = '';
                    const wrapper = createMockInstance(INumberInput, {
                        props,
                        mocks: {
                            parent,
                            watchModelValue: (INumberInput as any).watch.modelValue.handler
                        }
                    });

                    wrapper.watchModelValue(modelValue);

                    expect(wrapper.$emit).toHaveBeenCalledWith('update:modelValue', '');
                });

                it('should not allow value past max value', async () => {
                    const parent = {};
                    const max = '10';
                    const wrapper = createMockInstance(INumberInput, {
                        props: {
                            ...props,
                            max
                        },
                        mocks: {
                            parent,
                            watchModelValue: (INumberInput as any).watch.modelValue.handler
                        }
                    });

                    wrapper.watchModelValue('20');

                    expect(wrapper.$emit).toHaveBeenCalledWith('update:modelValue', max);
                });

                it('should not allow value under min value', async () => {
                    const parent = {};
                    const min = '10';
                    const wrapper = createMockInstance(INumberInput, {
                        props: {
                            ...props,
                            min
                        },
                        mocks: {
                            parent,
                            watchModelValue: (INumberInput as any).watch.modelValue.handler
                        }
                    });

                    wrapper.watchModelValue('5');

                    expect(wrapper.$emit).toHaveBeenCalledWith('update:modelValue', min);
                });

                it('should call parent.onInput if defined', async () => {
                    const parent = { onInput: vi.fn() };
                    const wrapper = createMockInstance(INumberInput, {
                        props,
                        mocks: {
                            parent,
                            watchModelValue: (INumberInput as any).watch.modelValue.handler
                        }
                    });

                    wrapper.watchModelValue('10');

                    expect(parent.onInput).toHaveBeenCalledWith(wrapper.name, '10');
                });
            });
        });
    });
});


text:
**Baseline :** Apprenez à développer des applications Android au goût du jour rapidement !

**Durée :** 4 jours

## Public visé

Cette formation s'adresse aux développeurs ayant déjà une connaissance de la programmation orientée objet, plus spécifiquement Java. En particulier, elle s'adresse aux personnes souhaitant se lancer dans le développement d'applications mobiles sur Android.

## Description

Cette formation vous permettra d'acquérir les bases du **développement d'applications mobiles sur Android**. A l'issue des 4 jours, vous serez autonome dans la **réalisation d'applications Android**.
Tout au long de la formation, vous **mettrez en pratique la théorie** en créant une application Android vitrine présentant les principaux développements.

## Pré-requis

- Programmation orientée objet
- Ordinateur portable à apporter

## Objectifs pédagogiques

- Installer et configurer un environnement de développement sur sa machine
- Comprendre et écrire du code Android
- Construire une application Android en respectant les bonnes pratiques
- Publier son application sur le Play Store
- Connaître les principales libraries du monde Android

## Méthodes pédagogiques (administratif)
On visera une alternance de 50% de travaux pratiques et 50% de cours théoriques.
Les supports de cours seront fourni au format PDF accompagnés d'un lien vers le code source réalisé durant la formation.

## Evaluation des acquis pédagogiques (administratif)
Durant les 4 jours de formation, les TPs sont contrôlés et corrigés par le formateur

## Programme

#### Jour 1 : ABC d'Android et Interface Utilisateur Native

- **Présentation** et **historique** de la plateforme Android
- Installer et configurer l'**environnement de développement** sur sa machine
- Comprendre les **principes de programmation**
- Créer un premier projet 'Hello Android'
  - Arborescence du projet, fichiers clés
  - Familiarisation via la réalisation de tâches simples
  - Déploiement sur émulateur et appareil physique
- Connaître les principaux **éléments d'interface utilisateur native**
  - Vue
  - Ressource
  - Élément graphique natif
  - Message utilisateur
- Appréhender la philosophie du **Material Design**
- Créer une interface utilisateur élaborée
  - Construction d'une interface avec un agencement élaboré
  - Mise en pratique de quelques composants graphiques

#### Jour 2 : Outils du Développeur et Interface Utilisateur Interactive

- Connaître les principaux **outils du développeur**
  - Messages systèmes
  - Débugage
  - Déploiement
  - Tests
  - Librairies et références
- Anticiper la **compatibilité des versions** et le passage à Kotlin
- Importer des projets exemples
- Exploiter les messages d'erreur et le débugage
- Rendre son interface utilisateur interactive avec les **contrôleurs**
  - Adaptateur, utilisation avec une liste de données
  - Gestion des interactions
  - Navigation entre écrans
- Structurer son application
  - Utilisation des menus natifs
  - Utilisation des Fragments versus Activity
  - Communication d'informations entre Activity

#### Jour 3 : Gestion des données et communication réseau

- Stockage de données clé-valeur via les **préférences utilisateurs**
  - Conception des préférences
  - Interfaces de préférences
  - Fichiers de préférences
- Mettre en place des préférences dans son application
  - Utilisation des préférences de l'utilisateur (clé-valeur)
  - Création d'un écran de préférence
  - Récupération des valeurs depuis le fichier de préférences
- Envisager toutes les solutions de **persistance des données**
  - Système de fichiers
  - Base de données SQLite
- Enregistrer des données avec la librairie **Realm**
  - Stockage de données structurées
- Maîtriser les enjeux de la **communication réseau**
  - Contexte d'échange
  - Traitement en tâche de fond
  - Communication HTTP
- Communiquer avec un Web Service via la librairie **Retrofit**
  - Recevoir des données d'un Web Service
  - Envoyer des données à un Web Service

#### Jour 4 : Personnalisation d'interface utilisateur et publication

- Personnaliser l'interface utilisateur
  - **Animation**
  - Vue personnalisée
  - **Capteurs**
- Utiliser d'autres applications
- Créer une vue simple en code Java avec un **Canvas**
  - Animation graphiques et sonores d'éléments
  - Utilisation de l'accéléromètre pour animer un élément graphique
- Ouvrir l'application des paramètres
- **Prendre une photo** avec l'application native
- Préparer la **publication** de son application
  - App Store Optimization
  - Console de publication
  - Statistiques

## Le formateur

![formation](https://gravatar.com/avatar/60d8d9b39be4c97c111c10867f24ca7f?s=100) Ingénieur en développement mobile depuis 2010, [Macha DA COSTA](https://twitter.com/MachaDaCosta) s'est spécialisée dans la conception, le développement et la publication d'applications mobiles Android. En tant qu'indépendante, elle réalise des vacations à l'Université de Nice Sophia-Antipolis et accompagne ses clients dans leurs projets mobiles ou web. Dans son temps libre, elle cours au bord de la mer, joue de la capoeira et de la bass.


text:
public class PowerOfThree {

    public boolean isPowerOfThree(int n) {
        if(n <= 0) return false;
        return 1162261467 % n == 0;
    }

    public static void main(String[] args) {
        PowerOfThree solution = new PowerOfThree();
        System.out.println(solution.isPowerOfThree(1162261467));
    }
}


text:
package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"strconv"

	"github.com/docker/libcompose/project"
	"k8s.io/kubernetes/pkg/api"
	"k8s.io/kubernetes/pkg/api/unversioned"
)

var (
	composeFile string
	outputDir   string
)

func init() {
	flag.StringVar(&composeFile, "compose-file", "docker-compose.yml", "Specify an alternate compose `file`")
	flag.StringVar(&outputDir, "output-dir", "output", "Kubernetes configs output `directory`")
}

func main() {
	flag.Parse()

	p := project.NewProject(&project.Context{
		ProjectName: "kube",
		ComposeFile: composeFile,
	})

	if err := p.Parse(); err != nil {
		log.Fatalf("Failed to parse the compose project from %s: %v", composeFile, err)
	}
	if err := os.MkdirAll(outputDir, 0755); err != nil {
		log.Fatalf("Failed to create the output directory %s: %v", outputDir, err)
	}

	for name, service := range p.Configs {
		rc := &api.ReplicationController{
			TypeMeta: unversioned.TypeMeta{
				Kind:       "ReplicationController",
				APIVersion: "v1",
			},
			ObjectMeta: api.ObjectMeta{
				Name:   name,
				Labels: map[string]string{"service": name},
			},
			Spec: api.ReplicationControllerSpec{
				Replicas: 1,
				Selector: map[string]string{"service": name},
				Template: &api.PodTemplateSpec{
					ObjectMeta: api.ObjectMeta{
						Labels: map[string]string{"service": name},
					},
					Spec: api.PodSpec{
						Containers: []api.Container{
							{
								Name:  name,
								Image: service.Image,
							},
						},
					},
				},
			},
		}

		// Configure the container ports.
		var ports []api.ContainerPort
		for _, port := range service.Ports {
			portNumber, err := strconv.Atoi(port)
			if err != nil {
				log.Fatalf("Invalid container port %s for service %s", port, name)
			}
			ports = append(ports, api.ContainerPort{ContainerPort: portNumber})
		}

		rc.Spec.Template.Spec.Containers[0].Ports = ports

		// Configure the container restart policy.
		switch service.Restart {
		case "", "always":
			rc.Spec.Template.Spec.RestartPolicy = api.RestartPolicyAlways
		case "no":
			rc.Spec.Template.Spec.RestartPolicy = api.RestartPolicyNever
		case "on-failure":
			rc.Spec.Template.Spec.RestartPolicy = api.RestartPolicyOnFailure
		default:
			log.Fatalf("Unknown restart policy %s for service %s", service.Restart, name)
		}

		data, err := json.MarshalIndent(rc, "", "  ")
		if err != nil {
			log.Fatalf("Failed to marshal the replication controller: %v", err)
		}

		// Save the replication controller for the Docker compose service to the
		// configs directory.
		outputFileName := fmt.Sprintf("%s-rc.yaml", name)
		outputFilePath := filepath.Join(outputDir, outputFileName)
		if err := ioutil.WriteFile(outputFilePath, data, 0644); err != nil {
			log.Fatalf("Failed to write replication controller %s: %v", outputFileName, err)
		}
		fmt.Println(outputFilePath)
	}
}


text:
// Copyright (c) 2010 Aalto University
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

// File created: 2010-08-11 10:36:08

package org.seqdoop.hadoop_bam;

import java.io.IOException;
import java.io.OutputStream;

import htsjdk.samtools.SAMFileHeader;

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapreduce.TaskAttemptContext;

/** A convenience class that you can use as a RecordWriter for BAM files.
 *
 *
The write function ignores the key, just outputting the SAMRecord.

 */
public class KeyIgnoringBAMRecordWriter<K> extends BAMRecordWriter<K> {
	public KeyIgnoringBAMRecordWriter(
			Path output, Path input, boolean writeHeader, TaskAttemptContext ctx)
		throws IOException
	{
		super(output, input, writeHeader, ctx);
	}
	public KeyIgnoringBAMRecordWriter(
			Path output, SAMFileHeader header, boolean writeHeader,
			TaskAttemptContext ctx)
		throws IOException
	{
		super(output, header, writeHeader, ctx);
	}
	public KeyIgnoringBAMRecordWriter(
			OutputStream output, SAMFileHeader header, boolean writeHeader)
		throws IOException
	{
		super(output, header, writeHeader);
	}

	@Override public void write(K ignored, SAMRecordWritable rec) throws IOException {
		writeAlignment(rec.get());
	}
}


text:
title: Learning, emotions, and mental maps
authorId: Locke
category: learning
createdAt: 2016-08-22T11:14:24.349Z
---

*I gave this talk earlier in August at my local LDS congregation.*

Recently I was visiting family and ended up on babysitting duty for
several hours for some of my nieces and nephews.

An hour or two in they decided they wanted to watch a movie. Which I, as
the babysitter, was quite fine with. They picked the Pixar movie "Inside
Out" which I hadn't seen. And I ended up really enjoying the movie. It's
quite novel. It covers a few traumatic weeks in the life of a 11-year
old girl who's moving across the country from Minnesota to here, to San
Francisco. The novel part is that they turn her emotions into
characters. Joy, Sadness, Anger, Disgust, and Fear. The movie is
constantly zooming into her "head" to show them working in their
"command center". Her emotions are constantly monitoring the situations
the girl is getting into and debate over possible responses and take
turns directing her actions.

I really liked this "council of the mind" metaphor. Where, when deciding
something, we simulate our different emotions and "personalities" as
real people suggesting and debating possible options.

Something I thought particularly interesting about the movie (I won't
spoil the ending if you haven't seen it) is how Joy, the ringleader of
the emotions, learns to appreciate Sadness. At the start of the movie
she thinks Sadness is useless at best and at worst, destructive. But as
the drama unfolds, she learns that Sadness does have an important role
to play.

I feel like I've reacted in similar ways to some emotions in the past.
I'd feel I was a bad person if I felt sad, despair, anger, fear,
powerless, and so on and tried to avoid situations where I'd feel those
"bad" emotions.

But what I've learned is that there are no "bad" or "good" emotions.
Emotions are simply signals from our subconscious to the conscious part
of our brain. Emotions shouldn't control us, they are meant to guide us.

If you touch a hot stove and get burnt, it doesn't mean you should now
avoid the stove forever more! It just means you should use oven mitts
next time! The stove is really useful!

Emotions can teach us really useful things!

Some scriptures.

>"if ye are prepared ye shall not fear" — [D&C 38:30](https://www.lds.org/scriptures/dc-testament/dc/38.30?lang=eng)

If we flip that around it says that if you're preparing for something
and you're *feeling a lot of fear* then perhaps you just need to
redouble your preparation!

Another scripture.

> "I fear not what man can do; for perfect love casteth out
all fear." — [Mormon 8:16](https://www.lds.org/scriptures/bofm/morm/8.16?lang=eng)

If you feel you need to do something or perhaps talk to someone and are
fearing people's responses — perhaps in the council of your mind you
should stop and listen closely to what Love has to say. Perhaps once
given a voice, Love would "cast out" Fear.

One day your Shame and Guilt might be telling you that you've done
something wrong that you need to make amends for. But it could also just
be someone trying to manipulate you!

Emotions aren't perfect guides. Council with your emotions but don't
blindly follow them.

Let's talk about maps! Maps are super useful. We use them to help us
navigate unfamiliar territory. Maps come in all sorts. Some maps are
detailed. Others are high-level and vague.

But maps aren't reality. They're a representation of reality that show
the most important information that we need to solve a problem
(generally driving or walking around).

In a similar way, our brains hold maps to reality which we use to
navigate through life. We don't experience reality directly but as
mediated by our "mental maps". We're constantly building new maps and
tweaking old maps (or even sometimes forgetting maps we don't need
anymore). Like maps of the physical world, our *mental* maps can be
vague or detailed. Imagine taking a chemistry class. When we start, our
understanding of chemistry might be quite poor. Something like a map of
the world zoomed way out so we can only see the continents perhaps. But
as we learn, our mental map of chemistry gets more and more detailed
until soon we can see coastlines, lakes, rivers, mountains, and so on.

One big difference between our mental maps and maps of the physical
world is our mental maps are often wrong! Imagine if Google Maps had
roads that didn't exist, or that said a road was a freeway but actually
had a big brick wall in the middle that we'd slam into. Imagine if
Google Maps gave us bad directions 1/4 of the time. It'd be horrible!
We'd just want to stay home and do nothing. That's what happens too if
our mental maps of the world are poor.

Great maps help us navigate our lives confidently. Poor mental maps lead
us astray and cause problems and missed opportunities.

## How our mental maps get out of sync with reality

>"It ain't what you don't know that gets you into trouble. It's what you
know for sure that just ain't so." — Mark Twain

We want to see the world as we feel it should be. We put things on our
mental maps that "just ain't so".

Why do we do this? There's lots of reasons. Perhaps it's something we
fear and try to avoid thinking about. Perhaps we want something so badly
we can't see a world where we don't get it. Perhaps there are things we
were taught when young that turn out to be wrong (evil traditions of
their fathers…), etc.

A lot of why we refuse to see the world as it really is comes from
pride. Pride, President Benson warned us is *the* great stumbling block.

Joseph Smith said we're "saved *no faster* than we get knowledge". Which
means *anything* that keeps us from learning, from gaining knowledge,
keeps us in our current pickle. Pride is what keeps us lost, keeps us
stumbling. Humility (the antidote to pride) is what lets us learn, is
what saves us.

We can all think of things that were hard when younger that now are
easy. What changed? We gained knowledge! We understand what we once
didn't understand. Our mental maps got better! We can navigate where
before we were lost. All of us have immense capacity to learn. None of
us are permanently stuck.

So if you're struggling with something, think to yourself "what is it
that I need to learn to be saved from my current problem and what aspect
of pride is blocking me from learning that?"

* Maybe you need a long walk to sort through your thoughts and feelings
and perhaps you're not used to asking for personal time and pride is
preventing you from asking your partner to cover you while gone.

* Perhaps there's someone you need to ask for help and pride is
preventing you from showing vulnerabilities in front of them.

* Or perhaps you just need to admit some unpleasant realities about
yourself and pride is preventing you from admitting that you're
inadequate and make mistakes.

What is the reward for these difficult learning exercises?? Good maps!
Mental maps of our world that helps you navigate confidently through
your life.

Pride is the great stumbling block. It's what stops us from learning
what we need so we can be saved from our predicaments. Humility helps us
see the world clearly and accurately and receive and give help to
others.

Emotions are an incredibly useful guides. There are no bad emotions.
They are what they are. Don't be ruled by them but take guidance from
them.

And finally, we need guidance from the Holy Ghost. It doesn't come as
often as I'm sure anyone wants but I testify it does come when we're
worthy and asking and the Lord chooses to bless us with it. Expect it,
record it and treasure and ponder it.

>For the Spirit speaketh the truth and lieth not. Wherefore, *it speaketh
of things as they really are*, and of things as they really will be;
wherefore, these things are manifested unto us plainly, for the
salvation of our souls. — Jacob 4:13

I testify the Spirit speaks the truth to us about our realities and this
is necessary for the salvation of our souls.


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>RawMessage (AWS SDK for Android - 2.2.1)</title>
<meta name="date" content="2015-04-21">
<link rel="stylesheet" type="text/css" href="../../../../../JavaDoc.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

com.amazonaws.services.simpleemail.model

Class RawMessage

java.lang.Object

com.amazonaws.services.simpleemail.model.RawMessage

All Implemented Interfaces:

Serializable

public class RawMessage
extends Object
implements Serializable

 Represents the raw data of the message.

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description

RawMessage()

Default constructor for a new RawMessage object.

RawMessage(ByteBuffer data)

Constructs a new RawMessage object.

Method Summary

Methods

Modifier and Type
Method and Description

boolean
equals(Object obj)

ByteBuffer
getData()

The raw data of the message.

int
hashCode()

void
setData(ByteBuffer data)

The raw data of the message.

String
toString()

Returns a string representation of this object; useful for testing and
 debugging.

RawMessage
withData(ByteBuffer data)

The raw data of the message.

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

RawMessage

public RawMessage()

Default constructor for a new RawMessage object.  Callers should use the
 setter or fluent setter (with...) methods to initialize this object after creating it.

RawMessage

public RawMessage(ByteBuffer data)

Constructs a new RawMessage object.
 Callers should use the setter or fluent setter (with...) methods to
 initialize any additional object members.

Parameters:

data - The raw data of the message. The client must ensure that
 the message format complies with Internet email standards regarding
 email header fields, MIME types, MIME encoding, and base64 encoding
 (if necessary).
For more information, go to the Amazon
 SES Developer Guide.

Method Detail

getData

public ByteBuffer getData()

The raw data of the message. The client must ensure that the message
 format complies with Internet email standards regarding email header
 fields, MIME types, MIME encoding, and base64 encoding (if necessary).

For more information, go to the Amazon
 SES Developer Guide.

Returns:

The raw data of the message. The client must ensure that the message
         format complies with Internet email standards regarding email header
         fields, MIME types, MIME encoding, and base64 encoding (if necessary).

For more information, go to the Amazon
         SES Developer Guide.

setData

public void setData(ByteBuffer data)

The raw data of the message. The client must ensure that the message
 format complies with Internet email standards regarding email header
 fields, MIME types, MIME encoding, and base64 encoding (if necessary).

For more information, go to the Amazon
 SES Developer Guide.

Parameters:

data - The raw data of the message. The client must ensure that the message
         format complies with Internet email standards regarding email header
         fields, MIME types, MIME encoding, and base64 encoding (if necessary).

For more information, go to the Amazon
         SES Developer Guide.

withData

public RawMessage withData(ByteBuffer data)

The raw data of the message. The client must ensure that the message
 format complies with Internet email standards regarding email header
 fields, MIME types, MIME encoding, and base64 encoding (if necessary).

For more information, go to the Amazon
 SES Developer Guide.

 Returns a reference to this object so that method calls can be chained together.

Parameters:

data - The raw data of the message. The client must ensure that the message
         format complies with Internet email standards regarding email header
         fields, MIME types, MIME encoding, and base64 encoding (if necessary).

For more information, go to the Amazon
         SES Developer Guide.

Returns:

A reference to this updated object so that method calls can be chained
         together.

toString

public String toString()

Returns a string representation of this object; useful for testing and
 debugging.

Overrides:

toString in class Object

Returns:

A string representation of this object.

See Also:

Object.toString()

hashCode

public int hashCode()

Overrides:

hashCode in class Object

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

Overview

Package

Class

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

                Copyright © 2010 Amazon Web Services, Inc. All Rights Reserved.


text:
module.exports = {
	configure: function(app) {
		require('./datasets').configure(app);
		require('./estadisticas').configure(app);
		require('./estados').configure(app);
		require('./fuentes').configure(app);
		require('./municipios').configure(app);
		require('./personas').configure(app);
		require('./meta').configure(app);
		require('./grupos').configure(app);
		require('./search').configure(app);
		require('./subgrupos').configure(app);
		require('./temas').configure(app);
	}
}


text:
<?php

namespace app\models\glabs\sites;

use app\commands\GlabsController;
use app\models\glabs\categories\BaseCategory;
use app\models\glabs\objects\ObjectException;
use PHPHtmlParser\Exceptions\CurlException;
use yii\base\InvalidParamException;

abstract class BaseSite
{
    /**
     * URL.
     *
     * @var string
     */
    protected $url;

    /**
     * Categories.
     *
     * @var array
     */
    protected $categoriesList = [];

    /**
     * Categories.
     *
     * @var BaseCategory[]
     */
    protected $categories = [];

    /**
     * Income categories.
     *
     * @var array
     */
    protected $inCategories = [];

    /**
     * Progress bar.
     *
     * @var string
     */
    public static $progressFormat = "\rCollect categories: %d. Collect objects: %d.";

    /**
     * @var integer
     */
    public static $doneCategories = 0;

    /**
     * @var integer
     */
    public static $doneObjects = 0;

    /**
     * Init.
     *
     * @param array   $categories Categories.
     * @param integer $count      Count object per category.
     * @param string  $url        Site Url.
     *
     * @throws CurlException
     * @throws ObjectException
     */
    public function __construct(array $categories, $count, $url = '') {
        if (false === strpos($this->url, 'http')) {
            $this->url = 'http://' . $this->url;
        }
        $this->url = rtrim($this->url, '/');
        $this->inCategories = $categories;
        $this->getCategoriesLinks($count);
    }

    /**
     * Parse action.
     *
     * @throws CurlException
     * @throws InvalidParamException
     * @throws ObjectException
     */
    public function parse()
    {
        foreach ($this->categories as $category) {
            $category->parse();
            GlabsController::showMessage('Successful sent objects: ' . GlabsController::$sentObjects);
        }
    }

    /**
     * Fill categories by name and URL.
     *
     * @param integer $count How many category objects to parse.
     *
     * @return bool
     *
     * @throws CurlException
     * @throws ObjectException
     */
    protected function getCategoriesLinks($count)
    {
        $host = $this->url;
        $categories = $this->inCategories;

        if (!$categories || (isset($categories[0]) && $categories[0] === '')) {
            $categories = array_keys($this->categoriesList);
        }

        foreach ($categories as $title) {
            if (!array_key_exists($title, $this->categoriesList)) {
                continue;
            }
            self::$doneCategories++;
            self::progress();
            $category = $this->categoriesList[$title];
            $url = array_map(function ($item) use ($host) { return $host . $item; }, $category['url']);
            $this->setCategory($url, $title, $category['category_id'], $category['type'], $count);
        }

        GlabsController::showMessage("\n");

        return true;
    }

    /**
     * Set category.
     *
     * @param $url          string
     * @param $title        string
     * @param $categoryId   integer
     * @param $categoryType string
     * @param $count        integer
     *
     * @throws CurlException
     * @throws ObjectException
     */
    protected function setCategory($url, $title, $categoryId, $categoryType, $count)
    {

    }

    /**
     * Show progress bar.
     */
    public static function progress()
    {
        GlabsController::showMessage(sprintf(self::$progressFormat, self::$doneCategories, self::$doneObjects), false);
    }
}


text:
All URIs are relative to *http://localhost*

Method | HTTP request | Description
------------- | ------------- | -------------
[**BlueOceanAPI_deletePipelineQueueItem**](BlueOceanAPI.md#BlueOceanAPI_deletePipelineQueueItem) | **DELETE** /blue/rest/organizations/{organization}/pipelines/{pipeline}/queue/{queue} |
[**BlueOceanAPI_getAuthenticatedUser**](BlueOceanAPI.md#BlueOceanAPI_getAuthenticatedUser) | **GET** /blue/rest/organizations/{organization}/user/ |
[**BlueOceanAPI_getClasses**](BlueOceanAPI.md#BlueOceanAPI_getClasses) | **GET** /blue/rest/classes/{class} |
[**BlueOceanAPI_getJsonWebKey**](BlueOceanAPI.md#BlueOceanAPI_getJsonWebKey) | **GET** /jwt-auth/jwks/{key} |
[**BlueOceanAPI_getJsonWebToken**](BlueOceanAPI.md#BlueOceanAPI_getJsonWebToken) | **GET** /jwt-auth/token |
[**BlueOceanAPI_getOrganisation**](BlueOceanAPI.md#BlueOceanAPI_getOrganisation) | **GET** /blue/rest/organizations/{organization} |
[**BlueOceanAPI_getOrganisations**](BlueOceanAPI.md#BlueOceanAPI_getOrganisations) | **GET** /blue/rest/organizations/ |
[**BlueOceanAPI_getPipeline**](BlueOceanAPI.md#BlueOceanAPI_getPipeline) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline} |
[**BlueOceanAPI_getPipelineActivities**](BlueOceanAPI.md#BlueOceanAPI_getPipelineActivities) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/activities |
[**BlueOceanAPI_getPipelineBranch**](BlueOceanAPI.md#BlueOceanAPI_getPipelineBranch) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/branches/{branch}/ |
[**BlueOceanAPI_getPipelineBranchRun**](BlueOceanAPI.md#BlueOceanAPI_getPipelineBranchRun) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/branches/{branch}/runs/{run} |
[**BlueOceanAPI_getPipelineBranches**](BlueOceanAPI.md#BlueOceanAPI_getPipelineBranches) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/branches |
[**BlueOceanAPI_getPipelineFolder**](BlueOceanAPI.md#BlueOceanAPI_getPipelineFolder) | **GET** /blue/rest/organizations/{organization}/pipelines/{folder}/ |
[**BlueOceanAPI_getPipelineFolderPipeline**](BlueOceanAPI.md#BlueOceanAPI_getPipelineFolderPipeline) | **GET** /blue/rest/organizations/{organization}/pipelines/{folder}/pipelines/{pipeline} |
[**BlueOceanAPI_getPipelineQueue**](BlueOceanAPI.md#BlueOceanAPI_getPipelineQueue) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/queue |
[**BlueOceanAPI_getPipelineRun**](BlueOceanAPI.md#BlueOceanAPI_getPipelineRun) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs/{run} |
[**BlueOceanAPI_getPipelineRunLog**](BlueOceanAPI.md#BlueOceanAPI_getPipelineRunLog) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs/{run}/log |
[**BlueOceanAPI_getPipelineRunNode**](BlueOceanAPI.md#BlueOceanAPI_getPipelineRunNode) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs/{run}/nodes/{node} |
[**BlueOceanAPI_getPipelineRunNodeStep**](BlueOceanAPI.md#BlueOceanAPI_getPipelineRunNodeStep) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs/{run}/nodes/{node}/steps/{step} |
[**BlueOceanAPI_getPipelineRunNodeStepLog**](BlueOceanAPI.md#BlueOceanAPI_getPipelineRunNodeStepLog) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs/{run}/nodes/{node}/steps/{step}/log |
[**BlueOceanAPI_getPipelineRunNodeSteps**](BlueOceanAPI.md#BlueOceanAPI_getPipelineRunNodeSteps) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs/{run}/nodes/{node}/steps |
[**BlueOceanAPI_getPipelineRunNodes**](BlueOceanAPI.md#BlueOceanAPI_getPipelineRunNodes) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs/{run}/nodes |
[**BlueOceanAPI_getPipelineRuns**](BlueOceanAPI.md#BlueOceanAPI_getPipelineRuns) | **GET** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs |
[**BlueOceanAPI_getPipelines**](BlueOceanAPI.md#BlueOceanAPI_getPipelines) | **GET** /blue/rest/organizations/{organization}/pipelines/ |
[**BlueOceanAPI_getSCM**](BlueOceanAPI.md#BlueOceanAPI_getSCM) | **GET** /blue/rest/organizations/{organization}/scm/{scm} |
[**BlueOceanAPI_getSCMOrganisationRepositories**](BlueOceanAPI.md#BlueOceanAPI_getSCMOrganisationRepositories) | **GET** /blue/rest/organizations/{organization}/scm/{scm}/organizations/{scmOrganisation}/repositories |
[**BlueOceanAPI_getSCMOrganisationRepository**](BlueOceanAPI.md#BlueOceanAPI_getSCMOrganisationRepository) | **GET** /blue/rest/organizations/{organization}/scm/{scm}/organizations/{scmOrganisation}/repositories/{repository} |
[**BlueOceanAPI_getSCMOrganisations**](BlueOceanAPI.md#BlueOceanAPI_getSCMOrganisations) | **GET** /blue/rest/organizations/{organization}/scm/{scm}/organizations |
[**BlueOceanAPI_getUser**](BlueOceanAPI.md#BlueOceanAPI_getUser) | **GET** /blue/rest/organizations/{organization}/users/{user} |
[**BlueOceanAPI_getUserFavorites**](BlueOceanAPI.md#BlueOceanAPI_getUserFavorites) | **GET** /blue/rest/users/{user}/favorites |
[**BlueOceanAPI_getUsers**](BlueOceanAPI.md#BlueOceanAPI_getUsers) | **GET** /blue/rest/organizations/{organization}/users/ |
[**BlueOceanAPI_postPipelineRun**](BlueOceanAPI.md#BlueOceanAPI_postPipelineRun) | **POST** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs/{run}/replay |
[**BlueOceanAPI_postPipelineRuns**](BlueOceanAPI.md#BlueOceanAPI_postPipelineRuns) | **POST** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs |
[**BlueOceanAPI_putPipelineFavorite**](BlueOceanAPI.md#BlueOceanAPI_putPipelineFavorite) | **PUT** /blue/rest/organizations/{organization}/pipelines/{pipeline}/favorite |
[**BlueOceanAPI_putPipelineRun**](BlueOceanAPI.md#BlueOceanAPI_putPipelineRun) | **PUT** /blue/rest/organizations/{organization}/pipelines/{pipeline}/runs/{run}/stop |
[**BlueOceanAPI_search**](BlueOceanAPI.md#BlueOceanAPI_search) | **GET** /blue/rest/search/ |
[**BlueOceanAPI_searchClasses**](BlueOceanAPI.md#BlueOceanAPI_searchClasses) | **GET** /blue/rest/classes/ |

# **BlueOceanAPI_deletePipelineQueueItem**
```c
// Delete queue item from an organization pipeline queue
//
void BlueOceanAPI_deletePipelineQueueItem(apiClient_t *apiClient, char * organization, char * pipeline, char * queue);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**queue** | **char \*** | Name of the queue item |

### Return type

void

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: Not defined

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getAuthenticatedUser**
```c
// Retrieve authenticated user details for an organization
//
user_t* BlueOceanAPI_getAuthenticatedUser(apiClient_t *apiClient, char * organization);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |

### Return type

[user_t](user.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getClasses**
```c
// Get a list of class names supported by a given class
//
char* BlueOceanAPI_getClasses(apiClient_t *apiClient, char * _class);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**_class** | **char \*** | Name of the class |

### Return type

char*

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getJsonWebKey**
```c
// Retrieve JSON Web Key
//
char* BlueOceanAPI_getJsonWebKey(apiClient_t *apiClient, int key);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**key** | **int** | Key ID received as part of JWT header field kid |

### Return type

char*

### Authorization

No authorization required

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getJsonWebToken**
```c
// Retrieve JSON Web Token
//
char* BlueOceanAPI_getJsonWebToken(apiClient_t *apiClient, int expiryTimeInMins, int maxExpiryTimeInMins);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**expiryTimeInMins** | **int** | Token expiry time in minutes, default: 30 minutes | [optional]
**maxExpiryTimeInMins** | **int** | Maximum token expiry time in minutes, default: 480 minutes | [optional]

### Return type

char*

### Authorization

No authorization required

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getOrganisation**
```c
// Retrieve organization details
//
organisation_t* BlueOceanAPI_getOrganisation(apiClient_t *apiClient, char * organization);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |

### Return type

[organisation_t](organisation.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getOrganisations**
```c
// Retrieve all organizations details
//
list_t* BlueOceanAPI_getOrganisations(apiClient_t *apiClient);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |

### Return type

[list_t](organisation.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipeline**
```c
// Retrieve pipeline details for an organization
//
pipeline_t* BlueOceanAPI_getPipeline(apiClient_t *apiClient, char * organization, char * pipeline);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |

### Return type

[pipeline_t](pipeline.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineActivities**
```c
// Retrieve all activities details for an organization pipeline
//
list_t* BlueOceanAPI_getPipelineActivities(apiClient_t *apiClient, char * organization, char * pipeline);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |

### Return type

[list_t](pipeline_activity.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineBranch**
```c
// Retrieve branch details for an organization pipeline
//
branch_impl_t* BlueOceanAPI_getPipelineBranch(apiClient_t *apiClient, char * organization, char * pipeline, char * branch);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**branch** | **char \*** | Name of the branch |

### Return type

[branch_impl_t](branch_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineBranchRun**
```c
// Retrieve branch run details for an organization pipeline
//
pipeline_run_t* BlueOceanAPI_getPipelineBranchRun(apiClient_t *apiClient, char * organization, char * pipeline, char * branch, char * run);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**branch** | **char \*** | Name of the branch |
**run** | **char \*** | Name of the run |

### Return type

[pipeline_run_t](pipeline_run.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineBranches**
```c
// Retrieve all branches details for an organization pipeline
//
multibranch_pipeline_t* BlueOceanAPI_getPipelineBranches(apiClient_t *apiClient, char * organization, char * pipeline);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |

### Return type

[multibranch_pipeline_t](multibranch_pipeline.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineFolder**
```c
// Retrieve pipeline folder for an organization
//
pipeline_folder_impl_t* BlueOceanAPI_getPipelineFolder(apiClient_t *apiClient, char * organization, char * folder);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**folder** | **char \*** | Name of the folder |

### Return type

[pipeline_folder_impl_t](pipeline_folder_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineFolderPipeline**
```c
// Retrieve pipeline details for an organization folder
//
pipeline_impl_t* BlueOceanAPI_getPipelineFolderPipeline(apiClient_t *apiClient, char * organization, char * pipeline, char * folder);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**folder** | **char \*** | Name of the folder |

### Return type

[pipeline_impl_t](pipeline_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineQueue**
```c
// Retrieve queue details for an organization pipeline
//
list_t* BlueOceanAPI_getPipelineQueue(apiClient_t *apiClient, char * organization, char * pipeline);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |

### Return type

[list_t](queue_item_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineRun**
```c
// Retrieve run details for an organization pipeline
//
pipeline_run_t* BlueOceanAPI_getPipelineRun(apiClient_t *apiClient, char * organization, char * pipeline, char * run);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**run** | **char \*** | Name of the run |

### Return type

[pipeline_run_t](pipeline_run.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineRunLog**
```c
// Get log for a pipeline run
//
char* BlueOceanAPI_getPipelineRunLog(apiClient_t *apiClient, char * organization, char * pipeline, char * run, int start, int download);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**run** | **char \*** | Name of the run |
**start** | **int** | Start position of the log | [optional]
**download** | **int** | Set to true in order to download the file, otherwise it's passed as a response body | [optional]

### Return type

char*

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineRunNode**
```c
// Retrieve run node details for an organization pipeline
//
pipeline_run_node_t* BlueOceanAPI_getPipelineRunNode(apiClient_t *apiClient, char * organization, char * pipeline, char * run, char * node);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**run** | **char \*** | Name of the run |
**node** | **char \*** | Name of the node |

### Return type

[pipeline_run_node_t](pipeline_run_node.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineRunNodeStep**
```c
// Retrieve run node details for an organization pipeline
//
pipeline_step_impl_t* BlueOceanAPI_getPipelineRunNodeStep(apiClient_t *apiClient, char * organization, char * pipeline, char * run, char * node, char * step);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**run** | **char \*** | Name of the run |
**node** | **char \*** | Name of the node |
**step** | **char \*** | Name of the step |

### Return type

[pipeline_step_impl_t](pipeline_step_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineRunNodeStepLog**
```c
// Get log for a pipeline run node step
//
char* BlueOceanAPI_getPipelineRunNodeStepLog(apiClient_t *apiClient, char * organization, char * pipeline, char * run, char * node, char * step);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**run** | **char \*** | Name of the run |
**node** | **char \*** | Name of the node |
**step** | **char \*** | Name of the step |

### Return type

char*

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineRunNodeSteps**
```c
// Retrieve run node steps details for an organization pipeline
//
list_t* BlueOceanAPI_getPipelineRunNodeSteps(apiClient_t *apiClient, char * organization, char * pipeline, char * run, char * node);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**run** | **char \*** | Name of the run |
**node** | **char \*** | Name of the node |

### Return type

[list_t](pipeline_step_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineRunNodes**
```c
// Retrieve run nodes details for an organization pipeline
//
list_t* BlueOceanAPI_getPipelineRunNodes(apiClient_t *apiClient, char * organization, char * pipeline, char * run);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**run** | **char \*** | Name of the run |

### Return type

[list_t](pipeline_run_node.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelineRuns**
```c
// Retrieve all runs details for an organization pipeline
//
list_t* BlueOceanAPI_getPipelineRuns(apiClient_t *apiClient, char * organization, char * pipeline);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |

### Return type

[list_t](pipeline_run.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getPipelines**
```c
// Retrieve all pipelines details for an organization
//
list_t* BlueOceanAPI_getPipelines(apiClient_t *apiClient, char * organization);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |

### Return type

[list_t](pipeline.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getSCM**
```c
// Retrieve SCM details for an organization
//
github_scm_t* BlueOceanAPI_getSCM(apiClient_t *apiClient, char * organization, char * scm);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**scm** | **char \*** | Name of SCM |

### Return type

[github_scm_t](github_scm.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getSCMOrganisationRepositories**
```c
// Retrieve SCM organization repositories details for an organization
//
list_t* BlueOceanAPI_getSCMOrganisationRepositories(apiClient_t *apiClient, char * organization, char * scm, char * scmOrganisation, char * credentialId, int pageSize, int pageNumber);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**scm** | **char \*** | Name of SCM |
**scmOrganisation** | **char \*** | Name of the SCM organization |
**credentialId** | **char \*** | Credential ID | [optional]
**pageSize** | **int** | Number of items in a page | [optional]
**pageNumber** | **int** | Page number | [optional]

### Return type

[list_t](github_organization.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getSCMOrganisationRepository**
```c
// Retrieve SCM organization repository details for an organization
//
list_t* BlueOceanAPI_getSCMOrganisationRepository(apiClient_t *apiClient, char * organization, char * scm, char * scmOrganisation, char * repository, char * credentialId);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**scm** | **char \*** | Name of SCM |
**scmOrganisation** | **char \*** | Name of the SCM organization |
**repository** | **char \*** | Name of the SCM repository |
**credentialId** | **char \*** | Credential ID | [optional]

### Return type

[list_t](github_organization.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getSCMOrganisations**
```c
// Retrieve SCM organizations details for an organization
//
list_t* BlueOceanAPI_getSCMOrganisations(apiClient_t *apiClient, char * organization, char * scm, char * credentialId);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**scm** | **char \*** | Name of SCM |
**credentialId** | **char \*** | Credential ID | [optional]

### Return type

[list_t](github_organization.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getUser**
```c
// Retrieve user details for an organization
//
user_t* BlueOceanAPI_getUser(apiClient_t *apiClient, char * organization, char * user);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**user** | **char \*** | Name of the user |

### Return type

[user_t](user.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getUserFavorites**
```c
// Retrieve user favorites details for an organization
//
list_t* BlueOceanAPI_getUserFavorites(apiClient_t *apiClient, char * user);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**user** | **char \*** | Name of the user |

### Return type

[list_t](favorite_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_getUsers**
```c
// Retrieve users details for an organization
//
user_t* BlueOceanAPI_getUsers(apiClient_t *apiClient, char * organization);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |

### Return type

[user_t](user.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_postPipelineRun**
```c
// Replay an organization pipeline run
//
queue_item_impl_t* BlueOceanAPI_postPipelineRun(apiClient_t *apiClient, char * organization, char * pipeline, char * run);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**run** | **char \*** | Name of the run |

### Return type

[queue_item_impl_t](queue_item_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_postPipelineRuns**
```c
// Start a build for an organization pipeline
//
queue_item_impl_t* BlueOceanAPI_postPipelineRuns(apiClient_t *apiClient, char * organization, char * pipeline);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |

### Return type

[queue_item_impl_t](queue_item_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_putPipelineFavorite**
```c
// Favorite/unfavorite a pipeline
//
favorite_impl_t* BlueOceanAPI_putPipelineFavorite(apiClient_t *apiClient, char * organization, char * pipeline, int body);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**body** | **int** | Set JSON string body to {\"favorite\": true} to favorite, set value to false to unfavorite |

### Return type

[favorite_impl_t](favorite_impl.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_putPipelineRun**
```c
// Stop a build of an organization pipeline
//
pipeline_run_t* BlueOceanAPI_putPipelineRun(apiClient_t *apiClient, char * organization, char * pipeline, char * run, char * blocking, int timeOutInSecs);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**organization** | **char \*** | Name of the organization |
**pipeline** | **char \*** | Name of the pipeline |
**run** | **char \*** | Name of the run |
**blocking** | **char \*** | Set to true to make blocking stop, default: false | [optional]
**timeOutInSecs** | **int** | Timeout in seconds, default: 10 seconds | [optional]

### Return type

[pipeline_run_t](pipeline_run.md) *

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_search**
```c
// Search for any resource details
//
char* BlueOceanAPI_search(apiClient_t *apiClient, char * q);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**q** | **char \*** | Query string |

### Return type

char*

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

# **BlueOceanAPI_searchClasses**
```c
// Get classes details
//
char* BlueOceanAPI_searchClasses(apiClient_t *apiClient, char * q);
```

### Parameters
Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
**apiClient** | **apiClient_t \*** | context containing the client configuration |
**q** | **char \*** | Query string containing an array of class names |

### Return type

char*

### Authorization

[jenkins_auth](../README.md#jenkins_auth)

### HTTP request headers

 - **Content-Type**: Not defined
 - **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)


text:
[![Build Status](https://travis-ci.org/joedursun/pivotal.png)](https://travis-ci.org/joedursun/pivotal)
[![Code Climate](https://codeclimate.com/github/joedursun/pivotal/badges/gpa.svg)](https://codeclimate.com/github/joedursun/pivotal)
[![codecov.io](https://codecov.io/github/joedursun/pivotal/coverage.svg?branch=master)](https://codecov.io/github/joedursun/pivotal?branch=master)

## About
This pivotal gem is designed to work with v5 of Pivotal Tracker's API. There are no external dependencies,
so you'll never have to worry about conflicts.

To see all of the supported functionality of Pivotal API v5, [check out their docs here](http://www.pivotaltracker.com/help/api/rest/v5#top). At the moment, this gem only supports a subset of the Pivotal API. See below for some examples of what's possible now.

Before you get started, you'll need to set a couple of environment variables:

`export PIVOTAL_TOKEN="YOUR API TOKEN GOES HERE"`

`export PIVOTAL_PROJECT_ID="PIVOTAL PROJECT ID GOES HERE"`

## Structure:
Several of the classes defined in Pivotal inherit from Pivotal::API. The API class defines methods like `where` and `create`
so that any child class can support common queries. Think ActiveRecord.

## Supported Ruby versions
For the most up to date list of supported Ruby versions check the [Travis CI page](https://travis-ci.org/joedursun/pivotal)

## Usage

### Stories:
To find by id:
```ruby
Pivotal::Story.where(id: 123456789)
# => [#<Pivotal::Story:0x007fd032e6fe88 @kind="story", @id=123456789, @created_at="2016-01-23T05:17:46Z"...]
```

You can fetch many at one time:
```ruby
filters = {with_state: :accepted, with_story_type: :bug, limit: 10}
Pivotal::Story.where(filters)
```

Each of the story attributes that come back from Pivotal's API can be accessed via attr_readers so you can do things like:
```ruby
filters = {with_label: :urgent}
Pivotal::Story.where(filters).sort_by(&:accepted_at).last.name
```

Now that you have a story, you can add a label (each call to `add_label` will make a Post request):
```ruby
filters = {with_state: :accepted, with_story_type: :chore, limit: 10}
Pivotal::Story.where(filters).each {|s| s.add_label('whatever label name')}
```

[Here are the docs](http://www.pivotaltracker.com/help/api/rest/v5#Stories) for what search params can be used to find stories.

### Projects:
All of the queries for `Story` above are equally valid (with the exception of filter names; see the appropriate Pivotal docs page).

On top of the usual queries, there are a few convenience methods to help automate deployments.

To find all accepted and unreleased stories:
```ruby
Pivotal::Project.accepted_unreleased_stories
# => [#<Pivotal::Story:0x007fd032e6fe88 @kind="story", @id=123456789, @created_at="2016-01-23T05:17:46Z"...]
```

When it's time for deploying to production you can create a new release marker and label for all of your stories that have
gone out:

```ruby
Pivotal::Project.update_for_release('New Release Label Goes Here')
```

### Releases

If you want to get the most recent release:
```ruby
Pivotal::Release.most_recent
# => #<Pivotal::Release:0x007fd032e6fe88 @kind="release", @id=123456789, @accepted_at="2016-01-23T05:17:46Z"...
```

By default `most_recent` searches only for releases in the last two weeks. If it's been a while since the last release,
just provide a sufficient number of days back to use in the search:
```ruby
Pivotal::Release.most_recent
# => nil
Pivotal::Release.most_recent(30)
# => #<Pivotal::Release:0x007fd032e6fe88 @kind="release", @id=123456789, @accepted_at="2016-01-03T22:34:16Z"...
```

Suppose you have stories that are going to be deployed with your release and you want to add a label to all of them:
```ruby
ready_to_deploy_stories = Pivotal::Project.accepted_unreleased_stories
release = Pivotal::Release.new(label: 'label_for_release', stories: ready_to_deploy_stories)
# The following param is optional. If not provided, then the release label is used.
release.add_label_to_stories('Label to accompany release')
```


text:
// Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
//
// You are hereby granted a non-exclusive, worldwide, royalty-free license to use,
// copy, modify, and distribute this software in source code or binary form for use
// in connection with the web services and APIs provided by Facebook.
//
// As with any software that integrates with the Facebook platform, your use of
// this software is subject to the Facebook Developer Principles and Policies
// [http://developers.facebook.com/policy/]. This copyright notice shall be
// included in all copies or substantial portions of the software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#import "TargetConditionals.h"

#if !TARGET_OS_TV

#import <Foundation/Foundation.h>

#import "FBSDKCopying.h"

NS_ASSUME_NONNULL_BEGIN

/**
  Extension protocol for NSMutableCopying that adds the mutableCopy method, which is implemented on NSObject.

 NSObject<NSCopying, NSMutableCopying> implicitly conforms to this protocol.
 */
NS_SWIFT_NAME(MutableCopying)
@protocol FBSDKMutableCopying <FBSDKCopying, NSMutableCopying>

/**
  Implemented by NSObject as a convenience to mutableCopyWithZone:.
 @return A mutable copy of the receiver.
 */
- (id)mutableCopy;

@end

NS_ASSUME_NONNULL_END

#endif


text:
"""
Django settings for djasmine project.

Generated by 'django-admin startproject' using Django 1.9.

For more information on this file, see
https://docs.djangoproject.com/en/1.9/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.9/ref/settings/
"""

import os
import jasmine_core

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.9/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'o)-_2wabolqon7(o72)-p1lrizz6h&nifj!=#bz3pe1z_!pkx%'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = [
    'django.contrib.staticfiles',
    'djasmine',
]

MIDDLEWARE_CLASSES = [
    'django.middleware.common.CommonMiddleware',
]

ROOT_URLCONF = 'test_project.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR + '/templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
            ],
        },
    },
]

WSGI_APPLICATION = 'test_project.wsgi.application'

# Database
# https://docs.djangoproject.com/en/1.9/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.9/howto/static-files/
JASMINE_SPEC_ROOT = BASE_DIR + '/spec'

STATIC_URL = '/static/'
STATICFILES_DIRS = [
    jasmine_core.__path__[0],
    JASMINE_SPEC_ROOT,
]


text:
layout: page
categories: dictionary ct2010
---

##ACS 2008-2012 Median Household Income Variables

---

####**geoid**
Unique 11-digit US 2010 Census Tract ID.

####**t10mhhi**
Median Household Income (t10_057001) from 2008-2012 American Community Survey

---
[American Community Survey](http://www.census.gov/acs/www/)