text:
\chapter{Results and Conclusions}
\label{chap:results}

This chapter outlines the results of the experiments performed using the methods outlined in the preceding chapter. For each section in this chapter an brief comparison of the similarity exhibited by each feature is given followed by lower dimensional representations of the feature space. Finally, plots examining the quality of the visualisation are given.

Each of the experiments in this section used a single image from each patient in the full set of 360 images of both left, right and mediolateral oblique and craniocaudal views chosen at random. This meant was so as not to overrepresent a single patient for the real dataset. Therefore, 90 real mammograms in total were used for each experiment. The set of phantom mammograms used in this project consisted of 60 images but were divided into 6 groups corresponding to only a single ``case". Because of this limitation a single breast phantom from each case was selected at random to be included in the data used for the experiments, bringing the total number of images used in all experiments to 96.

Features extracted from both sets of images are compared using a two sample Kolmogorov-Smirnov (KS) test and are reported in the relevant section. The three dimensionality reduction algorithms were tested with each of the different feature sets and visualisations of the feature space in both 2 and 3 dimensions are shown for each.

Two different kinds of quality measure derived from the co-ranking matrix were computed for each of the visualisations shown in this section. The quality metrics used were trustworthiness \& continuity and the local continuity meta-criteria up to a neighbourhood of size $k=50$.

\section{Blob features}
The results for the two sample KS test between the real and synthetic datasets for blob features detected over 10 scales are shown in table \ref{table:blob_features_ks}. An explanation of what each type of feature means can be found in section \ref{subsubsec:implementation-blob-features}. 2D projections of the blob feature space as produced by t-SNE, Isomap and locally linear embedding are shown in figures \ref{fig:blob_SNE_mapping}, \ref{fig:blob_iso_mapping}, and \ref{fig:blob_LLE_mapping} respectively.

In each of the figures the real mammograms are shown as coloured dots and the breast phantoms are shown as coloured triangles. The labels corresponding to the colours used in each of the visualisations are the image's BIRADS class (in the case of real mammograms) or the volumetric breast density (VBD) (in the case of breast phantoms).

Generally speaking the phantom mammograms are shown to be very different from the real mammograms features used. The size of blobs detected in the phantom mammograms are generally larger and contain far fewer small scale blobs when compared to real mammograms. This is reflected in the projections for this feature space.

In the t-SNE projections it can be seen that all of the phantom blobs, regardless of VBD, are grouped towards the bottom of the distribution which contains a relatively high proportion of BIRADS risk class 3 \& 4 images. The projections produced by Isomap and LLE generally separate the breast phantoms for the original data more than with t-SNE. Several of the real mammograms with features that match those of the breast phantoms are also interspersed with the phantom mammograms. This can be seen best in the 2D projection produced by Isomap in figure \ref{fig:blob_iso_mapping}. These real mammograms are ones which tend to have a higher number of larger blobs detected than real mammograms in general.

\begin{table}[H]
\label{table:blob_features_ks}
\centering
\primitiveinput{tables/blob_features_ks}
\caption{Comparison of the Kolmogorov-Smirnov test results for each feature generated from the radii of blobs detected in an image between real and phantom mammograms.}
\end{table}

The quality evaluation for each of the visualisations are shown in figures \ref{fig:TC_2d_blobs}, \ref{fig:TC_3d_blobs}, and \ref{fig:LCMC_blobs}. The quality metrics shown in these figures suggest that the 2D visualisation produced by Isomap is the most trustworthy, but t-SNE has better continuity. In the case of the 3D projections Isomap provides a better visualisation with it topping both criteria. For both projections Isomap show better performance in terms of the LCMC, but is overtaken for larger values of $k$ in 2D projections by t-SNE and in 3D projections by LLE.

\clearpage

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/blob_SNE_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/blob_SNE_mapping_3d.png}}
	\caption{2D \& 3D projections of the blob feature space produced by the t-SNE algorithm with a learning rate of 200 and perplexity of 20.}\label{fig:blob_SNE_mapping}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/blob_iso_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/blob_iso_mapping_3d.png}}
	\caption{2D \& 3D projections of the blob feature space  produced by the Isomap algorithm with 4 neighbours.}\label{fig:blob_iso_mapping}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/blob_lle_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/blob_lle_mapping_3d.png}}
	\caption{2D \& 3D projections of the blob feature space produced by the LLE algorithm with 4 neighbours.}\label{fig:blob_LLE_mapping}
\end{figure}
\clearpage

\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/blob_trustworthiness_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/blob_continuity_2d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 2D projections produced from blob features.}\label{fig:TC_2d_blobs}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/blob_trustworthiness_3d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/blob_continuity_3d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 3D projections produced from blob features.}\label{fig:TC_3d_blobs}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/blob_lcmc_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/blob_lcmc_3d.png}}
	\caption{LCMC of both the 2D projection (left) and 3D projection (right) of the feature space for blobs.}\label{fig:LCMC_blobs}
\end{figure}
\clearpage

\subsection{Line features}
Results for the KS two sample test between the two feature spaces can be seen in table \ref{table:line_features_ks}. Again, as with blobs, the distributions for real and synthetic mammograms are not in particularly good agreement according to the test. 2D and 3D projections for the line feature space for each of the three different dimensionality reduction algorithms are shown in figures \ref{fig:line_SNE_mapping}, \ref{fig:line_iso_mapping}, and \ref{fig:line_LLE_mapping} respectively.

Note that in these results the value of the min area feature was removed. When using the min area feature all projections would produce two clusters. One smaller cluster would be created containing which contained blobs where the min area was much larger than the rest of the dataset. This is most likely caused by a thresholding issue causing some unwanted smaller lines to be retained for some of the images.

\begin{table}[H]
\label{table:line_features_ks}
\centering
\primitiveinput{tables/line_features_ks}
\caption{Comparison of the Kolmogorov-Smirnov test results for each feature generated from the area of lines detected in an image between real and phantom mammograms.}
\end{table}

The t-SNE projection shows that there is a general transition from images which contain a high mean area of linear structure on the bottom right towards images which have a lower mean area in the top left. In terms of BIRADS risk it can be seen that very low and very high risk classes are grouped towards the bottom right, reflecting that less liner structure is detected using the orientated bins method in low risk classes (because there's very little dense structure present) and high risk classes (because dense areas are mostly large, homogenous blobs not linear structure). As can be clearly seen from the visualisation the synthetic images are grouped towards the lower end reflecting the smaller size of the linear structures detected. The 3D version produced by t-SNE produced a far worse projection with less visible structure.

The projections produced by Isomap produce more clearly show the synthetics begin grouped in with the very low/high risk blobs towards the left of the mapping. For LLE the majority of the blobs are pushed away from the main body of the mapping and closer to some of the outliers of the real mammograms.

Examination of the three quality criteria show that Isomap produces better projections across both the 2D and 2D visualisations. t-SNE produced a 2D mapping which was comparable to Isomap in terms of trustworthiness and continuity, and LCMC. However in the case of the 3D case this was radically worse over all measures.

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/line_SNE_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/line_SNE_mapping_3d.png}}
	\caption{2D \& 3D projections of the line feature space produced by the t-SNE algorithm with a learning rate of 200 and perplexity of 20.}\label{fig:line_SNE_mapping}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/line_iso_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/line_iso_mapping_3d.png}}
	\caption{2D \& 3D projections of the line feature space  produced by the Isomap algorithm with 4 neighbours.}\label{fig:line_iso_mapping}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/line_lle_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/line_lle_mapping_3d.png}}
	\caption{2D \& 3D projections of the line feature space produced by the LLE algorithm with 4 neighbours.}\label{fig:line_LLE_mapping}
\end{figure}
\clearpage

\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_trustworthiness_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_continuity_2d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 2D projections produced from line features.}\label{fig:TC_2d_lines}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_trustworthiness_3d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_continuity_3d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 3D projections produced from line features.}\label{fig:TC_3d_lines}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_lcmc_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_lcmc_3d.png}}
	\caption{LCMC of both the 2D projection (left) and 3D projection (right) of the feature space for lines.}\label{fig:LCMC_lines}
\end{figure}
\clearpage

\begin{figure}[H]
	\label{fig:mammogram-histogram}
	\centering
	\includegraphics[width=0.8\textwidth]{Images/inverted_hist.png}
	\caption{Comparison of the histogram of a real mammogram (blue) against a synthetic mammogram (green). The distribution of intensities are radically different from one another.}
\end{figure}

\subsection{Intensity \& Texture Features}
\label{subsec:results-texture}
Intensity and texture features showed the lowest similarity between the real and phantom datasets. As can be seen in figure \ref{fig:mammogram-histogram} the intensity distribution of the phantom mammograms are nothing like a real mammogram. Because of this difference the results show that the they are clearly in different spaces. The results of the KS two sample test showed that the two distributions generated for both intensity and texture features are completely different. The results of the two sample Kolmogorov-Smirnov test are included in appendix \ref{appendix:ks-test} because the number of features for blobs is based on the number of scales used leading to the a large number (up to 100) of entries.

The feature spaces presented in this section were generated by taking ROIs defined by the blob and line features detected from each of the mammograms by computing intensity and texture features from each image patch. Because blobs are detected across a range of scales the average value for each scale is used leading to a feature space of size $nk$ where $n$ is the number of features and $k$ is the number of scales (e.g. for texture: $n = 4$ and $k = 10$ so it has $40$ features).

The results of performing dimensionality reduction on both of these feature spaces is that in all almost all cases the synthetic mammograms are separated from the real mammograms into an isolated cluster on their own. This is because the values for both types of feature are on average much higher for the breast phantoms than the real mammograms.

For features derived from patches defined by blobs it can be seen that between the real mammograms there is a trend visible in both intensity and textural features which causes some transition between high to low risk. This is particularly visible for intensity features in the 2D plot produced by t-SNE shown in figure \ref{fig:intensity_SNE_mapping} and in the 2D plot for Isomap shown in figure \ref{fig:texture_iso_mapping} for texture features. For both intensity and texture feature LLE was shown to produce two clear clusters. One which contains the synthetics and one which contains the real mammograms. LLE still shows some variation between real in a similar way to what is seen in the projections produced by Isomap and LLE, but the resulting visualisation shows a much clear division.

In the case of intensity features this transition is caused by a higher detection of blobs which are of generally higher intensity. For texture features the trend is explained by a transition for blobs with low contrast and dissimilarity and high homogeneity and energy corresponding to high risk blobs transitioning through to low risk blobs where the reverse is true.

Intensity features derived from lines do show a degree of separation between high and low risk mammograms. High risk mammograms typically have a higher average intensity. This is most clearly seen in the 2D visualisation produced by t-SNE in \ref{fig:intensity_SNE_mapping_lines}. On the other hand the texture features do not appear to show any meaningful relationship between risk classes. LLE shows results that are also very similar to what is seen in blob features and the reasons behind this splitting are much the same.

The quality measures for intensity features derived from blobs show that these visualisations are generally less faithful in comparison to shape based features. Isomap is again a winner here with it producing better visualisations across all measures. Both t-SNE and LLE generally performed much worse than Isomap. The embedding by texture features are much more faithful. The 2D projections show a close call between Isomap and t-SNE. For 3D projections t-SNE is the clear loser, being dramatically worse compared with t-SNE and Isomap.

Quality measures taken from the visualisations for intensity from lines show that the mapping produced by Isomap is better for projections in both two and three dimensions, but that t-SNE is at least comparable to Isomap in 2D. The results for texture features derived from lines show that the t-SNE performance of t-SNE is better for 2D. In the three dimensions Isomap is again a clear winner.

%------------------------------------------------------------------------------------
% Blob intensity and texture features
%------------------------------------------------------------------------------------

\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/intensity_SNE_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/intensity_SNE_mapping_3d.png}}
	\caption{2D \& 3D projections of the intensity feature space produced by the t-SNE algorithm with a learning rate of 200 and perplexity of 20.}\label{fig:intensity_SNE_mapping}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/intensity_iso_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/intensity_iso_mapping_3d.png}}
	\caption{2D \& 3D projections of the intensity feature space generated from blobs produced by the Isomap algorithm with 4 neighbours.}\label{fig:intensity_iso_mapping}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/intensity_lle_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/intensity_lle_mapping_3d.png}}
	\caption{2D \& 3D projections of the intensity feature space generated from blobs produced by the LLE algorithm with 4 neighbours.}\label{fig:intensity_LLE_mapping}
\end{figure}
\clearpage

% Quality for blob intensity features
%------------------------------------------------------------------------------------
\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/intensity_trustworthiness_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/intensity_continuity_2d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 2D projections produced from intensity features from blobs.}\label{fig:TC_2d_intensity}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/intensity_trustworthiness_3d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/intensity_continuity_3d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 3D projections produced from intensity features from blobs.}\label{fig:TC_3d_intensity}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/intensity_lcmc_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/intensity_lcmc_3d.png}}
	\caption{LCMC of both the 2D projection (left) and 3D projection (right) of the feature space for intensity from blobs.}\label{fig:LCMC_intensity}
\end{figure}
\clearpage

\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/texture_SNE_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/texture_SNE_mapping_3d.png}}
	\caption{2D \& 3D projections of the texture feature space generated from blobs generated from blobs produced by the t-SNE algorithm with a learning rate of 200 and perplexity of 20.}\label{fig:texture_SNE_mapping}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/texture_iso_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/texture_iso_mapping_3d.png}}
	\caption{2D \& 3D projections of the texture feature space generated from blobs produced by the Isomap algorithm with 4 neighbours.}\label{fig:texture_iso_mapping}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/texture_lle_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/texture_lle_mapping_3d.png}}
	\caption{2D \& 3D projections of the texture feature space generated from blobs produced by the LLE algorithm with 4 neighbours.}\label{fig:texture_LLE_mapping}
\end{figure}
\clearpage

% Quality for blob texture features
%------------------------------------------------------------------------------------

\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/texture_trustworthiness_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/texture_continuity_2d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 2D projections produced from texture features from blobs.}\label{fig:TC_2d_texture}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/texture_trustworthiness_3d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/texture_continuity_3d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 3D projections produced from texture features from blobs.}\label{fig:TC_3d_texture}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/texture_lcmc_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/texture_lcmc_3d.png}}
	\caption{LCMC of both the 2D projection (left) and 3D projection (right) of the feature space for texture.}\label{fig:LCMC_texture}
\end{figure}
\clearpage

%------------------------------------------------------------------------------------
% Line intensity and texture features
%------------------------------------------------------------------------------------

\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/line_intensity_SNE_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/line_intensity_SNE_mapping_3d.png}}
	\caption{2D \& 3D projections of the intensity feature space for lines produced by the t-SNE algorithm with a learning rate of 200 and perplexity of 20.}\label{fig:intensity_SNE_mapping_lines}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/line_intensity_iso_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/line_intensity_iso_mapping_3d.png}}
	\caption{2D \& 3D projections of the intensity feature space generated from lines produced by the Isomap algorithm with 4 neighbours.}\label{fig:intensity_iso_mapping_lines}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/line_intensity_lle_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/line_intensity_lle_mapping_3d.png}}
	\caption{2D \& 3D projections of the intensity feature space for lines generated from blobs produced by the LLE algorithm with 4 neighbours.}\label{fig:intensity_LLE_mapping_lines}
\end{figure}
\clearpage

% Quality for line intensity features
%------------------------------------------------------------------------------------
\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_intensity_trustworthiness_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_intensity_continuity_2d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 2D projections produced from intensity features from lines.}\label{fig:TC_2d_intensity}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_intensity_trustworthiness_3d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_intensity_continuity_3d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 3D projections produced from intensity features from lines.}\label{fig:TC_3d_intensity}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_intensity_lcmc_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/line_intensity_lcmc_3d.png}}
	\caption{LCMC of both the 2D projection (left) and 3D projection (right) of the feature space for intensity from lines.}\label{fig:LCMC_intensity}
\end{figure}
\clearpage

\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/lines_texture_SNE_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/lines_texture_SNE_mapping_3d.png}}
	\caption{2D \& 3D projections of the texture feature space generated generated from lines produced by the t-SNE algorithm with a learning rate of 200 and perplexity of 20.}\label{fig:texture_SNE_mapping_lines}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/lines_texture_iso_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/lines_texture_iso_mapping_3d.png}}
	\caption{2D \& 3D projections of the texture feature space generated from lines produced by the Isomap algorithm with 4 neighbours.}\label{fig:texture_iso_mapping_lines}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.4\textwidth]{figures/mappings/lines_texture_lle_mapping_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/mappings/lines_texture_lle_mapping_3d.png}}
	\caption{2D \& 3D projections of the texture feature space generated from lines produced by the LLE algorithm with 4 neighbours.}\label{fig:texture_LLE_mapping_lines}
\end{figure}
\clearpage

% Quality for line texture features
%------------------------------------------------------------------------------------

\clearpage
\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/lines_texture_trustworthiness_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/lines_texture_continuity_2d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 2D projections produced from texture features from lines.}\label{fig:TC_2d_texture}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/lines_texture_trustworthiness_3d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/lines_texture_continuity_3d.png}}
	\caption{Trustworthiness (left) and continuity (right) of the 3D projections produced from texture features from lines.}\label{fig:TC_3d_texture}
\end{figure}

\begin{figure}[H]
	\centering
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/lines_texture_lcmc_2d.png}}
	\subfigure{\includegraphics[width=0.49\textwidth]{figures/quality_measures/lines_texture_lcmc_3d.png}}
	\caption{LCMC of both the 2D projection (left) and 3D projection (right) of the feature space from lines for texture.}\label{fig:LCMC_texture}
\end{figure}
\clearpage

\section{Conclusions}
In summary, it can be concluded that the synthetic mammograms used as part of this experiment are not significantly related to real mammograms in terms of the features derived during this study. The synthetic mammograms appear to be closest to real mammograms in terms of the shape of the structures present in the image. The best results from this experiment were derived from the feature space of multi-scale blobs. Line features also seemed to positively show the the real and synthetic mammograms are at least in the same space in terms of shape. However, texture and intensity features derived from either of the features clearly show that the two datasets are not in the same intensity space. The two sample KS test confirms that the features created from both datasets are statistically not drawn from the same distribution and therefore we must conclude that they are, for all features presented here, effectively different.

This conclusion roughly correlates with the limitations discussed by the authors of the synthetic data \cite{bakic2002mammogram1, bakic2002mammogram2, bakic2003mammogram3}. They state that the synthetic mammograms are closest to real mammograms in terms of shape but are not so close in terms of intensity and texture. In the experiments with shape features presented here the major difference between the real and synthetic mammograms was caused by a lack of small scale structure being detected in the synthetic mammograms. This causes them to be grouped in with mammograms which are deemed to be of higher risk, regardless of their effective risk, because of the lack of small blob counts detected. The same can be said for line features where the number and size of lines is generally smaller, regardless of the risk.

The quality evaluation of the visualisations produced suggests that Isomap produces visualisations which best capture the local neighbourhood structure of mappings. t-SNE appears to often show similar levels of faithfulness in compared to Isomap in two dimensions, but was shown to be much worse for three dimensions.


text:
<?xml version="1.0" encoding="utf-8"?>
<!--未来几天天气的信息布局; 最外层使用了LinearLayout定义了一个半透明的背景, 然后TextView定义了一个标题,
    接着使用了一个LinearLayout定义了一个用于显示未来几天天气信息的布局.(这个布局并没有放入内容, 这是要根据服
    务器返回的数据在代码中动态添加的), 为此我们定义了一个未来天气信息的字布局forecast_item.xml-->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_margin="15dp"
    android:background="#8000">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginLeft="15dp"
        android:layout_marginTop="15dp"
        android:text="预报"
        android:textColor="#fff"
        android:textSize="20sp"/>

    <LinearLayout
        android:id="@+id/forecast_layout"
        android:orientation= "vertical"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"></LinearLayout>

</LinearLayout>

redpajama_set_name: RedPajamaGithub


text:
package cn.org.quark.admin.controller;

import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Restrictions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import cn.org.quark.admin.entity.CoreDept;
import cn.org.quark.admin.entity.CoreResource;
import cn.org.quark.admin.entity.CoreRole;
import cn.org.quark.admin.entity.CoreUser;
import cn.org.quark.admin.manager.DeptManager;
import cn.org.quark.admin.manager.RoleManager;
import cn.org.quark.admin.manager.UserManager;
import cn.org.quark.core.common.RtnCode;
import cn.org.quark.core.dao.support.CriteriaSetup;
import cn.org.quark.core.dao.support.Page;
import cn.org.quark.core.exception.BizException;
import cn.org.quark.core.login.LoginUtil;
import cn.org.quark.core.login.Loginer;
import cn.org.quark.core.utils.UtilString;
import cn.org.quark.core.web.springmvc.BaseEntityAction;
import cn.org.quark.core.web.support.ResultData;
import cn.org.quark.core.web.support.RtnResult;
import cn.org.quark.core.web.support.RtnStatusResult;

@Controller("mvcUserAction")
@RequestMapping("/user")
public class UserAction extends BaseEntityAction<CoreUser,UserManager>{
	private static Logger logger = LoggerFactory.getLogger(UserAction.class);
	/**
	 *
	 * @return
	 */
	@RequestMapping("/pwdedit")
	public String editPwd(){
		return "admin/pwd_edit";
	}
	/**
	 * 修改密码
	 * @param oldPwd
	 * @param newPwd
	 * @return
	 */
	@RequestMapping("/pwdmodify")
	@ResponseBody
	public ResultData modifyPwd(String oldPwd , String newPwd,HttpServletRequest request){
		Loginer loginer = LoginUtil.getLoginer(request);
		logger.debug("==>loginid:"+loginer.getLoginid()+",oldPwd:"+oldPwd+",newPwd:"+newPwd);
		String id = loginer.getUserid();
		if(!userManager.isRightPwd(id,oldPwd)){
			throw new BizException(RtnCode.PWD_OLDPWD_INCORRECT);
		}
		userManager.changePwd(id, newPwd);
		ResultData resultData = new ResultData();
		return resultData;
	}
	/**
	 * 修改个人信息
	 * @param coreUser
	 * @param request
	 * @return
	 */
	@RequestMapping("/modifyInfo")
	@ResponseBody
	public RtnStatusResult modifyInfo(CoreUser coreUser , HttpServletRequest request){
		RtnStatusResult result = new RtnStatusResult();
		try {
			Loginer loginer = LoginUtil.getLoginer(request);
			String id = loginer.getUserid();
			CoreUser _coreUser = userManager.get(id);
			_coreUser.setCname(coreUser.getCname());
			_coreUser.setEmail(coreUser.getEmail());
			_coreUser.setMobile(coreUser.getMobile());
			_coreUser.setSex(coreUser.getSex());
			_coreUser.setSign(coreUser.getSign());
			userManager.save(_coreUser);
		} catch (Exception e) {
			result.setCode(RtnCode.OTHER_ERROR);
			result.setMessage(e.getMessage());
		}
		return result;
	}
	/**
	 * 查询用户信息
	 * @param request
	 * @return
	 */
	@RequestMapping("/queryInfo")
	@ResponseBody
	public RtnResult<CoreUser> queryInfo(HttpServletRequest request){
		RtnResult<CoreUser> result = new RtnResult<CoreUser>();
		try {
			Loginer loginer = LoginUtil.getLoginer(request);
			String id = loginer.getUserid();
			CoreUser _coreUser = userManager.get(id);
			result.setData(_coreUser);
		} catch (Exception e) {
			result.setCode(RtnCode.OTHER_ERROR);
			result.setMessage(e.getMessage());
		}
		return result;
	}
	/**
	 * 修改密码
	 * @param oldPwd
	 * @param newPwd
	 * @return
	 * @throws Exception
	 */
	@RequestMapping("/modifystatus")
	@ResponseBody
	public ResultData modifyStatus(String oid , String status) throws Exception{
		super.getEntityManager().changeStatus(oid, status);
		ResultData resultData = new ResultData();
		return resultData;
	}

	@RequestMapping("/index")
	public String index() {
		return "admin/user_list";
	}
	@RequestMapping("/list")
	@ResponseBody
	public ResultData<List<CoreUser>> list(String deptId ,String name, Page page) throws Exception{

		List<CoreDept> coreDepts = deptManager.queryLayerChildrenDept(deptId);
		CriteriaSetup criteriaSetup = new CriteriaSetup();
		criteriaSetup.addCriterion(Restrictions.in("dept", coreDepts));
		if(!UtilString.isEmpty(name)){
			criteriaSetup.addCriterion(Restrictions.like("cname", name,MatchMode.ANYWHERE));
		}
		return super.doListEntity(criteriaSetup, page);
	}

	/**
	 * 删除
	 * @param id
	 * @return
	 * @throws Exception
	 */
	@RequestMapping("/delete")
	@ResponseBody
	public ResultData<CoreUser> delete(String id) throws Exception{
		if("1".equals(id)){
			ResultData r = new ResultData();
			r.setCode(RtnCode.CANNOT_OPERATE);
			return r;
		}
		return super.delete(id);
	}

	/**
	 * 编辑
	 * @param id
	 * @return
	 * @throws Exception
	 */
	@RequestMapping("/edit")
	@ResponseBody
	public ResultData<CoreUser> edit(String id) throws Exception{
		return super.edit(id);
	}
	@Override
	protected void resetEditEntity(CoreUser entity) {
		entity.setDeptOid(entity.getDept().getOid());
	}

	/**
	 * 保存
	 * @param entity
	 * @return
	 * @throws Exception
	 */
	@RequestMapping("/save")
	@ResponseBody
	public ResultData<CoreUser> save(CoreUser entity) throws Exception{
		if(UtilString.isEmpty(entity.getOid())) entity.setOid(null);
		return super.save(entity);
	}

	@RequestMapping("/grant")
	@ResponseBody
	public ResultData<CoreRole> grant(String userid , String roleids) throws Exception{
		Assert.hasLength(userid,"userid is empty");
		Assert.hasLength(roleids,"roleids is empty");
		userManager.saveRoles(userid, roleids.split(","));;
		return new ResultData();
	}

	@Autowired
	private UserManager userManager;
	@Autowired
	private DeptManager deptManager;
}


text:
package org.vaadin.gwtol3.client.control;

import com.google.gwt.core.client.JavaScriptObject;

/**
 * Options passed to the ScaleLineControl on creation
 */
public class ScaleLineControlOptions extends JavaScriptObject {
    protected ScaleLineControlOptions() {
    }

    public static final native ScaleLineControlOptions create()/*-{
        return {};
    }-*/;

    /** Sets the css class name of the control. Default is ol-scale-line
     *
     * @param className className
     */
    public final native void setClassName(String className)/*-{
        this.className=className;
    }-*/;

    /** Sets the minimum width in pixels. Default is 64
     *
     * @param minWidth
     */
    public final native void setMinWidth(int minWidth)/*-{
        this.minWidth=minWidth;
    }-*/;

    /** Sets the units of the scale line ('degrees', 'imperial', 'nautical', 'metric', 'us') Default is metric.
     *
     * @param units
     */
    public final native void setUnits(String units)/*-{
        this.units=units;
    }-*/;

    public static final String UNITS_DEGREES="degrees";
    public static final String UNITS_IMPERIAL="imperial";
    public static final String UNITS_NAUTICAL="nautical";
    public static final String UNITS_METRIC="metric";
    public static final String UNITS_US="us";
}


text:
package org.apache.accumulo.core.data;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.apache.accumulo.core.data.thrift.TKey;
import org.apache.accumulo.core.data.thrift.TKeyValue;
import org.apache.accumulo.core.security.ColumnVisibility;
import org.apache.hadoop.io.Text;
import org.junit.Test;

public class KeyTest {

  @Test
  public void testDeletedCompare() {
    Key k1 = new Key("r1".getBytes(), "cf".getBytes(), "cq".getBytes(), new byte[0], 0, false);
    Key k2 = new Key("r1".getBytes(), "cf".getBytes(), "cq".getBytes(), new byte[0], 0, false);
    Key k3 = new Key("r1".getBytes(), "cf".getBytes(), "cq".getBytes(), new byte[0], 0, true);
    Key k4 = new Key("r1".getBytes(), "cf".getBytes(), "cq".getBytes(), new byte[0], 0, true);

    assertTrue(k1.equals(k2));
    assertTrue(k3.equals(k4));
    assertTrue(k1.compareTo(k3) > 0);
    assertTrue(k3.compareTo(k1) < 0);
  }

  @Test
  public void testCopyData() {
    byte row[] = "r".getBytes();
    byte cf[] = "cf".getBytes();
    byte cq[] = "cq".getBytes();
    byte cv[] = "cv".getBytes();

    Key k1 = new Key(row, cf, cq, cv, 5l, false, false);
    Key k2 = new Key(row, cf, cq, cv, 5l, false, true);

    assertSame(row, k1.getRowBytes());
    assertSame(cf, k1.getColFamily());
    assertSame(cq, k1.getColQualifier());
    assertSame(cv, k1.getColVisibility());

    assertSame(row, k1.getRowData().getBackingArray());
    assertSame(cf, k1.getColumnFamilyData().getBackingArray());
    assertSame(cq, k1.getColumnQualifierData().getBackingArray());
    assertSame(cv, k1.getColumnVisibilityData().getBackingArray());

    assertNotSame(row, k2.getRowBytes());
    assertNotSame(cf, k2.getColFamily());
    assertNotSame(cq, k2.getColQualifier());
    assertNotSame(cv, k2.getColVisibility());

    assertNotSame(row, k2.getRowData().getBackingArray());
    assertNotSame(cf, k2.getColumnFamilyData().getBackingArray());
    assertNotSame(cq, k2.getColumnQualifierData().getBackingArray());
    assertNotSame(cv, k2.getColumnVisibilityData().getBackingArray());

    assertEquals(k1, k2);

  }

  @Test
  public void testString() {
    Key k1 = new Key("r1");
    Key k2 = new Key(new Text("r1"));
    assertEquals(k2, k1);

    k1 = new Key("r1", "cf1");
    k2 = new Key(new Text("r1"), new Text("cf1"));
    assertEquals(k2, k1);

    k1 = new Key("r1", "cf2", "cq2");
    k2 = new Key(new Text("r1"), new Text("cf2"), new Text("cq2"));
    assertEquals(k2, k1);

    k1 = new Key("r1", "cf2", "cq2", "cv");
    k2 = new Key(new Text("r1"), new Text("cf2"), new Text("cq2"), new Text("cv"));
    assertEquals(k2, k1);

    k1 = new Key("r1", "cf2", "cq2", "cv", 89);
    k2 = new Key(new Text("r1"), new Text("cf2"), new Text("cq2"), new Text("cv"), 89);
    assertEquals(k2, k1);

    k1 = new Key("r1", "cf2", "cq2", 89);
    k2 = new Key(new Text("r1"), new Text("cf2"), new Text("cq2"), 89);
    assertEquals(k2, k1);

  }

  @Test
  public void testVisibilityFollowingKey() {
    Key k = new Key("r", "f", "q", "v");
    assertEquals(k.followingKey(PartialKey.ROW_COLFAM_COLQUAL_COLVIS).toString(), "r f:q [v%00;] " + Long.MAX_VALUE + " false");
  }

  public void testVisibilityGetters() {
    Key k = new Key("r", "f", "q", "v1|(v2&v3)");

    Text expression = k.getColumnVisibility();
    ColumnVisibility parsed = k.getColumnVisibilityParsed();

    assertEquals(expression, new Text(parsed.getExpression()));
  }

  @Test
  public void testThrift() {
    Key k = new Key("r1", "cf2", "cq2", "cv");
    TKey tk = k.toThrift();
    Key k2 = new Key(tk);
    assertEquals(k, k2);
  }

  @Test(expected=IllegalArgumentException.class)
  public void testThrift_Invalid() {
    Key k = new Key("r1", "cf2", "cq2", "cv");
    TKey tk = k.toThrift();
    tk.setRow((byte[]) null);
    new Key(tk);
  }

  @Test
  public void testCompressDecompress() {
    List<KeyValue> kvs = new ArrayList<KeyValue>();
    kvs.add(new KeyValue(new Key(), new byte[] {}));
    kvs.add(new KeyValue(new Key("r"), new byte[] {}));
    kvs.add(new KeyValue(new Key("r", "cf"), new byte[] {}));
    kvs.add(new KeyValue(new Key("r2", "cf"), new byte[] {}));
    kvs.add(new KeyValue(new Key("r", "cf", "cq"), new byte[] {}));
    kvs.add(new KeyValue(new Key("r2", "cf2", "cq"), new byte[] {}));
    kvs.add(new KeyValue(new Key("r", "cf", "cq", "cv"), new byte[] {}));
    kvs.add(new KeyValue(new Key("r2", "cf2", "cq2", "cv"), new byte[] {}));
    kvs.add(new KeyValue(new Key("r2", "cf2", "cq2", "cv"), new byte[] {}));
    kvs.add(new KeyValue(new Key(), new byte[] {}));

    List<TKeyValue> tkvs = Key.compress(kvs);
    Key.decompress(tkvs);

    assertEquals(kvs.size(), tkvs.size());
    Iterator<KeyValue> kvi = kvs.iterator();
    Iterator<TKeyValue> tkvi = tkvs.iterator();

    while (kvi.hasNext()) {
      KeyValue kv = kvi.next();
      TKeyValue tkv = tkvi.next();
      assertEquals(kv.getKey(), new Key(tkv.getKey()));
    }
  }
}


text:
module Azure::ServiceFabric::V6_4_0_36
  module Models
    #
    # Represents the base for all Node Events.
    #
    class NodeEvent < FabricEvent

      include MsRestAzure

      def initialize
        @Kind = "NodeEvent"
      end

      attr_accessor :Kind

      # @return [String] The name of a Service Fabric node.
      attr_accessor :node_name

      #
      # Mapper for NodeEvent class as Ruby Hash.
      # This will be used for serialization/deserialization.
      #
      def self.mapper()
        {
          client_side_validation: true,
          required: false,
          serialized_name: 'NodeEvent',
          type: {
            name: 'Composite',
            class_name: 'NodeEvent',
            model_properties: {
              event_instance_id: {
                client_side_validation: true,
                required: true,
                serialized_name: 'EventInstanceId',
                type: {
                  name: 'String'
                }
              },
              category: {
                client_side_validation: true,
                required: false,
                serialized_name: 'Category',
                type: {
                  name: 'String'
                }
              },
              time_stamp: {
                client_side_validation: true,
                required: true,
                serialized_name: 'TimeStamp',
                type: {
                  name: 'DateTime'
                }
              },
              has_correlated_events: {
                client_side_validation: true,
                required: false,
                serialized_name: 'HasCorrelatedEvents',
                type: {
                  name: 'Boolean'
                }
              },
              Kind: {
                client_side_validation: true,
                required: true,
                serialized_name: 'Kind',
                type: {
                  name: 'String'
                }
              },
              node_name: {
                client_side_validation: true,
                required: true,
                serialized_name: 'NodeName',
                type: {
                  name: 'String'
                }
              }
            }
          }
        }
      end
    end
  end
end


text:
SHELL := bash

# Environment variables.
export PYTHONPATH := $(CURDIR):$(PYTHONPATH)
export MAX_LINE_LENGTH := 79

# Default game settings for `run`.
DEFAULT_WIDTH := 10
DEFAULT_HEIGHT := 10
DEFAULT_DELAY := 0.5

# Verbosity settings.
V_FLAGS := $(if $V,$(foreach n,$(shell seq $(V)),-v),)

# Build everything needed to install.
.PHONY: build
build:
	python setup.py build

# Install everything from build directory.
.PHONY: install
install:
	python setup.py install

# Install in development mode.
.PHONY: develop
develop:
	python setup.py develop

# Install deps.
.PHONY: deps
deps:
	pip install $(V_FLAGS) -r requirements.dev.txt

# Format code.
.PHONY: fmt
fmt:
	pyfmt --select $(if $(SELECT),$(SELECT),modified) $(if $(AMEND),--commit amend --commit-msg)

# Format code and stage changes.
.PHONY: fix
fix: fmt
	git add -u

# Run tests.
.PHONY: test
test:
	py.test $(if $V,--verbosity=$V)

# Format + test.
.PHONY: check
check: fmt test
	python setup.py check

# Run app.
W ?= $(if $(WIDTH),$(WIDTH),$(DEFAULT_WIDTH))
H ?= $(if $(HEIGHT),$(HEIGHT),$(DEFAULT_HEIGHT))
DELAY := --delay $(if $(DELAY),$(DELAY),$(DEFAULT_DELAY))
SEP := $(if $(SEPARATOR), --separator $(SEPARATOR))
PAD := $(if $(PADDING), --padding $(PADDING))
OUT := $(if $(OUTFILE), --outfile $(OUTFILE))
.PHONY: run
run:
	python conway $(DELAY)$(SEP)$(PAD)$(OUT) -- $(W) $(H)


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

<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<TITLE>
Uses of Class org.apache.hadoop.yarn.webapp.hamlet.Hamlet.SPAN (hadoop-yarn-common 2.3.0 API)
</TITLE>

<META NAME="date" CONTENT="2015-03-06">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../../../../stylesheet.css" TITLE="Style">

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes

Uses of Class
org.apache.hadoop.yarn.webapp.hamlet.Hamlet.SPAN

Packages that use Hamlet.SPAN

org.apache.hadoop.yarn.webapp.hamlet

Uses of Hamlet.SPAN in org.apache.hadoop.yarn.webapp.hamlet

Methods in org.apache.hadoop.yarn.webapp.hamlet that return Hamlet.SPAN

 Hamlet.SPAN<T>
Hamlet.SPAN._(Object... lines)

 Hamlet.SPAN<T>
Hamlet.SPAN._r(Object... lines)

 Hamlet.SPAN<T>
Hamlet.SPAN.$class(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$dir(HamletSpec.Dir value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$id(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$lang(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$onclick(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$ondblclick(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$onkeydown(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$onkeypress(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$onkeyup(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$onmousedown(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$onmousemove(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$onmouseout(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$onmouseover(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$onmouseup(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$style(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.$title(String value)

 Hamlet.SPAN<T>
Hamlet.SPAN.a(String href,
  String anchorText)

 Hamlet.SPAN<T>
Hamlet.SPAN.a(String selector,
  String href,
  String anchorText)

 Hamlet.SPAN<T>
Hamlet.SPAN.abbr(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.abbr(String selector,
     String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.b(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.b(String selector,
  String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.bdo(HamletSpec.Dir dir,
    String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.br(String selector)

 Hamlet.SPAN<T>
Hamlet.SPAN.button(String selector,
       String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.cite(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.cite(String selector,
     String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.code(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.code(String selector,
     String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.del(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.dfn(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.dfn(String selector,
    String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.em(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.em(String selector,
   String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.i(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.i(String selector,
  String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.img(String src)

 Hamlet.SPAN<T>
Hamlet.SPAN.ins(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.kbd(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.kbd(String selector,
    String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.label(String forId,
      String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.q(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.q(String selector,
  String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.samp(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.samp(String selector,
     String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.script(String src)

 Hamlet.SPAN<T>
Hamlet.SPAN.small(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.small(String selector,
      String cdata)

 Hamlet.SPAN<Hamlet.TD<T>>
Hamlet.TD.span()

 Hamlet.SPAN<Hamlet.TH<T>>
Hamlet.TH.span()

 Hamlet.SPAN<Hamlet.CAPTION<T>>
Hamlet.CAPTION.span()

 Hamlet.SPAN<Hamlet.BUTTON<T>>
Hamlet.BUTTON.span()

 Hamlet.SPAN<Hamlet.LEGEND<T>>
Hamlet.LEGEND.span()

 Hamlet.SPAN<Hamlet.FIELDSET<T>>
Hamlet.FIELDSET.span()

 Hamlet.SPAN<Hamlet.LABEL<T>>
Hamlet.LABEL.span()

 Hamlet.SPAN<Hamlet.LI<T>>
Hamlet.LI.span()

 Hamlet.SPAN<Hamlet.DD<T>>
Hamlet.DD.span()

 Hamlet.SPAN<Hamlet.DT<T>>
Hamlet.DT.span()

 Hamlet.SPAN<Hamlet.DEL<T>>
Hamlet.DEL.span()

 Hamlet.SPAN<Hamlet.INS<T>>
Hamlet.INS.span()

 Hamlet.SPAN<Hamlet.Q<T>>
Hamlet.Q.span()

 Hamlet.SPAN<Hamlet.PRE<T>>
Hamlet.PRE.span()

 Hamlet.SPAN<Hamlet.H6<T>>
Hamlet.H6.span()

 Hamlet.SPAN<Hamlet.H5<T>>
Hamlet.H5.span()

 Hamlet.SPAN<Hamlet.H4<T>>
Hamlet.H4.span()

 Hamlet.SPAN<Hamlet.H3<T>>
Hamlet.H3.span()

 Hamlet.SPAN<Hamlet.H2<T>>
Hamlet.H2.span()

 Hamlet.SPAN<Hamlet.H1<T>>
Hamlet.H1.span()

 Hamlet.SPAN<Hamlet.P<T>>
Hamlet.P.span()

 Hamlet.SPAN<Hamlet.OBJECT<T>>
Hamlet.OBJECT.span()

 Hamlet.SPAN<Hamlet.A<T>>
Hamlet.A.span()

 Hamlet.SPAN<Hamlet.DIV<T>>
Hamlet.DIV.span()

 Hamlet.SPAN<Hamlet.ADDRESS<T>>
Hamlet.ADDRESS.span()

 Hamlet.SPAN<Hamlet.BDO<T>>
Hamlet.BDO.span()

 Hamlet.SPAN<Hamlet.SPAN<T>>
Hamlet.SPAN.span()

 Hamlet.SPAN<Hamlet.SUP<T>>
Hamlet.SUP.span()

 Hamlet.SPAN<Hamlet.SUB<T>>
Hamlet.SUB.span()

 Hamlet.SPAN<Hamlet.ACRONYM<T>>
Hamlet.ACRONYM.span()

 Hamlet.SPAN<Hamlet.ABBR<T>>
Hamlet.ABBR.span()

 Hamlet.SPAN<Hamlet.CITE<T>>
Hamlet.CITE.span()

 Hamlet.SPAN<Hamlet.VAR<T>>
Hamlet.VAR.span()

 Hamlet.SPAN<Hamlet.KBD<T>>
Hamlet.KBD.span()

 Hamlet.SPAN<Hamlet.SAMP<T>>
Hamlet.SAMP.span()

 Hamlet.SPAN<Hamlet.CODE<T>>
Hamlet.CODE.span()

 Hamlet.SPAN<Hamlet.DFN<T>>
Hamlet.DFN.span()

 Hamlet.SPAN<Hamlet.STRONG<T>>
Hamlet.STRONG.span()

 Hamlet.SPAN<Hamlet.EM<T>>
Hamlet.EM.span()

 Hamlet.SPAN<Hamlet.SMALL<T>>
Hamlet.SMALL.span()

 Hamlet.SPAN<Hamlet.B<T>>
Hamlet.B.span()

 Hamlet.SPAN<Hamlet.I<T>>
Hamlet.I.span()

 Hamlet.SPAN<T>
Hamlet.SPAN.span(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.span(String selector,
     String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.strong(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.strong(String selector,
       String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.sub(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.sub(String selector,
    String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.sup(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.sup(String selector,
    String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.textarea(String selector,
         String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.var(String cdata)

 Hamlet.SPAN<T>
Hamlet.SPAN.var(String selector,
    String cdata)

Methods in org.apache.hadoop.yarn.webapp.hamlet that return types with arguments of type Hamlet.SPAN

 Hamlet.A<Hamlet.SPAN<T>>
Hamlet.SPAN.a()

 Hamlet.A<Hamlet.SPAN<T>>
Hamlet.SPAN.a(String selector)

 Hamlet.ABBR<Hamlet.SPAN<T>>
Hamlet.SPAN.abbr()

 Hamlet.B<Hamlet.SPAN<T>>
Hamlet.SPAN.b()

 Hamlet.BDO<Hamlet.SPAN<T>>
Hamlet.SPAN.bdo()

 Hamlet.BR<Hamlet.SPAN<T>>
Hamlet.SPAN.br()

 Hamlet.BUTTON<Hamlet.SPAN<T>>
Hamlet.SPAN.button()

 Hamlet.BUTTON<Hamlet.SPAN<T>>
Hamlet.SPAN.button(String selector)

 Hamlet.CITE<Hamlet.SPAN<T>>
Hamlet.SPAN.cite()

 Hamlet.CODE<Hamlet.SPAN<T>>
Hamlet.SPAN.code()

 Hamlet.DEL<Hamlet.SPAN<T>>
Hamlet.SPAN.del()

 Hamlet.DFN<Hamlet.SPAN<T>>
Hamlet.SPAN.dfn()

 Hamlet.EM<Hamlet.SPAN<T>>
Hamlet.SPAN.em()

 Hamlet.I<Hamlet.SPAN<T>>
Hamlet.SPAN.i()

 Hamlet.IMG<Hamlet.SPAN<T>>
Hamlet.SPAN.img()

 Hamlet.INPUT<Hamlet.SPAN<T>>
Hamlet.SPAN.input()

 Hamlet.INPUT<Hamlet.SPAN<T>>
Hamlet.SPAN.input(String selector)

 Hamlet.INS<Hamlet.SPAN<T>>
Hamlet.SPAN.ins()

 Hamlet.KBD<Hamlet.SPAN<T>>
Hamlet.SPAN.kbd()

 Hamlet.LABEL<Hamlet.SPAN<T>>
Hamlet.SPAN.label()

 Hamlet.MAP<Hamlet.SPAN<T>>
Hamlet.SPAN.map()

 Hamlet.MAP<Hamlet.SPAN<T>>
Hamlet.SPAN.map(String selector)

 Hamlet.OBJECT<Hamlet.SPAN<T>>
Hamlet.SPAN.object()

 Hamlet.OBJECT<Hamlet.SPAN<T>>
Hamlet.SPAN.object(String selector)

 Hamlet.Q<Hamlet.SPAN<T>>
Hamlet.SPAN.q()

 Hamlet.SAMP<Hamlet.SPAN<T>>
Hamlet.SPAN.samp()

 Hamlet.SCRIPT<Hamlet.SPAN<T>>
Hamlet.SPAN.script()

 Hamlet.SELECT<Hamlet.SPAN<T>>
Hamlet.SPAN.select()

 Hamlet.SELECT<Hamlet.SPAN<T>>
Hamlet.SPAN.select(String selector)

 Hamlet.SMALL<Hamlet.SPAN<T>>
Hamlet.SPAN.small()

 Hamlet.SPAN<Hamlet.SPAN<T>>
Hamlet.SPAN.span()

 Hamlet.STRONG<Hamlet.SPAN<T>>
Hamlet.SPAN.strong()

 Hamlet.SUB<Hamlet.SPAN<T>>
Hamlet.SPAN.sub()

 Hamlet.SUP<Hamlet.SPAN<T>>
Hamlet.SPAN.sup()

 Hamlet.TEXTAREA<Hamlet.SPAN<T>>
Hamlet.SPAN.textarea()

 Hamlet.TEXTAREA<Hamlet.SPAN<T>>
Hamlet.SPAN.textarea(String selector)

 Hamlet.VAR<Hamlet.SPAN<T>>
Hamlet.SPAN.var()

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes

Copyright © 2015 Apache Software Foundation. All Rights Reserved.


text:
<?php
namespace gossi\formatter\parser;

use phootwork\tokenizer\Token;
use phootwork\tokenizer\TokenCollection;
use phootwork\tokenizer\TokenVisitorInterface;

class TokenTracker implements TokenVisitorInterface {

	private $tokens;
	private $context;

	private $next;
	private $prev;

	public function __construct(TokenCollection $tokens, Context $contextManager) {
		$this->tokens = $tokens;
		$this->context = $contextManager;
		$this->context->setTracker($this);
	}

	public function visitToken(Token $token) {
		$this->next = $this->nextToken($token);
		$this->prev = $this->prevToken($token);
		$this->context->visitToken($token);
	}

	public function getNextToken() {
		return $this->next;
	}

	public function getPrevToken() {
		return $this->prev;
	}

	public function nextToken(Token $token, $offset = 1) {
		$index = $this->tokens->indexOf($token);
		$index += $offset;
		$token = $this->tokens->get($index);

		if ($token === null) {
			$token = new Token();
		}

		return $token;
	}

	public function prevToken($token, $offset = 1) {
		$index = $this->tokens->indexOf($token);
		$index -= $offset;
		$token = $this->tokens->get($index);

		if ($token === null) {
			$token = new Token();
		}

		return $token;
	}

	public function isLastToken(Token $token) {
		return $this->tokens->indexOf($token) == $this->tokens->size() - 1;
	}

}


text:
#include <aws/events/model/ListRuleNamesByTargetResult.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/core/AmazonWebServiceResult.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/UnreferencedParam.h>

#include <utility>

using namespace Aws::CloudWatchEvents::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
using namespace Aws;

ListRuleNamesByTargetResult::ListRuleNamesByTargetResult()
{
}

ListRuleNamesByTargetResult::ListRuleNamesByTargetResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
{
  *this = result;
}

ListRuleNamesByTargetResult& ListRuleNamesByTargetResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
{
  JsonView jsonValue = result.GetPayload().View();
  if(jsonValue.ValueExists("RuleNames"))
  {
    Array<JsonView> ruleNamesJsonList = jsonValue.GetArray("RuleNames");
    for(unsigned ruleNamesIndex = 0; ruleNamesIndex < ruleNamesJsonList.GetLength(); ++ruleNamesIndex)
    {
      m_ruleNames.push_back(ruleNamesJsonList[ruleNamesIndex].AsString());
    }
  }

  if(jsonValue.ValueExists("NextToken"))
  {
    m_nextToken = jsonValue.GetString("NextToken");

  }

  return *this;
}


text:
TableOperations.I18N = {
	"Align":					  "Align",
	"All four sides":				  "All four sides",
	"Apply style to all cells":                       "Apply style to all cells",
	"Background":					  "Background",
	"Baseline":                                       "Baseline",
	"Border":					  "Border",
	"Borders":					  "Borders",
	"Bottom":                                         "Bottom",
	"CSS Style":					  "Style",
	"Caption":					  "Caption",
	"Cell Properties":                                "Cell Properties",
	"Center":					  "Center",
	"Char":                                           "Char",
	"Collapsed borders":                              "Collapsed borders",
	"Color":					  "Color",
	"Description":					  "Description",
	"FG Color":					  "FG Color",
	"Float":                                          "Float",
	"Frames":					  "Frames",
	"Height":                                         "Height",
	"How many columns would you like to merge?":      "How many columns would you like to merge?",
	"How many rows would you like to merge?":         "How many rows would you like to merge?",
	"Image URL":					  "Image URL",
	"Justify":                                        "Justify",
	"Layout":					  "Layout",
	"Left":						  "Left",
	"Margin":                                         "Margin",
	"Middle":                                         "Middle",
	"No rules":					  "No rules",
	"No sides":					  "No sides",
	"Not set":                                        "Not set",
	"None":                                           "None",
	"Padding":					  "Padding",
	"Please click into some cell":                    "Please click into some cell",
	"Right":					  "Right",
	"Row Properties":                                 "Row Properties",
	"Rules will appear between all rows and columns": "Rules will appear between all rows and columns",
	"Rules will appear between columns only":	  "Rules will appear between columns only",
	"Rules will appear between rows only":		  "Rules will appear between rows only",
	"Rules":					  "Rules",
	"Spacing and padding":                            "Spacing and padding",
	"Spacing":					  "Spacing",
	"Summary":					  "Summary",
	"TO-cell-delete":				  "Delete cell",
	"TO-cell-insert-after":				  "Insert cell after",
	"TO-cell-insert-before":			  "Insert cell before",
	"TO-cell-merge":				  "Merge cells",
	"TO-cell-prop":					  "Cell properties",
	"TO-cell-split":				  "Split cell",
	"TO-col-delete":				  "Delete column",
	"TO-col-insert-after":				  "Insert column after",
	"TO-col-insert-before":				  "Insert column before",
	"TO-col-split":					  "Split column",
	"TO-row-delete":				  "Delete row",
	"TO-row-insert-above":				  "Insert row before",
	"TO-row-insert-under":				  "Insert row after",
	"TO-row-prop":					  "Row properties",
	"TO-row-split":					  "Split row",
	"TO-table-prop":				  "Table properties",
	"Table Properties":				  "Table Properties",
	"Text align":                                     "Text align",
	"The bottom side only":				  "The bottom side only",
	"The left-hand side only":			  "The left-hand side only",
	"The right and left sides only":		  "The right and left sides only",
	"The right-hand side only":			  "The right-hand side only",
	"The top and bottom sides only":		  "The top and bottom sides only",
	"The top side only":				  "The top side only",
	"Aborted: please enter a positive integer":       "Aborted: please enter a positive integer",
	"Top":                                            "Top",
	"Unset color":                                    "Unset color",
	"Vertical align":                                 "Vertical align",
	"Width":					  "Width",
	"not-del-last-cell":				  "Cannot delete the last cell in a row.",
	"not-del-last-col":				  "Cannot delete the last column in a table.",
	"not-del-last-row":				  "Cannot delete the last row in a table.",
	"percent":					  "percent",
	"pixels":					  "pixels",
	"points":					  "points"
};


text:
#include "drd_clientobj.h"        /* struct mutex_info        */
#include "drd_error.h"
#include "drd_malloc_wrappers.h"
#include "drd_mutex.h"
#include "drd_suppression.h"      /* drd_start_suppression()  */
#include "pub_drd_bitmap.h"       /* LHS_W, ...               */
#include "pub_tool_vki.h"
#include "pub_tool_basics.h"
#include "pub_tool_libcassert.h"  /* tl_assert()              */
#include "pub_tool_libcbase.h"    /* strlen()                 */
#include "pub_tool_libcfile.h"    /* VG_(get_startup_wd)()    */
#include "pub_tool_libcprint.h"   /* VG_(printf)()            */
#include "pub_tool_machine.h"
#include "pub_tool_mallocfree.h"  /* VG_(malloc), VG_(free)   */
#include "pub_tool_options.h"     /* VG_(clo_xml)             */
#include "pub_tool_threadstate.h" /* VG_(get_pthread_id)()    */
#include "pub_tool_tooliface.h"   /* VG_(needs_tool_errors)() */

/* Local function declarations. */

static Char* drd_get_error_name(Error* e);

/* Local variables. */

static Bool s_show_conflicting_segments = True;

void DRD_(set_show_conflicting_segments)(const Bool scs)
{
   s_show_conflicting_segments = scs;
}

void DRD_(trace_msg)(const char* format, ...)
{
   va_list vargs;
   va_start(vargs, format);
   if (VG_(clo_xml)) {
      VG_(printf_xml)("  <trace><text>");
      VG_(vprintf_xml)(format, vargs);
      VG_(printf_xml)("</text></trace>\n");
   } else {
      VG_(vmessage)(Vg_UserMsg, format, vargs);
      VG_(message)(Vg_UserMsg, "\n");
   }
   va_end(vargs);
}

void DRD_(trace_msg_w_bt)(const char* format, ...)
{
   va_list vargs;
   va_start(vargs, format);
   if (VG_(clo_xml)) {
      VG_(printf_xml)("  <trace><text>");
      VG_(vprintf_xml)(format, vargs);
      VG_(printf_xml)("</text>\n");
   } else {
      VG_(vmessage)(Vg_UserMsg, format, vargs);
      VG_(message)(Vg_UserMsg, "\n");
   }
   VG_(get_and_pp_StackTrace)(VG_(get_running_tid)(), VG_(clo_backtrace_size));
   va_end(vargs);
   if (VG_(clo_xml))
      VG_(printf_xml)("  </trace>\n");
}

/**
 * Emit error message detail in the format requested by the user.
 */
static void print_err_detail(const char* format, ...) PRINTF_CHECK(1, 2);
static void print_err_detail(const char* format, ...)
{
   va_list vargs;
   va_start(vargs, format);
   if (VG_(clo_xml))
      VG_(vprintf_xml)(format, vargs);
   else
      VG_(vmessage)(Vg_UserMsg, format, vargs);
   va_end(vargs);
}

/**
 * Describe the client address a as good as possible, putting the result in ai.
 */
static
void describe_malloced_addr(Addr const a, AddrInfo* const ai)
{
   Addr heap_block_start;

   if (DRD_(heap_addrinfo)(a, &heap_block_start, &ai->size, &ai->lastchange))
   {
      ai->akind = eMallocd;
      ai->rwoffset = a - heap_block_start;
   }
   else
   {
      ai->akind = eUnknown;
   }
}

/**
 * Report where a client synchronization object has been observed for the first
 * time. The printed call stack will either refer to a pthread_*_init() or a
 * pthread_*lock() call.
 */
static void first_observed(const Addr obj)
{
   DrdClientobj* cl;

   cl = DRD_(clientobj_get_any)(obj);
   if (cl) {
      tl_assert(cl->any.first_observed_at);
      if (VG_(clo_xml)) {
         print_err_detail("  <first_observed_at>\n"
                          "    <what>%pS</what>\n"
                          "    <address>0x%lx</address>\n",
                          DRD_(clientobj_type_name)(cl->any.type), obj);
         VG_(pp_ExeContext)(cl->any.first_observed_at);
         print_err_detail("  </first_observed_at>\n");
      } else {
         print_err_detail("%s 0x%lx was first observed at:\n",
                          DRD_(clientobj_type_name)(cl->any.type), obj);
         VG_(pp_ExeContext)(cl->any.first_observed_at);
      }
   }
}

static
void drd_report_data_race(Error* const err, const DataRaceErrInfo* const dri)
{
   const Bool xml = VG_(clo_xml);
   const char* const what_prefix = xml ? "  <what>" : "";
   const char* const what_suffix = xml ? "</what>" : "";
   const char* const auxwhat_prefix = xml ? "  <auxwhat>" : "";
   const char* const auxwhat_suffix = xml ? "</auxwhat>" : "";
   const char* const indent = xml ? "  " : "";
   AddrInfo ai;

   XArray* /* of HChar */ descr1
      = VG_(newXA)( VG_(malloc), "drd.error.drdr2.1",
                    VG_(free), sizeof(HChar) );
   XArray* /* of HChar */ descr2
      = VG_(newXA)( VG_(malloc), "drd.error.drdr2.2",
                    VG_(free), sizeof(HChar) );

   tl_assert(dri);
   tl_assert(dri->addr);
   tl_assert(dri->size > 0);
   tl_assert(descr1);
   tl_assert(descr2);

   (void) VG_(get_data_description)(descr1, descr2, dri->addr);
   /* If there's nothing in descr1/2, free them.  Why is it safe to to
      VG_(indexXA) at zero here?  Because VG_(get_data_description)
      guarantees to zero terminate descr1/2 regardless of the outcome
      of the call.  So there's always at least one element in each XA
      after the call.
   */
   if (0 == VG_(strlen)( VG_(indexXA)( descr1, 0 ))) {
      VG_(deleteXA)( descr1 );
      descr1 = NULL;
   }
   if (0 == VG_(strlen)( VG_(indexXA)( descr2, 0 ))) {
      VG_(deleteXA)( descr2 );
      descr2 = NULL;
   }
   /* Assume (assert) that VG_(get_data_description) fills in descr1
      before it fills in descr2 */
   if (descr1 == NULL)
      tl_assert(descr2 == NULL);
   /* So anyway.  Do we have something useful? */
   if (descr1 == NULL)
   {
      /* No.  Do Plan B. */
      describe_malloced_addr(dri->addr, &ai);
   }

   print_err_detail("%sConflicting %s by thread %d at 0x%08lx size %ld%s\n",
                    what_prefix, dri->access_type == eStore ? "store" : "load",
                    dri->tid, dri->addr, dri->size, what_suffix);

   VG_(pp_ExeContext)(VG_(get_error_where)(err));
   if (descr1 != NULL) {
      print_err_detail("%s%s\n", indent, (HChar*)VG_(indexXA)(descr1, 0));
      if (descr2 != NULL)
         print_err_detail("%s%s\n", indent, (HChar*)VG_(indexXA)(descr2, 0));
   } else if (ai.akind == eMallocd && ai.lastchange) {
      print_err_detail("%sAddress 0x%lx is at offset %ld from 0x%lx.%s%s",
                       auxwhat_prefix, dri->addr, ai.rwoffset,
                       dri->addr - ai.rwoffset, auxwhat_suffix,
                       xml ? "\n" : "");
      if (xml)
         print_err_detail("  <allocation_context>\n");
      else
         print_err_detail(" Allocation context:\n");
      VG_(pp_ExeContext)(ai.lastchange);
      if (xml)
         print_err_detail("  </allocation_context>\n");
   } else {
      char sect_name[64];
      VgSectKind sect_kind;

      sect_kind = VG_(DebugInfo_sect_kind)(sect_name, sizeof(sect_name),
                                           dri->addr);
      if (sect_kind != Vg_SectUnknown) {
         print_err_detail("%sAllocation context: %ps section of %ps%s\n",
                          auxwhat_prefix, VG_(pp_SectKind)(sect_kind),
                          sect_name, auxwhat_suffix);
      } else {
         print_err_detail("%sAllocation context: unknown.%s\n",
                          auxwhat_prefix, auxwhat_suffix);
      }
   }
   if (s_show_conflicting_segments)
   {
      DRD_(thread_report_conflicting_segments)(dri->tid,
                                               dri->addr, dri->size,
                                               dri->access_type);
   }

   if (descr2)
      VG_(deleteXA)(descr2);
   if (descr1)
      VG_(deleteXA)(descr1);
}

/**
 * Compare two error contexts. The core function VG_(maybe_record_error)()
 * calls this function to compare error contexts such that errors that occur
 * repeatedly are only printed once. This function is only called by the core
 * if the error kind of e1 and e2 matches and if the ExeContext's of e1 and
 * e2 also match.
 */
static Bool drd_compare_error_contexts(VgRes res, Error* e1, Error* e2)
{
   tl_assert(VG_(get_error_kind)(e1) == VG_(get_error_kind)(e2));

   switch (VG_(get_error_kind)(e1))
   {
   case DataRaceErr:
   {
      const DataRaceErrInfo* const dri1 = VG_(get_error_extra)(e1);
      const DataRaceErrInfo* const dri2 = VG_(get_error_extra)(e2);
      return dri1->access_type == dri2->access_type
	     && dri1->size == dri2->size;
   }
   case MutexErr:
   {
      const MutexErrInfo* const mei1 = VG_(get_error_extra)(e1);
      const MutexErrInfo* const mei2 = VG_(get_error_extra)(e2);
      return mei1->mutex == mei2->mutex;
   }
   default:
      return True;
   }
}

/**
 * Called by the core just before an error message will be printed. Used by
 * DRD to print the thread number as a preamble.
 */
static void drd_tool_error_before_pp(Error* const e)
{
   static DrdThreadId s_last_tid_printed = 1;
   DrdThreadId* err_extra;

   err_extra = VG_(get_error_extra)(e);

   if (err_extra && *err_extra != s_last_tid_printed && !VG_(clo_xml)) {
      VG_(umsg)("%s:\n", DRD_(thread_get_name)(*err_extra));
      s_last_tid_printed = *err_extra;
   }
}

/** Report an error to the user. */
static void drd_tool_error_pp(Error* const e)
{
   const Bool xml = VG_(clo_xml);
   const char* const what_prefix = xml ? "  <what>" : "";
   const char* const what_suffix = xml ? "</what>" : "";

   if (xml)
      VG_(printf_xml)( "  <kind>%pS</kind>\n", drd_get_error_name(e));

   switch (VG_(get_error_kind)(e))
   {
   case DataRaceErr: {
      drd_report_data_race(e, VG_(get_error_extra)(e));
      break;
   }
   case MutexErr: {
      MutexErrInfo* p = (MutexErrInfo*)(VG_(get_error_extra)(e));
      tl_assert(p);
      if (p->recursion_count >= 0) {
         print_err_detail("%s%s: mutex 0x%lx, recursion count %d, owner %d."
                          "%s\n", what_prefix, VG_(get_error_string)(e),
                          p->mutex, p->recursion_count, p->owner, what_suffix);
      } else {
         print_err_detail("%sThe object at address 0x%lx is not a mutex.%s\n",
                          what_prefix, p->mutex, what_suffix);
      }
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      first_observed(p->mutex);
      break;
   }
   case CondErr: {
      CondErrInfo* cdei =(CondErrInfo*)(VG_(get_error_extra)(e));
      print_err_detail("%s%s: cond 0x%lx%s\n", what_prefix,
                       VG_(get_error_string)(e), cdei->cond, what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      first_observed(cdei->cond);
      break;
   }
   case CondDestrErr: {
      CondDestrErrInfo* cdi = (CondDestrErrInfo*)(VG_(get_error_extra)(e));
      print_err_detail("%s%s: cond 0x%lx, mutex 0x%lx locked by thread %d%s\n",
                       what_prefix, VG_(get_error_string)(e), cdi->cond,
                       cdi->mutex, cdi->owner, what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      first_observed(cdi->mutex);
      break;
   }
   case CondRaceErr: {
      CondRaceErrInfo* cei = (CondRaceErrInfo*)(VG_(get_error_extra)(e));
      print_err_detail("%sProbably a race condition: condition variable 0x%lx"
                       " has been signaled but the associated mutex 0x%lx is"
                       " not locked by the signalling thread.%s\n",
                       what_prefix, cei->cond, cei->mutex, what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      first_observed(cei->cond);
      first_observed(cei->mutex);
      break;
   }
   case CondWaitErr: {
      CondWaitErrInfo* cwei = (CondWaitErrInfo*)(VG_(get_error_extra)(e));
      print_err_detail("%s%s: condition variable 0x%lx, mutexes 0x%lx and"
                       " 0x%lx%s\n", what_prefix, VG_(get_error_string)(e),
                       cwei->cond, cwei->mutex1, cwei->mutex2, what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      first_observed(cwei->cond);
      first_observed(cwei->mutex1);
      first_observed(cwei->mutex2);
      break;
   }
   case SemaphoreErr: {
      SemaphoreErrInfo* sei = (SemaphoreErrInfo*)(VG_(get_error_extra)(e));
      tl_assert(sei);
      print_err_detail("%s%s: semaphore 0x%lx%s\n", what_prefix,
                       VG_(get_error_string)(e), sei->semaphore, what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      first_observed(sei->semaphore);
      break;
   }
   case BarrierErr: {
      BarrierErrInfo* bei = (BarrierErrInfo*)(VG_(get_error_extra)(e));
      tl_assert(bei);
      print_err_detail("%s%s: barrier 0x%lx%s\n", what_prefix,
                       VG_(get_error_string)(e), bei->barrier, what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      if (bei->other_context) {
         if (xml)
            print_err_detail("  <confl_wait_call>\n");
         print_err_detail("%sConflicting wait call by thread %d:%s\n",
                          what_prefix, bei->other_tid, what_suffix);
         VG_(pp_ExeContext)(bei->other_context);
         if (xml)
            print_err_detail("  </confl_wait_call>\n");
      }
      first_observed(bei->barrier);
      break;
   }
   case RwlockErr: {
      RwlockErrInfo* p = (RwlockErrInfo*)(VG_(get_error_extra)(e));
      tl_assert(p);
      print_err_detail("%s%s: rwlock 0x%lx.%s\n", what_prefix,
                       VG_(get_error_string)(e), p->rwlock, what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      first_observed(p->rwlock);
      break;
   }
   case HoldtimeErr: {
      HoldtimeErrInfo* p =(HoldtimeErrInfo*)(VG_(get_error_extra)(e));
      tl_assert(p);
      tl_assert(p->acquired_at);
      if (xml)
         print_err_detail("  <acquired_at>\n");
      else
         print_err_detail("Acquired at:\n");
      VG_(pp_ExeContext)(p->acquired_at);
      if (xml)
         print_err_detail("  </acquired_at>\n");
      print_err_detail("%sLock on %s 0x%lx was held during %d ms"
                       " (threshold: %d ms).%s\n", what_prefix,
                       VG_(get_error_string)(e), p->synchronization_object,
                       p->hold_time_ms, p->threshold_ms, what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      first_observed(p->synchronization_object);
      break;
   }
   case GenericErr: {
      GenericErrInfo* gei = (GenericErrInfo*)(VG_(get_error_extra)(e));
      print_err_detail("%s%s%s\n", what_prefix, VG_(get_error_string)(e),
                       what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      if (gei->addr)
	 first_observed(gei->addr);
      break;
   }
   case InvalidThreadId: {
      InvalidThreadIdInfo* iti =(InvalidThreadIdInfo*)(VG_(get_error_extra)(e));
      print_err_detail("%s%s 0x%llx%s\n", what_prefix, VG_(get_error_string)(e),
                       iti->ptid, what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      break;
   }
   case UnimpHgClReq: {
      UnimpClReqInfo* uicr =(UnimpClReqInfo*)(VG_(get_error_extra)(e));
      print_err_detail("%sThe annotation macro %s has not yet been implemented"
                       " in %ps%s\n", what_prefix, uicr->descr,
                       "<valgrind/helgrind.h>", what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      break;
   }
   case UnimpDrdClReq: {
      UnimpClReqInfo* uicr =(UnimpClReqInfo*)(VG_(get_error_extra)(e));
      print_err_detail("%sThe annotation macro %s has not yet been implemented"
                       " in %ps%s\n", what_prefix, uicr->descr,
                       "<valgrind/drd.h>", what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      break;
   }
   default:
      print_err_detail("%s%s%s\n", what_prefix, VG_(get_error_string)(e),
                       what_suffix);
      VG_(pp_ExeContext)(VG_(get_error_where)(e));
      break;
   }
}

static UInt drd_tool_error_update_extra(Error* e)
{
   switch (VG_(get_error_kind)(e))
   {
   case DataRaceErr:
      return sizeof(DataRaceErrInfo);
   case MutexErr:
      return sizeof(MutexErrInfo);
   case CondErr:
      return sizeof(CondErrInfo);
   case CondDestrErr:
      return sizeof(CondDestrErrInfo);
   case CondRaceErr:
      return sizeof(CondRaceErrInfo);
   case CondWaitErr:
      return sizeof(CondWaitErrInfo);
   case SemaphoreErr:
      return sizeof(SemaphoreErrInfo);
   case BarrierErr:
      return sizeof(BarrierErrInfo);
   case RwlockErr:
      return sizeof(RwlockErrInfo);
   case HoldtimeErr:
      return sizeof(HoldtimeErrInfo);
   case GenericErr:
      return sizeof(GenericErrInfo);
   case InvalidThreadId:
      return sizeof(InvalidThreadIdInfo);
   case UnimpHgClReq:
      return sizeof(UnimpClReqInfo);
   case UnimpDrdClReq:
      return sizeof(UnimpClReqInfo);
   default:
      tl_assert(False);
      break;
   }
}

/**
 * Parse suppression name.
 *
 * The suppression types recognized by DRD are the same types as the error
 * types supported by DRD. So try to match the suppression name against the
 * names of DRD error types.
 */
static Bool drd_is_recognized_suppression(Char* const name, Supp* const supp)
{
   DrdErrorKind skind = 0;

   if (VG_(strcmp)(name, STR_DataRaceErr) == 0)
      skind = DataRaceErr;
   else if (VG_(strcmp)(name, STR_MutexErr) == 0)
      skind = MutexErr;
   else if (VG_(strcmp)(name, STR_CondErr) == 0)
      skind = CondErr;
   else if (VG_(strcmp)(name, STR_CondDestrErr) == 0)
      skind = CondDestrErr;
   else if (VG_(strcmp)(name, STR_CondRaceErr) == 0)
      skind = CondRaceErr;
   else if (VG_(strcmp)(name, STR_CondWaitErr) == 0)
      skind = CondWaitErr;
   else if (VG_(strcmp)(name, STR_SemaphoreErr) == 0)
      skind = SemaphoreErr;
   else if (VG_(strcmp)(name, STR_BarrierErr) == 0)
      skind = BarrierErr;
   else if (VG_(strcmp)(name, STR_RwlockErr) == 0)
      skind = RwlockErr;
   else if (VG_(strcmp)(name, STR_HoldtimeErr) == 0)
      skind = HoldtimeErr;
   else if (VG_(strcmp)(name, STR_GenericErr) == 0)
      skind = GenericErr;
   else if (VG_(strcmp)(name, STR_InvalidThreadId) == 0)
      skind = InvalidThreadId;
   else if (VG_(strcmp)(name, STR_UnimpHgClReq) == 0)
      skind = UnimpHgClReq;
   else if (VG_(strcmp)(name, STR_UnimpDrdClReq) == 0)
      skind = UnimpDrdClReq;
   else
      return False;

   VG_(set_supp_kind)(supp, skind);
   return True;
}

/**
 * Read additional suppression information from the suppression file.
 *
 * None of the suppression patterns recognized by DRD has 'extra' lines
 * of information in the suppression file, so just return True to indicate
 * that reading the 'extra' lines succeeded.
 */
static
Bool drd_read_extra_suppression_info(Int fd, Char** bufpp,
                                     SizeT* nBufp, Supp* supp)
{
   return True;
}

/**
 * Determine whether or not the types of the given error message and the
 * given suppression match.
 */
static Bool drd_error_matches_suppression(Error* const e, Supp* const supp)
{
   return VG_(get_supp_kind)(supp) == VG_(get_error_kind)(e);
}

static Char* drd_get_error_name(Error* e)
{
   switch (VG_(get_error_kind)(e))
   {
   case DataRaceErr:  return VGAPPEND(STR_, DataRaceErr);
   case MutexErr:     return VGAPPEND(STR_, MutexErr);
   case CondErr:      return VGAPPEND(STR_, CondErr);
   case CondDestrErr: return VGAPPEND(STR_, CondDestrErr);
   case CondRaceErr:  return VGAPPEND(STR_, CondRaceErr);
   case CondWaitErr:  return VGAPPEND(STR_, CondWaitErr);
   case SemaphoreErr: return VGAPPEND(STR_, SemaphoreErr);
   case BarrierErr:   return VGAPPEND(STR_, BarrierErr);
   case RwlockErr:    return VGAPPEND(STR_, RwlockErr);
   case HoldtimeErr:  return VGAPPEND(STR_, HoldtimeErr);
   case GenericErr:   return VGAPPEND(STR_, GenericErr);
   case InvalidThreadId: return VGAPPEND(STR_, InvalidThreadId);
   case UnimpHgClReq:  return VGAPPEND(STR_, UnimpHgClReq);
   case UnimpDrdClReq: return VGAPPEND(STR_, UnimpDrdClReq);
   default:
      tl_assert(0);
   }
   return 0;
}

/**
 * Return extra suppression information.
 *
 * Invoked while printing a suppression pattern because the user
 * specified --gen-suppressions=yes or all on the command line. DRD does not
 * define any 'extra' suppression information.
 */
static
Bool drd_get_extra_suppression_info(Error* e,
                                    /*OUT*/Char* buf, Int nBuf)
{
   return False;
}

/** Tell the Valgrind core about DRD's error handlers. */
void DRD_(register_error_handlers)(void)
{
   VG_(needs_tool_errors)(drd_compare_error_contexts,
                          drd_tool_error_before_pp,
                          drd_tool_error_pp,
                          False,
                          drd_tool_error_update_extra,
                          drd_is_recognized_suppression,
                          drd_read_extra_suppression_info,
                          drd_error_matches_suppression,
                          drd_get_error_name,
                          drd_get_extra_suppression_info);
}


text:
package co.edu.unal.libreriapp.model;

public class ExchangeTransaction {

	private String bookId;
	private String myOfferBookId;

	public ExchangeTransaction(String bookId, String myOfferBookId) {
		this.bookId = bookId;
		this.myOfferBookId = myOfferBookId;
	}

	public String getBookId() {
		return bookId;
	}

	public void setBookId(String bookId) {
		this.bookId = bookId;
	}

	public String getMyOfferBookId() {
		return myOfferBookId;
	}

	public void setMyOfferBookId(String myOfferBookId) {
		this.myOfferBookId = myOfferBookId;
	}

}


text:
package com.navercorp.pinpoint.web.vo.stat.chart.application;

import com.navercorp.pinpoint.web.util.TimeWindow;
import com.navercorp.pinpoint.web.vo.stat.chart.ChartGroupBuilder;
import com.navercorp.pinpoint.web.vo.stat.chart.StatChart;
import com.navercorp.pinpoint.web.vo.stat.chart.StatChartGroup;

import java.util.List;
import java.util.Objects;

public class DefaultApplicationChart<T, P extends Number> implements StatChart<ApplicationStatPoint<P>> {
    private final TimeWindow timeWindow;
    private final List<T> statList;
    private final ChartGroupBuilder<T, ApplicationStatPoint<P>> builder;

    public DefaultApplicationChart(TimeWindow timeWindow, List<T> statList, ChartGroupBuilder<T, ApplicationStatPoint<P>> builder) {
        this.timeWindow = Objects.requireNonNull(timeWindow, "timeWindow");
        this.statList = Objects.requireNonNull(statList, "statList");
        this.builder = Objects.requireNonNull(builder, "builder");
    }

    @Override
    public StatChartGroup<ApplicationStatPoint<P>> getCharts() {
        return builder.build(timeWindow, statList);
    }

}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace AzureADB2CSample.Controllers
{
    [Route("[controller]/[action]")]
    public class AccountController : Controller
    {
        private readonly AzureAdB2COptions _options;

        public AccountController(IOptions<AzureAdB2COptions> b2cOptions)
        {
            _options = b2cOptions.Value;
        }

        [HttpGet]
        public IActionResult SignIn()
        {
            var redirectUrl = Url.Action(nameof(HomeController.Index), "Home");
            return Challenge(
                new AuthenticationProperties { RedirectUri = redirectUrl },
                OpenIdConnectDefaults.AuthenticationScheme);
        }

        [HttpGet]
        public IActionResult ResetPassword()
        {
            var redirectUrl = Url.Action(nameof(HomeController.Index), "Home");
            var properties = new AuthenticationProperties { RedirectUri = redirectUrl };
            properties.Items[AzureAdB2COptions.PolicyAuthenticationProperty] = _options.ResetPasswordPolicyId;
            return Challenge(properties, OpenIdConnectDefaults.AuthenticationScheme);
        }

        [HttpGet]
        public IActionResult EditProfile()
        {
            var redirectUrl = Url.Action(nameof(HomeController.Index), "Home");
            var properties = new AuthenticationProperties { RedirectUri = redirectUrl };
            properties.Items[AzureAdB2COptions.PolicyAuthenticationProperty] = _options.EditProfilePolicyId;
            return Challenge(properties, OpenIdConnectDefaults.AuthenticationScheme);
        }

        [HttpGet]
        public IActionResult SignOut()
        {
            var callbackUrl = Url.Action(nameof(SignedOut), "Account", values: null, protocol: Request.Scheme);
            return SignOut(new AuthenticationProperties { RedirectUri = callbackUrl },
                CookieAuthenticationDefaults.AuthenticationScheme, OpenIdConnectDefaults.AuthenticationScheme);
        }

        [HttpGet]
        public IActionResult SignedOut()
        {
            if (User.Identity.IsAuthenticated)
            {
                // Redirect to home page if the user is authenticated.
                return RedirectToAction(nameof(HomeController.Index), "Home");
            }

            return View();
        }

        [HttpGet]
        public IActionResult AccessDenied()
        {
            return View();
        }
    }
}


text:
package de.wackernagel.android.sidekick.helper;

import android.graphics.Rect;
import android.support.annotation.IntRange;
import android.support.v7.widget.RecyclerView;
import android.view.View;

public class GridGutterDecoration extends RecyclerView.ItemDecoration {

    private final int gutterSize;
    private final int spanCount;
    private boolean gutterOutsideTopAndBottom;
    private boolean gutterOutsideLeftAndRight;

    /**
     * Add some space between each item and the outside edges.
     *
     * @param gutterSize Space between each item and the outside edges
     * @param spanCount Number of grid columns
     */

    public GridGutterDecoration(@IntRange(from = 0) final int gutterSize, @IntRange(from = 1) final int spanCount) {
        this( gutterSize, spanCount, true, true );
    }

    /**
     * Add some space between each item and the outside edges.
     *
     * @param gutterSize Space between each item and the outside edges
     * @param spanCount Number of grid columns
     * @param outside Add a gutter on the outside edges of the grid
     */
    public GridGutterDecoration(@IntRange(from = 0) final int gutterSize, @IntRange(from = 1) final int spanCount, final boolean outside ) {
        this( gutterSize, spanCount, outside, outside );
    }

    /**
     * Add some space between each item and the outside edges.
     *
     * @param gutterSize Space between each item and the outside edges
     * @param spanCount Number of grid columns
     * @param gutterOutsideTopAndBottom Add a gutter on the first row top and last row bottom
     * @param gutterOutsideLeftAndRight Add a gutter on the first column left and last column right
     */
    public GridGutterDecoration(@IntRange(from = 0) final int gutterSize, @IntRange(from = 1) final int spanCount, final boolean gutterOutsideTopAndBottom, final boolean gutterOutsideLeftAndRight ) {
        this.gutterSize = gutterSize;
        this.spanCount = spanCount;
        this.gutterOutsideTopAndBottom = gutterOutsideTopAndBottom;
        this.gutterOutsideLeftAndRight = gutterOutsideLeftAndRight;
    }

    @Override
    public void getItemOffsets( Rect outRect, View view, RecyclerView parent, RecyclerView.State state ) {
        int itemPosition = parent.getChildAdapterPosition( view );
        int column = itemPosition % spanCount;
        int itemCount = parent.getAdapter() != null ? parent.getAdapter().getItemCount() : 0;
        int rowCount = ( itemCount / spanCount) + ( itemCount % spanCount == 0 ? 0 : 1 );
        boolean isFirstRow = itemPosition < spanCount;
        boolean isLastRow = itemPosition >= ( (rowCount - 1) * spanCount);

        if( gutterOutsideLeftAndRight ) {
            outRect.left = gutterSize - column * gutterSize / spanCount;
            outRect.right = (column + 1) * gutterSize / spanCount;
        } else {
            outRect.left = column * gutterSize / spanCount;
            outRect.right = gutterSize - (column + 1) * gutterSize / spanCount;
        }

        outRect.bottom = gutterSize;

        if( isFirstRow && gutterOutsideTopAndBottom ) {
            outRect.top = gutterSize;
        }

        if( isLastRow && !gutterOutsideTopAndBottom ) {
            outRect.bottom = 0;
        }
    }
}


text:
layout: page-classic-sidebar-left
title: Notificação de Mudança de Status
featimg: MapAntifraud.png
previous: /docs/1.0/analise
next: /docs/1.0/autenticacao
---
---

Serviço que envia um post de notificação ao cliente caso haja alguma alteração de status.

* É necessário solicitar a Equipe de Implementação o cadastramento da URL de Mudança de Status.
Quando estimulada pelo servidor da Braspag, enviando o POST, a URL cadastrada para Retorno de
Mudança de Status, deverá retornar o código HTTP 200 (OK), indicando que a mensagem foi recebida e processada com sucesso pelo servidor da loja.

* Se a URL de mudança de status da loja for acessada pelo servidor da Braspag não exibir o código de
confirmação ou ocorrer uma falha na conexão, o servidor irá fazer mais 3 tentativas de envio.

* A URL de mudança de Status de Pagamento somente pode utilizar porta 80 (padrão para http) ou porta
443 (padrão para https). Recomendamos que a loja trabalhe sempre com SSL para esta url, ou seja, sempre HTTPS.

![Notificação de Mudança de Status]({{ site.url }}/img/PostNotification.png){: .centerimg }{:title="Notificação de Mudança de Status "}

#### `POST`{:.http-post} Notificação de Mudança de Status
----------------------------------------------
Abaixo seguem os exemplos de mensagem que o servidor da Braspag enviará à URL cadastrada, e como deve ser a resposta enviada em caso de sucesso.

**REQUEST:**

``` http
POST https://urlcadastrada.loja.com.br/Notification/ HTTP/1.1
Host: urlcadastrada.loja.com.br
Content-Type: application/json
```

``` json
{
   "Id":"9004ba26-f1f1-e611-9400-005056970d6f",
   "OrderId":"4493d42c-8732-4b13-aadc-b07e89732c27",
   "OriginalDecision":"Review",
   "NewDecision":"Accept",
   "Reviewer":"Alberto Moreira da Silva",
   "ReviewerComments":"Transação Aceita Após Ligação para o Cliente",
   "Notes":null,
   "Queue":null,
   "Profile":null
}
```

**RESPONSE:**

``` http
HTTP/1.1 200 Ok
```


text:
package io.aos.concurrent.spl4;

public class Entrepot1 {

    private int article;

    public int get() {
        System.out.println("Consumer got : " + article);
        return article;
    }

    public void put(int article) {
        this.article = article;
        System.out.println("Producter put : " + article);
    }
}


text:
using System;

namespace Avro.Reflect
{
    /// <summary>
    /// Constructor
    /// </summary>
    /// <typeparam name="TAvro">Avro type</typeparam>
    /// <typeparam name="TProperty">Property type</typeparam>
    public abstract class TypedFieldConverter<TAvro, TProperty> : IAvroFieldConverter
    {
        /// <summary>
        /// Convert from Avro type to property type
        /// </summary>
        /// <param name="o">Avro value</param>
        /// <param name="s">Schema</param>
        /// <returns>Property value</returns>
        public abstract TProperty From(TAvro o, Schema s);

        /// <summary>
        /// Convert from property type to Avro type
        /// </summary>
        /// <param name="o"></param>
        /// <param name="s"></param>
        /// <returns></returns>
        public abstract TAvro To(TProperty o, Schema s);

        /// <summary>
        /// Implement untyped interface
        /// </summary>
        /// <param name="o"></param>
        /// <param name="s"></param>
        /// <returns></returns>
        public object FromAvroType(object o, Schema s)
        {
            if (!typeof(TAvro).IsAssignableFrom(o.GetType()))
            {
                throw new AvroException($"Converter from {typeof(TAvro).Name} to {typeof(TProperty).Name} cannot convert object of type {o.GetType().Name} to {typeof(TAvro).Name}, object {o.ToString()}");
            }

            return From((TAvro)o, s);
        }

        /// <summary>
        /// Implement untyped interface
        /// </summary>
        /// <returns></returns>
        public Type GetAvroType()
        {
            return typeof(TAvro);
        }

        /// <summary>
        /// Implement untyped interface
        /// </summary>
        /// <returns></returns>
        public Type GetPropertyType()
        {
            return typeof(TProperty);
        }

        /// <summary>
        /// Implement untyped interface
        /// </summary>
        /// <param name="o"></param>
        /// <param name="s"></param>
        /// <returns></returns>
        public object ToAvroType(object o, Schema s)
        {
            if (!typeof(TProperty).IsAssignableFrom(o.GetType()))
            {
                throw new AvroException($"Converter from {typeof(TAvro).Name} to {typeof(TProperty).Name} cannot convert object of type {o.GetType().Name} to {typeof(TProperty).Name}, object {o.ToString()}");
            }

            return To((TProperty)o, s);
        }
    }
}


text:
'use strict';

angular.module('wilson.i18n', []).provider('i18nextService', function() {
  var options = {};

  /**
   * Initialize the i18nextServiceProvider with a set of options.
   *
   * @public
   * @method init
   * @param o
   */
  this.init = function(o) {
    options = _.extend(options, o);

    window.i18n.init(options);
  };

  var getTranslateForNamespace = function(namespace) {
    //Return a function that has a default namespace
    return function(text, options) {
      //create a default callback if needed
      options = options || {};

      // default namespace is component name
      if (typeof options.ns !== 'string' || options.ns === '') {
        options.ns = namespace;
      }

      //use the i18n provider to translate the text
      return window.i18n.t(text, options);
    };
  };

  function traverseRecursive(value, key, list, handler) {
    if (_.isObject(value) || _.isArray(value)) {
      _.each(value, function(v, k, l) {
        l[k] = traverseRecursive(v, k, l, handler);
      });
      return list[key];
    } else {
      // jsonOb is a number or string
      return handler(value, key, list);
    }
  }

  function traverse(object, handler) {
    //set default handler to an identity function
    handler = handler || _.identity;

    if (_.isObject(object) || _.isArray(object)) {
      _.each(object, function(value, key, list) {
        list[key] = traverseRecursive(value, key, list, handler);
      });
      return object;
    } else {
      // jsonOb is a number or string
      return handler(object);
    }
  }

  var getTranslateJsonForNamespace = function(namespace) {
    var translate = getTranslateForNamespace(namespace);

    //Return a function that has a default namespace
    return function(jsonObj, options) {
      options = options || {};
      options.ignoreKeys = options.ignoreKeys || [];

      return traverse(jsonObj, function(value, key, list) {
        var newValue = value;
        if (_.isString(value) && !_.contains(options.ignoreKeys, key)) {
          newValue = translate(value, options);
        }
        return newValue;
      });
    };
  };

  /**
   * Returns the translate method of the i18nextService
   *
   * @public
   * @method $get
   */

  this.$get = ['$window', function($window) {
    return {
      translate: $window.i18n.t,

      getTranslateForNamespace: getTranslateForNamespace,

      getTranslatorForNamespace: function(namespace) {
        var translator = {
          translate: getTranslateForNamespace(namespace),
          translateJson: getTranslateJsonForNamespace(namespace)
        };

        return translator;
      },

      getSupportedLanguages: function() {
        return options.languageData ? options.languageData : [];
      },

      getActiveLanguage: function() {
        return options.lng ? options.lng : options.fallbackLng;
      }
    };
  }];

});