text:
in and W.~Stuetzle},
	title = {Surface Light Fields for 3{D} Photography},
	booktitle = {Proceedings SIGGRAPH 2000},
	year = {2000},
	publisher = {ACM Press},
	address = {New Orleans},
	pages = {287--296},
	OPTmonth = {July},
}

@inproceedings{Isakse00:DRL,
	author = {A.~Isaksen and L.~McMillan and S.~J.~Gortler},
	title = {Dynamically Reparameterized Light Fields},
	booktitle = {Proceedings SIGGRAPH 2000},
	year = {2000},
	publisher = {ACM Press},
	address = {New Orleans},
	pages = {????},
	OPTmonth = {July},
}

@inproceedings{Chen93:VIF,
	author = {S.~E.~Chen and L.~Williams},
	title = {View Interpolation for Image Synthesis},
	booktitle = {Proceedings SIGGRAPH '93},
	year = {1993},
	publisher = {ACM Press},
	address = {???},
	pages = {279--288},
	OPTmonth = {???}
}

@article{Szeliski96:VMF,
	author = {R.~Szeliski},
	title = {Video Mosaics for Virtual Environments},
	journal = {IEEE Journal on Computer Graphics and Applications},
	volume = {16},
	number = {2},
	year = {1996},
	pages = {22--30}
}

@phdthesis{McMillan97:AIB,
	author = {L.~McMillan},
	title = {An Image--Based Approach to Three--Dimensional Computer Graphics},
	school = {Department of Computer Science,
		University of North Carolina at Chapel Hill},
	year = {1997},
	address = {Chapell Hill, North Carolina}
}

@inproceedings{Seitz96:VM,
	author = {S.~M.~Seitz and C.~R.~Dyer},
	title = {View Morphing},
	booktitle = {Proceedings SIGGRAPH '96},
	year = {1996},
	publisher = {ACM Press},
	address = {New Orleans},
	pages = {21--30},
	OPTmonth = {August}
}

@inproceedings{Koch00:IBR,
	author = {R.~Koch and B.~Heigl and M.~Pollefeys},
	title = {Image--based Rendering from Uncalibrated Lightfields
		with Scaleable Geometry},
	booktitle = {Theoretical Foundations of Computer Vision},
	year = {2000},
	pages = {51--66}
}

@inproceedings{Levoy99:TDM,
	author = {M.~Levoy},
	title = {The Digital Michelangelo Project},
	booktitle = {Second International Conference on 3{D} Digital
		Imaging and Modeling},
	year = {1999},
	address = {Ottawa, Canada},
	OPTmonth = {October},
	pages = {5--8}
}

@book{Foley96:CGP,
   author    = {J. D. Foley and A. van Dam and S. K. Feiner and J. F. Hughes},
   title     = {Computer {G}raphics {P}rinciples and {P}ractice, {S}econd {E}dition in {C}},
   publisher = {Addison-Wesley Publishing Company},
   address   = {Reading, Massachusetts},
   year      = {1996}
}

@book{Glassner95:POD,
	author = {A.~S.~Glassner},
	title = {Principles of Digital Image Synthesis},
	publisher = {Morgan Kaufmann Publishers},
	address = {San Francisco, CA},
	year = {1995},
	isbn = {1-55860-276-3}
}

@article{Lee80:TAF,
	author = {D.~T.~Lee and B.~J.~Schachter},
	title = {Two Algorithms for Constructing a Delaunay Triangulation},
	volume = {9},
	number = {3},
	journal = {International Journal Computer and Information Sciences},
	year = {1980},
	pages = {219}
}

@article{Gouraud71:CSO,
	author = {H.~Gouraud},
	title = {Continuous Shading of Curved Surfaces},
	volume = {C--20},
	number = {6},
	journal = {IEEE Transactions on Computers},
	year = {1971},
	OPTmonth = {June},
	pages = {623--629}
}

@article{Delingette99:AHE,
	author = {H.~Delingette and S.~Cotin and N.~Ayache},
	title = {A Hybrid Elastic Model Allowing Real--Time Cutting,
		Deformations and Force--Feedback for Surgery Training and Simulation},
	journal = {Computer Animation '99},
	year = {1999},
	OPTmonth = {May},
	pages = {70--81},
	publisher = {IEEE Computer Society}
}

@article{Zeevi90:CIG,
	author = {Y.~Y.~Zeevi and M.~Porat and G.~A.~Geri},
	title = {Computer image generation for flight simulators:
		the Gabor approach},
	volume = {6},
	number = {2},
	journal = {The Visual Computer},
	year = {1990},
	OPTmonth = {March},
	pages = {93--105}
}

@article{Chapman99:VUE,
	author = {P.~Chapman and D.~Wills and G.~Brookes and P.~Stevens},
	title = {Visualizing Underwater Environments Using
		Multifrequency Sonar},
	volume = {19},
	number = {5},
	journal = {IEEE Computer Graphics \& Applications},
	year = {1999},
	OPTmonth = {September},
	pages = {61--65}
}

@inproceedings{Brooks88:SCO,
    author = {R. A. Brooks and A. M. Flynn and Th. Marill},
    title = {{Self Calibration of Motion and Stereo Vision for Mobile Robot Navigation}},
    volume = 1,
    year = 1988,
    pages = {398--410},
    booktitle = {DARPA Image Understanding Workshop},
    address = {Cambridge, MA}
}

@techreport{Brooks87:SCO,
    author = {R. A. Brooks and A. M. Flynn and Th. Marill},
    title = {{Self Calibration of Motion and Stereo Vision for Mobile Robot Navigation}},
    number = "AIM-984",
    year = "1987",
    institution = {Massachusetts Institute of Technology, Artificial Intelligence Laboratory}
}

@inproceedings{Brooks96:DMF,
    author = {M. J. Brooks and L. de Agapito and D. Q. Huynh and L. Baumela},
    title = {{Direct Methods for Self-Calibration of a Moving Stereo Head}},
    booktitle = "Proceedings European Conference on Computer Vision (ECCV)",
    volume = 2,
    pages = "415--426",
    year = "1996"
}

@inproceedings{Agapito98:SCA,
    author = "L. de Agapito and D. Q. Huynh and M. J. Brooks",
    title = {{Self-Calibrating a Stereo Head: An Error Analysis in the Neighbourhood of Degenerate Configurations}},
    booktitle = {Proceedings of the International Conference on
		Computer Vision (ICCV)},
    pages = "747-753",
    year = "1998"
}

@article{CohenOr96:ARP,
	author = {D.~Cohen--Or and E.~Rich and U.~Lerner and V.~Shenkar},
	title = {A Real--Time Photo--Realistic Visual Flythrough},
	volume = {2},
	number = {3},
	journal = {IEEE Transactions on Visualization and Computer Graphics},
	year = {1996},
	OPTmonth = {September}
}

@article{Lutz99:VDA,
	author = {B.~Lutz and M.~Weintke},
	title = {Virtual Dunhuang Art Cave: A Cave within a CAVE},
	volume = {18},
	number = {3},
	journal = {Computer Graphics Forum},
	year = {1999},
	OPTmonth = {September},
	publisher = {Blackwell Publishers},
	pages = {257--264}
}

@article{Phong75:IFC,
	author = {B.--T.~Phong},
	title = {Illumination for Computer Generated Pictures},
	volume = {18},
	number = {6},
	journal = {Communications of the ACM},
	year = {1975},
	OPTmonth = {June},
	pages = {311--317}
}

@book{Farin95:NCA,
	author = {G.~E.~Farin},
	title = {NURB Curves and Surfaces: from Projective Geometry
		to Practical Use},
	publisher = {A~K~Peters},
	address = {Wellesley, MA},
	year = {1995}
}

@article{Schlick94:ASO,
	author = {C.~Schlick},
	title = {A Survey of Shading and Reflectance Models},
	volume = {13},
	number = {2},
	journal = {Computer Graphics Forum},
	year = {1994},
	OPTmonth = {June},
	pages = {121--131}
}

@book{Girod00:P03,
	editor = {B.~Girod and G.~Greiner and H.~Niemann},
	title = {Principles of 3{D} Image Analysis and Synthesis},
	publisher = {Kluwer Academic Publishers},
	year = {2000},
	address = {Boston--Dordrecht--London}
}

@inproceedings{Dellaert99:UTC,
	author = {F.~Dellaert and W.~Burgard and D.~Fox and S.~Thrun},
	title = {Using the Condensation Algorithm for Robust,
		Vision--based Mobile Robot Localization},
	year = {1999},
	booktitle = {Proceedings of the IEEE Computer Society Conference
		on Computer Vision and Pattern Recognition},
	pages = {588--595}
}

@techreport{Fox98:AML,
	author = {D.~Fox and W.~Burgard and S.~Thrun},
	title = {Active Markov Localization for Mobile Robots},
	institution = {Carnegie Mellon University},
	year = {1998}
}

@book{Buxton00:TAO,
	author = {B.~Buxton},
	title = {The Art of Maya},
	publisher = {Alias Wavefront},
	year = {2000},
	address = {Toronto, Canada},
	isbn = {0-9685725-1-0}
}

@inproceedings{Bess94:KEB,
	author = {R.~Be{\3}},
	title = {Kalibrierung einer beweglichen, monokularen {K}amera
		zur {T}iefengewinnung aus {B}ildfolgen},
	booktitle = {Mustererkennung 1994},
	series = {Informatics},
	volume = {5},
	editor = {W.~G.~Kropatsch, H.~Bischof},
	pages = {524--531},
	publisher = {Springer--Verlag},
	address = {Berlin},
	year = {1994}
}

@inproceedings{Deinzer00:CIV,
	author = {F.~Deinzer and J.~Denzler and H.~Niemann},
	title = {Classifier Independent Viewpoint Selection for
		3-{D} Object Recognition},
	booktitle = {Mustererkennung 2000},
	series = {Informatics},
	editor = {G.~Sommer},
	pages = {237--244},
	publisher = {Springer--Verlag},
	address = {Heidelberg},
	year = {2000}
}

@article{Murase95:VLA,
	author = {H.~Murase and S.~Nayar},
	title = {Visual Learning and Recognition of 3-{D} Objects
		from Appearance},
	journal = {International Journal of Computer Vision},
	volume = {14},
	pages = {5--24},
	year = {1995}
}

@inproceedings{Poesl97:WFF,
	author = {J.~P{\"o}sl and H.~Niemann},
	title = {Wavelet Features for Statistical Object Localization
		without Segmentation},
	booktitle = {International Conference on Image Processing (ICIP)},
	volume = {3},
	pages = {170--173},
	year = {1997}
}

@inproceedings{Hornegger95:SLL,
	author = {J.~Hornegger and H.~Niemann},
	title = {Statistical Learning, Localization, and Identification of Objects},
	booktitle = {Proceedings of the International Conference on
		Computer Vision (ICCV)},
	pages = {914--919},
	year = {1995},
	OPTmonth = {June},
	publisher = {Computer Society Press},
	address = {Boston}
}

@book{Toern87:GO,
	author = {A.~T{\"o}rn and A.~{\v{Z}}ilinskas},
	title = {Global Optimization},
	volume = {350},
	series = {Lecture Notes in Computer Science},
	publisher = {Springer--Verlag},
	address = {Heidelberg},
	year = {1987}
}

@inproceedings{Steinbach97:REO,
	author = {E.~Steinbach and S.~Chaudhuri and B.~Girod},
	title = {Robust estimation of multi--component motion in image sequences
		using the epipolar constraint},
	booktitle = {Proceedings International Conference on Acoustics,
		Speech and Signal Processing},
	pages = {2689--2692},
	OPTmonth = {April},
	year = {1997}
}

@inproceedings{Irani99:MFO,
	author = {M.~Irani},
	title = {{Multi--Frame Optical Flow Estimation Using
		Subspace Constraints}},
	pages = {626--633},
	booktitle = {Proceedings of the International Conference on
		Computer Vision (ICCV)},
	address = {Corfu, Greece},
	year = {1999},
	OPTmonth = {September},
	publisher = {IEEE Computer Society Press}
}

@book{Borenstein96:NMR,
	author = {J.~Borenstein},
	title = {Navigating Mobile Robots: Systems and Techniques},
	publisher = {A K Peters, Ltd.},
	address = {Wellesley, MA},
	year = {1996}
}

@book{Maybeck79:SME,
	author = {P.~Maybeck},
	title = {Stochastic Models, Estimation and Control},
	volume = {I},
	publisher = {Academic Press},
	address = {New York},
	year = {1979}
}

@article{Isard98:CCD,
	author = {M.~Isard and A.~Blake},
	title = {{Condensation --- Conditional Density Propagation
		for Visual Tracking}},
	journal = ijcv,
	year = {1998},
	pages = {5--28},
	number = 1,
	volume = 29
}

@article{Kalman60:ANA,
	author = {R.~Kalman},
	title = {A new Approach to Linear Filtering and Prediction Problems},
	journal = {Journal of Basis Engineering},
	pages = {35-44},
	year = {1960}
}

@article{Anandan89:ACF,
	author = {P.~Anandan},
	title = {{A Computational Framework and an Algorithm for the
		Measurement of Visual Motion}},
	journal = ijcv,
	year = {1989},
	volume = {2},
	number = {3},
	pages = {283--310}
}

@inproceedings{Burt82:LCM,
	author = {P.~J.~Burt and C.~Yen and X.~Xu},
	title = {{Local Correlation Measures for Motion Analysis: A Comparative Study}},
	booktitle = {IEEE Conference on Pattern Recognition and Image Processing},
	pages = {269--274},
        address = {Las Vegas},
	year = {1982}
}

@book{Foerstner91:PSM,
	author = {W. F{\"o}rstner and A.~Pertl},
	title = {Photogrammetric Standard Methods and Digital Image Matching
		Techniques for High Precision Surface Measurements},
	publisher = {Elsevier Science Publications},
	year = {1991}
}

@article{Wood83:ROA,
	author = {G.~A.~Wood},
	title = {{Realities of Automatic Correlation Problem}},
	journal = {Photogrammetric Engineering and Remote Sensing},
	volume = {49},
	pages = {537--538},
	year = {1983}
}

@book{Sutton98:RL,
	author = {R.~S.~Sutton and A.~G.~Barto},
	title = {Reinforcement Learning},
	publisher = {A Bradford Book},
	address = {Cambridge, London},
	year = {1998}
}

@techreport{Viola95:ABM,
	type = {Technical Report},
	number = {AITR-1548},
	title = {Alignment by Maximization of Mutual Information},
	OPTmonth = {March},
	pages = {156},
	year = {1995},
	bibdate = {September 14, 1999},
  	author = {Paul A. Viola},
	institution = {Massachusetts Institute of Technology}
}

@book{Kempf97:ORM,
	author = {Renate Kempf and Chris Frazier and {OpenGL
		Architecture Review Board}},
	title = {{OpenGL} reference manual: the official reference
		document to {OpenGL}, version 1.1},
	publisher = {Ad{\-d}i{\-s}on-Wes{\-l}ey Developers Press},
	address = {Reading, MA, USA},
	edition = {Second},
	pages = {x + 490},
	year = {1997},
	ISBN = {0-201-46140-4},
	LCCN = {T385 .O642 1997},
	bibdate = {Tue May 25 08:28:35 1999},
}

@inproceedings{Schirmacher01:EFF,
	author = {H.~Schirmacher and C.~Vogelgsang and H.-P.~Seidel and G.~Greiner},
	title = {Efficient free form light field rendering},
	booktitle = {Proceedings of Vision, Modeling, and Visualization},
	address = {Erlangen, Germany},
	pages = {to appear},
	year = {2001},
	OPTmonth = {November}
}

@inproceedings{Quan94:IO6,
	author = {L.~Quan},
	title = {Invariants of 6 points from 3 uncalibrated images},
	booktitle = {Proceedings of European Conference on Computer Vision
		(ECCV)},
	publisher = {Springer--Verlag},
	pages = {459--469},
	year = {1994}
}

@inproceedings{Zinsser05:PSR,
  author = {T. Zin{\ss}er and J. Schmidt and H. Niemann},
  title = {{Point Set Registration with Integrated Scale Estimation}},
  booktitle = {Proceedings of the Eighth International Conference on Pattern Recognition and Image Processing (PRIP 2005)},
  year = 2005,
  editor = {R. Sadykhov and S. Ablameiko and A. Doudkin and L. Podenok},
  pages = {116-119},
  address = {Minsk, Republic of Belarus},
  OPTmonth = {May},
  isbn = {985-6329-55-8}
}

@phdthesis{Zinsser06:Diss,
  author = {T. Zin{\ss}er},
  title = {{Efficient and Robust Algorithms for Sparse 3-D Reconstruction from Image Sequences}},
  school = {Friedrich-Alexander Universit{\"a}t Erlangen-N{\"u}rnberg, Technische Fakult{\"a}t},
  year = 2007,
  address = {Erlangen, Germany},
  note={to appear}
}

@inproceedings{Zinsser03:ARI,
  author = "T. Zin{\ss}er and J. Schmidt and H. Niemann",
  title = {{A} {R}efined {ICP} {A}lgorithm for {R}obust 3-{D} {C}orrespondence {E}stimation},
  booktitle = "Proceedings of the " # icip,
  volume = {2},
  pages  = {695--698},
  year = 2003,
  address = "Barcelona, Spain",
 OPTmonth = sep,
  isbn = {0-7803-7750-8}
}

@inproceedings{Zinsser03:PAO,
  author = "T. Zin{\ss}er and J. Schmidt and H. Niemann",
  title = {{P}erformance {A}nalysis of {N}earest {N}eighbor {A}lgorithms for {ICP} {R}egistration of 3-{D} {P}oint {S}ets},
  pages = "199--206",
  crossref = {VMV2003}
}

@proceedings{VMV2003,
  title     = {Vision, Modeling, and Visualization 2003},
  booktitle = {Vision, Modeling, and Visualization 2003},
  editor    = {T.~Ertl and B.~Girod and G.~Greiner and H.~Niemann and H.-P.~Seidel and E.~Steinbach and R.~Westermann},
  year      = {2003},
 OPTmonth     = nov,
  publisher = {Aka/IOS Press, Berlin},
  address   = {Munich, Germany},
  ISBN = {3-89838-048-3}
}

@misc{Zinsser02:RSD,
  author = 	 {T. Zin{\ss}er},
  title = 	 {{Robuste Sch{\"a}tzung der Korrespondenzen zwischen 3-D Punktemengen}},
  howpublished =  {Diplomarbeit, Lehrstuhl f{\"u}r Mustererkennung, Universit{\"a}t Erlangen-N{\"u}rnberg},
  year = 	 {2002},
note = {Supervisors: J.\ Schmidt, F.\ Vogt}
}

@inproceedings{Schmidt04:VQB,
  author = "J. Schmidt and F. Vogt and H. Niemann",
  title = {{Vector Quantization Based Data Selection for Hand-Eye Calibration}},
  pages = 	 {21-28},
  crossref = {VMV2004}
}

@proceedings{VMV2004,
  title     = {Vision, Modeling, and Visualization 2004},
  booktitle = {Vision, Modeling, and Visualization 2004},
  editor    = {B. Girod and M. Magnor and H.-P. Seidel},
  year      = {2004},
 OPTmonth     = nov,
  publisher = {Aka/IOS Press, Berlin},
  address   = {Stanford, USA}
}

@article{Marr76:CCS,
   author    = {D. Marr and T. Poggio},
   title     = {Cooperative {C}omputation of {S}tereo {D}isparity},
   journal   = {Science},
   year      = {1976},
   volume    = {194},
   pages     = {209--236},
   enteredby = {Sebastian Vogt},
}

@inproceedings{Marr79:CTH,
   author    = {D. Marr and T. Poggio},
   title     = {A {C}omputational {T}heory of {H}uman {S}tereo {V}ision},
   crossref  = {RSL:1979},
   volume    = {B 204},
   pages     = {301--328},
   enteredby = {Sebastian Vogt},
}
@proceedings{RSL:1979,
   title     = {Proceedings of Royal Society London},
   booktitle = {Proceedings of Royal Society London},
   year      = {1979},
}

@inproceedings{Zomet01:ORL,
    author = "A. Zomet and L. Wolf and A. Shashua",
    title = {{Omni-Rig: Linear Self-Recalibration of a Rig with Varying Internal and External Parameters}},
    pages = "135--141",
    booktitle = {Proceedings of the International Conference on Computer Vision},
    address = {Vancouver, Canada},
   OPTmonth = jul,
    year = 2001,
    volume = 1
}

@inproceedings{Broggi01:SCO,
  author = "A. Broggi and M. Bertozzi and A. Fascioli",
  title = {{Self-Calibration of a Stereo Vision System for Automotive Applications}},
    pages = "3698--3703",
    booktitle = {Proceedings of the International Conference on Robotics and Automation},
    address = {Seoul, Korea},
   volume = 4,
   OPTmonth = may,
    year = 2001
}

@inproceedings{Dornaika01:SCO,
  author = "F. Dornaika",
  title = {{Self-Calibration of a Stereo Rig Using Monocular Epipolar Geometry}},
    pages = "467--472",
    booktitle = {Proceedings 8th IEEE International Conference on Computer Vision (ICCV)},
    address = {Vancouver, Canada},
   OPTmonth = jul,
    year = 2001
}

@article{Zhang97:ASS,
    author = "Z. Zhang",
    title = {{A Stereovision System for a Planetary Rover: Calibration, Correlation, Registration, and Fusion}},
    journal = "Machine Vision and Applications",
    volume = "10",
    number = "1",
    pages = "27--34",
    year = "1997"
}

@inproceedings{Zhang96:ASS,
    author = "Z. Zhang",
    title = {{A Stereovision System for a Planetary Rover: Calibration, Correlation, Registration, and Fusion}},
    booktitle = {Proceedings IEEE Workshop on Planetary Rover Technology and Systems},
    address = {Minneapolis, Minnesota, USA},
   OPTmonth = apr,
    year = 1996
}

@article{Horaud95:HEC,
    author = "Horaud, R. and Dornaika, F.",
    title = {{Hand-Eye Calibration}},
    journal = "International Journal of Robotics Research",
    volume = "14",
    number = "3",
   OPTmonth = "June",
    pages = "195--210",
    year = "1995"
}

@inproceedings{Hong95:EIH,
  author = "W. Hong and J. Slotine",
  title = "Experiments in Hand-Eye Coordination Using Active Vision",
    booktitle = {Proceedings of the Fourth International Symposium on Experimental Robotics, ISER'95},
    address = {Stanford, CA, USA},
    year = 1995
}

@inproceedings{Scheering98:UHE,
    author = "C. Scheering and B. Kersting",
    title = "Uncalibrated Hand-Eye Coordination with a Redundant Camera System",
    booktitle = {Proceedings International Conference on Robotics and Automation (ICRA-98)},
    year = 1998,
    pages = "2953--2958"
}

@article{Dornaika98:SRW,
  author = "F. Dornika and R. Horaud",
  title = "Simultaneous robot-world and hand-eye calibration",
   journal   = {IEEE Transactions on Robotics and Automation},
   year      = {1998},
   volume    = {14},
   number    = {4},
   pages     = {617--622}
}

@techreport{Dornaika97:SRW,
  author = "F. Dornika and R. Horaud",
  title = "Simultaneous robot-world and hand-eye calibration",
   OPTmonth =dec,
    institution = "INRIA",
    number = {98--},
    year = "1997"
}

@inproceedings{Hwang96:PTA,
  author = "W. Hwang and S. Howden and J. Weng",
  title = "Performing temporal action with a hand-eye system using the SHOSLIF approach",
    booktitle = {Proceedings Int'l Conference on Pattern Recognition},
  address = {Vienna, Austria},
OPTmonth = aug,
  year = "1996"
}

@InProceedings{Andreff99:OLH,
  author =	"N. Andreff and R. Horaud and B. Espiau",
  title =	{{On-line Hand-Eye Calibration}},
  booktitle =	"Second International Conference on 3-D Digital Imaging and Modeling (3DIM'99)",
  pages =	"430--436",
  OPTmonth =	"October",
  year =	"1999",
  address =	"Ottawa"
}

@article{Andreff01:RHE,
  author = {N. Andreff and R. Horaud and B. Espiau},
  title = {{Robot Hand-Eye Calibration Using Structure from Motion}},
  journal = {International Journal of Robotics Research},
  volume = {20},
  pages = {228--248},
  year = {2001}
}

@article{Grosskopf96:CAS,
  author = "S. Gro�kopf and A. Hildebrand and R. Malkewitz and W. M�ller and R. Ziegler and G and Graschew",
  title = "Computer Aided Surgery Vision and Feasibility of an Advanced Operation Theater",
    journal = {Computers \& Graphics},
  volume = {20},
  number = 6,
  pages = {825--838},
  year = {1996}
}

@article{Tsai89:ANT,
  author = "R.~Y. Tsai and R.~K. Lenz",
  title = {{A New Technique for Fully Autonomous and Efficient 3D Robotics Hand/Eye Calibration}},
   journal   = {IEEE Transactions on Robotics and Automation},
   year      = {1989},
   volume    = {5},
   number    = {3},
   pages     = {345--358}
}

@article{Shiu89:COW,
  author = "Y.~C. Shiu and S. Ahmad",
  title = {{Calibration of Wrist-Mounted Robotic Sensors by Solving Homogeneous Transform Equations of the Form AX = XB}},
   journal   = {IEEE Transactions on Robotics and Automation},
   year      = {1989},
   volume    = {5},
   number    = {3},
   pages     = {16--29}
}

@article{Wang92:ECO,
  author = "C. Wang",
  title = {{Extrinsic Calibration of a Vision Sensor Mounted on a Robot}},
   journal   = {IEEE Transactions on Robotics and Automation},
   year      = {1992},
   volume    = {8},
   number    = {2},
   pages     = {161--175}
}

@Book{Clow19:LGFF,
  author = {Mark Clow},
  title = {{Learn Google Flutter Fast:} 65 Example Apps},
   publisher = {Independently Published},
   year = {2019}
}

@Book{Sauter17:SMC,
  author = {Martin Sauter},
  title = {{From GSM to LTE-Advanced Pro and 5G:} An Introduction to Mobile Networks and Mobile Broadband},
   publisher = {John Wiley \& Sons Ltd.},
   year = {2017}
}

@book{tanenbaum12:computernetzwerke,
  author = {Tanenbaum, Andrew S.},
  description = {Computernetzwerke: Amazon.de: Andrew S. Tanenbaum: Bücher},
  edition = {5., aktualisierte. A.},
  isbn = {9783868941371},
  publisher = {Pearson},
  title = {Computernetzwerke},
  year = 2012
}

@manual{BT:core5,
    organization  = "Bluetooth SIG",
    title         = "Core Specification 5.2",
    year          =  2019,
    month         =  12,
	url           =  {https://www.bluetooth.com/specifications/bluetooth-core-specification/},
}

@manual{BT:GATTS,
  author = "{Bluetooth SIG, Inc.}",
  title = {GATT Specifications},
  year = 2019,
  url = {https://www.bluetooth.com/specifications/gatt/services},
  note = "\url{https://www.bluetooth.com/specifications/gatt/services} {[Online; accessed 2019-12-17]}"
}

@manual{BT:gattsDis,
  author = "{Bluetooth SIG, Inc.}",
  title = {{Device Information Service} Specification, Rev. V11r00},
  year = 2011,
  url = {https://www.bluetooth.org/docman/handlers/downloaddoc.ashx?doc_id=244369}
}

@manual{BT:gattsBas,
  author = "{Bluetooth SIG, Inc.}",
  title = {{Battery Service} Specification, Rev. V10r00},
  year = 2011,
  url = {https://www.bluetooth.org/docman/handlers/downloaddoc.ashx?doc_id=245138}
}

@manual{BT:gattsAios,
  author = "{Bluetooth SIG, Inc.}",
  title = {{Automation IO Service} Specification, Rev. V1.0.0},
  year = 2015,
  url = {https://www.bluetooth.org/DocMan/handlers/DownloadDoc.ashx?doc_id=304972}
}

@misc{BT:GATTC,
  author = "{Bluetooth SIG, Inc.}",
  title = {GATT Characteristics},
  year = 2019,
  url = {https://www.bluetooth.com/specifications/gatt/characteristics/},
  note = "\url{https://www.bluetooth.com/specifications/gatt/characteristics/} {[Online; accessed 2019-12-17]}"
}

@misc{GT:FLUTTER,
  title = {Google Trends Vergleich von Google Flutter, React Navtive und anderen Cross-Platform Development Tools},
  year = 2020,
  url = {https://trends.google.de/trends/explore?q=flutter,react%20native,xamarin,appcelerator,nativescript},
  note = "\url{https://trends.google.de/trends/explore?q=flutter,react%20native,xamarin,appcelerator,nativescript} {[Online; accessed 2020-01-07]}"
}

@misc{FL:FLUTHOME,
  title = {Google Flutter},
  year = 2020,
  url = {https://flutter.dev/},
  note = "\url{https://flutter.dev/} {[Online; accessed 2020-01-07]}"
}

@misc{FL:BLoCPatternFlut,
  author = "{Aditya Syal}",
  title = {BLoC Pattern in Flutter},
  publisher = "Flutter Devs",
  year = 2019,
  url = {http://flutterdevs.com/blog/bloc-pattern-in-flutter-part-1/},
  note = "\url{http://flutterdevs.com/blog/bloc-pattern-in-flutter-part-1/} {[Online; accessed 2020-02-24]}"
}

@misc{FL:ReactiveStreamsBLoC,
  title = {Reactive Programming - Streams - BLoC},
  publisher = "Didier Boelens",
  year = 2018,
  url = {https://www.didierboelens.com/2018/08/reactive-programming---streams---bloc/},
  note = "\url{https://www.didierboelens.com/2018/08/reactive-programming---streams---bloc/}{[Online; accessed 2020-02-24]}"
}

@misc{FL:BLoC,
  author = "{Felix Angelov}",
  title = {BLoC},
  publisher = "Bloclibrary",
  year = 2019,
  url = {https://bloclibrary.dev/#/},
  note = "\url{https://bloclibrary.dev/#/} {[Online; accessed 2020-02-24]}"
}

@misc{GG:pix3aspecs,
  title = {{Google Pixel 3a:} Technische Details},
  year = 2020,
  url = {https://store.google.com/de/product/pixel_3a_specs},
  note = "\url{https://store.google.com/de/product/pixel_3a_specs} {[Online; accessed 2020-01-07]}"
}

@article{JoeT16:BLE,
  author = "Joe Tillison",
  title = {{Bluetooth Low Energy (BLE) – A Short History of the BLE standard and GATT}},
  journal   = {IEEE Transactions on Robotics and Automation},
  publisher = {EDN Europe},
  year      = 2016,
}

@manual{ublox:sps,
  author = "{u-blox Holding AG}",
  title = {{u-blox Low Energy Serial Port Service} Protocol Specification, R11},
  year = 2019,
  url = {https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=2ahUKEwiGraa7rZLnAhUOV8AKHQl3AXsQFjAAegQIARAB&url=https%3A%2F%2Fwww.u-blox.com%2Fsites%2Fdefault%2Ffiles%2FLowEnergySerialPortService_ProtocolSpec_%2528UBX-16011192%2529.pdf&usg=AOvVaw1nmV9p5St50GS85Yk3sAvT}
}

@manual{esp:esp32data,
    organization  = "Espressif Systems",
    title         = "ESP32 Series Datasheet V3.3",
    year          =  2020,
	url           =  {https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf}
}

@misc{esp:esp32,
  author = "{ESPTech}",
  title = {Espressif ESP32 ESP-WROOM-32},
  year = 2020,
  url = {https://www.exp-tech.de/en/platforms/esp32/9372/espressif-esp32-esp-wroom-32},
  note = "\url{https://www.exp-tech.de/en/platforms/esp32/9372/espressif-esp32-esp-wroom-32}{[Online; accessed 2020-02-20]}"
}

@misc{esp:blethroughput,
  author = "{Espressif Systems}",
  title = {ESP-IDF BLE throughput GATT SERVER demo},
  year = 2020,
  url = {https://github.com/espressif/esp-idf/tree/release/v3.3/examples/bluetooth/ble_throughput/throughput_server#esp-idf-ble-throughput-gatt-server-demo},
  note = "\url{https://github.com/espressif/esp-idf/tree/release/v3.3/examples/bluetooth/ble_throughput/throughput_server#esp-idf-ble-throughput-gatt-server-demo}{[Online; accessed 2020-05-25]}"
}

@manual{esp:espble,
  organization  = "Espressif Systems",
  title = {Bluetooth API, Rev. 3.3-release},
  year = 2020,
  url = {https://docs.espressif.com/projects/esp-idf/en/release-v3.3/api-reference/bluetooth/index.html},
  note = "\url{https://docs.espressif.com/projects/esp-idf/en/release-v3.3/api-reference/bluetooth/index.html}"
}

@misc{ITW:FDMA,
  author = "{ITWissen.info}",
  title = {FDMA (frequency division multiple access)},
  year = 2011,
  url = {https://www.itwissen.info/FDMA-frequency-division-multiple-access-FDMA-Verfahren.html},
  note = "\url{https://www.itwissen.info/FDMA-frequency-division-multiple-access-FDMA-Verfahren.html} {[Online; accessed 2020-02-28]}"
}

@misc{RTOS:FreeROTS,
  title = {FreeRTOS {Quality RTOS \& Embedded Software}},
  year = 2020,
  url = {https://www.freertos.org/},
  note = "\url{https://www.freertos.org/}"
}

@misc{ITW:TDMA,
  author = "{ITWissen.info}",
  title = {TDMA (time division multiple access)},
  year = 2014,
  url = {https://www.itwissen.info/TDMA-time-division-multiple-access-TDMA-Verfahren.html},
  note = "\url{https://www.itwissen.info/TDMA-time-division-multiple-access-TDMA-Verfahren.html} {[Online; accessed 2020-02-28]}"
}

@book{chrupp:requirementsengineering,
  author = {Chris Rupp, die Sophisten},
  description = {Aus der praxis von klassisch bis agil},
  edition = {6., aktualisierte. und erweiterte},
  isbn = {9783446438934},
  publisher = {Hanser},
  title = {Requirementsengineering und Management},
  year = 2014
}

@book{gamma:designpatterns,
  author = {Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides},
  description = {Elements of reusable object-oriented Software},
  edition = {7. A.},
  isbn = {9789332555402},
  publisher = {Pearson},
  title = {Design Patterns},
  year = 2018
}

@book{bob:cleancode,
  author = {Robert C. Martin},
  description = {A Handbook of Agile Software Craftmanship},
  isbn = {9780132350884},
  publisher = {Prentice Hall Pearson Education},
  title = {Clean Code},
  year = 2017
}

@book{wallmueller:sqe,
  author = {Ernest Wallmüller},
  description = {Ein Leitfaden für bessere Software-Qualität},
  edition = {3.},
  isbn = {978-3-446-40405-2},
  publisher = {Hanser},
  title = {Software Quality Engineering},
  year = 2011
}

@ARTICLE{24765:2017,
  author={IEEE},
  journal={ISO/IEC/IEEE 24765:2017(E)},
  title={ISO/IEC/IEEE International Standard - Systems and software engineering--Vocabulary},
  year={2017},
  volume={},
  number={},
  pages={1-541},
  doi={10.1109/IEEESTD.2017.8016712}
}

@misc{DUDEN:prag,
  author = "{DUDEN}",
  title = {Wörterbuch},
  year = 2021,
  url = {https://www.duden.de/rechtschreibung/pragmatisch},
  note = "\url{https://www.duden.de/rechtschreibung/pragmatisch}"
}

@book{fors:acc,
  author = {Nicole Forsgren, PhD Jez Humble and Gene Kim},
  description = {Building and Scaling High Performing Technology Organizations},
  edition = {1.},
  isbn = {9783942788331},
  publisher = {IT Revolution Press},
  title = {Accelerate},
  year = 2018
}

@ARTICLE{conway:law,
  author={Melvin E. Conway},
  journal={F. D. Thompson Publications},
  title={How Do Committees Invent?},
  year={1968},
  volume={},
  number={},
  pages={},
  url = {http://www.melconway.com/research/committees.html},
}

license: MIT

license_type: permissive

branch_name: refs/heads/main

extension: bib


text:
package plugin

import (
	"bufio"
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"io"
	"net/url"
	"path"
	"strconv"
	"strings"
	"unicode"

	"github.com/pkg/errors"
)

func getMentionSearchQuery(username, org string) string {
	return buildSearchQuery("is:open mentions:%v archived:false %v", username, org)
}

func getReviewSearchQuery(username, org string) string {
	return buildSearchQuery("is:pr is:open review-requested:%v archived:false %v", username, org)
}

func getYourPrsSearchQuery(username, org string) string {
	return buildSearchQuery("is:pr is:open author:%v archived:false %v", username, org)
}

func getYourAssigneeSearchQuery(username, org string) string {
	return buildSearchQuery("is:open assignee:%v archived:false %v", username, org)
}

func getIssuesSearchQuery(org, searchTerm string) string {
	query := "is:open is:issue archived:false %v %v"
	orgField := ""
	if len(org) != 0 {
		orgField = fmt.Sprintf("org:%v", org)
	}

	return fmt.Sprintf(query, orgField, searchTerm)
}

func buildSearchQuery(query, username, org string) string {
	orgField := ""
	if len(org) != 0 {
		orgField = fmt.Sprintf("org:%v", org)
	}

	return fmt.Sprintf(query, username, orgField)
}

func pad(src []byte) []byte {
	padding := aes.BlockSize - len(src)%aes.BlockSize
	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
	return append(src, padtext...)
}

func unpad(src []byte) ([]byte, error) {
	length := len(src)
	unpadding := int(src[length-1])

	if unpadding > length {
		return nil, errors.New("unpad error. This could happen when incorrect encryption key is used")
	}

	return src[:(length - unpadding)], nil
}

func encrypt(key []byte, text string) (string, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return "", errors.Wrap(err, "could not create a cipher block, check key")
	}

	msg := pad([]byte(text))
	ciphertext := make([]byte, aes.BlockSize+len(msg))
	iv := ciphertext[:aes.BlockSize]
	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
		return "", errors.Wrap(err, "readFull was unsuccessful, check buffer size")
	}

	cfb := cipher.NewCFBEncrypter(block, iv)
	cfb.XORKeyStream(ciphertext[aes.BlockSize:], msg)
	finalMsg := base64.URLEncoding.EncodeToString(ciphertext)
	return finalMsg, nil
}

func decrypt(key []byte, text string) (string, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return "", errors.Wrap(err, "could not create a cipher block, check key")
	}

	decodedMsg, err := base64.URLEncoding.DecodeString(text)
	if err != nil {
		return "", errors.Wrap(err, "could not decode the message")
	}

	if (len(decodedMsg) % aes.BlockSize) != 0 {
		return "", errors.New("blocksize must be multiple of decoded message length")
	}

	iv := decodedMsg[:aes.BlockSize]
	msg := decodedMsg[aes.BlockSize:]

	cfb := cipher.NewCFBDecrypter(block, iv)
	cfb.XORKeyStream(msg, msg)

	unpadMsg, err := unpad(msg)
	if err != nil {
		return "", errors.Wrap(err, "unpad error, check key")
	}

	return string(unpadMsg), nil
}

func parseOwnerAndRepo(full, baseURL string) (string, string) {
	full = strings.TrimSuffix(strings.TrimSpace(strings.Replace(full, baseURL, "", 1)), "/")
	splitStr := strings.Split(full, "/")

	if len(splitStr) == 1 {
		owner := splitStr[0]
		return owner, ""
	}

	owner := splitStr[0]
	repo := splitStr[1]
	return owner, repo
}

func parseGitHubUsernamesFromText(text string) []string {
	usernameMap := map[string]bool{}
	usernames := []string{}

	for _, word := range strings.FieldsFunc(text, func(c rune) bool {
		return !(c == '-' || c == '@' || unicode.IsLetter(c) || unicode.IsNumber(c))
	}) {
		if len(word) < 2 || word[0] != '@' {
			continue
		}

		if word[1] == '-' || word[len(word)-1] == '-' {
			continue
		}

		if strings.Contains(word, "--") {
			continue
		}

		name := word[1:]
		if !usernameMap[name] {
			usernames = append(usernames, name)
			usernameMap[name] = true
		}
	}

	return usernames
}

func fixGithubNotificationSubjectURL(url, issueNum string) string {
	url = strings.Replace(url, "api.", "", 1)
	url = strings.Replace(url, "repos/", "", 1)
	url = strings.Replace(url, "/pulls/", "/pull/", 1)
	url = strings.Replace(url, "/commits/", "/commit/", 1)
	url = strings.Replace(url, "/api/v3", "", 1)
	url = strings.Replace(url, "comments/", issueNum+"#issuecomment-", 1)
	return url
}

func fullNameFromOwnerAndRepo(owner, repo string) string {
	return fmt.Sprintf("%s/%s", owner, repo)
}

func isFlag(text string) bool {
	return strings.HasPrefix(text, "--")
}

func parseFlag(flag string) string {
	return strings.TrimPrefix(flag, "--")
}

func containsValue(arr []string, value string) bool {
	for _, element := range arr {
		if element == value {
			return true
		}
	}

	return false
}

// filterLines filters lines in a string from start to end.
func filterLines(s string, start, end int) (string, error) {
	scanner := bufio.NewScanner(strings.NewReader(s))
	var buf strings.Builder
	for i := 1; scanner.Scan() && i <= end; i++ {
		if i < start {
			continue
		}
		buf.Write(scanner.Bytes())
		buf.WriteByte(byte('\n'))
	}

	if err := scanner.Err(); err != nil {
		return "", errors.Wrap(err, "scanner error occurred")
	}
	return buf.String(), nil
}

// getLineNumbers return the start and end lines from an anchor tag
// of a github permalink.
func getLineNumbers(s string) (start, end int) {
	// split till -
	parts := strings.Split(s, "-")

	if len(parts) > 2 {
		return -1, -1
	}

	switch len(parts) {
	case 1:
		// just a single line
		l := getLine(parts[0])
		if l == -1 {
			return -1, -1
		}
		if l < permalinkLineContext {
			return 0, l + permalinkLineContext
		}
		return l - permalinkLineContext, l + permalinkLineContext
	case 2:
		// a line range
		start := getLine(parts[0])
		end := getLine(parts[1])
		if start > end && (start != -1 && end != -1) {
			return -1, -1
		}
		return start, end
	}
	return -1, -1
}

// getLine returns the line number in int from a string
// of form L<num>.
func getLine(s string) int {
	// check starting L and minimum length.
	if !strings.HasPrefix(s, "L") || len(s) < 2 {
		return -1
	}

	line, err := strconv.Atoi(s[1:])
	if err != nil {
		return -1
	}
	return line
}

// isInsideLink reports whether the given index in a string is preceded
// by zero or more space, then (, then ].
//
// It is a poor man's version of checking markdown hyperlinks without
// using a full-blown markdown parser. The idea is to quickly confirm
// whether a permalink is inside a markdown link or not. Something like
// "text ]( permalink" is rare enough. Even then, it is okay if
// there are false positives, but there cannot be any false negatives.
//
// Note: it is fine to go one byte at a time instead of one rune because
// we are anyways looking for ASCII chars.
func isInsideLink(msg string, index int) bool {
	stage := 0 // 0 is looking for space or ( and 1 for ]

	for i := index; i > 0; i-- {
		char := msg[i-1]
		switch stage {
		case 0:
			if char == ' ' {
				continue
			}
			if char == '(' {
				stage++
				continue
			}
			return false
		case 1:
			if char == ']' {
				return true
			}
			return false
		}
	}
	return false
}

// getCodeMarkdown returns the constructed markdown for a permalink.
func getCodeMarkdown(user, repo, repoPath, word, lines string, isTruncated bool) string {
	final := fmt.Sprintf("\n[%s/%s/%s](%s)\n", user, repo, repoPath, word)
	ext := path.Ext(repoPath)
	// remove the preceding dot
	if len(ext) > 1 {
		ext = strings.TrimPrefix(ext, ".")
	}
	final += "```" + ext + "\n"
	final += lines
	if isTruncated { // add an ellipsis if lines were cut off
		final += "...\n"
	}
	final += "```\n"
	return final
}

// getToDoDisplayText returns the text to be displayed in todo listings.
func getToDoDisplayText(baseURL, title, url, notifType string) string {
	owner, repo := parseOwnerAndRepo(url, baseURL)
	repoURL := fmt.Sprintf("%s%s/%s", baseURL, owner, repo)
	repoWords := strings.Split(repo, "-")
	if len(repo) > 20 && len(repoWords) > 1 {
		repo = "..." + repoWords[len(repoWords)-1]
	}
	repoPart := fmt.Sprintf("[%s/%s](%s)", owner, repo, repoURL)

	if len(title) > 80 {
		title = strings.TrimSpace(title[:80]) + "..."
	}
	titlePart := fmt.Sprintf("[%s](%s)", title, url)

	if notifType == "" {
		return fmt.Sprintf("* %s %s\n", repoPart, titlePart)
	}

	return fmt.Sprintf("* %s %s %s\n", repoPart, notifType, titlePart)
}

// isValidURL checks if a given URL is a valid URL with a host and a http or http scheme.
func isValidURL(rawURL string) error {
	u, err := url.ParseRequestURI(rawURL)
	if err != nil {
		return err
	}

	if u.Scheme != "http" && u.Scheme != "https" {
		return errors.Errorf("URL schema must either be %q or %q", "http", "https")
	}

	if u.Host == "" {
		return errors.New("URL must contain a host")
	}

	return nil
}

// lastN returns the last n characters of a string, with the rest replaced by *.
// At most 3 characters are replaced. The rest is cut off.
func lastN(s string, n int) string {
	if n < 0 {
		return ""
	}

	out := []byte(s)
	if len(out) > n+3 {
		out = out[len(out)-n-3:]
	}
	for i := range out {
		if i < len(out)-n {
			out[i] = '*'
		}
	}

	return string(out)
}

repository: mattermost/mattermost-plugin-github

repo_name: mattermost/mattermost-plugin-github

branch_name: refs/heads/master

gha_language: Go

extension: go


text:
// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"context"
	"strconv"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// EnvironmentEntryEntity EnvironmentEntryEntity model
//
// swagger:model EnvironmentEntryEntity
type EnvironmentEntryEntity struct {

	// The time the environment was created
	// Format: date-time
	CreatedAt strfmt.DateTime `json:"created_at,omitempty"`

	// Description of the Environment
	Description string `json:"description,omitempty"`

	// Information about known linkages to representations of services outside of FireHydrant.
	ExternalResources []*ExternalResourceEntity `json:"external_resources"`

	// UUID of the Environment
	ID string `json:"id,omitempty"`

	// Name of the Environment
	Name string `json:"name,omitempty"`
}

// Validate validates this environment entry entity
func (m *EnvironmentEntryEntity) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateCreatedAt(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateExternalResources(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *EnvironmentEntryEntity) validateCreatedAt(formats strfmt.Registry) error {
	if swag.IsZero(m.CreatedAt) { // not required
		return nil
	}

	if err := validate.FormatOf("created_at", "body", "date-time", m.CreatedAt.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *EnvironmentEntryEntity) validateExternalResources(formats strfmt.Registry) error {
	if swag.IsZero(m.ExternalResources) { // not required
		return nil
	}

	for i := 0; i < len(m.ExternalResources); i++ {
		if swag.IsZero(m.ExternalResources[i]) { // not required
			continue
		}

		if m.ExternalResources[i] != nil {
			if err := m.ExternalResources[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("external_resources" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("external_resources" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

// ContextValidate validate this environment entry entity based on the context it is used
func (m *EnvironmentEntryEntity) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateExternalResources(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *EnvironmentEntryEntity) contextValidateExternalResources(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.ExternalResources); i++ {

		if m.ExternalResources[i] != nil {
			if err := m.ExternalResources[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("external_resources" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("external_resources" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

// MarshalBinary interface implementation
func (m *EnvironmentEntryEntity) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *EnvironmentEntryEntity) UnmarshalBinary(b []byte) error {
	var res EnvironmentEntryEntity
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

repository: firehydrant/api-client-go

repo_name: firehydrant/api-client-go

gha_license_id: MIT


text:
package controllers

import (
	"encoding/base64"
	"encoding/json"
	"log"
	"strings"

	"github.com/MixinNetwork/bot-api-go-client"
	"github.com/MixinNetwork/bot-manager/externals"
	"github.com/MixinNetwork/bot-manager/models"
	"github.com/MixinNetwork/bot-manager/utils"
)

// 客户端消息入口
func readMessage(messageCome <-chan models.MessengerChannel, hash string) {
	for msg := range messageCome {
		_msg := &msg.Message
		if _msg.Source == "ACKNOWLEDGE_MESSAGE_RECEIPT" {
			models.UpdateMessage(_msg.MessageId, _msg.Status)
			for _, chanel := range models.HashManagerMap[hash] {
				if chanel != nil {
					var m models.RespMessage
					m.MessageId = _msg.MessageId
					m.Status = _msg.Status
					m.Source = _msg.Source
					chanel <- m
				}
			}
			continue
		}

		adminIds := models.GetAdminIdsByBotId(msg.ClientID)
		isManager := checkManager(_msg.UserId, adminIds)
		if !isManager && _msg.Category == "PLAIN_TEXT" {
			if replayed := handleAutoReplayMessage(msg, hash, adminIds); replayed {
				continue
			}
		}

		//  2. 转发给已登录的后端管理的管理员
		forwardLoginDashboardAdmins(msg, hash, isManager, adminIds)

		// 转发给手机端
		if isManager {
			// 管理员的消息
			if _msg.QuoteMessageId != "" {
				//	1. 转发给其他管理员
				//  2. 转发给被 Quote 的用户
				if hasError := handleAdminClientMessageWithQuote(msg, adminIds); !hasError {
					continue
				}
			} else {
				// 1. 判断是否是 APP_CARD
				if hasError := handleAdminClientMessageWithNoQuote(msg, adminIds); !hasError {
					continue
				}
			}
		} else {
			// 其他人员的消息
			//	1. 直接转发给管理员的 Messenger
			handleNonAdminClientMessage(msg, adminIds)
		}
	}
}

func checkManager(userId string, UserIds []string) bool {
	for _, id := range UserIds {
		if id == userId {
			return true
		}
	}
	return false
}

// 处理自动回复消息
func handleAutoReplayMessage(msg models.MessengerChannel, hash string, adminIds []string) bool {
	_msg := &msg.Message
	decodeBytes, _ := base64.StdEncoding.DecodeString(_msg.Data)
	decodeString := strings.ToLower(string(decodeBytes))
	replayData, replayCategory := models.GetAutoReplayMessageByKey(msg.ClientID, decodeString)
	if replayData != "" {
		forwardDashboardMessage(&models.Message{
			Category:         _msg.Category,
			CreatedAt:        utils.FormatTime(_msg.CreatedAt),
			MessageId:        _msg.MessageId,
			Source:           _msg.Source,
			UserId:           _msg.UserId,
			QuoteMessageId:   _msg.QuoteMessageId,
			ConversationId:   _msg.ConversationId,
			Data:             _msg.Data,
			RepresentativeId: _msg.RepresentativeId,
			Status:           _msg.Status,
			UpdatedAt:        utils.FormatTime(_msg.UpdatedAt),
		}, msg.ClientID, msg.SessionID, msg.PrivateKey, hash, false, adminIds)
		var sendMessages []*bot.MessageRequest
		base64Data := base64.StdEncoding.EncodeToString([]byte(replayData))
		messageId := bot.UuidNewV4().String()
		sendMessages = append(sendMessages, &bot.MessageRequest{
			MessageId:      messageId,
			Category:       replayCategory,
			Data:           base64Data,
			ConversationId: _msg.ConversationId,
			RecipientId:    _msg.UserId,
		})
		err := externals.SendBatchMessage(sendMessages, msg.ClientID, msg.SessionID, msg.PrivateKey)
		if err != nil {
			log.Println("转发自动回复的消息出问题了。", err)
			return true
		}
		forwardDashboardMessage(&models.Message{
			Category:       replayCategory,
			CreatedAt:      utils.FormatTime(_msg.CreatedAt),
			MessageId:      messageId,
			UserId:         _msg.UserId,
			ConversationId: _msg.ConversationId,
			Data:           base64Data,
			UpdatedAt:      utils.FormatTime(_msg.UpdatedAt),
		}, msg.ClientID, msg.SessionID, msg.PrivateKey, hash, false, adminIds)
		return true
	}
	return false
}

// 转发给管理后台
func forwardLoginDashboardAdmins(msg models.MessengerChannel, hash string, isManager bool, adminIds []string) {
	_msg := &msg.Message
	forwardDashboardMessage(&models.Message{
		Category:         _msg.Category,
		CreatedAt:        utils.FormatTime(_msg.CreatedAt),
		MessageId:        _msg.MessageId,
		Source:           _msg.Source,
		UserId:           _msg.UserId,
		QuoteMessageId:   _msg.QuoteMessageId,
		ConversationId:   _msg.ConversationId,
		Data:             _msg.Data,
		RepresentativeId: _msg.RepresentativeId,
		Status:           _msg.Status,
		UpdatedAt:        utils.FormatTime(_msg.UpdatedAt),
	}, msg.ClientID, msg.SessionID, msg.PrivateKey, hash, isManager, adminIds)
}

// 处理含有quote的消息客户端管理员消息
func handleAdminClientMessageWithQuote(msg models.MessengerChannel, adminIds []string) bool {
	_msg := &msg.Message
	originMessage := models.GetOriginMessageById(msg.ClientID, _msg.QuoteMessageId)
	if originMessage == nil {
		log.Println("没找到这条消息originMessage，", _msg.QuoteMessageId)
		return false
	}
	forwardMessages := models.GetForwardMessagesByOrigin(msg.ClientID, originMessage.OriginMessageId)
	if forwardMessages == nil {
		log.Println("没找到这条消息forwardMessage", originMessage.OriginMessageId)
		return false
	}
	// 转发给其他管理员，包含quote自己
	var sendMessages []*bot.MessageRequest
	for _, userId := range adminIds {
		if userId == _msg.UserId {
			continue
		}
		conversationId := bot.UniqueConversationId(msg.ClientID, userId)
		sendMessages = append(sendMessages, &bot.MessageRequest{
			MessageId:        bot.UuidNewV4().String(),
			Category:         _msg.Category,
			Data:             _msg.Data,
			QuoteMessageId:   forwardMessages[userId].MessageId,
			ConversationId:   conversationId,
			RecipientId:      userId,
			RepresentativeId: _msg.UserId,
		})
	}
	// 转发给被 Quote 的那个用户
	sendMessages = append(sendMessages, &bot.MessageRequest{
		ConversationId: originMessage.ConversationId,
		RecipientId:    originMessage.RecipientId,
		MessageId:      bot.UuidNewV4().String(),
		Category:       _msg.Category,
		Data:           _msg.Data,
		QuoteMessageId: originMessage.OriginMessageId,
	})
	err := externals.SendBatchMessage(sendMessages, msg.ClientID, msg.SessionID, msg.PrivateKey)
	if err != nil {
		log.Println("转发管理员消息出问题了。", err)
		return false
	}
	for _, message := range sendMessages {
		models.AddForwardMessage(models.ForwardMessage{
			ClientId:        msg.ClientID,
			MessageId:       message.MessageId,
			AdminId:         _msg.UserId,
			RecipientId:     message.RecipientId,
			OriginMessageId: originMessage.MessageId,
			ConversationId:  message.ConversationId,
			AdminMessageId:  _msg.MessageId,
			CreatedAt:       utils.FormatTime(_msg.CreatedAt),
		})
	}
	return true
}

// 处理管理员客户端发送的消息（无quote_id）
func handleAdminClientMessageWithNoQuote(msg models.MessengerChannel, adminIds []string) bool {
	_msg := &msg.Message
	if _msg.Category == "APP_CARD" {
		_, err := sendBroadcast(&models.Bot{
			ClientId:   msg.ClientID,
			SessionId:  msg.SessionID,
			PrivateKey: msg.PrivateKey,
		}, _msg.Category, _msg.Data, true)
		if err != nil {
			log.Println("client_message handleAdminClientMessageWithNoQuote", err)
			return false
		}
	}
	return true
}

func sendBroadcast(clientBot *models.Bot, category, data string, isBase64Data bool) ([]*bot.MessageRequest, error) {
	// 1. 拿到所有的用户
	userList := models.GetBotUserListById(clientBot.ClientId)
	// 3. 构建所有的消息
	var sendMessages []*bot.MessageRequest
	base64Data := ""
	if isBase64Data {
		base64Data = data
	} else {
		if category == "PLAIN_TEXT" {
			base64Data = base64.StdEncoding.EncodeToString([]byte(data))
		} else if category == "PLAIN_IMAGE" {
			_msgData, err := json.Marshal(data)
			base64Data = base64.StdEncoding.EncodeToString(_msgData)
			if err != nil {
				return nil, err
			}
		}
	}
	for _, user := range userList {
		sendMessages = append(sendMessages, &bot.MessageRequest{
			ConversationId: bot.UniqueConversationId(clientBot.ClientId, user),
			RecipientId:    user,
			MessageId:      bot.UuidNewV4().String(),
			Category:       category,
			Data:           base64Data,
		})
	}
	err := externals.SendBatchMessage(sendMessages, clientBot.ClientId, clientBot.SessionId, clientBot.PrivateKey)
	if err != nil {
		return nil, err
	}
	return sendMessages, nil
}

// 处理非管理员客户端消息
var notHandleMessage = map[string]bool{
	"MESSAGE_RECALL": true,
}

// 处理非管理员消息
func handleNonAdminClientMessage(msg models.MessengerChannel, adminIds []string) {
	_msg := &msg.Message
	if notHandleMessage[_msg.Category] {
		return
	}
	var sendMessages []*bot.MessageRequest
	for _, userId := range adminIds {
		conversationId := bot.UniqueConversationId(msg.ClientID, userId)
		messageId := bot.UuidNewV4().String()
		sendMessages = append(sendMessages, &bot.MessageRequest{
			ConversationId:   conversationId,
			RecipientId:      userId,
			RepresentativeId: _msg.UserId,
			MessageId:        messageId,
			Category:         _msg.Category,
			Data:             _msg.Data,
		})
		models.AddForwardMessage(models.ForwardMessage{
			ClientId:        msg.ClientID,
			MessageId:       messageId,
			OriginMessageId: _msg.MessageId,
			RecipientId:     _msg.UserId,
			ConversationId:  _msg.ConversationId,
			AdminId:         userId,
			CreatedAt:       utils.FormatTime(_msg.CreatedAt),
		})
	}
	if sendMessages != nil {
		err := externals.SendBatchMessage(sendMessages, msg.ClientID, msg.SessionID, msg.PrivateKey)
		if err != nil {
			log.Printf("转发普通消息出问题了。 %#v", err)
			log.Printf("%#v", sendMessages[0])
		}
	} else {
		log.Printf("没找到管理员？？%s,%#v", msg.ClientID, msg.Message)
	}
}

repository: hi-carry-lee/bot-manager

repo_name: hi-carry-lee/bot-manager


text:
@inproceedings{hickey2016pseudo,
 author = {Hickey, P and Ma, Peter C and Banuti, D and Ihme, M},
 booktitle = {Proceedings of the Combustion Institute-Canadian Section; Spring Technical Meeting, Waterloo, Canada},
 title = {Pseudo-phase change in transcritical combustion for liquid rocket engines},
 year = {2016}
}

repository: mpilab-uw/mpilab

repo_name: mpilab-uw/mpilab


text:
@Article{ramirezalpizar:rb:2017,
  author    = {Ramirez-Alpizar, Ixchel G. and Harada, Kensuke and Yoshida, Eiichi},
  title     = {Human-based framework for the assembly of elastic objects by a dual-arm robot},
  journal   = {Robomech Journal},
  year      = {2017},
  volume    = {4},
  number    = {20},
  month     = {August},
  doi       = {10.1186/s40648-017-0088-0},
  url       = {https://robomechjournal.springeropen.com/track/pdf/10.1186/s40648-017-0088-0},
  keywords  = {Assembly, Deformable object, Human demonstration},
  abstract  = {This paper proposes a new framework for planning assembly tasks involving elastic parts. As an example of these kind of assembly tasks, we deal with the insertion of ring-shaped objects into a cylinder by a dual-arm robot. The proposed framework is a combination of human movements to determine the overall assembly strategy and an optimization-based motion planner to generate the robot trajectories. The motion of the human’s hands, more specifically, the motion of the fingers gripping the object is captured by a Leap Motion Controller. Then, key points in the recorded trajectory of the position and orientation of the human’s fingers are extracted. These points are used as partial goals in the optimization-based motion planner that generates the robot arms’ trajectories which minimize the object’s deformation. Through experimental results it was verified the validity of the extracted key points from the human’s movements that enable the robot to successfully assemble ring-shaped elastic objects. We compared these results with the assembly done by purely repeating all of the human’s hands movements.},
  publisher = {Springer Open}
}

gha_language: TeX


text:
SUMMARY = "ioquake3 is a baseline Quake 3 which may be used for further development and baseq3 fun."

DESCRIPTION = "The ioquake3 community effort to continue supporting/developing id's Quake III Arena http://www.ioquake3.org/"

SECTION = "games"
HOMEPAGE = "https://github.com/ioquake/ioq3"

LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING.txt;md5=87113aa2b484c59a17085b5c3f900ebf"

SRC_URI = 	" \
		git://github.com/ioquake/ioq3.git;branch=master \
		"

SRCREV = "45de6be4c233891eb70e5592f3287a4af39d6002"

S = "${WORKDIR}/git"

DEPENDS = "libsdl2 curl zlib libjpeg-turbo libogg libopus opusfile virtual/mesa virtual/libgl"

COPYDIR = "${D}${datadir}/${PN}"
export COPYDIR

COPYBINDIR = "${D}${bindir}"
export COPYBINDIR

DEFAULT_BASEDIR="${datadir}/${PN}"
export DEFAULT_BASEDIR

# do not strip right in 'copyfiles' target. Let bitbake do it.
NO_STRIP = "1"
export NO_STRIP

# do not use internal libs
USE_INTERNAL_LIBS = "0"
export USE_INTERNAL_LIBS

# use standard system headers
USE_LOCAL_HEADERS = "0"
export LOCAL_HEADERS

# do not use openAL
USE_OPENAL = "0"
export USE_OPENAL

#do not build the renderers as external libraries
USE_RENDERER_DLOPEN = "0"
export USE_RENDERER_DLOPEN

ARCH= "${TRANSLATED_TARGET_ARCH}"
export ARCH

inherit pkgconfig

do_install () {
	mkdir -p ${COPYDIR}
	mkdir -p ${COPYBINDIR}
	oe_runmake copyfiles
}

repository: fgpolito/meta-clik

repo_name: fgpolito/meta-clik

extension: bb


text:
@misc{tarver2023equalizer,
 author = {Tarver, Chance and Tonnemacher, Matthew and Muhammad, Khurram},
 month = {February~16},
 note = {US Patent App. 17/818,672},
 title = {Equalizer digital self interference cancelation for hybrid mimo transmitters},
 year = {2023}
}


text:
require recipes-security/optee/optee-examples.inc

SRCREV = "f301ee9df2129c0db683e726c91dc2cefe4cdb65"

repository: openbmc/openbmc

repo_name: openbmc/openbmc

gha_license_id: NOASSERTION

gha_language: Python


text:
package data

import (
	"context"
	"github.com/bevgene/go-currency-rate/app/clients"
	"github.com/bevgene/go-currency-rate/app/model"
	"github.com/go-masonry/mortar/interfaces/cfg"
	"github.com/go-masonry/mortar/interfaces/log"
	"go.uber.org/fx"
)

type (
	CurrencyRateDao interface {
		GetRates(ctx context.Context) (*model.ExchangeRateDocument, error)
	}

	currencyRateDaoImplDeps struct {
		fx.In

		Logger          log.Logger
		Config          cfg.Config
		Lifecycle       fx.Lifecycle
		LazyMongoClient *clients.LazyMongoClient
	}

	currencyRateDaoImpl struct {
		deps currencyRateDaoImplDeps
	}
)

func CreateCurrencyRateDao(deps currencyRateDaoImplDeps) (result CurrencyRateDao) {
	result = &currencyRateDaoImpl{
		deps: deps,
	}
	return
}

func (impl *currencyRateDaoImpl) GetRates(ctx context.Context) (*model.ExchangeRateDocument, error) {
	return impl.deps.LazyMongoClient.Client.GetLatestRateDocument(ctx)
}

repository: bevgene/go-currency-converter

repo_name: bevgene/go-currency-converter


text:
@article{sormaz2017knowing,
 author = {Sormaz, Mladen and Jefferies, Elizabeth and Bernhardt, Boris C and Karapanagiotidis, Theodoros and Mollo, Giovanna and Bernasconi, Neda and Bernasconi, Andrea and Hartley, Tom and Smallwood, Jonathan},
 journal = {NeuroImage},
 pages = {400--410},
 publisher = {Academic Press},
 title = {Knowing what from where: Hippocampal connectivity with temporoparietal cortex at rest is linked to individual differences in semantic and topographic memory},
 volume = {152},
 year = {2017}
}

repository: tkarapan/academic-kickstart

repo_name: tkarapan/academic-kickstart


text:
@inproceedings{Hjalmarsson_i:95a,
 address = {Rome, Italy},
 author = {H. Hjalmarsson},
 booktitle = {Proceedings of European Control Conference},
 pages = {2869-2874},
 title = {Model-Free Tuning of Controllers: Experience with Time-Varying Linear Systems},
 year = {1995}
}

repository: hhjalmars/academic-kickstart

repo_name: hhjalmars/academic-kickstart


text:
//go:build windows
// +build windows

package enforcer

import (
	"errors"
	"fmt"
	"syscall"

	"golang.org/x/sys/windows"
)

func validateTokenForUser(token syscall.Token, expectedUsername, expectedDomain string) error {
	t := windows.Token(token)

	user, err := t.GetTokenUser()
	if err != nil {
		return fmt.Errorf("unable to get user: %v", err)
	}

	username, domain, accType, err := user.User.Sid.LookupAccount("")
	if err != nil {
		return fmt.Errorf("unable to look up account: %v", err)
	}

	if accType != windows.SidTypeUser {
		return errors.New("token is not for a standard user")
	}

	if username != expectedUsername || domain != expectedDomain {
		return errors.New("token does not match expected user")
	}

	return nil
}

repository: scjalliance/resourceful

repo_name: scjalliance/resourceful


text:
KBRANCH ?= "dev-5.4"
LINUX_VERSION ?= "5.4.39"

SRCREV="30079d65ac31588d4535122fdb14278ef5804ce4"

require linux-aspeed.inc

repository: velumanit/openbmc

repo_name: velumanit/openbmc


text:
require intltool_${PV}.bb

inherit native

EXTRA_OEMAKE = "'PERL_TARGET=/usr/bin/env perl'"

do_configure_prepend() {
	cd ${S}
	for i in intltool*.in ; do
	 	sed -i -e s:-w::g $i
	done
}

do_configure_append() {
        sed -i -e s:head\ -1:head\ -n1:g intltool.m4
}

SRC_URI[md5sum] = "7adee54938b22d32c63ecb5223fd4249"
SRC_URI[sha256sum] = "f30cbb62345310a27f74a43fef17f146d99203c097c6460002da0a22d969a594"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@inproceedings{vidalmata2021joint,
  title={Joint visual-temporal embedding for unsupervised learning of actions in untrimmed sequences},
  author={VidalMata, Rosaura G and Scheirer, Walter J and Kukleva, Anna and Cox, David and Kuehne, Hilde},
  booktitle={Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision (WACV)},
  year={2021}
}


text:
@article{jacobsson07improved,
 author = {K. Jacobsson and L. L. H. Andrew and A. K. Tang and
S. H. Low and H. Hjalmarsson},
 journal = {IEEE Transactions on Automatic Control},
 number = {3},
 pages = {551-564},
 title = {An Improved Link Model for Window Flow Control and Its Application
to FAST TCP},
 volume = {54},
 year = {2009}
}


text:
package main

import "github.com/evanljp/algorithm/tags"

var _ = []tags.LUT{tags.LookupTable}

func isIsomorphic(s string, t string) bool {
	sarr := []rune(s)
	tarr := []rune(t)
	if len(sarr) != len(tarr) {
		return false
	}
	dict := make(map[rune]rune)
	used := make(map[rune]struct{})
	for i, sr := range sarr {
		val, ok := dict[sr]
		tr := tarr[i]
		if !ok {
			if _, ok = used[tr]; ok {
				return false
			} else {
				dict[sr] = tr
				used[tr] = struct{}{}
			}
		} else if val != tr {
			return false
		}
	}
	return true
}

func main() {

}

repository: EvanLjp/notebook

repo_name: EvanLjp/notebook


text:
/*
Copyright The Kubeform Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Code generated by client-gen. DO NOT EDIT.

package fake

import (
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	labels "k8s.io/apimachinery/pkg/labels"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
	types "k8s.io/apimachinery/pkg/types"
	watch "k8s.io/apimachinery/pkg/watch"
	testing "k8s.io/client-go/testing"
	v1alpha1 "kubeform.dev/kubeform/apis/aws/v1alpha1"
)

// FakeS3AccountPublicAccessBlocks implements S3AccountPublicAccessBlockInterface
type FakeS3AccountPublicAccessBlocks struct {
	Fake *FakeAwsV1alpha1
	ns   string
}

var s3accountpublicaccessblocksResource = schema.GroupVersionResource{Group: "aws.kubeform.com", Version: "v1alpha1", Resource: "s3accountpublicaccessblocks"}

var s3accountpublicaccessblocksKind = schema.GroupVersionKind{Group: "aws.kubeform.com", Version: "v1alpha1", Kind: "S3AccountPublicAccessBlock"}

// Get takes name of the s3AccountPublicAccessBlock, and returns the corresponding s3AccountPublicAccessBlock object, and an error if there is any.
func (c *FakeS3AccountPublicAccessBlocks) Get(name string, options v1.GetOptions) (result *v1alpha1.S3AccountPublicAccessBlock, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewGetAction(s3accountpublicaccessblocksResource, c.ns, name), &v1alpha1.S3AccountPublicAccessBlock{})

	if obj == nil {
		return nil, err
	}
	return obj.(*v1alpha1.S3AccountPublicAccessBlock), err
}

// List takes label and field selectors, and returns the list of S3AccountPublicAccessBlocks that match those selectors.
func (c *FakeS3AccountPublicAccessBlocks) List(opts v1.ListOptions) (result *v1alpha1.S3AccountPublicAccessBlockList, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewListAction(s3accountpublicaccessblocksResource, s3accountpublicaccessblocksKind, c.ns, opts), &v1alpha1.S3AccountPublicAccessBlockList{})

	if obj == nil {
		return nil, err
	}

	label, _, _ := testing.ExtractFromListOptions(opts)
	if label == nil {
		label = labels.Everything()
	}
	list := &v1alpha1.S3AccountPublicAccessBlockList{ListMeta: obj.(*v1alpha1.S3AccountPublicAccessBlockList).ListMeta}
	for _, item := range obj.(*v1alpha1.S3AccountPublicAccessBlockList).Items {
		if label.Matches(labels.Set(item.Labels)) {
			list.Items = append(list.Items, item)
		}
	}
	return list, err
}

// Watch returns a watch.Interface that watches the requested s3AccountPublicAccessBlocks.
func (c *FakeS3AccountPublicAccessBlocks) Watch(opts v1.ListOptions) (watch.Interface, error) {
	return c.Fake.
		InvokesWatch(testing.NewWatchAction(s3accountpublicaccessblocksResource, c.ns, opts))

}

// Create takes the representation of a s3AccountPublicAccessBlock and creates it.  Returns the server's representation of the s3AccountPublicAccessBlock, and an error, if there is any.
func (c *FakeS3AccountPublicAccessBlocks) Create(s3AccountPublicAccessBlock *v1alpha1.S3AccountPublicAccessBlock) (result *v1alpha1.S3AccountPublicAccessBlock, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewCreateAction(s3accountpublicaccessblocksResource, c.ns, s3AccountPublicAccessBlock), &v1alpha1.S3AccountPublicAccessBlock{})

	if obj == nil {
		return nil, err
	}
	return obj.(*v1alpha1.S3AccountPublicAccessBlock), err
}

// Update takes the representation of a s3AccountPublicAccessBlock and updates it. Returns the server's representation of the s3AccountPublicAccessBlock, and an error, if there is any.
func (c *FakeS3AccountPublicAccessBlocks) Update(s3AccountPublicAccessBlock *v1alpha1.S3AccountPublicAccessBlock) (result *v1alpha1.S3AccountPublicAccessBlock, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewUpdateAction(s3accountpublicaccessblocksResource, c.ns, s3AccountPublicAccessBlock), &v1alpha1.S3AccountPublicAccessBlock{})

	if obj == nil {
		return nil, err
	}
	return obj.(*v1alpha1.S3AccountPublicAccessBlock), err
}

// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *FakeS3AccountPublicAccessBlocks) UpdateStatus(s3AccountPublicAccessBlock *v1alpha1.S3AccountPublicAccessBlock) (*v1alpha1.S3AccountPublicAccessBlock, error) {
	obj, err := c.Fake.
		Invokes(testing.NewUpdateSubresourceAction(s3accountpublicaccessblocksResource, "status", c.ns, s3AccountPublicAccessBlock), &v1alpha1.S3AccountPublicAccessBlock{})

	if obj == nil {
		return nil, err
	}
	return obj.(*v1alpha1.S3AccountPublicAccessBlock), err
}

// Delete takes name of the s3AccountPublicAccessBlock and deletes it. Returns an error if one occurs.
func (c *FakeS3AccountPublicAccessBlocks) Delete(name string, options *v1.DeleteOptions) error {
	_, err := c.Fake.
		Invokes(testing.NewDeleteAction(s3accountpublicaccessblocksResource, c.ns, name), &v1alpha1.S3AccountPublicAccessBlock{})

	return err
}

// DeleteCollection deletes a collection of objects.
func (c *FakeS3AccountPublicAccessBlocks) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
	action := testing.NewDeleteCollectionAction(s3accountpublicaccessblocksResource, c.ns, listOptions)

	_, err := c.Fake.Invokes(action, &v1alpha1.S3AccountPublicAccessBlockList{})
	return err
}

// Patch applies the patch and returns the patched s3AccountPublicAccessBlock.
func (c *FakeS3AccountPublicAccessBlocks) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1alpha1.S3AccountPublicAccessBlock, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewPatchSubresourceAction(s3accountpublicaccessblocksResource, c.ns, name, pt, data, subresources...), &v1alpha1.S3AccountPublicAccessBlock{})

	if obj == nil {
		return nil, err
	}
	return obj.(*v1alpha1.S3AccountPublicAccessBlock), err
}

repository: ibelikov/kubeform

repo_name: ibelikov/kubeform


text:
require libgpiod.inc

SRC_URI[md5sum] = "2ca0c3eb17d69e367b6f6a109ca86e41"
SRC_URI[sha256sum] = "972924195367f5fb045c023d65340c4b7dfc8764499516be446553865208dedc"

repository: astarche/meta-openembedded

repo_name: astarche/meta-openembedded

branch_name: refs/heads/nilrt/master/sumo


text:
@article{white2004trade,
 author = {White, Ethan P and Ernest, SK Morgan and Thibault, Katherine M},
 journal = {The American Naturalist},
 number = {5},
 pages = {670--676},
 publisher = {The University of Chicago Press},
 title = {Trade-offs in community properties through time in a desert rodent community},
 volume = {164},
 year = {2004}
}

repository: weecology/website

repo_name: weecology/website


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

import (
	"context"
	"io"
	"sort"
	"sync"
	"time"

	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"github.com/hashicorp/golang-lru/simplelru"
	"github.com/google/schedviz/analysis/sched"
	"github.com/google/schedviz/server/models"

	eventpb "github.com/google/schedviz/tracedata/schedviz_events_go_proto"
)

// CachedCollection is a collection and its metadata that is stored in the LRU cache.
type CachedCollection struct {
	collection     *sched.Collection
	systemTopology models.SystemTopology
	// Payload stores arbitrary data by a string key.
	payload map[string]interface{}
	// ready blocks until the collection is ready to be read.
	ready chan struct{}
	// Any error encountered while creating the collection.
	err error
}

// SchedCollection returns the cached collection's sched.Collection.
func (cc *CachedCollection) SchedCollection() *sched.Collection {
	return cc.collection
}

// SystemTopology returns the cached collection's system topology.
func (cc *CachedCollection) SystemTopology() *models.SystemTopology {
	return &cc.systemTopology
}

// GetPayload returns the specified payload from the cached collection,
// and a boolean indicating whether it was present.
func (cc *CachedCollection) GetPayload(name string) (interface{}, bool) {
	got, ok := cc.payload[name]
	return got, ok
}

// SetPayload sets the specified name to the provided payload in the cached
// collection, replacing whatever was there before.
func (cc *CachedCollection) SetPayload(name string, payload interface{}) {
	cc.payload[name] = payload
}

func newCachedCollection() *CachedCollection {
	return &CachedCollection{
		ready: make(chan struct{}),
	}
}

// wait blocks until release() has been called on the receiver.  At that point,
// the receiver should no longer be modified.  Returns the CachedCollection's
// error, if returning because release was called, or the context's error, if
// the context was cancelled.
func (cc *CachedCollection) wait(ctx context.Context) error {
	// Block on the cached collection's Ready channel, or the context ending,
	// whichever comes first.
	select {
	case <-cc.ready:
		return cc.err
	case <-ctx.Done():
		return ctx.Err()
	}
}

// release unblocks any outstanding or future wait calls on the receiver.  It
// should only be called when the receiver is fully populated and will no
// longer be modified.
func (cc *CachedCollection) release() {
	close(cc.ready)
}

type storageBase struct {
	lruCache                  *simplelru.LRU
	mu                        sync.Mutex
	failOnUnknownEventFormat  bool
	loadTimes                 map[string]time.Time
	cacheAdds, cacheEvictions int
	now                       func() time.Time
}

func newStorageBase(cacheSize int) (*storageBase, error) {
	lru, err := simplelru.NewLRU(cacheSize, nil)
	if err != nil {
		return nil, err
	}
	return &storageBase{
		lruCache:  lru,
		loadTimes: map[string]time.Time{},
		now:       time.Now,
	}, nil
}

// addToCache adds the provided collection, keyed by the specified name, to the
// LRU cache.  If a collection had to be evicted to make room for the new one,
// its total time in the cache is returned.  sb.mu must be acquired before
// calling sb.addToCache.
func (sb *storageBase) addToCache(collectionName string, collection *CachedCollection) time.Duration {
	oldestCollectionName, _, oldestFound := sb.lruCache.GetOldest()
	var oldestLoadTime time.Time
	oldestLoadTimeFound := false
	if oldestFound {
		oldestLoadTime, oldestLoadTimeFound = sb.loadTimes[oldestCollectionName.(string)]
	}
	evicted := sb.lruCache.Add(collectionName, collection)
	sb.loadTimes[collectionName] = sb.now()
	sb.cacheAdds++
	if evicted && oldestLoadTimeFound {
		sb.cacheEvictions++
		delete(sb.loadTimes, oldestCollectionName.(string))
		return sb.now().Sub(oldestLoadTime)
	}
	return 0
}

// extractEventNames gets a list of all event descriptor names in the event set
func (sb *storageBase) extractEventNames(es *eventpb.EventSet) ([]string, error) {
	var events []string
	for idx, ed := range es.EventDescriptor {
		if ed.Name < 0 || int(ed.Name) >= len(es.StringTable) {
			return nil, status.Errorf(codes.Internal, "invalid event name %d in event descriptor %d", ed.Name, idx)
		}
		events = append(events, es.StringTable[ed.Name])
	}
	sort.Strings(events)
	return events, nil
}

// cacheStats returns cache addition and eviction statistics, for use in testing.
func (sb *storageBase) cacheStats() (adds, evictins int) {
	sb.mu.Lock()
	defer sb.mu.Unlock()
	return sb.cacheAdds, sb.cacheEvictions
}

// getCollectionFromCache returns the named collection, if it is stored in the
// cache.  It also returns a bool signifying whether the collection was in the
// cache at the start of the call, and a Duration, nonzero if a collection had
// to be evicted from the cache during this operation, indicating how long the
// evicted collection had been in the cache.
// If addCollection is true, a new, empty, CachedCollection will be placed in
// the cache under the provided name.  Note that if this occurs, the returned
// bool will still be false, though the returned CachedCollection will be in
// the cache.  release() should be called on the returned CachedCollection when
// it will no longer be modified.
func (sb *storageBase) getCollectionFromCache(collectionName string, addCollection bool) (*CachedCollection, bool, time.Duration, error) {
	sb.mu.Lock()
	cachedValue, ok := sb.lruCache.Get(collectionName)
	if !ok && addCollection {
		defer sb.mu.Unlock()
		cachedCollection := newCachedCollection()
		evictedDuration := sb.addToCache(collectionName, cachedCollection)

		return cachedCollection, false, evictedDuration, nil
	}
	sb.mu.Unlock()
	var cachedCollection *CachedCollection
	if ok {
		cachedCollection, ok = cachedValue.(*CachedCollection)
		if !ok {
			return nil, false, 0, status.Error(codes.Internal, "unknown type stored in collection cache")
		}
	}
	return cachedCollection, ok, 0, nil
}

// StorageService is an interface containing the APIs that storage services expose
type StorageService interface {
	UploadFile(ctx context.Context, req *models.CreateCollectionRequest, fileHeader io.Reader) (string, error)
	DeleteCollection(ctx context.Context, editor string, collectionUniqueName string) error
	// GetCollection returns the specified collection, or any error encountered
	// procuring it.  If the collection exists in the cache, the cached version
	// will be returned, otherwise, it will be created and added to the cache
	// before being returned.
	// Implementations should use CachedCollection's synchronization properties:
	//  * When adding a new collection to the cache, implementors should call
	//    release() on the CachedCollection after populating it and before
	//    returning.  If any error is encountered while populating the
	//    CachedCollection, its err field should be set accordingly.
	//  * When finding a CachedCollection already in the cache, implementors
	//    should call wait() on that CachedCollection before returning it.
	//    After wait() returns, the CachedCollection's err field should be
	//    checked, and GetCollection should return any non-nil error there.
	GetCollection(ctx context.Context, collectionName string) (*CachedCollection, error)
	GetCollectionMetadata(ctx context.Context, collectionUniqueName string) (models.Metadata, error)
	EditCollection(ctx context.Context, editor string, req *models.EditCollectionRequest) error
	ListCollectionMetadata(ctx context.Context, user string, collectionName string) ([]models.Metadata, error)
	GetCollectionParameters(ctx context.Context, collectionName string) (models.CollectionParametersResponse, error)
	GetFtraceEvents(ctx context.Context, req *models.FtraceEventsRequest) (models.FtraceEventsResponse, error)
	// Helper
	SetFailOnUnknownEventFormat(option bool)
}

repository: google/schedviz

repo_name: google/schedviz


text:
#[==[.md INTERNAL
# `SuperbuildExternalProject`

This file is basically a wrapper around CMake's `ExternalProject` module with
additional support for managing environments, parallel build settings, download
management, and output suppression.
#]==]

if (TRUE OR CMAKE_VERSION VERSION_LESS "3.21") # Patches haven't landed yet.
  # Needed for fixes.
  include("${CMAKE_CURRENT_LIST_DIR}/patches/ExternalProject.cmake")
else ()
  include(ExternalProject)
endif ()

# Because of the wrapped and nested way that "make" needs to get called, it's
# not able to utilize the top level make jobserver so it's -j level must be
# manually controlled.
include(ProcessorCount)
processorcount(superbuild_cpu_count)
if (NOT superbuild_cpu_count)
  set(SUPERBUILD_NCPUS 8)
endif ()

set(SUPERBUILD_PROJECT_PARALLELISM "${superbuild_cpu_count}"
  CACHE STRING "Number of jobs to use when compiling subprojects")
mark_as_advanced(SUPERBUILD_PROJECT_PARALLELISM)

include(CMakeDependentOption)
cmake_dependent_option(SUPERBUILD_USE_JOBSERVER "Whether to use the top-level jobserver or not" OFF
  "CMAKE_GENERATOR MATCHES Makefiles" OFF)
mark_as_advanced(SUPERBUILD_USE_JOBSERVER)

if (CMAKE_GENERATOR MATCHES "Makefiles")
  set(superbuild_make_program "${CMAKE_MAKE_PROGRAM}")
else ()
  find_program(SUPERBUILD_MAKE_PROGRAM
    NAMES gmake make
    DOC "Path to the `make` executable to use")
  if (SUPERBUILD_MAKE_PROGRAM)
    set(superbuild_make_program "${SUPERBUILD_MAKE_PROGRAM}")
  else ()
    set(superbuild_make_program "make")
  endif ()
endif ()

add_custom_target(download-all)

set(old_policy_114 1)
if (POLICY CMP0114)
  cmake_policy(GET CMP0114 cmp0114_state)
  if (cmp0114_state STREQUAL "NEW")
    set(old_policy_114 0)
  endif ()
endif ()

set(_superbuild_independent_step_targets
  download
  update
  patch)
if (old_policy_114)
  set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
    PROPERTY
      EP_INDEPENDENT_STEP_TARGETS "${_superbuild_independent_step_targets}")
else ()
  set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
    PROPERTY
      EP_STEP_TARGETS "${_superbuild_independent_step_targets}")
endif ()

option(SUPERBUILD_OFFLINE_BUILD "Do not update git repositories during the build" OFF)
if (SUPERBUILD_OFFLINE_BUILD)
  set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
    PROPERTY
      EP_UPDATE_DISCONNECTED ON)
endif ()

# Version of the function which strips PROCESS_ENVIRONMENT arguments for
# ExternalProject_add.
function (_superbuild_ep_strip_extra_arguments name)
  set(arguments)
  set(accumulate FALSE)

  _ep_get_add_keywords(keywords)

  foreach (arg IN LISTS ARGN)
    if (arg STREQUAL "PROCESS_ENVIRONMENT")
      set(skip TRUE)
    elseif (arg IN_LIST keywords)
      set(skip FALSE)
    endif ()

    if (NOT skip)
      list(APPEND arguments "${arg}")
    endif ()
  endforeach ()

  ExternalProject_add("${name}" "${arguments}")
endfunction ()

# Wraps a command in a CMake script which handles environment management.
function (_superbuild_ep_wrap_command var target command_name)
  get_property(has_command TARGET "${target}"
    PROPERTY "_EP_${command_name}_COMMAND" SET)
  set("has_${var}"
    "${has_command}"
    PARENT_SCOPE)

  get_property(command TARGET "${target}"
    PROPERTY "_EP_${command_name}_COMMAND")

  if (NOT has_command)
    if (command_name STREQUAL "CONFIGURE")
      _ep_extract_configure_command(command "${target}")
      if (command)
        set(has_command 1)
      endif ()
    else ()
      # Get the ExternalProject-generated command.
      _ep_get_build_command("${target}" "${command_name}" command)
      set(has_command 1)
    endif ()
  endif ()

  # Replace $(MAKE) usage.
  set(submake_regex "^\\$\\(MAKE\\)")
  if (command MATCHES "${submake_regex}")
    set(submake_command "${superbuild_make_program}")
    if (NOT SUPERBUILD_USE_JOBSERVER)
      list(APPEND submake_command "-j${SUPERBUILD_PROJECT_PARALLELISM}")
    endif ()
    string(REGEX REPLACE "${submake_regex}" "${submake_command}" command "${command}")
  endif ()

  if (command)
    string(TOLOWER "${command_name}" step)
    set(new_command
      "${CMAKE_COMMAND}" -P
      "${CMAKE_CURRENT_BINARY_DIR}/${target}-${step}.cmake")
  else ()
    set(has_command 0)
  endif ()

  set("original_${var}"
    "${command}"
    PARENT_SCOPE)
  set("${var}"
    "${command_name}_COMMAND" "${new_command}"
    PARENT_SCOPE)

  set("req_${var}"
    "${has_command}"
    PARENT_SCOPE)
endfunction ()

function (_superbuild_ExternalProject_add name)
  # Create a temporary target so we can query target properties.
  add_custom_target("sb-${name}")
  _ep_get_add_keywords(keywords)
  list(APPEND keywords
    PROCESS_ENVIRONMENT)
  _ep_parse_arguments("${keywords}" "sb-${name}" _EP_ "${ARGN}")

  get_property(has_process_environment TARGET "sb-${name}"
    PROPERTY _EP_PROCESS_ENVIRONMENT SET)
  if (NOT has_process_environment)
    _superbuild_ep_strip_extra_arguments(${name} "${ARGN}")
    return ()
  endif ()

  # Wrap the three main commands which require environment manipulation.
  _superbuild_ep_wrap_command(configure_command "sb-${name}" CONFIGURE)
  _superbuild_ep_wrap_command(build_command     "sb-${name}" BUILD)
  _superbuild_ep_wrap_command(install_command   "sb-${name}" INSTALL)

  set(args)
  if (has_configure_command OR req_configure_command)
    list(APPEND args
      "${configure_command}")
  endif ()
  if (has_build_command OR req_build_command)
    list(APPEND args
      "${build_command}")
  endif ()
  list(APPEND args
    "${install_command}")

  # Now strip `PROCESS_ENVIRONMENT` and commands from arguments.
  set(skippable_args
    PROCESS_ENVIRONMENT
    BUILD_COMMAND
    INSTALL_COMMAND
    CONFIGURE_COMMAND)
  set(skip FALSE)
  foreach (arg IN LISTS ARGN)
    if (arg IN_LIST keywords)
      if (arg IN_LIST skippable_args)
        set(skip TRUE)
      else ()
        set(skip FALSE)
      endif ()
    endif ()
    if (NOT skip)
      list(APPEND args
        "${arg}")
    endif ()
  endforeach ()

  set(suppress_default OFF)
  if (DEFINED "_superbuild_suppress_${name}_output")
    set(suppress_default "${_superbuild_suppress_${name}_output}")
  endif ()

  # Add option to dump the output to a file. This keeps it hidden from CTest if
  # it just cannot be silenced.
  option("SUPPRESS_${name}_OUTPUT" "Suppress output for ${name}" "${suppress_default}")
  mark_as_advanced("SUPPRESS_${name}_OUTPUT")

  if (SUPPRESS_${name}_OUTPUT)
    # Silence the build and install steps.
    list(APPEND args
      LOG_BUILD   1
      LOG_INSTALL 1)
  endif ()

  if (SUPERBUILD_DEBUG_CONFIGURE_STEPS)
    list(APPEND args
      LOG_CONFIGURE 1)
  endif ()

  # Quote args to keep empty list elements around so that we properly parse
  # empty install, configure, build, etc.
  ExternalProject_add("${name}" "${args}")

  # Hook up the download step with the `download-all` target.
  if (TARGET "${name}-download")
    add_dependencies(download-all
      "${name}-download")
  endif ()

  # Configure the scripts after the call ExternalProject_add() since that sets
  # up the directories correctly.
  get_target_property(process_environment "sb-${name}"
    _EP_PROCESS_ENVIRONMENT)
  _ep_replace_location_tags("${name}" process_environment)

  # Configure each CMake script used during the actual build.
  foreach (step IN ITEMS configure build install)
    if (req_${step}_command)
      set(step_command "${original_${step}_command}")
      _ep_replace_location_tags("${name}" step_command)

      configure_file(
        "${CMAKE_CURRENT_LIST_DIR}/cmake/superbuild_handle_environment.cmake.in"
        "${CMAKE_CURRENT_BINARY_DIR}/sb-${name}-${step}.cmake"
        @ONLY)
    endif ()
  endforeach ()
endfunction ()

repository: zenotech/openmpi-superbuild

repo_name: zenotech/openmpi-superbuild

gha_language: CMake

extension: cmake


text:
@book{flickenger_wifi,
	address = {Paris},
	title = {Le {WiFi} à 200\%: [100 trucs, secrets et techniques]},
	isbn = {2841772829},
	shorttitle = {Le {WiFi} à 200\%},
	pages = {286},
	publisher = {O'Reilly},
	author = {Rob FLICKENGER},
	year = {2004},
	keywords = {réseau informatique local sans fil, réseau informatique sans fil}
}

@book{geron_wifi,
	address = {Paris},
	edition = {3e édition},
	title = {{WiFi} professionnel: la norme 802.11, le déploiement, la sécurité},
	isbn = {9782100529636},
	series = {Infopro. Réseaux et télécoms},
	shorttitle = {{WiFi} professionnel},
	pages = {380},
	publisher = {Dunod},
	author = {Aurélien GÉRON},
	year = {2009},
	keywords = {réseau informatique sans fil}
}

@book{wong_pdf,
	author = {Stanley WONG},
	title = {The evolution of wireless security in 802.11 networks: WEP, WPA and 802.11 standards},
	year = {2003},
	pages = {12},
}

@misc{deterioration,
	author = {François CHARLET},
	title = {Détériorer des données informatiques est punissable},
	url = {http://francoischarlet.ch/2011/deteriorer-des-donnees-informatiques-est-punissable},
	year = {15.03.2014},
}

@misc{soustraction,
	author = {François CHARLET},
	title = {La soustraction de données informatiques},
	url = {http://francoischarlet.ch/2011/la-soustraction-de-donnees-informatiques},
	year = {15.03.2014},
}

@misc{risques,
	author = {François CHARLET},
	title = {Que risque le hacker en droit pénal suisse ?},
	url = {http://francoischarlet.ch/2011/que-risque-le-hacker-en-droit-penal-suisse},
	year = {15.03.2014},
}

@misc{code_suisse,
	author = {},
	title = {RS 311.0 Code pénal suisse du 21 décembre 1937},
	url = {http://www.admin.ch/opc/fr/classified-compilation/19370083/index.htmla143},
	year = {15.03.2014},
}

@misc{security_uncorked,
	author = {Uncorked Security},
	title = {A Brief History of Wireless Security},
	url = {http://securityuncorked.com/2008/08/history-of-wireless-security/},
	year = {11.08.2014},
}

@misc{aircrack,
	author = {Aircack-ng},
	title = {Main Menu},
	url = {http://aircrack-ng.org/doku.php?id=Main\#documentation},
	year = {11.08.2014},
}

@misc{wiki_wifi,
	author = {Wikipédia},
	title = {Wi-Fi},
	url = {http://fr.wikipedia.org/w/index.php?title=Wi-Fi\&oldid=101783355},
	year = {07.03.2014},
}

@misc{wiki_wep,
	author = {Wikipédia},
	title = {Wired Equivalent Privacy},
	url = {http://fr.wikipedia.org/w/index.php?title=Wi red\_Equivalent\_Privacy\&oldid=101070080},
	year = {17.03.2014},
}

@misc{crack_wep,
	author = {FR Kali-Linux},
	title = {Cracker la clé wep avec Kali-linux},
	url = {http://www.kali-linux.fr/wifi/cracker-cle-wep},
	year = {04.08.2014},
}

@misc{crack_wep_noclient,
	author = {FR Kali-Linux},
	title = {Cracker une clé wifi, chiffrement WEP sans clients sous kali-linux},
	url = {http://www.kali-linux.fr/wifi/cracker-cle-wep-sans-client},
	year = {04.08.2014},
}

@misc{security_wepsucks,
	author = {Uncorked Security},
	title = {WEP Sucks, so Why are You Using It?},
	url = {https://securityuncorked.com/2008/08/wep-sucks-so-why-are-you-using-it/},
	year = {11.08.2014},
}

@misc{avs4you,
	author = {AVS4YOU},
	title = {Introduction aux réseaux $\gg$ Quels types d'attaques de réseau existent ?},
	url = {http://onlinehelp.avs4you.com/fr/AVS-Firewall/Introduction/NetworkAttacks.aspx},
	year = {04.09.2014},
}

@misc{wiki_ieee,
	author = {Wikipédia},
	title = {IEEE 802.11},
	url = {http://fr.wikipedia.org/w/index.php?title=IEEE\_802.11\&ol did=104528902},
	year = {30.08.2014},
}

@book{pdf_fragmentation,
	author = {Andrea BITTAU and Mark HANDLEY and Joshua LACKEY},
	title = {The Final Nail in WEP's Coffin},
	pages = {15},
}

@misc{security_wep_algorythm,
	author = {Nikita BORISOV and Ian GOLDBERG and David WAGNER},
	title = {Security of the WEP algorithm},
	url = {http://www.isaac.cs.berkeley.edu/isaac/wep-faq.html},
	year = {11.08.2014},
}

@misc{reseau_commentcamarche,
	author = {Commentçamarche},
	title = {Le concept de réseau},
	url = {http://www.commentcamarche.net/contents/508-le-concept-de-reseau},
	year = {19.09.2014},
}

@misc{imagetitre,
	author = {Asgovnet},
	title = {Image de la page de titre},
	url = {http://www.asgovnet.be/site/},
	year = {25.09.2014},
}


text:
SUMMARY = "Main program"
DESCRIPTION = "Handle main function"
LICENSE = "CLOSED"

FILESEXTRAPATHS_prepend := "${THISDIR}/../../../../:"

SRC_URI =  " \
    file://main.service \
    file://xiaopi \
    file://src/ \
    file://CMakeLists.txt \
"

inherit systemd cmake

S = "${WORKDIR}"
EXTRA_OECMAKE = ""

DEPENDS = "nlohmann-json pistache openssl wpa-supplicant userland pear libice libsrtp librtp paho-mqtt-c curl"
RDEPENDS_${PN} += "bash libwpa-client"
SYSTEMD_PACKAGES = "${PN}"
SYSTEMD_SERVICE_${PN} = "main.service"
SYSTEMD_AUTO_ENABLE = "enable"
SYSTEMD_AUTO_ENABLE_${PN} = "enable"
INSANE_SKIP_${PN} = "ldflags"
FILES_${PN} += "/opt/xiaopi"

# -Wl,--as-needed cause that open pi camera failed
TARGET_LDFLAGS = "-Wl,-O1 -Wl,--hash-style=gnu"

do_install_append () {

    install -d ${D}/opt/
    cp -r ${WORKDIR}/xiaopi ${D}/opt/

    install -d ${D}${systemd_unitdir}/system/
    install -m 0644 ${WORKDIR}/main.service ${D}${systemd_unitdir}/system
}

license: Unlicense,MIT

repository: oldcrazyeye/xiaopi

detected_licenses: Unlicense MIT

repo_name: oldcrazyeye/xiaopi


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

package keppel

import (
	"errors"
)

//StorageDriver is the abstract interface for a multi-tenant-capable storage
//backend where the keppel-registry fleet can store images.
type StorageDriver interface {
	//ReadConfig unmarshals the configuration for this driver type into this
	//driver instance. The `unmarshal` function works exactly like in
	//UnmarshalYAML. This method shall only fail if the input data is malformed.
	//It shall not make any network requests.
	ReadConfig(unmarshal func(interface{}) error) error

	//GetEnvironment produces the environment variables (in the standard
	//"key=value" format) that need to be passed to a keppel-registry process to
	//set it up to read from/write to this storage. `tenantID` identifies the
	//tenant which controls access to this account.
	//
	//The tenant is backed by the given AuthDriver. Implementations should
	//inspect the driver to ensure that the storage backend can work with this
	//authentication method, returning ErrAuthDriverMismatch otherwise.
	GetEnvironment(account Account, driver AuthDriver) ([]string, error)
}

//Error types used by StorageDriver.
var (
	ErrAuthDriverMismatch = errors.New("given AuthDriver is not supported by this StorageDriver")
)

var storageDriverFactories = make(map[string]func() StorageDriver)

//NewStorageDriver creates a new StorageDriver using one of the factory functions
//registered with RegisterStorageDriver().
func NewStorageDriver(name string) (StorageDriver, error) {
	factory := storageDriverFactories[name]
	if factory != nil {
		return factory(), nil
	}
	return nil, errors.New("no such storage driver: " + name)
}

//RegisterStorageDriver registers an StorageDriver. Call this from func init() of the
//package defining the StorageDriver.
func RegisterStorageDriver(name string, factory func() StorageDriver) {
	if _, exists := storageDriverFactories[name]; exists {
		panic("attempted to register multiple storage drivers with name = " + name)
	}
	storageDriverFactories[name] = factory
}

repository: steven-zou/keppel

repo_name: steven-zou/keppel